All servers / Research / Extenshi MCP server
Extenshi MCP server
Extenshi MCP server — bring the extension catalog (search, security, market research) and pre-publish scanning into your AI tools
Tested by ConnectATDScore 79 out of 100. Tested 2026-11-18 on package version 0.32.0. Package: @extenshi/mcp · source
Score breakdown
| Runs | 18 / 20 | |
|---|---|---|
| Tool descriptions | 17 / 20 | |
| Package safety | 12 / 20 | |
| Maintenance | 20 / 20 | |
| Adoption | 12 / 20 |
What we saw
- Starts and answers the MCP handshake: yes (11.2 seconds including download)
- Tools offered: 108
- Last published: 2026-11-18
- Weekly downloads (npm): 2,124
- License: MIT · Direct dependencies: 10
Notes
- The package runs install scripts, which execute code when you install it.
Want this server set up for your team?
ConnectATD builds AI automation and wires up MCP servers like this one. Tell us what you are trying to do.
Talk to ConnectATDTools and how they are described
Agents choose tools from these descriptions. Under each name you can see how many of its parameters are explained.
list_pay_apps0 of 3 parameters describedList your independent Pay applications. No development project required. Paginated: nextCursor is set while more results exist. Requires pay.read permission.
create_pay_app0 of 3 parameters describedCreate an independent Pay application; linking a development project is optional. `trialDays` (0–365, optional) sets a free trial at once, since a new application has no buyers yet; set_pay_trial changes it later. Not idempotent: each call creates a new application, including a call repeated after a timeout. Requires pay.write permission.
get_pay_app0 of 1 parameter describedRead your Pay application, its optional project link and its free trial (`trialDays`, null when there is none). Requires pay.read permission.
get_pay_readiness0 of 1 parameter describedCheck current checkout and launch prerequisites. A passing checkout check does not prove a live external purchase or SDK publication. `warnings` are non-blocking (`ready` ignores them): offer_translations lists offer text not yet translated into the project's languages, with counts per language and fixWith (get_pay_offer_translations → set_pay_offer_translations). Requires pay.read permission.
get_pay_payment_evidence0 of 1 parameter describedRead what Extenshi's own payment ledger proves about this application's payment path, per mode: checkout completed, license issued, an installation received the signed license, restored on a second installation, refund revoked. Derived from provider-signed webhooks, not from any report; opaque IDs and timestamps only, no buyer data. Only a live-mode purchase can satisfy a release's payment requirement; test-mode purchases are listed without satisfying it. Requires pay.read permission.
link_pay_app0 of 2 parameters describedLink your Pay application to your development project. Existing purchases remain attached to the Pay application. Requires pay.write permission.
unlink_pay_app0 of 1 parameter describedRemove the optional development-project link without deleting Pay data. Requires pay.write permission.
archive_pay_app0 of 1 parameter describedArchive your application and stop new checkout. Payment records and existing entitlements are preserved. With this connection’s API key the change applies at once, without the owner’s approval; only the hosted connector (OAuth) turns it into a proposal. Requires pay.write permission.
export_pay_data0 of 4 parameters describedExport one page of one resource (offers, payments, subscriptions, entitlements or customers). nextCursor is null on the last page. Offer rows include sortOrder, their position on the paywall (lower shows first). The output contains sensitive customer and payment data. Requires pay.read permission.
get_pay_seller0 of 1 parameter describedRead seller connection, public profile, offers (terms, sortOrder, active and sync state), the publishable SDK key and the public entitlement verification key. Those two keys are the ones meant to be embedded in extension code; secret keys are not part of the response. Agreement signing and KYC take place in the browser. Requires pay.read permission.
connect_pay_seller0 of 3 parameters describedStart Stripe Connect onboarding and return a browser action URL. KYC and legal acceptance are completed by the author at that URL; this tool does not perform them. Requires pay.write permission.
refresh_pay_seller0 of 1 parameter describedRefresh current payment-provider onboarding status. This does not complete KYC or accept agreements. Requires pay.write permission.
set_pay_seller_profile0 of 2 parameters describedSave the public seller profile: display name, support URL or email, and terms URL. The values are stored as provided and are publicly visible. With this connection’s API key the change applies at once, without the owner’s approval; only the hosted connector (OAuth) turns it into a proposal. Requires pay.write permission.
upsert_pay_offer0 of 10 parameters describedCreate or update an offer keyed by a stable SKU. On an existing offer every omitted field keeps its stored value: to change only the title or description, send appId, sku and the new text, and the price, features and paywall order (sortOrder) stay as they are; `description: null` clears the description. A new SKU needs kind, amountMinor, currency and title (and interval for a subscription), with sortOrder 0 when omitted (lower shows first). An archived SKU needs the same, since saving it puts it back on sale. Price is in minor currency units. Subscriptions keep the given billing interval; one-time and lifetime offers store no interval. Price and features are stored as provided. `features` are entitlement keys (e.g. `full`): the SDK checks them with hasFeature and extensions match offers by them, so they stay untranslated; localized paywall bullets come from the extension, via showPaywall({ features }) with text from its _locales. `followUps` names the translations a changed title or description left missing or outdated (set_pay_offer_translations). With this connection’s API key the change applies at once, without the owner’s approval; only the hosted connector (OAuth) turns it into a proposal. Requires pay.write permission.
archive_pay_offer0 of 2 parameters describedStop offering a SKU for new checkout; historical purchases are preserved. With this connection’s API key the change applies at once, without the owner’s approval; only the hosted connector (OAuth) turns it into a proposal. Requires pay.write permission.
get_pay_offer_translations0 of 1 parameter describedRead the translatable text of the application's active offers (title, description) keyed `<sku>/<field>`, with the project's languages and each language's translated, missing and outdated fields. Feature keys are entitlement keys, listed under `notTranslated` and not counted as missing. The paywall shows an offer in the buyer's browser language when the project ships it; the SDK's own buttons and labels are already translated. get_project_state `localization` summarizes this with every other translated surface. Requires pay.read permission.
set_pay_offer_translations0 of 5 parameters describedSave one language of the offers' translations: `translations` maps `<sku>/<field>` keys from get_pay_offer_translations to text; `sources` (optional) carries the original each was translated from, and a save whose original has changed since is refused. An empty string removes a translation; a `<sku>/feature:<n>` key is refused (TRANSLATIONS_INVALID: features are entitlement keys). Prices, SKUs, plans and feature keys are not changed. Answers with the saved language's translations and every language's status (`view: 'saved_locale'`, the default); `view: 'all_locales'` returns every language's translations, as get_pay_offer_translations does. Requires pay.write permission.
set_pay_enabled0 of 2 parameters describedEnable or disable new payments for the application; requires a connected payment provider. Enabling re-reads the seller status from the provider (charges and payouts). It does not verify the public profile, agreement or offer sync: buyers can check out only when every readiness check reported by get_pay_readiness passes. Enabling is a live commerce change. With this connection’s API key the change applies at once, without the owner’s approval; only the hosted connector (OAuth) turns it into a proposal. Requires pay.write permission.
set_pay_trial0 of 2 parameters describedSet the application's free trial: `trialDays` (0–365) free days for every installation, counted on Extenshi's server from the first time the SDK reads that installation's license; null turns the trial off. One clock per installation per application, so switching offers does not restart it, and an installation restored through purchase recovery keeps the earliest start. The end is derived from the stored start, so a new length also moves trials already running. The SDK reads it with getTrial() and the trial:ending / trial:ended events; the extension does not store a start date itself. With this connection’s API key the change applies at once, without the owner’s approval; only the hosted connector (OAuth) turns it into a proposal. Requires pay.write permission.
rotate_pay_key0 of 1 parameter describedGenerate a new publishable SDK key. Not idempotent: each call issues another key. Prior keys remain accepted for installed extension builds; this does not revoke any secret. Requires pay.write permission.
import_manifest1 of 13 parameters describedImport an existing manifest.json into the Dojo manifest editor and project labels. Input: parsed JSON, optional default-locale messages, and optional messagesByLocale — every _locales/<lang>/messages.json keyed by locale code (only the keys named by the __MSG_*__ fields of the manifest are needed) — whose non-default locales fill the Dojo translations of name and description. Repository translations replace editor text per field; translations the repository lacks are kept, and warnings name each replaced one. Source import fills supported fields and preserves all other JSON; built imports remain separate observations. Default dryRun=true returns changes and expectedStateHash without writing; dryRun=false with that hash applies them. Does not infer data collection, prices, or publication. Requires project.write. `provenance` is required: {source: "agent", observedAt: ISO-8601 timestamp, toolVersion: your client name and version}.
create_project1 of 6 parameters describedCreate a new extension project (a Dojo workspace) owned by this identity, through the same service the Dojo project wizard uses, with the same ownership and limits. Returns JSON {projectId, dojoUrl, project, pendingDecisions, nextSteps}: the next steps cover binding the repository and the starter files. Idempotent: a repeated request with the same idempotencyKey returns the project it already created (replayed: true); the same key with different input is rejected. Requires project.write. On this local server the answer also carries `buildMap` {running, url (while running), offered, declined, offers, home} for projectDir: the author’s build map (npx @extenshi/cli map), one per project for every agent and git worktree; absent when the directory cannot be read.
get_decisions1 of 1 parameter describedOwner decisions for one project: the AMO add-on id, license, seller public name, support contact and terms, pricing, target browsers and target locales. Each entry reports its status (undecided, proposed or decided), the value, a suggested default where one is derivable (a stable {GUID} add-on id or the id already in the Firefox manifest, the project browsers), who proposed or decided it and when, and which releases it blocks (blocksBrowsers, blocksPayment). `pending` lists the keys the owner has not decided. FREE.
propose_decision1 of 6 parameters describedPropose a value for one owner decision. The proposal is stored with its rationale, proposer and time; the owner accepts or edits it on the Dojo project page, which is the only place a decision becomes decided. A key the owner already decided is refused (DECISION_ALREADY_DECIDED). Value formats: amo.addonId {GUID} or name@domain; license an AMO license slug (below); seller.publicName text; seller.supportContact an email or HTTPS URL; seller.terms an HTTPS URL; pricing {model: free|paid|donations, trialDays?, plans?: subscription|lifetime|one_time}; targetBrowsers an array of chrome/firefox/edge; targetLocales an array of locale codes. License: AMO accepts exactly these case-sensitive slugs: all-rights-reserved, MIT, Apache-2.0, MPL-2.0, GPL-3.0-only, ISC, BSD-2-Clause, GPL-2.0-only, LGPL-2.1-only, LGPL-3.0-only, AGPL-3.0-only, Unlicense. Another SPDX id (BSD-3-Clause, GPL-3.0-or-later) is accepted, but AMO then needs it as customLicense (name + text) in the listing. npm's UNLICENSED in package.json means proprietary, so propose all-rights-reserved; Unlicense is a public-domain dedication. A misspelled slug (mit, GPL-3.0, UNLICENSED) is refused. Idempotent per idempotencyKey. Requires project.write.
set_store_listing1 of 4 parameters describedRecord where this project is listed in one store and how far it got: status planned (not submitted), submitted (sent for review, in review) or live (public). Works before the listing is public: an AMO URL in review, a Chrome item id reserved in the Developer Dashboard, an Edge Partner Center productId before any public URL exists. url is that store's listing page (chromewebstore.google.com/detail/…, addons.mozilla.org/…/addon/<slug>/, microsoftedge.microsoft.com/addons/detail/…); itemId is the public store id (Chrome 32 letters a–p, AMO slug/number/GUID, Edge 32 letters a–z); productId is Edge-only; submittedAt a date. A live listing needs url or itemId. The entry is replaced whole (fields you leave out are removed); listing null removes it. Only live listings reach public pages: draft_landing_page fills install buttons from them, not from planned or submitted ones. Read them back in get_project_state workspace.document.storeListings or list_my_projects. Returns {listings, urls, publicUrls, pending, revision}. Idempotent per idempotencyKey. Requires project.write.
get_project_workspace2 of 3 parameters describedRead revisioned source/built manifests, repository metadata, scope and release snapshot. These are observations, separate from scaffold drafts.
get_release_readiness2 of 3 parameters describedExplain readiness for the recorded browser and artifact by locale. Local or agent reports are not treated as CI attestations. Stale evidence does not pass. Requires a Pro project. Readiness is measured against the release recorded in the workspace: until apply_project_patch sets patch.release (browser, version, artifactDigest, manifestDigest, locales, paymentRequired, and commit or dirtyTreeDigest) it reports RELEASE_NOT_RECORDED; after that, evidence counts only when it matches that release artifactDigest. When the project has a linked Pay application, the payment check also carries `platform`: what Extenshi's own payment ledger proves (checkout, license, installation activation, recovery, refund). A live-mode purchase through those stages passes the check with source 'platform'; test-mode purchases are listed without passing it. Clients cannot record source 'platform'. `warnings` lists what does not block but needs action before upload, such as a decided license that is not an AMO slug and needs customLicense in the AMO listing, and TRANSLATIONS_INCOMPLETE: server-side text (Pay offers, license terms, privacy policy, hosted pages, landing page) still missing or outdated in the project languages, each surface with its fixWith tools — the same counts as get_project_state `localization`.
connection_diagnosticsno parametersVerify authentication, granted scopes, supported workspace contracts and actual write permissions (incl. hosted.write, evidence uploads and, for a projectId, CI ingest configuration) and the Pay scopes a key carries. Includes credit balances, the registered tools and, on the local server, `client` {version, latestVersion, updateAvailable}; credentials and secrets are not included. A failed sign-in returns an error that says how to sign in again.
diff_project_state0 of 7 parameters describedPreview a three-way metadata diff against a server-held base revision. No writes. `provenance` is required: {source: "agent", observedAt: ISO-8601 timestamp, toolVersion: your client name and version}.
apply_project_patch0 of 7 parameters describedApply a typed project metadata patch with expectedRevision and idempotencyKey. Source and built manifests are stored separately, including unknown keys. Omitted fields are left unchanged; tombstones explicitly delete. No source upload or scaffold overwrite. patch.release records the release that get_release_readiness measures against; patch.storeListings records store listings per store (set_store_listing does the same for one store without the revision bookkeeping). Requires project.write OAuth scope. `provenance` is required: {source: "agent", observedAt: ISO-8601 timestamp, toolVersion: your client name and version}.
create_ci_ingest_secret0 of 1 parameter describedCreate or rotate the per-project secret the extenshi-evidence-action uses to POST CI evidence (POST /projects/:id/evidence/ingest). The secret is returned only once; the action reads it from the repository GitHub Actions secret EXTENSHI_EVIDENCE_SECRET. Not idempotent: creating again invalidates the previous secret. Requires project.write.
upsert_hosted_page0 of 3 parameters describedRegister the project's homepage or support page URL (HTTPS only; the server fetches the public page and hashes the body, so the URL has to be publicly reachable). The registered homepage URL feeds HOMEPAGE_URL when the integration config file is regenerated. Requires hosted.write. API reference: https://docs.extenshi.io/developers/project-sync#hosted-pages-from-the-api
verify_hosted_artifact0 of 2 parameters describedVerify a hosted page actually serves what its record says: re-fetches and compares content. kind=homepage|support compares against the registered body hash (verified | changed | unreachable); kind=privacy checks the published policy version's HTML is what the public page really serves. Requires hosted.write. API reference: https://docs.extenshi.io/developers/project-sync#hosted-pages-from-the-api
remove_hosted_page0 of 2 parameters describedRemove the project's registered homepage or support page — for a project moving off a URL or a mis-registered address. The public page itself keeps working; only the project record is forgotten. Requires hosted.write. API reference: https://docs.extenshi.io/developers/project-sync#hosted-pages-from-the-api
publish_landing_page25 of 26 parameters describedPublish the project's landing page (homepage) on Extenshi hosting — the same page generate_landing_page returns, rendered server-side from the form (no caller HTML is stored) and served at page.extenshi.io/{code}, or at the root of the project's custom domain once it is ACTIVE (set_custom_domain). A schema-v2 form (schemaVersion 2; draft_landing_page returns one, preview_landing_page validates it) adds sections, theme tokens, SEO, per-locale pages at {url}/{locale} with hreflang, and llms.txt; pricing plans with offerSku take price and period from the live Pay offer. The code is permanent: republishing creates a new version at the same URL. By default the URL is also registered as the project homepage, which feeds HOMEPAGE_URL. Hosted images are limited to store screenshot URLs (from get_extension) and images uploaded in the Dojo Page generator or with upload_project_media (use its url for local screenshots or a logo); the logo may also be an inline SVG or a raster data: URL. After publishing, the server fetches the public URL: live.status is verified (it serves these bytes), changed or unreachable (with live.detail, e.g. HTTP 404) — only verified means visitors see the page. Returns JSON {url, publicCode, versionNumber, contentHash, bytes, warnings, homepage, live, nextSteps, followUps}; followUps names project languages the form has no locales.<tag> page for. Requires hosted.write. API reference: https://docs.extenshi.io/developers/project-sync#hosted-pages-from-the-api
get_landing_page3 of 4 parameters describedThe project's hosted landing page: public code, live version, publish state, URL (null when unpublished) and the form the live version was rendered from. By default the form comes as a summary (locales, sections, links, logo, size of each field); view "full" returns the form, narrowed by fields and locales when given.
unpublish_landing_page0 of 1 parameter describedTake the hosted landing page offline (it answers 404). The public code and version history are kept, so publishing again restores the same URL. A homepage registration that points at this page is removed with it. Requires hosted.write. API reference: https://docs.extenshi.io/developers/project-sync#hosted-pages-from-the-api
draft_landing_page2 of 3 parameters describedDraft a full homepage (schema v2) from what the project already knows: the manifest draft and its store translations, the published page or saved Page generator form, public project media, Extenshi Pay offers (pricing plans bound by SKU), hosted artifacts (privacy policy, uninstall feedback form, license terms), owner decisions (seller.supportContact for supportUrl, pricing for the trial in the FAQ), the newest source/built manifest version and the locales, with built-in headings translated for the languages Extenshi ships. Writes nothing. Returns JSON {form, sources (field → where it came from), todos (what only you can supply — features, how-it-works, real testimonials, translations), problems, previewUrl}. The form is accepted as-is by preview_landing_page and publish_landing_page. The install buttons come from the project's live store listings (set_store_listing); planned or submitted listings stay off the page and appear in todos instead. storeUrls overrides them for a store; accentColor sets the brand colour (the server cannot see your Pay SDK theme). Requires project.read.
preview_landing_page25 of 26 parameters describedValidate and render a landing form exactly as publish_landing_page would — same image rules, store-locale check, Pay offer prices and canonical URL — without publishing. Returns JSON {ok, problems: [{path, severity, message, fix}], html (the page for `locale`), url, locales, bytes, contentHash, llmsTxt, warnings}. `ok: false` means publish would refuse the form; every problem says what to change. `html` is byte-for-byte the page publish would serve. Requires project.read.
list_landing_page_versions0 of 1 parameter describedVersion history of the hosted landing page, newest first: versionNumber, createdAt, contentHash, reason (publish | rollback | domain — a canonical switch after the custom domain changed), restoredFromVersion, schemaVersion, locales and which one is live. Requires project.read.
rollback_landing_page0 of 3 parameters describedRestore an earlier version of the hosted landing page. History stays append-only: the old form is published as a NEW version, re-rendered with today's URL and Pay offer prices. Returns the same JSON as publish_landing_page. Requires hosted.write.
get_custom_domain0 of 1 parameter describedThe project's custom domain: hostname, status (PENDING → VERIFIED → ACTIVE; FAILED; SUSPENDED when the TXT record disappeared), the exact DNS records to set, whether HTTPS for custom domains is enabled on the platform (edgeConfigured) and the next step. Only ACTIVE is served. Requires project.read.
set_custom_domain0 of 2 parameters describedAdd a custom domain (www.example.com, or the apex) for the homepage and every hosted page of the project (Pro; one hostname per project). Returns the exact DNS records: a CNAME to hosted.extenshi.io (at an apex: CNAME flattening / ALIAS / ANAME, or use www) and a TXT ownership token that stays in place (it is re-checked). Nothing is served until verify_custom_domain confirms the token and the HTTPS certificate is issued; then the homepage is served at the domain root, its canonical and HOMEPAGE_URL switch to it. Replacing the hostname starts over. Requires hosted.write.
verify_custom_domain0 of 1 parameter describedCheck the custom domain now: looks up the TXT token, requests or refreshes the HTTPS certificate, and moves the status (PENDING/FAILED → VERIFIED → ACTIVE). When it becomes ACTIVE the landing page is republished with the new canonical and HOMEPAGE_URL moves to https://{hostname}/ (the integration file in get_project_state follows). Safe to call repeatedly; DNS changes can take minutes. The platform also re-checks every 6 hours. Requires hosted.write.
remove_custom_domain0 of 1 parameter describedRemove the custom domain: it stops being served, the certificate is released, and the landing canonical and HOMEPAGE_URL move back to page.extenshi.io/{code}. Remove the DNS records afterwards. Requires hosted.write.
get_install_instructions0 of 1 parameter describedThe hosted install instructions page of a project: {page: {publicCode, enabled, publishedAt, input, url} or null, draft, draftProblems} — `draft` is the form saved by the install-instructions tool in the cabinet; `draftProblems` lists why it cannot be published as it is. The page shows store and optional sideload steps for Chrome, Firefox and Edge in the visitor’s browser language (en, es, pt-BR, fr, de, it, ru, ja, ko, zh-CN, ar), the visitor’s own browser first. Free. Requires project.read.
publish_install_instructions0 of 2 parameters describedPublish (or update) the project’s install instructions at a stable public URL (dojo.extenshi.io/instructions/<code>, or https://<custom domain>/instructions). Without `input` the form saved in the cabinet is published (a saved form that does not validate is refused with INSTRUCTIONS_INVALID and its field errors). Store URLs are the https listing links on chromewebstore.google.com, addons.mozilla.org and microsoftedge.microsoft.com; browsers without one are hidden unless none is set. The install steps are translated by Extenshi; `features` are translated with set_page_translations (surface instructions). Returns {publicCode, url, followUps}; followUps names the languages whose features translation is missing or outdated. Free. Requires hosted.write.
unpublish_install_instructions0 of 1 parameter describedTake the hosted install instructions offline. The code and URL are kept, so publishing again restores the same URL. Requires hosted.write.
get_page_translations0 of 1 parameter describedThe developer-written text on the project's hosted uninstall forms, feedback forms, welcome pages and install instructions (the features list), for translation: per page {surface, publicCode, name, defaultLocale, locales, fields [{path, source, label, max, multiline}], status per language [{locale, translated, missing, outdated}], translations}. Languages are the project’s (manifest translations + the targetLocales decision); the install instructions page offers every language its steps come in. Built-in text (buttons, reasons, footers) is translated by Extenshi into en, es, pt-BR, fr, de, it, ru, ja, ko, zh-CN and ar and is not listed. A page is shown in the user’s browser language when the project offers it, otherwise in defaultLocale; an untranslated or outdated field shows its original. Uninstall survey and feedback form text itself is changed with update_uninstall_form / update_feedback_form. Requires project.read.
set_page_translations3 of 6 parameters describedSave one language of one uninstall form, feedback form, welcome page or install instructions page: `translations` maps field paths (from get_page_translations) to translated text; the server records which original each translates, so a later edit of the original marks it outdated. An empty string removes a translation. Unknown paths, over-long text and the default language are refused (TRANSLATIONS_INVALID). Placeholders and product names are kept as written. Returns the page’s updated translation status. Requires hosted.write.
get_legal_translations1 of 2 parameters describedTranslated copies of the project's published privacy policy or license terms. The English version is the binding text and stays at the base URL; each translation lives at <url>/<locale>, says it is a translation for convenience and links to the English original. Extenshi translates its own template text (en, es, pt-BR, fr, de, it, ru, ja, ko, zh-CN, ar); what you translate is listed in fields: `section:<id>` for a section the author edited or added (translate the whole section, heading line included) and `answer:<field>` for free-text answers inside template sentences (e.g. a retention period). A section without a current translation is shown in English. Returns {defaultLocale: "en", locales, fields, status per language, translations, urls}. Languages are the project’s (manifest translations + targetLocales). Requires a published document; privacy_policy needs project.read, license_terms pay.read.
set_legal_translations3 of 5 parameters describedSave one language of the privacy policy or license terms translation: `translations` maps field paths from get_legal_translations to text. A `section:<id>` text is accepted as exactly one section: its "## " heading line first ("# " for `section:lead`) and no other heading. The server records which English text each translates, so a later edit marks it outdated; an empty string removes one. Only the project’s languages are accepted (TRANSLATIONS_INVALID otherwise). Nothing changes in the English original. privacy_policy needs hosted.write and a Pro project; license_terms needs pay.write. With this connection’s API key a save goes live at once on the translated page, without the owner’s approval; only the hosted connector (OAuth) stores it as a proposal.
get_license_terms_questionnaire0 of 1 parameter describedThe questions of the project's "License terms & refunds" questionnaire as data: field, question, type, choices, length and number limits, and when each answer is required before the owner can publish. Questions only: it returns no saved answers, seller or Pay state, so project read access is enough (no pay.read). Pair it with draft_license_terms. FREE.
draft_license_terms1 of 2 parameters describedGenerate the license terms & refunds text from answers supplied in the call, without saving anything: the markdown the owner would publish, the unanswered questions that block publishing, and the normalized answers. An empty extensionName takes the project name. Saved answers, the seller and Pay offers are not read (they need pay.read), so plan types the seller sells are not cross-checked here; Dojo checks them when the owner saves and publishes. FREE.
get_license_terms1 of 1 parameter describedThe saved license terms & refunds of a Pay application: status (none, draft, published, outdated), the draft answers and text with its draftHash, the published version {versionNumber, url, versionUrl, contentHash, effectiveDate}, every version, missingRequired (unanswered fields that block publishing), ownerInputRequired (seller identity fields only the owner fills in Dojo) and problems. Requires pay.read. FREE.
save_license_terms_draft3 of 5 parameters describedSave answers to the license terms questionnaire as the draft (field names from get_license_terms_questionnaire). The seller identity answers (sellerLegalName, sellerCountry, sellerAddress, sellerRegistration) stay as the owner saved them: send them empty or unchanged; a different value is refused (OWNER_INPUT_ONLY), and empty ones are listed in ownerInputRequired. A draft the owner edited by hand in Dojo is refused (DRAFT_HAND_EDITED). dryRun: true returns the preview without saving. expectedDraftHash refuses the save when the draft changed since you read it (DRAFT_CHANGED); saving the same answers again is a no-op (unchanged: true). Returns {draftHash, preview {markdown, html}, missingRequired, ownerInputRequired, problems, publishable}. Nothing is published. Requires pay.write.
request_license_terms_publication2 of 3 parameters describedAsk the owner to publish the draft with this draftHash. Returns {status: pending_approval, approvalId, approvalUrl, expiresAt}: nothing is published until the owner approves it in Dojo, where they see the text against the live version; get_approval returns the outcome (result {versionNumber, url, sellerTermsDecided}). With alsoDecideSellerTerms (default true) the owner's approval also decides seller.terms as the published URL. Refused straight away when the draft changed or has open questions. `followUps` names the sections and answers this version would leave untranslated in the project languages (set_legal_translations, after approval). Requires pay.write.
publish_license_terms2 of 2 parameters describedPublish the draft with this draftHash as a new version of the public license terms page, without an approval step. Needs an API key with the separate pay.legal.publish permission (granted at dojo.extenshi.io/api-keys); otherwise PAY_LEGAL_PUBLISH_REQUIRED, and request_license_terms_publication asks the owner instead. Returns {versionNumber, url, versionUrl, contentHash, sellerTerms, followUps}; seller.terms is proposed as the URL for the owner to decide; followUps names what to translate next with set_legal_translations. Changes the page buyers read before they pay. Requires pay.write and pay.legal.publish.
verify_license_terms_live1 of 1 parameter describedCheck that the published license terms are what buyers get: {ok, url, versionNumber, checks [{id, ok, detail}]} for published, content_hash (stored text matches its hash), page_reachable, page_serves_version (the public page shows this version), paywall_links (the paywall links "License terms" and "Refund policy" to it) and seller_terms_decision (seller.terms is decided as this URL). A failed check is a result, not an error. Requires project.read. FREE.
rollback_license_terms2 of 4 parameters describedBring back an earlier version of the license terms: its text becomes the draft, then it is published as a new version (history stays). mode request (default) asks the owner exactly like request_license_terms_publication and returns pending_approval; mode publish publishes directly and needs an API key with pay.legal.publish. Returns {restored {draftHash, restoredFrom}, publication}. Requires pay.write.
list_uninstall_forms0 of 1 parameter describedThe project's hosted uninstall surveys: {id, name, publicCode, url, enabled, primary, responseCount, createdAt, updatedAt}. `primary` is the one generated setUninstallURL code points at; a survey keeps its URL for life. Requires project.read. FREE.
get_uninstall_form1 of 2 parameters describedOne uninstall survey in full: every setting, the per-reason outcomes and follow-up questions, its URL, `updatedAt` (pass it back as expectedUpdatedAt to update_uninstall_form), the page heading and where it comes from (`headline`, or `default` built from `title`, which is the store listing name or the project name), and translation status per project language {translated, missing, outdated}. Requires project.read. FREE.
update_uninstall_form4 of 8 parameters describedChange an uninstall survey. `patch` is partial: absent fields keep their value, null clears an optional text, list fields replace the whole list. The merged survey passes the same validation as the Dojo editor (lengths, http(s) links, outcomes and questions only for reasons the survey offers). dryRun: true returns {changes [{field, before, after}], staleTranslations [{locale, paths}], warnings} and writes nothing. A write needs expectedUpdatedAt (from get_uninstall_form) and an idempotencyKey (UUID): a survey saved since you read it is refused (CONFLICT FORM_CHANGED); a retry with the same key returns the first result (replayed: true). Translations whose original changed are kept and listed as stale: re-translate them with set_page_translations; `followUps` (also on a dry run) names that tool with the count of missing and outdated fields per language. Turning askContact on needs confirmPrivacyChange: true, since the privacy policy then has to cover email collection. The public URL and the collected responses stay as they are. The change is listed for the owner in Dojo with proposedBy. Requires hosted.write.
get_uninstall_offer1 of 2 parameters describedThe discounted offer of one uninstall survey: after an answer whose reason is in the offer's list, the survey shows the project plans at a discount and takes the payment on the page; the buyer then installs the extension again and restores the purchase by email. Returns `offer` {status, reasons, items [{sku, percentOff}], discountDuration, claimTtlHours, maxRedemptions, revision} (revision 0 = none yet; pass it back as expectedRevision), `blockers` (what still stops buyers from seeing it: not_premium, form_disabled, no_pay_application, seller_not_ready, recovery_unavailable, no_reasons, no_plans, not_active; no_install_page only removes the install link after payment), `plans` (the active Pay offers a discount may be set on) and `stats` {shown, checkoutStarted, redeemed}. Requires project.read. FREE.
update_uninstall_offer4 of 10 parameters describedSet the discounted offer of an uninstall survey. Send the WHOLE offer every time. `reasons` are the answers that show it, from one to all of the survey’s reasons: a reason key, `custom:<label>` or `other` (read them with get_uninstall_form). `items` give a whole percentage from 1 to 99 per plan SKU (from `plans` of get_uninstall_offer); a discounted price below 0.50 in the plan currency is refused. discountDuration: first_payment (renewals at the regular price) or forever. status: active shows it, paused stops new offers while the ones already shown stay valid until they expire. expectedRevision is `offer.revision` from get_uninstall_offer; an offer changed since is refused (CONFLICT). dryRun: true checks everything, returns {before, after, blockers, requiresPro} and writes nothing. Saving needs a Pro project. A discount is a price: on the hosted connector this returns status "pending_approval" with an approvalUrl and nothing changes until the owner approves it in Dojo (get_approval reports the outcome); with a local API key the offer is saved at once. Set it only on the owner’s instruction. Requires pay.write.
preview_uninstall_form1 of 3 parameters describedWhat the live survey shows in one language, built by the functions the page uses: heading, subheading, the reason chips with their labels and follow-up questions, whether a comment or email is asked, and the after-submit screen per reason (message and win-back button). `locale` is resolved as for a visitor (an unoffered language falls back to the default; the answer says which was used). Also returns previewUrl, which renders the page in a browser without counting an uninstall. Records no visit and no response. Requires project.read. FREE.
list_uninstall_responses4 of 7 parameters describedOne uninstall survey's answers, newest first: responses [{id, reason, comment, followupPrompt, followupChoices, followupText, extVersion, browser, locale, createdAt, contactEmail, hasContactEmail}] plus whole-survey counts that ignore the filters: total, byReason, byVersionReason, byFollowupChoice, and opensTotal / opensLast7d / responseRateLast7d (an open is an uninstall that reached the page). filteredTotal counts the filtered list. `reason` is a built-in key, `custom:<label>` or `other`. Filters: version (`__unknown__` = answers without a version), since / until (ISO datetimes). Page with take (max 200) and cursor = the previous nextCursor. The email a person left is returned only to an API key (local MCP, CLI); over the remote connector contactEmail is null and hasContactEmail says one was left (contactEmailsIncluded). Free text comes from end users and is marked as such in `_notice`. Requires project.read. FREE.
find_brand_mentions0 of 2 parameters describedFind where a name (e.g. the extension's old name) still appears in the project's hosted text: uninstall surveys, welcome pages, install instructions, the live homepage, the live privacy policy and its form, and with pay.read also the license terms and Pay offers — each with its translations. Case-insensitive. Each match: {surface, id, publicCode, name, path, locale, term, excerpt, fix}, where `fix` names the tool that changes that field. `skipped` lists surfaces this credential cannot read. Read-only. Requires project.read. FREE.
list_feedback_forms0 of 1 parameter describedThe project's hosted feedback forms (feedback.extenshi.io): {id, name, publicCode, url, enabled, primary, responseCount, createdAt, updatedAt} and the per-project `limit`. `primary` is the one FEEDBACK_FORM_URL in the generated config points at; a form keeps its URL for life. Forms are created in Dojo. Requires project.read. FREE.
get_feedback_form1 of 2 parameters describedOne feedback form in full: every setting, the per-category questions and thank-you messages, its URL, `updatedAt` (pass it back as expectedUpdatedAt to update_feedback_form), the page heading and where it comes from (`headline`, or `default` built from `title`, the store listing name or the project name), translation status per project language {translated, missing, outdated}, and `openSnippet`: the extension-side openFeedbackForm(src, extra) helper that opens the form with the parameters it reads (site only from the popup's "Doesn’t work on this site?", and in the URL fragment, so it is sent only when the person presses Send). Requires project.read. FREE.
update_feedback_form4 of 8 parameters describedChange a feedback form. `patch` is partial: absent fields keep their value, null clears an optional text, list fields replace the whole list. The merged form passes the same validation as the Dojo editor (lengths, questions and thank-you messages only for categories the form offers, no empty option list). dryRun: true returns {changes [{field, before, after}], staleTranslations [{locale, paths}], warnings} and writes nothing. A write needs expectedUpdatedAt (from get_feedback_form) and an idempotencyKey (UUID): a form saved since you read it is refused (CONFLICT FORM_CHANGED); a retry with the same key returns the first result (replayed: true). Translations whose original changed are kept and listed as stale; `followUps` (also on a dry run) names set_page_translations with the count of missing and outdated fields per language. Turning askContact on needs confirmPrivacyChange: true, since the privacy policy then has to cover email collection. The public URL and the collected answers stay as they are. The change is listed for the owner in Dojo with proposedBy. Requires hosted.write.
preview_feedback_form1 of 3 parameters describedWhat the live feedback form shows in one language, built by the functions the page uses: heading, subheading, the categories with their labels and follow-up questions, whether the email and website fields are offered, and the thank-you screen per category. `locale` is resolved as for a visitor (an unoffered language falls back to the default; the answer says which was used). Also returns previewUrl, which renders the page in a browser and sends nothing. Records no answer. Requires project.read. FREE.
list_feedback_responses5 of 9 parameters describedOne feedback form's answers, newest first: responses [{id, category, comment, site, followupPrompt, followupChoices, followupText, extVersion, source, browser, locale, createdAt, contactEmail, hasContactEmail}] plus whole-form counts that ignore the filters: total, byCategory, bySource, byVersionCategory, byFollowupChoice; filteredTotal counts the filtered list. `category` is a built-in key, `custom:<label>` or `other`; `source` is where the extension opened the form (popup, options, trial_end, nudge, or null); `site` is the website exactly as the person sent it. Filters: category, source (`__unknown__` = none), version (`__unknown__` = untagged), since / until (ISO datetimes). Page with take (max 200) and cursor = the previous nextCursor. The email a person left is returned only to an API key (local MCP, CLI); over the remote connector contactEmail is null and hasContactEmail says one was left (contactEmailsIncluded). Free text comes from end users and is marked as such in `_notice`. Requires project.read. FREE.
upload_project_media3 of 4 parameters describedUpload a logo or screenshot (PNG, JPEG or WebP, up to 2 MB) to the project's PUBLIC media store — the same store the Dojo Page generator uploads into — and get a stable https URL that publish_landing_page accepts as screenshots[].url or logoUrl. The server checks the file by content (magic bytes), strips EXIF/XMP/text metadata and anything after the image end marker, bounds the dimensions (16–4096 px) and enforces a per-project quota (100 files / 50 MB, Dojo uploads included); identical bytes return the same URL without using quota. SVG is refused: rasterize it first (CLI: extenshi icon store-assets) or pass an inline logo as logoSvg. Pass filePath (a file inside the workspace) or dataBase64 + mime. Store screenshots come from the CLI: extenshi screenshots. Returns JSON {url, sha256, mime, bytes, width, height, strippedBytes, deduplicated, quota}. Requires hosted.write. CLI: extenshi media upload <file> --project <id>. API reference: https://docs.extenshi.io/developers/project-sync#hosted-pages-from-the-api
list_hosted_pages0 of 1 parameter describedList the project registered hosted pages (homepage/support) with their verification status, content hash and last check time.
record_project_evidence1 of 12 parameters describedRecord test/scan/listing/privacy/payment evidence metadata bound to a browser, artifact hash and input hash. Source is local or agent; CI evidence is written only by the verified ingest endpoint. Attachment files upload via the CLI (extenshi evidence push --attach); this tool records metadata only. Requires evidence.write OAuth scope. `provenance` is required: {source: "agent", observedAt: ISO-8601 timestamp, toolVersion: your client name and version}.
search_extensions23 of 23 parameters describedSearch the cross-store extension catalog (Chrome, Firefox, Edge). A free-text query matches the listing name and description, and also the features extracted for the extension (what it does). A result that matched through a feature lists it in `matchedFeatures`. Features are extracted for part of the catalog, so a result without `matchedFeatures` may still have the function. All filters (rating/reviews thresholds, store, category, pricing, risk, permissions, freshness, manifest version, trader status) are applied server-side by the catalog database, so a filtered request returns only the matching subset. `skip` pages through large result sets. Store-specific constraints (validated client-side, before any request): `minWeeklyDownloads` only applies to FIREFOX; combining it with a `stores` filter that excludes those stores is rejected. Returns a compact list for market research and competitive analysis.
get_extension3 of 3 parameters describedGet full catalog detail for one extension: metadata, per-store ratings, install counts, categories, and a security badge. Identify it by numeric catalog `extension_id` OR by its `store_id` (the id in the store URL; add `store` for a Chrome/Edge id).
get_reviews8 of 8 parameters describedGet store user reviews for one extension from Firefox Add-ons and Edge Add-ons: star rating, a short review excerpt, date and language, plus a store-level `aggregate` (rating, count, reviews link). Chrome Web Store review rows are NOT returned (their text cannot be redistributed) — for a Chrome extension the `aggregate` (with a link to the store reviews tab) is the only public review content. Reviewer identity is intentionally omitted. Paginated newest-first by default (or by highest rating); `cursor` takes the `nextCursor` from a previous call. Cursors are sort-specific: a cursor is valid only with the `sort` it was issued for. Reads existing scraped reviews; `min_rating` narrows to positive or critical feedback.
get_security3 of 3 parameters describedGet the security analysis for an extension: safety score (0–100, higher = safer — the same coefficient the website shows), risk category, finding counts by severity, and the top grouped findings (scanner, rule, severity, count). Also returns an approximate install-dialog preview computed from the store-listed permissions (consolidated + deduped), available even for unscanned extensions. Reads existing scan results — does not trigger a new scan. Identify the extension by numeric `extension_id` OR `store_id` (+`store` for Chrome/Edge). NB: this tool costs 3 read credits (it fetches security, risk, and install-preview data).
get_risk_by_store_ids1 of 1 parameter describedLook up the safety score and risk category for MANY extensions at once, addressed by their STORE ids (the id in the store URL) — the inventory case: you have a list of what a user has installed and need risk for all of it. Up to 40 extensions per call, and the WHOLE call costs 1 read credit (not 1 per extension; get_security costs 3 credits per extension). Returns safety score (0–100, higher = safer, the same number the website shows), risk category, severity counts, last scan date and the catalog URL per extension. Each store id is resolved through its cross-store cluster to the same listing the extension page renders, so these answers agree with the website. `store` is REQUIRED per entry — Chrome and Edge ids share one format. An extension with no score has not been scanned yet (`scanned: false`); ids with no catalog listing come back under `notInCatalog`. Neither means "safe". The full findings list of ONE extension comes from get_security.
market_overview3 of 5 parameters describedAggregate catalog market intelligence. Called with NO arguments it returns a full CATALOG-WIDE overview: totals, store split, the category tree, and the extended facet breakdown — Manifest V2/V3 adoption, sensitive-permission histogram, security risk-tier distribution, trader status, update-recency, and review-count buckets. Pass a `query` (and/or store/category filters) to scope those facets to a search result set instead.
get_credit_balanceno parametersReport your remaining Extenshi credits — for checking whether a large request fits the balance before running it. Returns every credit pool of the signed-in Extenshi account: `read` (spent one-per-call by search_extensions / get_extension / get_reviews / market_overview / get_risk_by_store_ids — the last one covers up to 40 extensions for that single credit; get_security costs 3) and `scan` (spent by scan_extension), plus `icon` and `inventory`. Each pool reports `remaining` — the number that actually gates calls (one-time free grant + purchased credits) — and `freeRemaining` (how much of the one-time, non-renewing signup grant is left). FREE to call: checking the balance spends no credit. Fetching N extensions takes read.remaining ≥ N (≥ 3N with get_security on each).
get_approval1 of 1 parameter describedReport where a proposed change stands (any pending_approval response: the hosted connector’s proposals, and request_license_terms_publication on any connection): pending (waiting for the owner in Dojo), applying, applied, rejected, failed, expired or superseded, with a one-line summary and, once applied, the outcome. Takes the approvalId from a pending_approval response. Approving happens only in Dojo, by the owner; this tool only reads. FREE — spends no credit.
list_my_projectsno parametersList the extension projects owned by the signed-in Extenshi account — the developer's own workspaces on extenshi.io. Returns id, name, status, target browsers, the bound GitHub repo (if any) and the claimed store listing (if any). Applies when the developer refers to "my extension" or "my project": the returned id is what get_project_state takes. `storeListings` is where each project is listed per store (planned / submitted / live — set_store_listing records it). FREE — reading your own projects spends no credit.
get_project_state4 of 4 parameters describedRead one of the developer's own projects as state you can build from: the extension TYPES they picked (popup / side panel / page enhancer / in-page assistant), the required permissions those types force, the exact manifest.json the project produces for each target browser, the files that type needs, live hosted URLs (uninstall survey), and an index of every saved tool state with its size. It reflects the site configuration at the time of the call; later changes on the site appear in a later read. The additive workspace envelope holds revisioned local observations separately from these scaffold drafts; its `document.storeListings` is where the project is listed per store (status planned / submitted / live, url, itemId, Edge productId; set_store_listing records it). It also returns the integration contract: `integration.file` is the exact content for `integration.path` that wires the extension to this project. Those bytes carry a fingerprint extenshi.io uses to tell the developer's edits from its own; a reassembled equivalent file lacks it, and the site then stops managing the values in it. `integration.unwired` lists the links this project has not set up yet (no URLs exist for them). Tool-state payloads are NOT inlined by default (a single row can be 256 KiB); includeToolStates selects which keys to inline. Manifests come as summaries by default (version, top-level keys, size, digest, origin imported/generated, and which keys of each drafted manifest differ from the imported source/built one); pass manifests "full" for the bodies, or get_project_scaffold for one browser's manifest file. `staleNames` is null until the project is renamed; after a rename it lists the earlier names (`earlierNames`), every hosted field that still holds one (`mentions`, at most 20, each with the tool that fixes it; `total`, `truncated`) and a `warning` sentence — find_brand_mentions with those names returns them all. License terms and Pay offers are searched only with pay.read (otherwise listed in `skipped`). `localization` is every server-side translation the project still lacks: {defaultLocale, locales, complete, missing, outdated, next, surfaces [{kind (pay_offers | license_terms | privacy_policy | hosted_page | landing_page), name, missing, outdated, locales [{locale, total, missing, outdated}], fixWith {read, write, args}}]}; `next` is one sentence naming the largest gap and its tools. Pay surfaces need pay.read (otherwise `skipped`); the extension's own _locales files are not part of it (localize_workflow covers those). FREE — spends no credit. Type definitions are in list_extension_templates. On this local server the answer also carries `buildMap` {running, url (while running), offered, declined, offers, home} for projectDir: the author’s build map (npx @extenshi/cli map), one per project for every agent and git worktree; absent when the directory cannot be read.
get_project_scaffold2 of 2 parameters describedThe starter extension one of the developer's own projects produces, as FILES ready to write: manifest.json for the target browser, the background worker, the panel or content-script files that project's types need, placeholder icons, and src/extenshi.config.js. The config carries a fingerprint that lets extenshi.io recognise the repository as this project's; a hand-rebuilt config lacks it, and the site then stops managing those values. Intended for a NEW extension: it is a complete starter set whose files would replace same-named files in an existing repository. It is the same file set the site commits. One browser per call (default: the project's first target). FREE — spends no credit.
list_privacy_policy_versions1 of 1 parameter describedList hosted privacy-policy versions for one of the developer's Pro projects: version number, kind (generated / edited / ai_updated / reverted), and which one is live. The public URL is in get_project_state hostedArtifacts.privacyPolicy. Pro only — a free project returns PROJECT_PREMIUM_REQUIRED. Does not spend a credit.
get_privacy_policy_version2 of 2 parameters describedRead the markdown (and HTML) of one hosted privacy-policy version; version numbers come from list_privacy_policy_versions. Pro only. Does not spend a credit.
publish_privacy_policy3 of 3 parameters describedPublish a hosted privacy policy for a Pro project. Changes the live public policy page. Without bodyMarkdown it generates the policy from the saved form and manifest (the first version is produced this way); with bodyMarkdown it publishes that edited (or AI-updated) draft at the same public URL. Once published, PRIVACY_POLICY_URL in the integration.file from get_project_state is the hosted URL. Pro only. With this connection’s API key the new version goes live at once, without the owner’s approval; only the hosted connector (OAuth) stores it as a proposal. The CLI command `extenshi privacy publish <file.md>` sends a file’s exact bytes and checks the stored text against it. `followUps` [{tool, readFirst, args, reason}] names the translations the new version leaves missing or outdated (set_legal_translations).
update_privacy_policy_with_ai1 of 1 parameter describedPropose an updated privacy policy that keeps the author's custom wording and adds sections required by new permissions or data practices. Returns proposedMarkdown only; nothing goes live. aiStep states whether the AI step ran (ran | did_not_run | discarded | not_needed) and notice says why; unless aiStep is ran, proposedMarkdown is a deterministic section merge, not an AI draft. conflictHeadings and missingCategories list what still needs a manual edit. Publishing is a separate step (publish_privacy_policy with the returned kind). Requires a policy that is already published. Pro only.
get_development_guide1 of 1 parameter describedFor extension-development tasks: returns the complete tool inventory for THIS connection, the Extenshi service directory with access requirements and docs links, GitHub/code placement guidance, and the ordered workflow from idea and repository through implementation, assets, privacy, tests/CI, store submission and maintenance, plus store media: the scenes.json format for CLI screenshots (per-locale store screenshots) and listing artwork sizes per store. Distinguishes MCP tools from cabinet, CLI and external steps. Free; no key, account lookup or network request.
search_docs3 of 3 parameters describedSearch the official Extenshi documentation (docs.extenshi.io) — product guides plus the full @extenshi/cli command reference (scan, review-risk, publish, login). Applies to "how do I…" questions and to exact CLI commands and flags. Free: reads public docs, no API key or quota required. Without a query it lists every available documentation page.
localize_workflowno parametersGet the FREE local browser-extension localization workflow: prepare missing or stale _locales messages, translate with your own coding agent, apply validated translations and check placeholders, protected terms and listing risks. Returns commands and the JSON handoff contract. Static guidance only: no API key, network or Extenshi credits; translation uses your agent provider. Includes release availability and human review gates. Covers only the local _locales files: text stored on Extenshi (Pay offers, license terms, privacy policy, hosted pages, landing page) is listed in get_project_state `localization`.
generate_icon_workflow1 of 1 parameter describedGet the recommended FREE local workflow for creating a browser-extension icon: the agent draws the SVG itself, then `@extenshi/cli icon preview` renders an offline verification page (Chrome/Firefox/Edge toolbar mockups, palette switcher with contrast warnings, store-size matrix, PNG/ZIP export). Returns the icon design requirements (sizes, 16px legibility rules, light/dark survival) and exact commands. Static content: no API key, no network, no credits.
generate_welcome_page_workflow7 of 7 parameters describedGet the design brief for a browser-extension welcome page — the page a user lands on right after installing. Returns the one action the page is built to drive (pin the extension, keep the new-tab change, use it on a site), exactly which illustrations to produce for that goal, how to capture and crop them, how to place numbered/arrow markers showing where to click, the limits enforced on save, and the block JSON format. Store screenshots Extenshi already hosts (from get_extension) can serve as illustrations. Static content: no API key, no network, no credits.
generate_pin_guide8 of 8 parameters describedGet the illustrated "pin the extension to the toolbar" steps for Chrome, Edge and Firefox as an offline kit for a welcome page bundled INSIDE the extension: SVGs with the extension icon and numbered markers drawn in, an HTML fragment that passes the extension CSP, captions in 11 languages as chrome.i18n messages, and an ES module that picks the user's browser and reads whether the icon is already pinned (action.getUserSettings().isOnToolbar). The default `part` is a short overview with sizes; `html`, `messages`, `script` and `css` return the parts, narrowed by `browsers` / `locales`. `npx @extenshi/cli pin-guide` writes the same kit to disk. Static content: no API key, no network, no credits.
generate_landing_page24 of 24 parameters describedGenerate a static landing page (homepage) for a browser extension as one self-contained HTML file: no JavaScript, escaped text, http(s)-only links (the support link may also be a mailto: address), and store buttons only for the store URLs given. Same generator as the cabinet Page generator, so a saved `page-generator` form from get_project_state maps field for field. Optional logo (inline SVG, validated and embedded as an image, or an image URL), screenshots and the canonical homepage URL for Open Graph and JSON-LD. Returns JSON {html, bytes, warnings, nextSteps}: warnings list input that was dropped or clamped; nextSteps cover hosting the file on HTTPS and registering the URL with upsert_hosted_page, which feeds HOMEPAGE_URL. Extenshi does not host the page. With schemaVersion 2 the page is built from sections, theme tokens, SEO and locales (see the field descriptions); the result adds problems [{path, severity, message, fix}] and localePages. Static content: no API key, no network, no credits.
list_extension_templates1 of 1 parameter describedThe kinds of browser extension you can build, with the permissions each one REQUIRES: Popup (toolbar window), Side panel (docked beside the page), Page enhancer (runs on sites you list), In-page assistant (your own UI over any site). Types combine, and the required permissions are the union. Applies when choosing manifest permissions: it gives the minimum each shape needs (store review flags padded permissions). Also states the cross-browser rules (Chromium side_panel vs Firefox sidebar_action) and the rule that a manifest may not name a file the package lacks. FREE: no API key, no quota. A specific project's chosen types are in get_project_state.
scan_extension4 of 4 parameters describedRun a pre-publish security scan on a local extension artifact (.zip/.crx/.xpi) and return the report. Uses one scan from your one-time free allowance (3 scans) or a purchased scan credit once that runs out. Streams live per-scanner progress.
get_build_map1 of 1 parameter describedThe author’s build map of the extension project in projectDir (npx @extenshi/cli map): progress, the steps waiting on the author (needsYou), the steps that can start now (next, safe to run in parallel), who works on what, every step with the task it is on, and the variants offered to the author with their answer (reviews: waiting, picked, or redo with what to change). skills lists the published agent skills with the instructions for the steps not done yet (steps: step id → skill names; index: name → what it teaches and the url of its SKILL.md): load a step’s skills before working on it. One map per project, shared by every agent and git worktree. While the author’s map runs, the answer carries the project facts and the release the map runs (map); update, when present, says what to do because the map draws older or newer steps than this server knows, or a newer release is out. Otherwise facts is false and steps proven only by project files look not done. Free; local files only.
show_build_map2 of 2 parameters describedShow the author the build map in the conversation (clients that show MCP Apps, such as Claude, draw it inline; elsewhere the answer has the link to the author’s map). Pass `step` to open one step, such as the variants waiting on the author after request_build_review: the author picks one, asks for another round, marks their own tasks or skips a step right there, and get_build_map reads the answer. Call it when the author should look or choose; to read the map yourself use get_build_map, which draws nothing. Free; local files only.
report_build_step12 of 13 parameters describedReport on a build map step as an agent. state: start (you are on it; the answer names the step’s skills, the published instructions to load before the work), progress (with progress 0–1), done (closes the current task, or `task`; `files` are hashed into the evidence journal as proof) or stop. A step whose inputs are not done is refused while the author’s map runs. The author’s choice between variants is not closed by `done`: pass `choice` (the variant id the author picked in the chat) or `redo` (what to change, in the author’s words) to record the author’s answer. Never record a choice the author did not make. Free; writes .extenshi/build-map.json in the project.
request_build_review3 of 4 parameters describedOffer the author variants to choose from on the build map: icon concepts (iconConcepts), screenshots (screenshots) or listing copy (listing). Each variant is a preview page or image inside the project (an `npx @extenshi/cli icon preview` page fits icons) or an https address; `image` adds a thumbnail. The step waits on the author until they pick one or ask for another round. Returns the link to the step while the map runs: give it to the author, then read the answer with get_build_map. Free; local files only.
publish_extension14 of 14 parameters describedPublish an extension artifact (.zip/.crx/.xpi) to Chrome Web Store, Firefox AMO, and/or Edge Add-ons: uploads and submits a new version to each selected store. FREE and fully local: the upload goes from this machine straight to the store APIs using store credentials from the MCP server environment (CHROME_APP_ID/CHROME_PUBLISHER_ID/CHROME_SERVICE_ACCOUNT_KEY, FIREFOX_ADDON_GUID/FIREFOX_JWT_ISSUER/FIREFOX_JWT_SECRET, EDGE_PRODUCT_ID/EDGE_CLIENT_ID/EDGE_API_KEY). Chrome uses the author's own service account (Chrome Web Store API V2), which updates existing items only. The upload itself is local, but publishing is in an active testing phase: a quick Extenshi access check runs first (it identifies your account by EXTENSHI_API_KEY). Edge submissions are polled to a terminal status. For Firefox, listing_path turns the upload into a listed AMO submission with metadata: first-time add-on creation (gated by allow_new_addon or the project decision), per-locale name/summary/description, categories, license, homepage, support email and URL, privacy policy, release and reviewer notes, reviewer source (source_path) and previews (screenshots_dir); the result lists each step. source_path without listing_path updates an existing AMO add-on: the version is created with release_notes and reviewer_notes, the source archive is uploaded to it, and the listing stays as it is. The artifact is not security-scanned by this tool (scanning is scan_extension).
build_map_view0 of 2 parameters describedThe build map page reads its snapshot. Called by the page only.
build_map_answer0 of 3 parameters describedThe author answers on the build map page: marks a task, does a step themselves or skips it, picks a variant or asks for another round. Called by the page only, when the author clicks.
build_map_file0 of 5 parameters describedThe build map page loads a variant thumbnail. Called by the page only.
Tested in a sandbox with an empty environment: no API keys, a throwaway folder, nothing from a real account. A passing test shows the server runs and responds. It is not a security audit.