@chrischall/eventbrite-mcp 0.1.0 → 0.1.2

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   },
   "metadata": {
     "description": "MCP server for Eventbrite — your tickets and orders, organizer data, and public event discovery",
-    "version": "0.1.0"
+    "version": "0.1.2"
   },
   "plugins": [
     {
@@ -15,7 +15,7 @@
       "displayName": "Eventbrite",
       "source": "./",
       "description": "MCP server for Eventbrite — tickets, orders, organizer data, and public event search. Account tools use a personal API token; discovery search routes through the user's signed-in eventbrite.com tab via the fetchproxy bridge, reusing their authenticated session.",
-      "version": "0.1.0",
+      "version": "0.1.2",
       "author": {
         "name": "Chris Hall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "eventbrite-mcp",
   "displayName": "Eventbrite",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "MCP server for Eventbrite — your tickets and orders, organizer data, and public event discovery",
   "author": {
     "name": "Chris Hall",

package/README.md

@@ -79,20 +79,12 @@ Search flow: `eb_resolve_place {location: "Charlotte, NC"}` →
 `eb_resolve_place` also accepts a raw slug (`nc--charlotte`). A bare city with
 no state or country is rejected rather than guessed.
 
-## Hosted connector
-
-`src/worker.ts` deploys the token-API tools as a Cloudflare Worker remote
-connector for claude.ai (OAuth login collects your Eventbrite token). The
-discovery tools are **excluded** there — the browser bridge doesn't exist in a
-Worker. See `docs/DEPLOY-CONNECTOR.md`.
-
 ## Development
 
 ```sh
 npm install
 npm test          # node suite
 npm run build     # tsc + esbuild bundle
-npm run worker:test
 ```
 
 API shape notes (captured + verified): `docs/EVENTBRITE-API.md`. A

package/dist/bundle.js

@@ -3659,7 +3659,12 @@ var require_fast_uri = __commonJS({
     }
     function resolve(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
+      const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
+      const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
+      if (baseMalformed || relativeMalformed) {
+        throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+      }
+      const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
@@ -3785,6 +3790,7 @@ var require_fast_uri = __commonJS({
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
     var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+    var AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
     function getParseError(parsed, matches) {
       if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
         return 'URI path must start with "/" when authority is present.';
@@ -3819,6 +3825,20 @@ var require_fast_uri = __commonJS({
         parsed.error = "URI authority must not contain a literal backslash.";
         malformedAuthorityOrPort = true;
       }
+      const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
+      if (introducerMatch !== null) {
+        const region = introducerMatch[1];
+        const normalizedRegion = region.replace(/[\t\n\r]/g, "");
+        if (normalizedRegion.length >= 2) {
+          if (normalizedRegion.slice(0, 2) !== "//") {
+            parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+            malformedAuthorityOrPort = true;
+          } else if (region.length !== normalizedRegion.length) {
+            parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+            malformedAuthorityOrPort = true;
+          }
+        }
+      }
       const matches = uri.match(URI_PARSE);
       if (matches) {
         parsed.scheme = matches[1];
@@ -6985,10 +7005,17 @@ var init_errors = __esm({
 });
 
 // node_modules/@fetchproxy/protocol/dist/frames.js
+function readySignaturePayload(mcpHelloNonce, extHelloNonce, extensionSessionPub) {
+  const out = new Uint8Array(mcpHelloNonce.length + extHelloNonce.length + extensionSessionPub.length);
+  out.set(mcpHelloNonce, 0);
+  out.set(extHelloNonce, mcpHelloNonce.length);
+  out.set(extensionSessionPub, mcpHelloNonce.length + extHelloNonce.length);
+  return out;
+}
 var PROTOCOL_VERSION, HKDF_SESSION_INFO, KNOWN_CAPABILITIES;
 var init_frames = __esm({
   "node_modules/@fetchproxy/protocol/dist/frames.js"() {
-    PROTOCOL_VERSION = 2;
+    PROTOCOL_VERSION = 3;
     HKDF_SESSION_INFO = "fetchproxy/1.0.0/session";
     KNOWN_CAPABILITIES = /* @__PURE__ */ new Set([
       "fetch",
@@ -7000,7 +7027,8 @@ var init_frames = __esm({
       "read_indexed_db",
       "read_dom",
       "download",
-      "graphql"
+      "graphql",
+      "write_cookies"
     ]);
   }
 });
@@ -7110,6 +7138,15 @@ function assertHttpUrl(x, label) {
     throw new ProtocolError(`${label}: must be http(s), got ${u.protocol}`);
   }
 }
+function assertCookiePath(x, label) {
+  assertString(x, label);
+  if (!x.startsWith("/") || x.startsWith("//")) {
+    throw new ProtocolError(`${label}: must be an absolute path like "/campus"`);
+  }
+  if (x.includes("?") || x.includes("#") || x.includes("\\")) {
+    throw new ProtocolError(`${label}: must not contain a query, fragment, or backslash`);
+  }
+}
 function assertHttpsOriginOnly(x, label) {
   assertString(x, label);
   let u;
@@ -7549,13 +7586,43 @@ function validateInnerRequest(raw) {
     }
     assertHttpsOriginOnly(raw.init.origin, "inner.init.origin");
     assertNonEmptyKeyArray(raw.init.keys, "inner.init.keys");
+    if (raw.init.path !== void 0)
+      assertCookiePath(raw.init.path, "inner.init.path");
     for (const k of Object.keys(raw.init)) {
-      if (k !== "origin" && k !== "keys") {
+      if (k !== "origin" && k !== "keys" && k !== "path") {
         throw new ProtocolError(`inner.init: unexpected field ${JSON.stringify(k)} on read_cookies`);
       }
     }
     return raw;
   }
+  if (raw.op === "write_cookies") {
+    assertObject(raw.init, "inner.init");
+    assertHttpsOriginOnly(raw.init.origin, "inner.init.origin");
+    if (!Array.isArray(raw.init.cookies) || raw.init.cookies.length === 0) {
+      throw new ProtocolError("inner.init.cookies: must be a non-empty array");
+    }
+    for (const [i, entry] of raw.init.cookies.entries()) {
+      assertObject(entry, `inner.init.cookies[${i}]`);
+      assertString(entry.name, `inner.init.cookies[${i}].name`);
+      if (!SCOPE_KEY_RE.test(entry.name)) {
+        throw new ProtocolError(`inner.init.cookies[${i}].name: invalid key ${JSON.stringify(entry.name)}`);
+      }
+      assertString(entry.value, `inner.init.cookies[${i}].value`);
+      for (const k of Object.keys(entry)) {
+        if (k !== "name" && k !== "value") {
+          throw new ProtocolError(`inner.init.cookies[${i}]: unexpected field ${JSON.stringify(k)}`);
+        }
+      }
+    }
+    if (raw.init.path !== void 0)
+      assertCookiePath(raw.init.path, "inner.init.path");
+    for (const k of Object.keys(raw.init)) {
+      if (k !== "origin" && k !== "cookies" && k !== "path") {
+        throw new ProtocolError(`inner.init: unexpected field ${JSON.stringify(k)} on write_cookies`);
+      }
+    }
+    return raw;
+  }
   if (raw.op === "read_local_storage" || raw.op === "read_session_storage") {
     assertObject(raw.init, "inner.init");
     if (raw.init.origin === void 0) {
@@ -7742,7 +7809,7 @@ function validateInnerRequest(raw) {
     }
     return raw;
   }
-  throw new ProtocolError(`inner.op: must be one of "fetch", "read_cookies", "read_local_storage", "read_session_storage", "capture_request_header", "capture_redirect", "read_indexed_db", "read_dom", "download", "graphql_query"; got ${JSON.stringify(raw.op)}`);
+  throw new ProtocolError(`inner.op: must be one of "fetch", "read_cookies", "read_local_storage", "read_session_storage", "capture_request_header", "capture_redirect", "read_indexed_db", "read_dom", "download", "graphql_query", "write_cookies"; got ${JSON.stringify(raw.op)}`);
 }
 function assertNonEmptyKeyArray(value, label) {
   if (!Array.isArray(value)) {
@@ -7799,6 +7866,18 @@ function validateInnerResponse(raw) {
       }
       return raw;
     }
+    if (op === "write_cookies") {
+      if (raw.written === void 0) {
+        throw new ProtocolError("inner.written: missing on write_cookies response");
+      }
+      if (!Array.isArray(raw.written)) {
+        throw new ProtocolError("inner.written: must be an array");
+      }
+      for (const [i, name] of raw.written.entries()) {
+        assertString(name, `inner.written[${i}]`);
+      }
+      return raw;
+    }
     if (op === "read_local_storage" || op === "read_session_storage") {
       if (raw.values === void 0) {
         throw new ProtocolError(`inner.values: missing on ${String(op)} response`);
@@ -12037,6 +12116,158 @@ var init_session_ready = __esm({
   }
 });
 
+// node_modules/@fetchproxy/server/dist/identity.js
+import { readFile, writeFile, mkdir, chmod } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { homedir } from "node:os";
+function defaultIdentityDir() {
+  return join2(homedir(), ".fetchproxy", "identity");
+}
+function safeIdentityFileBase(serverName) {
+  if (!serverName || serverName === ".." || serverName.includes("..") || !SAFE_PLAIN.test(serverName) && !SAFE_SCOPED.test(serverName)) {
+    throw new Error(`unsafe serverName for identity file: ${JSON.stringify(serverName)}`);
+  }
+  return serverName.replace(/\//g, "_");
+}
+async function loadOrCreateIdentity(serverName, dir = defaultIdentityDir()) {
+  const safeFile = safeIdentityFileBase(serverName);
+  const path = join2(dir, `${safeFile}.json`);
+  await mkdir(dir, { recursive: true, mode: 448 });
+  try {
+    const raw = await readFile(path, "utf8");
+    const j2 = JSON.parse(raw);
+    return {
+      x25519Priv: fromB64(j2.x25519Priv),
+      x25519Pub: fromB64(j2.x25519Pub),
+      ed25519Priv: fromB64(j2.ed25519Priv),
+      ed25519Pub: fromB64(j2.ed25519Pub),
+      createdAt: j2.createdAt
+    };
+  } catch (e) {
+    if (e.code !== "ENOENT")
+      throw e;
+  }
+  const x = await generateX25519();
+  const ed = await generateEd25519();
+  const id = {
+    x25519Priv: x.privateKey,
+    x25519Pub: x.publicKey,
+    ed25519Priv: ed.privateKey,
+    ed25519Pub: ed.publicKey,
+    createdAt: Date.now()
+  };
+  const j = {
+    x25519Priv: toB64(id.x25519Priv),
+    x25519Pub: toB64(id.x25519Pub),
+    ed25519Priv: toB64(id.ed25519Priv),
+    ed25519Pub: toB64(id.ed25519Pub),
+    createdAt: id.createdAt
+  };
+  await writeFile(path, JSON.stringify(j, null, 2), { mode: 384 });
+  await chmod(path, 384);
+  return id;
+}
+var SAFE_PLAIN, SAFE_SCOPED;
+var init_identity = __esm({
+  "node_modules/@fetchproxy/server/dist/identity.js"() {
+    init_dist();
+    SAFE_PLAIN = /^[A-Za-z0-9._-]+$/;
+    SAFE_SCOPED = /^@[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+  }
+});
+
+// node_modules/@fetchproxy/server/dist/extension-trust.js
+import { readFile as readFile2, writeFile as writeFile2, rename, unlink, mkdir as mkdir2, chmod as chmod2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+function fileExtensionTrust(args) {
+  return {
+    allowNew: args.allowNew,
+    location: extensionTrustPath(args.serverName, args.dir ?? defaultIdentityDir()),
+    read: () => readExtensionPin(args.serverName, args.dir ?? defaultIdentityDir()),
+    write: (pin) => writeExtensionPin(args.serverName, pin, args.dir ?? defaultIdentityDir())
+  };
+}
+function allowNewExtensionIdentity(explicit, env = process.env) {
+  if (explicit !== void 0)
+    return explicit;
+  return env[TRUST_NEW_EXTENSION_ENV] === "1";
+}
+function decideExtensionTrust(args) {
+  const { pin, hello, allowNew, serverName } = args;
+  if (!pin)
+    return { decision: "first-use" };
+  if (pin.identityX25519Pub === hello.identityX25519Pub && pin.identityEd25519Pub === hello.identityEd25519Pub) {
+    return { decision: "pinned" };
+  }
+  const trustPath = args.location ?? extensionTrustPathHint(serverName);
+  if (allowNew) {
+    return {
+      decision: "replace",
+      message: `[fetchproxy] ${serverName}: accepting a NEW extension identity because ${TRUST_NEW_EXTENSION_ENV}=1 \u2014 re-pinning. Unset it once the browser you expect is connected.`
+    };
+  }
+  return {
+    decision: "refused",
+    message: `[fetchproxy] ${serverName}: refusing an extension whose identity is not the one this MCP paired with. If you re-installed the extension or moved to another browser, re-pair deliberately: run this MCP once with ${TRUST_NEW_EXTENSION_ENV}=1, or delete ${trustPath}. If you did neither, something else is answering as your browser.`
+  };
+}
+function extensionTrustPath(serverName, dir = defaultIdentityDir()) {
+  return join3(dir, `${safeIdentityFileBase(serverName)}.extension-trust.json`);
+}
+function extensionTrustPathHint(serverName) {
+  try {
+    return extensionTrustPath(serverName);
+  } catch {
+    return join3(defaultIdentityDir(), "<server-name>.extension-trust.json");
+  }
+}
+function isPin(x) {
+  if (!x || typeof x !== "object")
+    return false;
+  const r = x;
+  return typeof r.identityX25519Pub === "string" && typeof r.identityEd25519Pub === "string" && typeof r.pinnedAt === "number";
+}
+async function readExtensionPin(serverName, dir = defaultIdentityDir()) {
+  const path = extensionTrustPath(serverName, dir);
+  let raw;
+  try {
+    raw = await readFile2(path, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return null;
+    throw e;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`unreadable extension pin at ${path} (not JSON) \u2014 delete it to re-pair`);
+  }
+  if (!isPin(parsed)) {
+    throw new Error(`unreadable extension pin at ${path} (wrong shape) \u2014 delete it to re-pair`);
+  }
+  return {
+    identityX25519Pub: parsed.identityX25519Pub,
+    identityEd25519Pub: parsed.identityEd25519Pub,
+    pinnedAt: parsed.pinnedAt
+  };
+}
+async function writeExtensionPin(serverName, pin, dir = defaultIdentityDir()) {
+  const path = extensionTrustPath(serverName, dir);
+  await mkdir2(dir, { recursive: true, mode: 448 });
+  const tmp = `${path}.tmp`;
+  await writeFile2(tmp, JSON.stringify(pin, null, 2), { mode: 384 });
+  await chmod2(tmp, 384);
+  await rename(tmp, path);
+}
+var TRUST_NEW_EXTENSION_ENV;
+var init_extension_trust = __esm({
+  "node_modules/@fetchproxy/server/dist/extension-trust.js"() {
+    init_identity();
+    TRUST_NEW_EXTENSION_ENV = "FETCHPROXY_TRUST_NEW_EXTENSION";
+  }
+});
+
 // node_modules/@fetchproxy/server/dist/host.js
 async function startHost(opts) {
   const wss = new import_websocket_server.default({
@@ -12088,9 +12319,12 @@ async function startHost(opts) {
   }
   resetSessionPromise();
   let extensionHello = null;
+  let extensionClaim = null;
   wss.on("connection", (ws) => {
     let identified = null;
     let peerMcpId = null;
+    let closed = false;
+    let pinOnReady = false;
     ws.on("message", async (data) => {
       try {
         let frame;
@@ -12102,10 +12336,43 @@ async function startHost(opts) {
           return;
         }
         if (frame.type === "hello" && frame.role === "extension") {
-          if (extensionWs) {
+          if (extensionWs || extensionClaim) {
             ws.close(1008, "extension already connected");
             return;
           }
+          extensionClaim = ws;
+          let pin;
+          try {
+            pin = await opts.extensionTrust.read();
+          } catch (e) {
+            console.error(`[fetchproxy] ${String(e)}`);
+            if (extensionClaim === ws)
+              extensionClaim = null;
+            ws.close(1008, "extension pin unreadable");
+            return;
+          }
+          const outcome = decideExtensionTrust({
+            pin,
+            hello: frame,
+            allowNew: opts.extensionTrust.allowNew,
+            serverName: opts.ownServerName,
+            location: opts.extensionTrust.location
+          });
+          if (outcome.decision === "refused") {
+            console.warn(outcome.message);
+            if (extensionClaim === ws)
+              extensionClaim = null;
+            ws.close(1008, "extension identity is not the pinned one");
+            return;
+          }
+          if (outcome.decision === "replace")
+            console.warn(outcome.message);
+          if (closed || ws.readyState !== import_websocket.default.OPEN) {
+            if (extensionClaim === ws)
+              extensionClaim = null;
+            return;
+          }
+          pinOnReady = outcome.decision !== "pinned";
           identified = "extension";
           extensionWs = ws;
           extensionHello = frame;
@@ -12117,6 +12384,8 @@ async function startHost(opts) {
               console.error("[fetchproxy] onPairCode threw:", e);
             }
           }
+          for (const slot of peers.values())
+            slot.ws.send(JSON.stringify(frame));
           ws.send(JSON.stringify(ownHello));
           for (const slot of peers.values()) {
             ws.send(JSON.stringify(slot.helloFrame));
@@ -12152,6 +12421,8 @@ async function startHost(opts) {
           peers.set(frame.mcpId, { ws, helloFrame: frame });
           if (extensionWs)
             extensionWs.send(JSON.stringify(frame));
+          if (extensionHello)
+            ws.send(JSON.stringify(extensionHello));
           return;
         }
         if (frame.type === "ready") {
@@ -12163,7 +12434,7 @@ async function startHost(opts) {
             }
             const extEdPub = fromB64(extensionHello.identityEd25519Pub);
             const extNonce = fromB64(extensionHello.sessionNonce);
-            const msg = concatBytes(ownSessionNonce, extNonce);
+            const msg = readySignaturePayload(ownSessionNonce, extNonce, fromB64(frame.extensionSessionPub));
             const sig = fromB64(frame.sessionSig);
             let sigOk = false;
             try {
@@ -12176,6 +12447,18 @@ async function startHost(opts) {
               ws.close(1008, "extension session signature invalid");
               return;
             }
+            if (pinOnReady) {
+              pinOnReady = false;
+              try {
+                await opts.extensionTrust.write({
+                  identityX25519Pub: extensionHello.identityX25519Pub,
+                  identityEd25519Pub: extensionHello.identityEd25519Pub,
+                  pinnedAt: Date.now()
+                });
+              } catch (e) {
+                console.error(`[fetchproxy] could not persist the extension pin: ${String(e)}`);
+              }
+            }
             const extPub = fromB64(frame.extensionSessionPub);
             const shared = await ecdhX25519(opts.ownIdentity.x25519Priv, extPub);
             const key = await hkdfSha256(shared, ownSessionNonce, enc2.encode(HKDF_SESSION_INFO), 32);
@@ -12229,6 +12512,9 @@ async function startHost(opts) {
       }
     });
     ws.on("close", () => {
+      closed = true;
+      if (extensionClaim === ws)
+        extensionClaim = null;
       if (identified === "extension" && extensionWs === ws) {
         extensionWs = null;
         extensionHello = null;
@@ -12287,6 +12573,7 @@ var init_host = __esm({
     init_build_server_hello();
     init_session();
     init_session_ready();
+    init_extension_trust();
     PUBLIC_ORIGIN_RE = /^https?:\/\/(?!(127\.0\.0\.1|localhost)(:|$))/i;
     enc2 = new TextEncoder();
   }
@@ -12330,11 +12617,84 @@ async function startPeer(opts) {
     resolveFirstReady = resolve;
     rejectFirstReady = reject;
   });
+  let extensionHello = null;
+  let warnedUnverifiable = false;
+  let cachedPin = void 0;
+  const authenticateExtension = async (sessionSig, extensionSessionPub) => {
+    if (!extensionHello) {
+      if (opts.requireExtensionIdentity) {
+        console.error(`[fetchproxy] ${opts.serverName}: the concentrator does not forward the extension's identity, so this session cannot be verified \u2014 refusing. Upgrade the MCP holding the bridge port to 1.12.0 or later.`);
+        return false;
+      }
+      if (!warnedUnverifiable) {
+        warnedUnverifiable = true;
+        console.warn(`[fetchproxy] ${opts.serverName}: the concentrator does not forward the extension's identity (pre-1.12.0), so this peer cannot verify which browser it is talking to. Upgrade the MCP holding the bridge port to close this.`);
+      }
+      return true;
+    }
+    const payload = readySignaturePayload(sessionNonce, fromB64(extensionHello.sessionNonce), fromB64(extensionSessionPub));
+    let sigOk = false;
+    try {
+      sigOk = await ed25519Verify(fromB64(extensionHello.identityEd25519Pub), payload, fromB64(sessionSig));
+    } catch {
+      sigOk = false;
+    }
+    if (!sigOk) {
+      console.warn(`[fetchproxy] ${opts.serverName}: extension session signature invalid \u2014 refusing (the concentrator may be answering in the browser's place)`);
+      return false;
+    }
+    if (cachedPin === void 0) {
+      try {
+        cachedPin = await opts.extensionTrust.read();
+      } catch (e) {
+        console.error(`[fetchproxy] ${String(e)}`);
+        return false;
+      }
+    }
+    const pin = cachedPin;
+    const outcome = decideExtensionTrust({
+      pin,
+      hello: extensionHello,
+      allowNew: opts.extensionTrust.allowNew,
+      serverName: opts.serverName,
+      location: opts.extensionTrust.location
+    });
+    if (outcome.decision === "refused") {
+      console.warn(outcome.message);
+      return false;
+    }
+    if (outcome.decision === "replace")
+      console.warn(outcome.message);
+    if (outcome.decision !== "pinned") {
+      try {
+        const written = {
+          identityX25519Pub: extensionHello.identityX25519Pub,
+          identityEd25519Pub: extensionHello.identityEd25519Pub,
+          pinnedAt: Date.now()
+        };
+        await opts.extensionTrust.write(written);
+        cachedPin = written;
+      } catch (e) {
+        console.error(`[fetchproxy] could not persist the extension pin: ${String(e)}`);
+      }
+    }
+    return true;
+  };
   const onMessage = async (data) => {
     try {
       const raw = JSON.parse(data.toString());
       const frame = validateFrame(raw);
+      if (frame.type === "hello" && frame.role === "extension") {
+        extensionHello = frame;
+        return;
+      }
       if (frame.type === "ready" && frame.mcpId === opts.mcpId) {
+        const authorised = await authenticateExtension(frame.sessionSig, frame.extensionSessionPub);
+        if (!authorised) {
+          ws.close(1008, "extension identity refused");
+          rejectFirstReady(new Error("peer: extension identity refused"));
+          return;
+        }
         const extPub = fromB64(frame.extensionSessionPub);
         const shared = await ecdhX25519(opts.identity.x25519Priv, extPub);
         const sessionKey = await hkdfSha256(shared, sessionNonce, enc3.encode(HKDF_SESSION_INFO), 32);
@@ -12422,67 +12782,11 @@ var init_peer = __esm({
     init_build_server_hello();
     init_session();
     init_session_ready();
+    init_extension_trust();
     enc3 = new TextEncoder();
   }
 });
 
-// node_modules/@fetchproxy/server/dist/identity.js
-import { readFile, writeFile, mkdir, chmod } from "node:fs/promises";
-import { join as join2 } from "node:path";
-import { homedir } from "node:os";
-function defaultIdentityDir() {
-  return join2(homedir(), ".fetchproxy", "identity");
-}
-async function loadOrCreateIdentity(serverName, dir = defaultIdentityDir()) {
-  if (!serverName || serverName === ".." || serverName.includes("..") || !SAFE_PLAIN.test(serverName) && !SAFE_SCOPED.test(serverName)) {
-    throw new Error(`unsafe serverName for identity file: ${JSON.stringify(serverName)}`);
-  }
-  const safeFile = serverName.replace(/\//g, "_");
-  const path = join2(dir, `${safeFile}.json`);
-  await mkdir(dir, { recursive: true, mode: 448 });
-  try {
-    const raw = await readFile(path, "utf8");
-    const j2 = JSON.parse(raw);
-    return {
-      x25519Priv: fromB64(j2.x25519Priv),
-      x25519Pub: fromB64(j2.x25519Pub),
-      ed25519Priv: fromB64(j2.ed25519Priv),
-      ed25519Pub: fromB64(j2.ed25519Pub),
-      createdAt: j2.createdAt
-    };
-  } catch (e) {
-    if (e.code !== "ENOENT")
-      throw e;
-  }
-  const x = await generateX25519();
-  const ed = await generateEd25519();
-  const id = {
-    x25519Priv: x.privateKey,
-    x25519Pub: x.publicKey,
-    ed25519Priv: ed.privateKey,
-    ed25519Pub: ed.publicKey,
-    createdAt: Date.now()
-  };
-  const j = {
-    x25519Priv: toB64(id.x25519Priv),
-    x25519Pub: toB64(id.x25519Pub),
-    ed25519Priv: toB64(id.ed25519Priv),
-    ed25519Pub: toB64(id.ed25519Pub),
-    createdAt: id.createdAt
-  };
-  await writeFile(path, JSON.stringify(j, null, 2), { mode: 384 });
-  await chmod(path, 384);
-  return id;
-}
-var SAFE_PLAIN, SAFE_SCOPED;
-var init_identity = __esm({
-  "node_modules/@fetchproxy/server/dist/identity.js"() {
-    init_dist();
-    SAFE_PLAIN = /^[A-Za-z0-9._-]+$/;
-    SAFE_SCOPED = /^@[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
-  }
-});
-
 // node_modules/@fetchproxy/server/dist/error-kind.js
 function classifyFetchError(error51) {
   if (/Could not establish connection/i.test(error51) || /Receiving end does not exist/i.test(error51)) {
@@ -12532,6 +12836,24 @@ var init_classify_bridge_error = __esm({
 });
 
 // node_modules/@fetchproxy/server/dist/ws-server.js
+function protocolErrorFrom(error51) {
+  if (SCOPE_REJECTION.test(error51))
+    return new FetchproxyScopeError(error51);
+  if (NO_TAB_REJECTION.test(error51))
+    return new FetchproxyNoTabError(error51);
+  return new FetchproxyProtocolError(error51);
+}
+function normalizeCookiePath(path) {
+  if (path === void 0 || path === "")
+    return void 0;
+  const trimmed = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+  try {
+    assertCookiePath(trimmed, "path");
+  } catch (e) {
+    throw new Error(`FetchproxyServer: ${e instanceof Error ? e.message : String(e)} (got ${JSON.stringify(path)})`);
+  }
+  return trimmed;
+}
 function assertSubdomainLabel(label) {
   if (!SUBDOMAIN_LABEL_RE.test(label)) {
     throw new Error(`FetchproxyServer: subdomain must be a DNS label like "www" or "api" (or dot-separated like "auth.api"), got ${JSON.stringify(label)}`);
@@ -12556,7 +12878,7 @@ function assertUrlInDomains(field, url2, domains) {
   const declared = domains.map((d) => JSON.stringify(d)).join(", ");
   throw new Error(`FetchproxyServer: ${field} host "${host}" is outside declared domains [${declared}] \u2014 must be one of them or a subdomain`);
 }
-var FetchproxyProtocolError, FetchproxyHttpError, FetchproxyBridgeDownError, FetchproxyTimeoutError, SUBDOMAIN_LABEL_RE, DEFAULT_JSON_OK_STATUSES, FetchproxyServer;
+var FetchproxyProtocolError, FetchproxyHttpError, FetchproxyBridgeDownError, FetchproxyHintedError, FetchproxyScopeError, FetchproxyNoTabError, SCOPE_REJECTION, NO_TAB_REJECTION, FetchproxyTimeoutError, SUBDOMAIN_LABEL_RE, DEFAULT_JSON_OK_STATUSES, FetchproxyServer;
 var init_ws_server = __esm({
   "node_modules/@fetchproxy/server/dist/ws-server.js"() {
     init_dist();
@@ -12564,6 +12886,7 @@ var init_ws_server = __esm({
     init_host();
     init_peer();
     init_identity();
+    init_extension_trust();
     init_error_kind();
     init_classify_bridge_error();
     FetchproxyProtocolError = class extends Error {
@@ -12607,6 +12930,32 @@ var init_ws_server = __esm({
         this.hint = hint;
       }
     };
+    FetchproxyHintedError = class extends FetchproxyProtocolError {
+      /** The extension's raw rejection, unmodified. */
+      originalError;
+      /** What the user should actually do, in prose. */
+      hint;
+      constructor(originalError, hint) {
+        super(`${originalError} \u2014 ${hint}`);
+        this.name = "FetchproxyHintedError";
+        this.originalError = originalError;
+        this.hint = hint;
+      }
+    };
+    FetchproxyScopeError = class extends FetchproxyHintedError {
+      constructor(originalError) {
+        super(originalError, "the declared scope changed since you paired, so the extension is refusing the request. Revoke this MCP in the Transporter extension popup, then re-run \u2014 you will be asked to approve the new scope. This is not a version problem and does not need an update.");
+        this.name = "FetchproxyScopeError";
+      }
+    };
+    FetchproxyNoTabError = class extends FetchproxyHintedError {
+      constructor(originalError) {
+        super(originalError, "open a tab on that host and sign in, then re-run. This is not a version problem and does not need an update.");
+        this.name = "FetchproxyNoTabError";
+      }
+    };
+    SCOPE_REJECTION = /not in declared/;
+    NO_TAB_REJECTION = /no tab matching (?!.*content script loaded)/;
     FetchproxyTimeoutError = class extends FetchproxyProtocolError {
       url;
       timeoutMs;
@@ -12676,6 +13025,9 @@ var init_ws_server = __esm({
       // them off from `pending` (fetch) and `pendingReadCookies` (legacy
       // string-shape) so the response routing in `onInner` stays linear.
       pendingStorage = /* @__PURE__ */ new Map();
+      // 1.12.0+: write-cookies awaiters resolve the list of names actually
+      // written, so a caller can confirm rather than assume.
+      pendingWriteCookies = /* @__PURE__ */ new Map();
       // 0.3.0+: capture-header awaiters resolve a single string.
       pendingCapture = /* @__PURE__ */ new Map();
       // capture_redirect awaiters resolve the captured redirect URL string.
@@ -12802,6 +13154,8 @@ var init_ws_server = __esm({
           keepAliveIntervalMs: opts.keepAliveIntervalMs ?? 2e4,
           keepAliveMaxIdleMs: opts.keepAliveMaxIdleMs ?? 5 * 60 * 1e3,
           identityDir: opts.identityDir,
+          allowNewExtensionIdentity: opts.allowNewExtensionIdentity,
+          requireExtensionIdentity: opts.requireExtensionIdentity,
           onPairCode: opts.onPairCode
         };
       }
@@ -12901,7 +13255,8 @@ var init_ws_server = __esm({
             ownSessionStoragePointers: this.opts.sessionStoragePointers,
             ownDomSelectors: this.opts.domSelectors,
             ownGraphqlOps: this.opts.graphqlOps,
-            onPairCode: this.opts.onPairCode
+            onPairCode: this.opts.onPairCode,
+            extensionTrust: this.extensionTrust()
           });
           this.hostHandle.onOwnInner((inner) => this.onInner(inner));
           this.hostHandle.onExtensionDisconnect(() => {
@@ -12930,7 +13285,9 @@ var init_ws_server = __esm({
             localStoragePointers: this.opts.localStoragePointers,
             sessionStoragePointers: this.opts.sessionStoragePointers,
             domSelectors: this.opts.domSelectors,
-            graphqlOps: this.opts.graphqlOps
+            graphqlOps: this.opts.graphqlOps,
+            extensionTrust: this.extensionTrust(),
+            requireExtensionIdentity: this.opts.requireExtensionIdentity
           });
           this.peerHandle.onInner((inner) => this.onInner(inner));
           this.peerHandle.onRenegotiate(() => {
@@ -13069,6 +13426,23 @@ var init_ws_server = __esm({
       markActive() {
         this.noteActivityForKeepalive();
       }
+      /**
+       * #208: this MCP's pin on the extension's identity, stored beside its own
+       * identity key and so following `identityDir` wherever the caller put it.
+       *
+       * `allowNewExtensionIdentity` falls back to an environment variable when the
+       * caller expressed no opinion, because the thirteen MCPs that construct this
+       * class are separate packages: an operator whose extension re-install has
+       * just locked all of them out needs one lever that does not require patching
+       * every one of them.
+       */
+      extensionTrust() {
+        return fileExtensionTrust({
+          serverName: this.opts.serverName,
+          dir: this.opts.identityDir,
+          allowNew: allowNewExtensionIdentity(this.opts.allowNewExtensionIdentity)
+        });
+      }
       noteActivityForKeepalive() {
         const intervalMs = this.opts.keepAliveIntervalMs;
         if (intervalMs <= 0)
@@ -13132,6 +13506,7 @@ var init_ws_server = __esm({
             this.pending.delete(id);
             this.pendingReadCookies.delete(id);
             this.pendingStorage.delete(id);
+            this.pendingWriteCookies.delete(id);
             this.pendingCapture.delete(id);
             this.pendingRedirect.delete(id);
             this.pendingDownload.delete(id);
@@ -13253,7 +13628,7 @@ var init_ws_server = __esm({
             port: this.opts.port
           });
         }
-        return new FetchproxyProtocolError(result.error);
+        return protocolErrorFrom(result.error);
       }
       /**
        * Convenience wrapper around `fetch()`. Builds the URL from a path
@@ -13289,10 +13664,20 @@ var init_ws_server = __esm({
         }
         const url2 = isAbsolute ? path : `https://${host}${path}`;
         assertUrlInDomains("request url", url2, this.opts.domains);
+        let tabUrl = `https://${host}/`;
+        if (opts.viaTab !== void 0) {
+          try {
+            new URL(opts.viaTab);
+          } catch {
+            throw new Error(`FetchproxyServer.request: viaTab is not a valid URL: ${JSON.stringify(opts.viaTab)}`);
+          }
+          assertUrlInDomains("viaTab", opts.viaTab, this.opts.domains);
+          tabUrl = opts.viaTab;
+        }
         const init = {
           url: url2,
           method,
-          tabUrl: `https://${host}/`,
+          tabUrl,
           headers: opts.headers,
           body: opts.body
         };
@@ -13504,9 +13889,14 @@ var init_ws_server = __esm({
         let inner;
         if (opts.keys !== void 0) {
           this.assertScopeSubset(opts.keys, this.opts.cookieKeys, "cookieKeys");
+          const cookiePath = normalizeCookiePath(opts.path);
           const initV3 = {
+            // Origin stays BARE. The path travels as its own validated field —
+            // `assertHttpsOriginOnly` deliberately refuses a path here so one
+            // cannot be used to re-point the read past the domain gate.
             origin: `https://${host}`,
-            keys: [...opts.keys]
+            keys: [...opts.keys],
+            ...cookiePath !== void 0 ? { path: cookiePath } : {}
           };
           inner = { type: "request", id, op: "read_cookies", init: initV3 };
         } else {
@@ -13519,10 +13909,65 @@ var init_ws_server = __esm({
         await this.sendInnerFrame(inner);
         const result = await this._withVerbTimeout(pending, this.pendingReadCookies, id, `https://${host}`);
         if (!result.ok) {
-          throw new FetchproxyProtocolError(result.error);
+          throw protocolErrorFrom(result.error);
         }
         return result.cookies;
       }
+      /**
+       * 1.12.0+: overwrite the value of cookies this MCP already declares.
+       *
+       * The bridge's only write verb, and it exists for one failure class. Sites
+       * that ROTATE a credential cookie hand back a new value on every refresh; if
+       * the MCP refreshes and keeps the result to itself, the copy in the browser's
+       * cookie jar is dead, and the user gets signed out of a tab they never
+       * touched — usually reported to them as "inactivity". Writing the rotated
+       * value back is the only thing that repairs it.
+       *
+       * Requires `'write_cookies'` in capabilities, which the user approves at pair
+       * time as its own line. Every name must ALSO be in declared `cookieKeys`: a
+       * write can never reach a cookie the MCP was not already trusted to read, so
+       * granting it cannot widen which cookies are in play — only what may be done
+       * to the ones already listed.
+       *
+       * The extension refuses the whole request unless every named cookie already
+       * exists; this refreshes a value in place and deliberately cannot author new
+       * cookies. Returns the names actually written.
+       */
+      async writeCookies(opts) {
+        if (!this.opts.capabilities.includes("write_cookies")) {
+          throw new Error('FetchproxyServer.writeCookies(): MCP did not declare "write_cookies" in capabilities \u2014 add it to FetchproxyServerOpts.capabilities to enable this verb');
+        }
+        const names = Object.keys(opts.cookies);
+        if (names.length === 0) {
+          throw new Error("FetchproxyServer.writeCookies(): no cookies given");
+        }
+        await this.ensureConnected();
+        this.throwIfPendingPair();
+        if (opts.subdomain !== void 0)
+          assertSubdomainLabel(opts.subdomain);
+        const baseDomain = this.resolveBaseDomain(opts.domain);
+        const host = opts.subdomain ? `${opts.subdomain}.${baseDomain}` : baseDomain;
+        this.assertScopeSubset(names, this.opts.cookieKeys, "cookieKeys");
+        const cookiePath = normalizeCookiePath(opts.path);
+        const id = this.nextRequestId++;
+        const inner = {
+          type: "request",
+          id,
+          op: "write_cookies",
+          init: {
+            // Bare origin, same invariant as the read path: a path must never be
+            // able to move the request past the domain gate.
+            origin: `https://${host}`,
+            cookies: Object.entries(opts.cookies).map(([name, value]) => ({ name, value })),
+            ...cookiePath !== void 0 ? { path: cookiePath } : {}
+          }
+        };
+        const pending = new Promise((resolve, reject) => {
+          this.pendingWriteCookies.set(id, { resolve, reject });
+        });
+        await this.sendInnerFrame(inner);
+        return this._withVerbTimeout(pending, this.pendingWriteCookies, id, `https://${host}`);
+      }
       /**
        * 0.3.0+: read declared localStorage keys from the user's signed-in
        * tab. Requires `'read_local_storage'` in capabilities AND each key
@@ -14069,7 +14514,7 @@ var init_ws_server = __esm({
               storageCb.reject(new FetchproxyProtocolError(`unexpected ${String(inner.op)} response on storage awaiter`));
             }
           } else {
-            storageCb.reject(new FetchproxyProtocolError(inner.error));
+            storageCb.reject(protocolErrorFrom(inner.error));
           }
           return;
         }
@@ -14083,7 +14528,7 @@ var init_ws_server = __esm({
               captureCb.reject(new FetchproxyProtocolError(`unexpected ${String(inner.op)} response on capture awaiter`));
             }
           } else {
-            captureCb.reject(new FetchproxyProtocolError(inner.error));
+            captureCb.reject(protocolErrorFrom(inner.error));
           }
           return;
         }
@@ -14097,7 +14542,7 @@ var init_ws_server = __esm({
               redirectCb.reject(new FetchproxyProtocolError(`unexpected ${String(inner.op)} response on capture_redirect awaiter`));
             }
           } else {
-            redirectCb.reject(new FetchproxyProtocolError(inner.error));
+            redirectCb.reject(protocolErrorFrom(inner.error));
           }
           return;
         }
@@ -14111,7 +14556,7 @@ var init_ws_server = __esm({
               idbCb.reject(new FetchproxyProtocolError(`unexpected ${String(inner.op)} response on read_indexed_db awaiter`));
             }
           } else {
-            idbCb.reject(new FetchproxyProtocolError(inner.error));
+            idbCb.reject(protocolErrorFrom(inner.error));
           }
           return;
         }
@@ -14125,7 +14570,7 @@ var init_ws_server = __esm({
               downloadCb.reject(new FetchproxyProtocolError(`unexpected ${String(inner.op)} response on download awaiter`));
             }
           } else {
-            downloadCb.reject(new FetchproxyProtocolError(inner.error));
+            downloadCb.reject(protocolErrorFrom(inner.error));
           }
           return;
         }
@@ -14139,7 +14584,17 @@ var init_ws_server = __esm({
               graphqlCb.reject(new FetchproxyProtocolError(`unexpected ${String(inner.op)} response on graphql_query awaiter`));
             }
           } else {
-            graphqlCb.reject(new FetchproxyProtocolError(inner.error));
+            graphqlCb.reject(protocolErrorFrom(inner.error));
+          }
+          return;
+        }
+        const writeCookiesCb = this.pendingWriteCookies.get(inner.id);
+        if (writeCookiesCb) {
+          this.pendingWriteCookies.delete(inner.id);
+          if (inner.ok && inner.op === "write_cookies") {
+            writeCookiesCb.resolve([...inner.written]);
+          } else {
+            writeCookiesCb.reject(protocolErrorFrom(inner.ok ? "write_cookies response had the wrong op" : inner.error));
           }
           return;
         }
@@ -14182,6 +14637,9 @@ var init_ws_server = __esm({
         for (const { reject } of this.pendingStorage.values())
           reject(err);
         this.pendingStorage.clear();
+        for (const { reject } of this.pendingWriteCookies.values())
+          reject(err);
+        this.pendingWriteCookies.clear();
         for (const { reject } of this.pendingCapture.values())
           reject(err);
         this.pendingCapture.clear();
@@ -14560,6 +15018,8 @@ var init_dist2 = __esm({
     init_deadline();
     init_parse_html();
     init_batch();
+    init_extension_trust();
+    init_identity();
   }
 });
 
@@ -39265,7 +39725,7 @@ var pageSchema = {
 init_errors();
 
 // src/version.ts
-var VERSION = "0.1.0";
+var VERSION = "0.1.2";
 
 // src/client.ts
 import { dirname, join } from "path";
@@ -39286,10 +39746,10 @@ var EventbriteClient = class {
    * host's install-time smoke test) when EVENTBRITE_TOKEN isn't set yet.
    * Tool calls re-raise the error at request time.
    *
-   * Optional constructor seam: the hosted Cloudflare connector builds one
+   * Optional constructor seam: a hosted per-user deployment builds one
    * client per request with that user's `token` injected. The stdio path
    * passes no options, so the token resolves from the environment.
-   * The constructor is PURE (no I/O, no randomness) — it is run in Worker
+   * The constructor is PURE (no I/O, no randomness) — it may run in module
    * global scope via the module singleton below.
    */
   constructor(opts) {
@@ -39510,7 +39970,7 @@ var DiscoveryClient = class {
    * 1. `api` — `POST eventbriteapi.com/v3/destination/search/` with a bearer
    *    token. Verified live 2026-07-30: works with a private OR public token,
    *    no WAF, no CSRF, no cookies. This is the default because it needs no
-   *    browser and therefore works inside a Worker.
+   *    browser and therefore works without the bridge.
    * 2. `transport` — the fetchproxy bridge through a signed-in tab. Retained as
    *    a fallback for when no token is configured, or the API route refuses.
    *

package/dist/client.js

@@ -4,9 +4,9 @@ import { loadDotenvSafely, readEnvVar, createApiClient } from '@chrischall/mcp-u
 // Load .env for local dev; silently skip if dotenv is unavailable (e.g. mcpb
 // bundle). `loadDotenvSafely` swallows a missing dotenv module and never lets
 // .env override a host-provided value.
-// The try/catch guards the Cloudflare Worker runtime, where `import.meta.url`
+// The try/catch guards a non-Node runtime, where `import.meta.url`
 // is undefined and `fileURLToPath(undefined)` would throw at module init
-// (Worker startup validation) — there is no filesystem / .env to load there.
+// startup validation in such a runtime — and there is no .env to load there.
 try {
     const dir = dirname(fileURLToPath(import.meta.url));
     await loadDotenvSafely({ path: join(dir, '..', '.env'), override: false });
@@ -32,10 +32,10 @@ export class EventbriteClient {
      * host's install-time smoke test) when EVENTBRITE_TOKEN isn't set yet.
      * Tool calls re-raise the error at request time.
      *
-     * Optional constructor seam: the hosted Cloudflare connector builds one
+     * Optional constructor seam: a hosted per-user deployment builds one
      * client per request with that user's `token` injected. The stdio path
      * passes no options, so the token resolves from the environment.
-     * The constructor is PURE (no I/O, no randomness) — it is run in Worker
+     * The constructor is PURE (no I/O, no randomness) — it may run in module
      * global scope via the module singleton below.
      */
     constructor(opts) {

package/dist/discovery.js

@@ -19,7 +19,7 @@ function isUsableBrowsePage(result) {
         return false;
     return typeof result.body === 'string' && PLACE_ID_RE.test(result.body);
 }
-/** `fetch` with an AbortController deadline; called directly for workerd. */
+/** `fetch` with an AbortController deadline. */
 async function fetchWithTimeout(url, ms) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), ms);
@@ -219,7 +219,7 @@ export class DiscoveryClient {
      * 1. `api` — `POST eventbriteapi.com/v3/destination/search/` with a bearer
      *    token. Verified live 2026-07-30: works with a private OR public token,
      *    no WAF, no CSRF, no cookies. This is the default because it needs no
-     *    browser and therefore works inside a Worker.
+     *    browser and therefore works without the bridge.
      * 2. `transport` — the fetchproxy bridge through a signed-in tab. Retained as
      *    a fallback for when no token is configured, or the API route refuses.
      *

package/dist/index.js

@@ -15,7 +15,7 @@ import { registerDiscoveryTools } from './tools/discovery.js';
 //    documented host serves the consumer search at
 //    POST /destination/search/ with a plain bearer token — no WAF, no CSRF,
 //    no browser. That is now the primary route, so discovery works in a
-//    Worker too. The fetchproxy bridge (port 37149, bound lazily) is kept as
+//    a bridge-less deployment too. The bridge (port 37149, bound lazily) is kept as
 //    a FALLBACK for when no token is configured or the API route refuses.
 const transport = new FetchproxyTransport({
     version: VERSION,

package/dist/tools/account.js

@@ -3,7 +3,7 @@ import { textResult } from '@chrischall/mcp-utils';
 import { enc, qs, schemaContinuation } from './params.js';
 /**
  * Account-side tools on the documented API (`eventbriteapi.com/v3`, bearer
- * token). Transport-neutral: the hosted connector registers these with a
+ * token). Transport-neutral: a hosted deployment registers these with a
  * per-user client.
  */
 export function registerAccountTools(server, deps) {

package/dist/tools/discovery.js

@@ -5,7 +5,7 @@ import { toCompactEvent } from '../discovery.js';
  * Public event discovery. Verified live 2026-07-30: the documented host serves
  * the consumer search at POST /destination/search/ with a plain bearer token —
  * no WAF, no CSRF, no cookies — so these tools no longer require a browser and
- * ARE registered by the hosted connector. The fetchproxy bridge remains a
+ * ARE registered without a bridge. The fetchproxy bridge remains a
  * fallback on the stdio path.
  */
 export async function registerDiscoveryTools(server, deps) {
@@ -99,13 +99,13 @@ export async function registerDiscoveryTools(server, deps) {
         const data = await discovery.eventsByIds(event_ids, expand ? expand.split(',').map((s) => s.trim()) : undefined);
         return textResult(data);
     });
-    // eb_healthcheck diagnoses the BRIDGE. With no bridge (the Worker connector)
+    // eb_healthcheck diagnoses the BRIDGE. With no bridge
     // there is nothing for it to report on, so it is not registered at all —
     // better than a tool that always answers "no transport".
     if (!transport)
         return;
     // Imported lazily, AFTER the guard: a static import would drag the fetchproxy
-    // helper into the Worker bundle where it can never run.
+    // helper into a bundle where it can never run.
     const { registerBridgeHealthcheckTool } = await import('@chrischall/mcp-utils/fetchproxy');
     // The categories endpoint answers 200 JSON on the www host regardless of
     // login state, so it isolates bridge problems from Eventbrite-side problems.

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.0'; // x-release-please-version
+export const VERSION = '0.1.2'; // x-release-please-version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrischall/eventbrite-mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "mcpName": "io.github.chrischall/eventbrite-mcp",
   "description": "Eventbrite MCP server for Claude — developed and maintained by AI (Claude Code)",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -40,33 +40,23 @@
     "dev": "node dist/index.js",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "worker:dev": "wrangler dev",
-    "worker:deploy": "wrangler deploy",
-    "worker:test": "vitest run --config vitest.workers.config.ts"
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
     "@chrischall/mcp-utils": "^0.14.0",
-    "@fetchproxy/server": "^1.7.0",
+    "@fetchproxy/server": "^2.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "dotenv": "^17.4.0",
     "zod": "^4.4.2"
   },
   "devDependencies": {
-    "@chrischall/mcp-connector": "^1.1.1",
-    "@cloudflare/vitest-pool-workers": "^0.19.0",
-    "@cloudflare/workers-oauth-provider": "^0.8.1",
-    "@cloudflare/workers-types": "^5.20260708.1",
     "@types/node": "^26.0.0",
     "@vitest/coverage-v8": "^4.1.2",
-    "agents": "^0.19.0",
     "esbuild": "^0.28.0",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.2",
-    "wrangler": "^4.110.0"
+    "vitest": "^4.1.2"
   },
   "allowScripts": {
-    "esbuild@0.28.1": true,
-    "workerd@1.20260722.1": true
+    "esbuild@0.28.1": true
   }
 }

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/chrischall/eventbrite-mcp",
     "source": "github"
   },
-  "version": "0.1.0",
+  "version": "0.1.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@chrischall/eventbrite-mcp",
-      "version": "0.1.0",
+      "version": "0.1.2",
       "transport": {
         "type": "stdio"
       },

package/dist/eventbrite-auth.js

@@ -1,18 +0,0 @@
-import { EventbriteClient } from './client.js';
-/**
- * `ConnectorAuth` for the Eventbrite remote connector: the login page collects
- * the user's personal Eventbrite token (eventbrite.com/platform/api-keys),
- * verifies it against the current-user endpoint (a bad token throws, which
- * the connector surfaces back on the login page), and stores `{ token }`.
- */
-export const eventbriteAuth = {
-    service: 'Eventbrite',
-    accent: '#F05537',
-    privacyNote: 'Your Eventbrite private token is stored encrypted and used only to call the Eventbrite API on your behalf.',
-    fields: [{ name: 'token', label: 'Eventbrite private token', type: 'password' }],
-    async login(fields) {
-        const client = new EventbriteClient({ token: fields.token });
-        await client.request('GET', '/users/me/');
-        return { token: fields.token };
-    },
-};