@extension.dev/mcp 6.4.0 → 6.6.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "extension-mcp",
       "source": "./",
       "description": "MCP tools for browser extension development: scaffold from 60+ templates, run the dev server with HMR, inspect the live DOM and logs, and publish store-ready builds for Chrome, Edge, and Firefox.",
-      "version": "6.4.0",
+      "version": "6.6.0",
       "category": "development",
       "author": {
         "name": "Cezar Augusto"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "extension-mcp",
   "description": "MCP tools for browser extension development: scaffold from 60+ templates, run the dev server with HMR, inspect the live DOM and logs, and publish store-ready builds for Chrome, Edge, and Firefox. Ships /extension, /extension-add, /extension-debug, and /extension-publish commands.",
-  "version": "6.4.0",
+  "version": "6.6.0",
   "author": {
     "name": "Cezar Augusto",
     "email": "hello@extension.dev",

package/CHANGELOG.md

@@ -1,5 +1,101 @@
 # Changelog
 
+## 6.6.0
+
+A shared build belongs to the project that owns it, not to whoever happened to
+press publish. `extension_shares` now says which of the two it is looking at,
+and it names the publisher without ever inventing one.
+
+### Added
+
+- **Every listed share carries its owner and its publisher.** The platform now
+  returns `owner` and `sharedBy` on each row and both come through untouched,
+  alongside an `attribution` block that reads them. `attribution.ownership` is
+  `"project"` when the owning workspace holds the share, `"personal"` when one
+  person holds it alone, and `"unknown"` when the platform disclosed no owner.
+  `attribution.ownerPath` gives the owning `workspace/project` for a project
+  share. Ownership is read off `owner` and never off the publisher, because the
+  owner is what decides who may revoke a share and the publisher is only who
+  made it.
+- **`attribution.revocableBy` says who can actually pull the link back.** A
+  project share is revocable by any member of the owning workspace and by any
+  token scoped to the owning project. A personal share belongs to one person,
+  so nobody else can see it or revoke it and a project token cannot touch it.
+  Knowing which of the two you are holding is the difference between a revoke
+  that will work and a 404 that reads like a bug.
+- **`server.ownership` counts the listed shares by owner.** Project, personal
+  and unknown, so a list can be reasoned about without walking every row.
+
+### Changed
+
+- **A publisher is never guessed.** `attribution.credit` is the GitHub login
+  when the platform resolved one. When a share was made by a CLI token whose
+  issuer could not be resolved it reads `CLI token <id>`, which is exactly what
+  the credential itself proves, and a share made before attribution existed
+  reads as not recorded. The workspace slug, the project slug and the owner are
+  never substituted for a name, because naming a team where a human is expected
+  attributes the share to whoever the reader takes that team to be.
+  `attribution.creditSource` says which of the three it was.
+- **Attribution is stated as attribution.** The response spells out that
+  `sharedBy` records who published a share and grants and restricts nothing, so
+  it is not read as a permission.
+- **A truncated list is more explicit about why.** `truncated` also goes true
+  when the platform spends its budget working out which shares the caller is
+  entitled to see, so the note now says `matched` is a floor rather than a
+  total.
+- **Revoking a share the token does not own explains the personal case.** The
+  404 message already covered a different project and an already dead link; it
+  now also names a teammate's personal share, which no project token can
+  revoke.
+
+## 6.5.0
+
+A link you shared is no longer only as findable as the response that created
+it. The shares you have made are now listable, and revocable, from the tool
+that made them.
+
+### Added
+
+- **`extension_shares` lists and revokes the links you have shared.**
+  `share:true` hands back a public link, an `expiresAt` and a `revokeUrl`, and
+  until now the only copy of that `revokeUrl` was the tool response and the
+  project's own `.extension.dev/shared-previews.json`. Neither could say what
+  was actually still live, and neither existed at all for a link shared from
+  another machine. `action:"list"` (the default) asks the platform for every
+  artifact the logged-in project owns and returns each one's `artifactId`,
+  name, version, live or dead state, `createdAt`, `expiresAt`, `revokedAt`,
+  size, and its `previewUrl`, `zipUrl` and `revokeUrl`. `previewUrl` and
+  `zipUrl` come back null for anything no longer live, because a revoked or
+  expired address resolves for nobody and echoing it back would invite passing
+  on a dead link; `revokeUrl` stays on every row.
+- **`action:"revoke"` kills a link from where it was made.** It takes an
+  `artifactId` or, just as well, any URL of the share (`previewUrl`, `zipUrl`,
+  `viewUrl`, or `revokeUrl`), so the link you sent someone is enough to pull it
+  back without going to find a `curl` command. Revocation is permanent: the zip
+  is deleted and the id is burned, so a revoked link can never resolve again
+  and sharing the same build later mints a different one. The response says so
+  rather than reading like an undoable delete.
+- **The platform's answer is reconciled with the project's record.** Pass
+  `projectPath` and every listed share is matched against
+  `.extension.dev/shared-previews.json`: a share the project recorded carries
+  its local `sharedAt`, `browser` and `distDir`, a share the platform knows
+  about but the project does not is flagged `remoteOnly` (shared from another
+  machine or another checkout), and a local record with no artifact behind it
+  is reported under `localOnly`. The tool only ever reads that file, never
+  rewrites it, so its append-only history stays intact.
+- **A cut list is never passed off as the whole set.** When the platform
+  answers `truncated:true`, the response carries the count that came back
+  against the count that matched, says to raise `limit` or narrow with
+  `status:"live"`, and refuses to call a `localOnly` record dead, because a
+  share missing from a truncated list has not been shown to be gone.
+
+### Changed
+
+- **A successful share now says where to find the link again.** The `share`
+  note and the `extension_preview_web` tool description both point at
+  `extension_shares`, at the moment the link exists and the question of how to
+  reach it later is about to come up.
+
 ## 6.4.0
 
 A build on your machine can now become a link someone else can open, and the

package/README.md

@@ -133,6 +133,7 @@ cp node_modules/@extension.dev/mcp/claude/commands/*.md ~/my-extension/.claude/c
 | platform | `extension_whoami` | Show the stored login (never the token) |
 | platform | `extension_logout` | Remove stored credentials |
 | platform | `extension_preview_web` | Render a build in the web emulator, and share it as a link |
+| platform | `extension_shares` | List every link you have shared, and revoke one permanently |
 | platform | `extension_publish` | Publish a shareable preview to extension.dev |
 | platform | `extension_release_promote` | Promote a build to a release channel, headless |
 | platform | `extension_deploy` | Submit to the Chrome, Firefox, and Edge stores through extension.dev |
@@ -143,6 +144,8 @@ Browser-launching tools (`dev`, `start`, `preview`) shell out to the `extension`
 
 An unpacked extension is unusually hard to hand to someone: the only way to look at a colleague's work-in-progress has been to take their zip and run untrusted code with real browser permissions on your own machine. `extension_preview_web` with `share: true` uploads the `dist/` it just built and returns a link that renders those exact bytes in the emulator. Whoever opens it installs nothing and signs in to nothing, which is what lets a designer, a PM, or a reviewer into the loop at all. Sharing needs auth (`extension_login` or `EXTENSION_DEV_TOKEN`), the link expires, and `DELETE`ing the returned `revokeUrl` with the same token kills it early. Revocation is permanent and re-sharing mints a new link, so that `revokeUrl` is the only handle to the link you just made; every share is also appended to `.extension.dev/shared-previews.json` in the project (gitignored) so it survives losing the tool output. Without `share`, the tool returns a local-only deep link and uploads nothing.
 
+`extension_shares` is the other half of that: it lists every link the token has shared, live and dead, with the `previewUrl` and `revokeUrl` of each, and revokes one by `artifactId` or by pasting any of its URLs. Pass `projectPath` and it reconciles the platform's answer with the project's own record, so a link shared from another machine shows up as `remoteOnly` and a record with nothing behind it any more shows up under `localOnly`. It never rewrites the local file.
+
 That is a different job from shipping. Use `share` for the build you are holding right now; use `extension_publish` and `extension_release_promote` below for builds your CI has released.
 
 ## From preview to store

package/dist/module.js

@@ -566,6 +566,12 @@ __webpack_require__.d(reload_namespaceObject, {
     handler: ()=>reload_handler,
     schema: ()=>reload_schema
 });
+var shares_namespaceObject = {};
+__webpack_require__.r(shares_namespaceObject);
+__webpack_require__.d(shares_namespaceObject, {
+    handler: ()=>shares_handler,
+    schema: ()=>shares_schema
+});
 var source_inspect_namespaceObject = {};
 __webpack_require__.r(source_inspect_namespaceObject);
 __webpack_require__.d(source_inspect_namespaceObject, {
@@ -623,7 +629,7 @@ __webpack_require__.d(whoami_namespaceObject, {
     handler: ()=>whoami_handler,
     schema: ()=>whoami_schema
 });
-var package_namespaceObject = JSON.parse('{"rE":"6.4.0","El":{"OP":"4.0.16-canary.1784889479.74e12044"}}');
+var package_namespaceObject = JSON.parse('{"rE":"6.5.0","El":{"OP":"4.0.16-canary.1784889479.74e12044"}}');
 function credentialsPath() {
     if ("win32" === process.platform) {
         const base = process.env.APPDATA || process.env.LOCALAPPDATA || node_path.join(node_os.homedir(), "AppData", "Roaming");
@@ -4499,6 +4505,22 @@ function loadExisting(file) {
         unreadable: true
     };
 }
+function readSharedPreviews(projectPath) {
+    const file = sharedPreviewsPath(projectPath);
+    if (!node_fs.existsSync(file)) return {
+        path: file,
+        exists: false,
+        unreadable: false,
+        entries: []
+    };
+    const existing = loadExisting(file);
+    return {
+        path: file,
+        exists: true,
+        unreadable: existing.unreadable,
+        entries: existing.entries.filter((entry)=>entry && "string" == typeof entry.artifactId)
+    };
+}
 function recordSharedPreview(projectPath, entry) {
     const file = sharedPreviewsPath(projectPath);
     let preserved;
@@ -4629,7 +4651,7 @@ async function buildShare(projectPath, distDir, manifest, browser) {
         serves: "uploaded-local-build",
         localBuildUploaded: true,
         record,
-        note: "Anyone with this link can open the build you just made, running in the emulator. No install, no sign-in, no dev server. They can also download the whole build as a zip from zipUrl, so the link hands over the built code. It stays live until expiresAt; DELETE revokeUrl with the same token to kill it sooner, and a revoked link stays dead. revokeUrl is the only handle that pulls this link early and re-sharing mints a different one, so " + (record.recorded ? `it was also written to ${record.path} (record.path), which lists every share from this project.` : `keep it: ${record.note}`) + (record.warning ? ` ${record.warning}` : "")
+        note: "Anyone with this link can open the build you just made, running in the emulator. No install, no sign-in, no dev server. They can also download the whole build as a zip from zipUrl, so the link hands over the built code. It stays live until expiresAt; DELETE revokeUrl with the same token to kill it sooner, and a revoked link stays dead. revokeUrl is the only handle that pulls this link early and re-sharing mints a different one, so " + (record.recorded ? `it was also written to ${record.path} (record.path), which lists every share from this project.` : `keep it: ${record.note}`) + " To find this link again later, or to pull it back once it has left this conversation, run extension_shares: it lists every link this token has shared with its live or dead state, and revokes one by artifactId or by pasting any of its URLs." + (record.warning ? ` ${record.warning}` : "")
     };
 }
 function detectSurfaces(manifest) {
@@ -4652,7 +4674,7 @@ function detectSurfaces(manifest) {
 }
 const preview_web_schema = {
     name: "extension_preview_web",
-    description: "Preview an in-progress extension in the web emulator (no real browser). Builds the project (unless build:false), points preview.extension.dev at the dist directory over the dev-only preview://build scheme, and returns a deep link plus a loadability check against its dev server. preview is the author's front door: it renders YOUR build and carries the Emulated/Real lane toggle and the Trace tab. Pass surface:\"inspect\" to render in inspect.extension.dev instead (the evaluator's door, for fixture and forensic work). Pass share:true to UPLOAD the dist you just built and get back a public link (share.previewUrl) that renders those exact bytes for anyone who opens it, with no install and no dev server, and that also serves the whole build as a downloadable zip. Sharing needs a token scoped to an existing extension.dev workspace and project (extension_login or EXTENSION_DEV_TOKEN, valid up to 7 days), so a local folder with no project on the platform cannot share. Use share:true whenever the build has to reach someone who is not at this machine, since the plain deepLink only resolves locally.",
+    description: "Preview an in-progress extension in the web emulator (no real browser). Builds the project (unless build:false), points preview.extension.dev at the dist directory over the dev-only preview://build scheme, and returns a deep link plus a loadability check against its dev server. preview is the author's front door: it renders YOUR build and carries the Emulated/Real lane toggle and the Trace tab. Pass surface:\"inspect\" to render in inspect.extension.dev instead (the evaluator's door, for fixture and forensic work). Pass share:true to UPLOAD the dist you just built and get back a public link (share.previewUrl) that renders those exact bytes for anyone who opens it, with no install and no dev server, and that also serves the whole build as a downloadable zip. Sharing needs a token scoped to an existing extension.dev workspace and project (extension_login or EXTENSION_DEV_TOKEN, valid up to 7 days), so a local folder with no project on the platform cannot share. Use share:true whenever the build has to reach someone who is not at this machine, since the plain deepLink only resolves locally. Shared links do not disappear when this response scrolls away: extension_shares lists every link this token has shared and revokes any of them.",
     inputSchema: {
         type: "object",
         properties: {
@@ -4734,7 +4756,7 @@ const preview_web_schema = {
             share: {
                 type: "boolean",
                 default: false,
-                description: "Upload the built dist and return a public link (share.previewUrl) that renders those exact bytes in the emulator for anyone who opens it: no install, no sign-in, no dev server. The link also serves the whole build as a downloadable zip (share.zipUrl), so sharing it hands over the built code. Needs a token scoped to an existing extension.dev workspace and project (extension_login or EXTENSION_DEV_TOKEN, valid up to 7 days); without one this returns a login hint and never fails the local preview. The link stays live until share.expiresAt, and DELETEing share.revokeUrl with the same token kills it sooner; a revoked link stays dead, and re-sharing the same build returns a new link. Because re-sharing never reproduces the old link, every successful share is also appended to .extension.dev/shared-previews.json in the project (gitignored) so the revoke handle survives losing this response."
+                description: "Upload the built dist and return a public link (share.previewUrl) that renders those exact bytes in the emulator for anyone who opens it: no install, no sign-in, no dev server. The link also serves the whole build as a downloadable zip (share.zipUrl), so sharing it hands over the built code. Needs a token scoped to an existing extension.dev workspace and project (extension_login or EXTENSION_DEV_TOKEN, valid up to 7 days); without one this returns a login hint and never fails the local preview. The link stays live until share.expiresAt, and DELETEing share.revokeUrl with the same token kills it sooner; a revoked link stays dead, and re-sharing the same build returns a new link. Because re-sharing never reproduces the old link, every successful share is also appended to .extension.dev/shared-previews.json in the project (gitignored) so the revoke handle survives losing this response, and extension_shares lists what is actually live on the platform and revokes any of it by id or by URL."
             }
         },
         required: [
@@ -4869,6 +4891,458 @@ async function preview_web_handler(args) {
         });
     }
 }
+const ARTIFACT_ID = /^gen_[0-9a-f]{32}$/;
+const ARTIFACT_ID_ANYWHERE = /gen_[0-9a-f]{32}/;
+function parseArtifactRef(input) {
+    const raw = String(input ?? "").trim();
+    if (!raw) return null;
+    if (ARTIFACT_ID.test(raw)) return raw;
+    let parsed = null;
+    try {
+        parsed = new URL(raw);
+    } catch  {
+        parsed = null;
+    }
+    if (parsed) {
+        const fromQuery = parsed.searchParams.get("preview");
+        if (fromQuery && ARTIFACT_ID.test(fromQuery.trim())) return fromQuery.trim();
+        const segments = parsed.pathname.split("/").filter(Boolean);
+        for(let i = segments.length - 1; i >= 0; i -= 1){
+            const segment = decodeURIComponent(segments[i]);
+            if (ARTIFACT_ID.test(segment)) return segment;
+        }
+    }
+    const loose = ARTIFACT_ID_ANYWHERE.exec(raw);
+    return loose ? loose[0] : null;
+}
+function authError(name) {
+    return {
+        ok: false,
+        error: {
+            name,
+            message: "No token. Run extension_login, or set EXTENSION_DEV_TOKEN (create one in the extension.dev dashboard)."
+        }
+    };
+}
+async function readBody(res) {
+    const text = await res.text();
+    try {
+        return JSON.parse(text);
+    } catch  {
+        return {
+            message: text
+        };
+    }
+}
+async function listArtifacts(options = {}) {
+    const token = options.token ?? resolveToken();
+    if (!token) return authError("SharesAuthError");
+    const apiCheck = safeApiBase(resolveApiBase(options.api));
+    if (!apiCheck.ok) return {
+        ok: false,
+        error: {
+            name: "SharesConfigError",
+            message: apiCheck.message
+        }
+    };
+    const url = new URL(`${apiCheck.base}/api/artifacts`);
+    if (null != options.limit) url.searchParams.set("limit", String(options.limit));
+    if (options.liveOnly) url.searchParams.set("status", "live");
+    const doFetch = options.fetchImpl ?? fetch;
+    let res;
+    try {
+        res = await doFetch(url.toString(), {
+            headers: {
+                authorization: `Bearer ${token}`,
+                accept: "application/json"
+            }
+        });
+    } catch (err) {
+        return {
+            ok: false,
+            error: {
+                name: "SharesNetworkError",
+                message: `Could not reach ${url.toString()}: ${err?.message || err}`
+            }
+        };
+    }
+    const data = await readBody(res);
+    if (401 === res.status) return authError("SharesAuthError");
+    if (!res.ok) return {
+        ok: false,
+        error: {
+            name: "SharesListError",
+            status: res.status,
+            message: `Listing shares failed (${res.status}): ${data?.message || "unknown error"}`
+        }
+    };
+    const artifacts = Array.isArray(data.artifacts) ? data.artifacts : [];
+    const num = (value, fallback)=>"number" == typeof value && Number.isFinite(value) ? value : fallback;
+    return {
+        ok: true,
+        data: {
+            artifacts,
+            count: num(data.count, artifacts.length),
+            matched: num(data.matched, artifacts.length),
+            limit: num(data.limit, artifacts.length),
+            truncated: true === data.truncated,
+            scanned: num(data.scanned, 0)
+        }
+    };
+}
+async function revokeArtifact(options) {
+    const token = options.token ?? resolveToken();
+    if (!token) return authError("SharesAuthError");
+    const apiCheck = safeApiBase(resolveApiBase(options.api));
+    if (!apiCheck.ok) return {
+        ok: false,
+        error: {
+            name: "SharesConfigError",
+            message: apiCheck.message
+        }
+    };
+    const url = `${apiCheck.base}/api/artifacts/${encodeURIComponent(options.artifactId)}`;
+    const doFetch = options.fetchImpl ?? fetch;
+    let res;
+    try {
+        res = await doFetch(url, {
+            method: "DELETE",
+            headers: {
+                authorization: `Bearer ${token}`,
+                accept: "application/json"
+            }
+        });
+    } catch (err) {
+        return {
+            ok: false,
+            error: {
+                name: "SharesNetworkError",
+                message: `Could not reach ${url}: ${err?.message || err}`
+            }
+        };
+    }
+    const data = await readBody(res);
+    if (401 === res.status) return authError("SharesAuthError");
+    if (404 === res.status) return {
+        ok: false,
+        error: {
+            name: "SharesNotFoundError",
+            status: 404,
+            message: `The platform has no live share ${options.artifactId} for this token. It may already be revoked, already expired, owned by a different project than the one this token is scoped to, or a teammate's personal share, which belongs to that person alone and no project token can revoke.`
+        }
+    };
+    if (!res.ok) return {
+        ok: false,
+        error: {
+            name: "SharesRevokeError",
+            status: res.status,
+            message: `Revoking ${options.artifactId} failed (${res.status}): ${data?.message || "unknown error"}`
+        }
+    };
+    return {
+        ok: true,
+        data: {
+            artifactId: options.artifactId,
+            revoked: true === data.revoked,
+            ..."string" == typeof data.revokedAt ? {
+                revokedAt: data.revokedAt
+            } : {}
+        }
+    };
+}
+const LOGIN_HINT = "Run extension_login, or set EXTENSION_DEV_TOKEN (create one in the extension.dev dashboard).";
+const shares_schema = {
+    name: "extension_shares",
+    description: "List and revoke the public preview links this token has shared (the links extension_preview_web share:true hands out). action:\"list\" (default) asks the platform for every artifact owned by the logged-in project and returns each one's artifactId, name, version, live/dead state, createdAt, expiresAt, revokedAt, size, and its previewUrl, zipUrl and revokeUrl, so a link you lost the response for is findable again. Every row also carries owner and sharedBy as the platform returned them, plus an attribution block: attribution.ownership is \"project\" when the owning workspace holds the share and any member can revoke it, \"personal\" when one person holds it alone and nobody else can, and \"unknown\" when the platform disclosed no owner. attribution.credit names the publisher for credit only and never decides access; it reads \"CLI token <id>\" when the token's issuer could not be resolved and \"not recorded\" for a share made before attribution existed, and neither is a person's name. action:\"revoke\" kills one by artifactId or by pasting any of its URLs; revocation is PERMANENT (the id is burned and re-sharing mints a different link), so it cannot be undone. Pass projectPath to reconcile the platform's answer with .extension.dev/shared-previews.json, the project's own append-only record: a share made on another machine shows up as remoteOnly, and a record with no live artifact behind it shows up under localOnly. Needs the same token as sharing (extension_login or EXTENSION_DEV_TOKEN); without one, listing still returns the local record with a login hint instead of failing. Read-only for the local file: this tool never rewrites shared-previews.json.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                enum: [
+                    "list",
+                    "revoke"
+                ],
+                default: "list",
+                description: "list reads every share this token owns; revoke permanently kills one and cannot be undone."
+            },
+            artifactId: {
+                type: "string",
+                description: "Which share to revoke (the gen_... id from a share response or from action:\"list\"). Required for revoke unless url is given."
+            },
+            url: {
+                type: "string",
+                description: "Any URL of the share to revoke (previewUrl, zipUrl, viewUrl, or revokeUrl). The artifact id is read out of it, so the link you sent someone is enough to pull it back."
+            },
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root. Reconciles the platform's answer against this project's .extension.dev/shared-previews.json record. Read-only."
+            },
+            status: {
+                type: "string",
+                enum: [
+                    "all",
+                    "live"
+                ],
+                default: "all",
+                description: "all (default) includes expired and revoked shares, which is what makes a dead link explainable; live returns only links that still resolve."
+            },
+            limit: {
+                type: "number",
+                description: "How many shares to return, 1 to 200 (platform default 100). A cut list comes back with truncated:true."
+            },
+            api: {
+                type: "string",
+                description: "Platform base URL (defaults to https://www.extension.dev or EXTENSION_DEV_API_URL)."
+            }
+        },
+        required: []
+    }
+};
+const REVOCABLE_BY = {
+    project: "Any member of the owning workspace, and any token scoped to the owning project, can revoke this share.",
+    personal: "This is one person's personal share. Only that person can see it and revoke it, so a project token cannot pull it back.",
+    unknown: "The platform did not disclose an owner for this share, so who may revoke it cannot be stated here."
+};
+function shares_text(value) {
+    return "string" == typeof value ? value.trim() : "";
+}
+function ownershipOf(owner) {
+    const kind = shares_text(owner?.kind);
+    if ("project" === kind) return "project";
+    if ("user" === kind) return "personal";
+    return "unknown";
+}
+function creditOf(sharedBy) {
+    const login = shares_text(sharedBy?.login);
+    if (login) return {
+        credit: login,
+        creditSource: "login"
+    };
+    const tokenId = shares_text(sharedBy?.tokenId);
+    if (tokenId) return {
+        credit: `CLI token ${tokenId}`,
+        creditSource: "tokenId"
+    };
+    return {
+        credit: sharedBy ? "not recorded: the platform could not resolve who published this share" : "not recorded: this share predates publisher attribution",
+        creditSource: "none"
+    };
+}
+function attributionOf(artifact) {
+    const ownership = ownershipOf(artifact.owner);
+    const owner = artifact.owner;
+    const ownerPath = "project" === ownership && owner && "project" === owner.kind ? [
+        shares_text(owner.workspace),
+        shares_text(owner.project)
+    ].filter(Boolean).join("/") : "";
+    return {
+        ownership,
+        ...ownerPath ? {
+            ownerPath
+        } : {},
+        ...creditOf(artifact.sharedBy),
+        revocableBy: REVOCABLE_BY[ownership]
+    };
+}
+function localIndex(entries) {
+    const index = new Map();
+    for (const entry of entries){
+        const existing = index.get(entry.artifactId);
+        if (!existing || String(entry.sharedAt) > String(existing.sharedAt)) index.set(entry.artifactId, entry);
+    }
+    return index;
+}
+function localOnlyStatus(entry, truncated, now) {
+    if (truncated) return "unknown: the platform list was cut short, so this share may simply be past the returned window.";
+    const expiresAt = entry.expiresAt ? Date.parse(entry.expiresAt) : NaN;
+    if (Number.isFinite(expiresAt) && expiresAt <= now) return "expired: its own expiresAt has passed, and the platform no longer lists it.";
+    return "not owned by this token: expired and pruned, revoked long ago, or shared while logged in to a different project.";
+}
+async function listShares(args) {
+    const local = args.projectPath ? readSharedPreviews(args.projectPath) : void 0;
+    const localRecord = local ? {
+        path: local.path,
+        exists: local.exists,
+        entries: local.entries.length,
+        ...local.unreadable ? {
+            unreadable: "The file exists but could not be parsed, so no local reconciliation was possible."
+        } : {}
+    } : {
+        path: null,
+        note: "Pass projectPath to reconcile this list against the project's own share record."
+    };
+    const listing = await listArtifacts({
+        liveOnly: "live" === args.status,
+        ...null != args.limit ? {
+            limit: args.limit
+        } : {},
+        ...args.api ? {
+            api: args.api
+        } : {}
+    });
+    if (!listing.ok) {
+        const isAuth = "SharesAuthError" === listing.error.name;
+        return JSON.stringify({
+            ok: true,
+            action: "list",
+            server: {
+                listed: false,
+                errorName: listing.error.name,
+                reason: listing.error.message,
+                ...isAuth ? {
+                    loginHint: LOGIN_HINT
+                } : {}
+            },
+            shares: [],
+            localOnly: (local?.entries ?? []).map((entry)=>({
+                    ...entry
+                })),
+            localRecord,
+            note: isAuth ? `The platform was not asked, so live and dead cannot be told apart here. ${LOGIN_HINT} localOnly is this project's own record of every link it ever shared, revoke handles included.` : "The platform could not be reached, so localOnly below is this project's own record and not a statement about what is still live."
+        });
+    }
+    const now = Date.now();
+    const byId = localIndex(local?.entries ?? []);
+    const seen = new Set();
+    const shares = listing.data.artifacts.map((artifact)=>{
+        seen.add(artifact.artifactId);
+        const entry = byId.get(artifact.artifactId);
+        return {
+            ...artifact,
+            owner: artifact.owner ?? null,
+            sharedBy: artifact.sharedBy ?? null,
+            attribution: attributionOf(artifact),
+            recordedLocally: Boolean(entry),
+            ...entry ? {
+                sharedAt: entry.sharedAt,
+                ...entry.browser ? {
+                    browser: entry.browser
+                } : {},
+                ...entry.distDir ? {
+                    distDir: entry.distDir
+                } : {}
+            } : local ? {
+                remoteOnly: "Not in this project's record: shared from another machine or another checkout of the project."
+            } : {}
+        };
+    });
+    const localOnly = (local?.entries ?? []).filter((entry)=>!seen.has(entry.artifactId)).map((entry)=>({
+            ...entry,
+            status: localOnlyStatus(entry, listing.data.truncated, now)
+        }));
+    const liveCount = shares.filter((share)=>share.live).length;
+    const ownership = {
+        project: shares.filter((s)=>"project" === s.attribution.ownership).length,
+        personal: shares.filter((s)=>"personal" === s.attribution.ownership).length,
+        unknown: shares.filter((s)=>"unknown" === s.attribution.ownership).length
+    };
+    return JSON.stringify({
+        ok: true,
+        action: "list",
+        server: {
+            listed: true,
+            count: listing.data.count,
+            matched: listing.data.matched,
+            limit: listing.data.limit,
+            truncated: listing.data.truncated,
+            scanned: listing.data.scanned,
+            ownership,
+            ...listing.data.truncated ? {
+                truncatedNote: `This is not the whole set: ${listing.data.count} of ${listing.data.matched} matched shares came back at limit ${listing.data.limit}. truncated also goes true when the server spent its budget working out which shares you are entitled to see, so matched is a floor and not a total. Raise limit (max 200) or pass status:"live" to narrow it, and do not read a missing share as revoked.`
+            } : {}
+        },
+        shares,
+        ...local ? {
+            localOnly
+        } : {},
+        localRecord,
+        message: `${liveCount} of ${shares.length} listed shares still resolve${local ? `; ${localOnly.length} local record ${1 === localOnly.length ? "entry has" : "entries have"} no artifact behind them` : ""}. Revoke one with action:"revoke" and its artifactId or any of its URLs.`,
+        note: "previewUrl and zipUrl are null for a share that is no longer live, because a revoked or expired link cannot resolve for anyone. revokeUrl stays on every row. Revocation is permanent: a revoked id is burned and re-sharing the same build mints a different link.",
+        attributionNote: "attribution.ownership says who the share belongs to and therefore who may revoke it: project means the owning workspace holds it and any member can pull it back, personal means one person holds it alone. attribution.credit names the publisher and is attribution only, granting and restricting nothing. A credit of \"CLI token ...\" means the platform could not resolve which human minted that token, and a credit of \"not recorded\" means it never knew; neither is a name, and neither should be reported as one."
+    });
+}
+async function revokeShare(args) {
+    const ref = parseArtifactRef(args.artifactId || args.url || "");
+    if (!ref) return JSON.stringify({
+        ok: false,
+        action: "revoke",
+        error: {
+            name: "SharesInputError",
+            message: "Nothing to revoke. Pass artifactId (a gen_... id) or url (the previewUrl, zipUrl, viewUrl, or revokeUrl of the share). Run action:\"list\" to see both."
+        }
+    });
+    const result = await revokeArtifact({
+        artifactId: ref,
+        ...args.api ? {
+            api: args.api
+        } : {}
+    });
+    const local = args.projectPath ? readSharedPreviews(args.projectPath) : void 0;
+    const entry = local ? localIndex(local.entries).get(ref) : void 0;
+    const recordNote = local ? entry ? `${local.path} still lists this share as its own append-only history and was not rewritten, so the entry stays with its original sharedAt. The platform is the truth for whether a link resolves.` : `${local.path} has no entry for this share, so it was made from another machine or another checkout.` : void 0;
+    if (!result.ok) {
+        const isAuth = "SharesAuthError" === result.error.name;
+        return JSON.stringify({
+            ok: false,
+            action: "revoke",
+            artifactId: ref,
+            error: {
+                name: result.error.name,
+                message: result.error.message
+            },
+            ...isAuth ? {
+                loginHint: LOGIN_HINT
+            } : {},
+            ...recordNote ? {
+                recordNote
+            } : {}
+        });
+    }
+    return JSON.stringify({
+        ok: true,
+        action: "revoke",
+        artifactId: ref,
+        revoked: result.data.revoked,
+        ...result.data.revokedAt ? {
+            revokedAt: result.data.revokedAt
+        } : {},
+        ...recordNote ? {
+            recordNote
+        } : {},
+        note: "The link is dead for everyone, permanently: the zip is deleted and the id is burned, so it can never resolve again. Sharing the same build later returns a different link, and anyone holding the old one gets nothing."
+    });
+}
+async function shares_handler(args) {
+    if ("revoke" === args.action) return revokeShare({
+        ...args.artifactId ? {
+            artifactId: args.artifactId
+        } : {},
+        ...args.url ? {
+            url: args.url
+        } : {},
+        ...args.projectPath ? {
+            projectPath: args.projectPath
+        } : {},
+        ...args.api ? {
+            api: args.api
+        } : {}
+    });
+    return listShares({
+        ...args.projectPath ? {
+            projectPath: args.projectPath
+        } : {},
+        ...args.status ? {
+            status: args.status
+        } : {},
+        ...null != args.limit ? {
+            limit: args.limit
+        } : {},
+        ...args.api ? {
+            api: args.api
+        } : {}
+    });
+}
 const get_template_source_schema = {
     name: "extension_get_template_source",
     description: "Read source files from a template in the extension.dev template catalog. Use this to learn implementation patterns before building something similar.",
@@ -10652,6 +11126,7 @@ const tools = [
     start_namespaceObject,
     preview_namespaceObject,
     preview_web_namespaceObject,
+    shares_namespaceObject,
     stop_namespaceObject,
     get_template_source_namespaceObject,
     manifest_validate_namespaceObject,

package/dist/src/lib/artifacts-api.d.ts

@@ -0,0 +1,72 @@
+type FetchImpl = typeof fetch;
+export type ArtifactOwner = {
+    kind: "project";
+    workspace: string;
+    project: string;
+} | {
+    kind: "user";
+};
+export interface ArtifactPublisher {
+    via: "token" | "session";
+    login: string | null;
+    workspace: string | null;
+    project: string | null;
+    tokenId: string | null;
+}
+export interface ListedArtifact {
+    artifactId: string;
+    kind?: string;
+    name?: string;
+    slug?: string;
+    version?: string;
+    live: boolean;
+    createdAt?: string;
+    expiresAt?: string | null;
+    revokedAt?: string | null;
+    sizeBytes?: number | null;
+    previewUrl?: string | null;
+    viewUrl?: string | null;
+    zipUrl?: string | null;
+    revokeUrl?: string;
+    owner?: ArtifactOwner | null;
+    sharedBy?: ArtifactPublisher | null;
+}
+export interface ArtifactListing {
+    artifacts: ListedArtifact[];
+    count: number;
+    matched: number;
+    limit: number;
+    truncated: boolean;
+    scanned: number;
+}
+export interface ArtifactRevocation {
+    artifactId: string;
+    revoked: boolean;
+    revokedAt?: string;
+}
+export type ArtifactsOutcome<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: {
+        name: string;
+        message: string;
+        status?: number;
+    };
+};
+export declare function parseArtifactRef(input: string): string | null;
+export declare function listArtifacts(options?: {
+    limit?: number;
+    liveOnly?: boolean;
+    api?: string;
+    token?: string;
+    fetchImpl?: FetchImpl;
+}): Promise<ArtifactsOutcome<ArtifactListing>>;
+export declare function revokeArtifact(options: {
+    artifactId: string;
+    api?: string;
+    token?: string;
+    fetchImpl?: FetchImpl;
+}): Promise<ArtifactsOutcome<ArtifactRevocation>>;
+export {};

package/dist/src/lib/share-record.d.ts

@@ -23,4 +23,11 @@ export interface ShareRecordOutcome {
     warning?: string;
 }
 export declare function sharedPreviewsPath(projectPath: string): string;
+export interface SharedPreviewsFile {
+    path: string;
+    exists: boolean;
+    unreadable: boolean;
+    entries: SharedPreviewEntry[];
+}
+export declare function readSharedPreviews(projectPath: string): SharedPreviewsFile;
 export declare function recordSharedPreview(projectPath: string, entry: SharedPreviewEntry): ShareRecordOutcome;

package/dist/src/tools/shares.d.ts

@@ -0,0 +1,51 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            action: {
+                type: string;
+                enum: string[];
+                default: string;
+                description: string;
+            };
+            artifactId: {
+                type: string;
+                description: string;
+            };
+            url: {
+                type: string;
+                description: string;
+            };
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            status: {
+                type: string;
+                enum: string[];
+                default: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            api: {
+                type: string;
+                description: string;
+            };
+        };
+        required: never[];
+    };
+};
+export declare function handler(args: {
+    action?: string;
+    artifactId?: string;
+    url?: string;
+    projectPath?: string;
+    status?: string;
+    limit?: number;
+    api?: string;
+}): Promise<string>;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@extension.dev/mcp",
   "type": "module",
-  "version": "6.4.0",
-  "description": "MCP server that lets AI agents (Claude Code, Claude Desktop, Cursor, Copilot, Codex) build, run, inspect, and publish browser extensions. 35 tools for scaffolding, live DOM inspection, log streaming, and store-ready builds across Chrome, Edge, Firefox, Safari, and every Chromium- or Gecko-based browser (Brave, Opera, Vivaldi, Yandex, Waterfox, LibreWolf). Powered by extension.dev and Extension.js.",
+  "version": "6.6.0",
+  "description": "MCP server that lets AI agents (Claude Code, Claude Desktop, Cursor, Copilot, Codex) build, run, inspect, and publish browser extensions. 36 tools for scaffolding, live DOM inspection, log streaming, and store-ready builds across Chrome, Edge, Firefox, Safari, and every Chromium- or Gecko-based browser (Brave, Opera, Vivaldi, Yandex, Waterfox, LibreWolf). Powered by extension.dev and Extension.js.",
   "mcpName": "io.github.extensiondev/mcp",
   "license": "Apache-2.0",
   "author": {

package/server.json

@@ -1,19 +1,19 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-09-29/server.schema.json",
   "name": "io.github.extensiondev/mcp",
-  "description": "Build, run, inspect, and publish browser extensions from any MCP client. 35 tools, 11 browsers.",
+  "description": "Build, run, inspect, and publish browser extensions from any MCP client. 36 tools, 11 browsers.",
   "repository": {
     "url": "https://github.com/extensiondev/mcp",
     "source": "github"
   },
   "websiteUrl": "https://extension.dev",
-  "version": "6.4.0",
+  "version": "6.6.0",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@extension.dev/mcp",
-      "version": "6.4.0",
+      "version": "6.6.0",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"