@chrischall/tripadvisor-mcp 0.3.1 → 0.3.3

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   },
   "metadata": {
     "description": "MCP server for the TripAdvisor Terra API — location search, details, photos, and reviews",
-    "version": "0.3.1"
+    "version": "0.3.3"
   },
   "plugins": [
     {
@@ -15,7 +15,7 @@
       "displayName": "TripAdvisor",
       "source": "./",
       "description": "TripAdvisor travel data via the Terra API — search hotels, restaurants, and attractions, with details, photos, and reviews",
-      "version": "0.3.1",
+      "version": "0.3.3",
       "author": {
         "name": "Chris Hall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "tripadvisor-mcp",
   "displayName": "TripAdvisor",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "MCP server for the TripAdvisor Terra API — location search, details, photos, and reviews",
   "author": {
     "name": "Chris Hall",

package/dist/bundle.js

@@ -26725,17 +26725,33 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
+function getDotPath(path) {
+  if (path.length === 0) {
+    return "object root";
+  }
+  return path.reduce((acc, seg, index) => {
+    if (index === 0) {
+      return String(seg);
+    }
+    if (typeof seg === "number") {
+      return `${acc}[${seg}]`;
+    }
+    return `${acc}.${seg}`;
+  }, "");
+}
 function getParseErrorMessage(error51) {
   if (error51 && typeof error51 === "object") {
+    if ("issues" in error51 && Array.isArray(error51.issues) && error51.issues.length > 0) {
+      return error51.issues.map((i) => {
+        if (!i.path?.length) {
+          return i.message;
+        }
+        return `${i.message} at ${getDotPath(i.path)}`;
+      }).join("\n");
+    }
     if ("message" in error51 && typeof error51.message === "string") {
       return error51.message;
     }
-    if ("issues" in error51 && Array.isArray(error51.issues) && error51.issues.length > 0) {
-      const firstIssue = error51.issues[0];
-      if (firstIssue && typeof firstIssue === "object" && "message" in firstIssue) {
-        return String(firstIssue.message);
-      }
-    }
     try {
       return JSON.stringify(error51);
     } catch {
@@ -33350,16 +33366,7 @@ var Server = class extends Protocol {
     if (!methodSchema) {
       throw new Error("Schema is missing a method literal");
     }
-    let methodValue;
-    if (isZ4Schema(methodSchema)) {
-      const v4Schema = methodSchema;
-      const v4Def = v4Schema._zod?.def;
-      methodValue = v4Def?.value ?? v4Schema.value;
-    } else {
-      const v3Schema = methodSchema;
-      const legacyDef = v3Schema._def;
-      methodValue = legacyDef?.value ?? v3Schema.value;
-    }
+    const methodValue = getLiteralValue(methodSchema);
     if (typeof methodValue !== "string") {
       throw new Error("Schema method literal must be a string");
     }
@@ -34547,8 +34554,17 @@ var EMPTY_COMPLETION_RESULT = {
 import process3 from "node:process";
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+var STDIO_DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
 var ReadBuffer = class {
+  constructor(options) {
+    this._maxBufferSize = options?.maxBufferSize ?? STDIO_DEFAULT_MAX_BUFFER_SIZE;
+  }
   append(chunk2) {
+    const newSize = (this._buffer?.length ?? 0) + chunk2.length;
+    if (newSize > this._maxBufferSize) {
+      this.clear();
+      throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
+    }
     this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk2]) : chunk2;
   }
   readMessage() {
@@ -34576,18 +34592,24 @@ function serializeMessage(message) {
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 var StdioServerTransport = class {
-  constructor(_stdin = process3.stdin, _stdout = process3.stdout) {
+  constructor(_stdin = process3.stdin, _stdout = process3.stdout, options) {
     this._stdin = _stdin;
     this._stdout = _stdout;
-    this._readBuffer = new ReadBuffer();
     this._started = false;
     this._ondata = (chunk2) => {
-      this._readBuffer.append(chunk2);
-      this.processReadBuffer();
+      try {
+        this._readBuffer.append(chunk2);
+        this.processReadBuffer();
+      } catch (error51) {
+        this.onerror?.(error51);
+        this.close().catch(() => {
+        });
+      }
     };
     this._onerror = (error51) => {
       this.onerror?.(error51);
     };
+    this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
   }
   /**
    * Starts listening for messages on stdin.
@@ -34936,7 +34958,7 @@ var pageSchema = {
 };
 
 // src/version.ts
-var VERSION = "0.3.1";
+var VERSION = "0.3.3";
 
 // src/client.ts
 import { dirname, join } from "node:path";
@@ -35260,8 +35282,15 @@ function registerLocationTools(server) {
 }
 
 // node_modules/@fetchproxy/protocol/dist/frames.js
-var PROTOCOL_VERSION = 2;
+var PROTOCOL_VERSION = 3;
 var HKDF_SESSION_INFO = "fetchproxy/1.0.0/session";
+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 KNOWN_CAPABILITIES = /* @__PURE__ */ new Set([
   "fetch",
   "read_cookies",
@@ -35271,7 +35300,9 @@ var KNOWN_CAPABILITIES = /* @__PURE__ */ new Set([
   "capture_redirect",
   "read_indexed_db",
   "read_dom",
-  "download"
+  "download",
+  "graphql",
+  "write_cookies"
 ]);
 
 // node_modules/@fetchproxy/protocol/dist/mcp-id.js
@@ -35382,6 +35413,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;
@@ -35574,6 +35614,7 @@ function assertIndexedDbScopesArray(value, label) {
 }
 var DOM_SELECTOR_RE = /^[^-]{1,512}$/;
 var DOM_ATTRIBUTE_RE = /^[A-Za-z_:][A-Za-z0-9_:.\-]{0,127}$/;
+var GRAPHQL_OP_NAME_RE = /^[_A-Za-z][_0-9A-Za-z]{0,127}$/;
 function assertDomSelectorsArray(value, label) {
   if (!Array.isArray(value)) {
     throw new ProtocolError(`${label}: expected array, got ${typeof value}`);
@@ -35610,6 +35651,37 @@ function assertDomSelectorsArray(value, label) {
     }
   }
 }
+function assertGraphqlOpsArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new ProtocolError(`${label}: expected array, got ${typeof value}`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < value.length; i++) {
+    const entry = value[i];
+    assertObject(entry, `${label}[${i}]`);
+    if (entry.name === void 0) {
+      throw new ProtocolError(`${label}[${i}].name: missing`);
+    }
+    if (entry.operationName === void 0) {
+      throw new ProtocolError(`${label}[${i}].operationName: missing`);
+    }
+    if (typeof entry.name !== "string" || !SCOPE_KEY_RE.test(entry.name)) {
+      throw new ProtocolError(`${label}[${i}].name: invalid ${JSON.stringify(entry.name)}`);
+    }
+    if (typeof entry.operationName !== "string" || !GRAPHQL_OP_NAME_RE.test(entry.operationName)) {
+      throw new ProtocolError(`${label}[${i}].operationName: invalid ${JSON.stringify(entry.operationName)}`);
+    }
+    if (seen.has(entry.name)) {
+      throw new ProtocolError(`${label}: duplicate name ${JSON.stringify(entry.name)}`);
+    }
+    seen.add(entry.name);
+    for (const k of Object.keys(entry)) {
+      if (k !== "name" && k !== "operationName") {
+        throw new ProtocolError(`${label}[${i}]: unexpected field ${JSON.stringify(k)}`);
+      }
+    }
+  }
+}
 function validateFrame(raw) {
   assertObject(raw, "frame");
   const t = raw.type;
@@ -35688,6 +35760,9 @@ function validateHello(raw) {
     if (raw.domSelectors !== void 0) {
       assertDomSelectorsArray(raw.domSelectors, "hello.domSelectors");
     }
+    if (raw.graphqlOps !== void 0) {
+      assertGraphqlOpsArray(raw.graphqlOps, "hello.graphqlOps");
+    }
     assertBase64(raw.identityX25519Pub, "hello.identityX25519Pub");
     assertBase64(raw.identityEd25519Pub, "hello.identityEd25519Pub");
     assertBase64(raw.sessionNonce, "hello.sessionNonce");
@@ -35791,13 +35866,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) {
@@ -35937,6 +36042,28 @@ function validateInnerRequest(raw) {
     }
     return raw;
   }
+  if (raw.op === "graphql_query") {
+    assertObject(raw.init, "inner.init");
+    if (raw.init.name === void 0)
+      throw new ProtocolError("inner.init.name: missing");
+    if (raw.init.variables === void 0) {
+      throw new ProtocolError("inner.init.variables: missing");
+    }
+    assertString(raw.init.name, "inner.init.name");
+    if (raw.init.name.length === 0) {
+      throw new ProtocolError("inner.init.name: must be non-empty");
+    }
+    assertObject(raw.init.variables, "inner.init.variables");
+    if (raw.init.tabUrl !== void 0) {
+      assertString(raw.init.tabUrl, "inner.init.tabUrl");
+    }
+    for (const k of Object.keys(raw.init)) {
+      if (k !== "name" && k !== "variables" && k !== "tabUrl") {
+        throw new ProtocolError(`inner.init: unexpected field ${JSON.stringify(k)} on graphql_query`);
+      }
+    }
+    return raw;
+  }
   if (raw.op === "download") {
     assertObject(raw.init, "inner.init");
     if (raw.init.url === void 0) {
@@ -35962,7 +36089,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"; 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)) {
@@ -35993,6 +36120,10 @@ function assertStringMap(value, label) {
     }
   }
 }
+var KNOWN_RESPONSE_OPS = /* @__PURE__ */ new Set([
+  ...KNOWN_CAPABILITIES,
+  "graphql_query"
+]);
 function validateInnerResponse(raw) {
   assertPositiveInt(raw.id, "inner.id");
   if (raw.ok === true) {
@@ -36019,6 +36150,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`);
@@ -36054,6 +36197,13 @@ function validateInnerResponse(raw) {
       assertStringMap(raw.values, "inner.values");
       return raw;
     }
+    if (op === "graphql_query") {
+      if (raw.data === void 0) {
+        throw new ProtocolError("inner.data: missing on graphql_query response");
+      }
+      assertObject(raw.data, "inner.data");
+      return raw;
+    }
     if (op === "download") {
       assertObject(raw.value, "inner.value");
       assertString(raw.value.path, "inner.value.path");
@@ -36078,7 +36228,7 @@ function validateInnerResponse(raw) {
   if (raw.ok === false) {
     assertString(raw.error, "inner.error");
     if (raw.op !== void 0) {
-      if (typeof raw.op !== "string" || !KNOWN_CAPABILITIES.has(raw.op)) {
+      if (typeof raw.op !== "string" || !KNOWN_RESPONSE_OPS.has(raw.op)) {
         throw new ProtocolError(`inner.op: unknown response op ${JSON.stringify(raw.op)}`);
       }
     }
@@ -36270,11 +36420,33 @@ async function sealInnerFrame(sessionKey, mcpId, seq, inner) {
   };
 }
 async function openEncryptedFrame(sessionKey, frame) {
-  const iv = fromB64(frame.iv);
-  const ct = fromB64(frame.ciphertext);
-  const pt = await aesGcmOpen(sessionKey, iv, ct);
-  const parsed = JSON.parse(dec.decode(pt));
-  return validateInnerFrame(parsed);
+  const result = await openEncryptedFrameDetailed(sessionKey, frame);
+  if (result.stage === "ok")
+    return result.inner;
+  throw result.error instanceof Error ? result.error : new Error(String(result.error));
+}
+async function openEncryptedFrameDetailed(sessionKey, frame) {
+  let pt;
+  try {
+    const iv = fromB64(frame.iv);
+    const ct = fromB64(frame.ciphertext);
+    pt = await aesGcmOpen(sessionKey, iv, ct);
+  } catch (error51) {
+    return { stage: "decrypt-failed", error: error51 };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(dec.decode(pt));
+  } catch (error51) {
+    return { stage: "validation-failed", error: error51, recoveredId: void 0 };
+  }
+  try {
+    const inner = validateInnerFrame(parsed);
+    return { stage: "ok", inner };
+  } catch (error51) {
+    const recoveredId = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && typeof parsed.id === "number" && Number.isInteger(parsed.id) && parsed.id > 0 ? parsed.id : void 0;
+    return { stage: "validation-failed", error: error51, recoveredId };
+  }
 }
 
 // node_modules/@fetchproxy/server/dist/election.js
@@ -36400,6 +36572,12 @@ async function buildServerHello(opts) {
       ...d.attribute !== void 0 ? { attribute: d.attribute } : {}
     }));
   }
+  if (opts.graphqlOps && opts.graphqlOps.length > 0) {
+    hello.graphqlOps = opts.graphqlOps.map((d) => ({
+      name: d.name,
+      operationName: d.operationName
+    }));
+  }
   return hello;
 }
 
@@ -36461,6 +36639,148 @@ async function awaitSessionReady(ready, opts) {
   }
 }
 
+// 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";
+
+// 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";
+var SAFE_PLAIN = /^[A-Za-z0-9._-]+$/;
+var SAFE_SCOPED = /^@[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+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;
+}
+
+// node_modules/@fetchproxy/server/dist/extension-trust.js
+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())
+  };
+}
+var TRUST_NEW_EXTENSION_ENV = "FETCHPROXY_TRUST_NEW_EXTENSION";
+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);
+}
+
 // node_modules/@fetchproxy/server/dist/host.js
 var PUBLIC_ORIGIN_RE = /^https?:\/\/(?!(127\.0\.0\.1|localhost)(:|$))/i;
 var enc2 = new TextEncoder();
@@ -36490,7 +36810,8 @@ async function startHost(opts) {
     indexedDbScopes: opts.ownIndexedDbScopes,
     localStoragePointers: opts.ownLocalStoragePointers,
     sessionStoragePointers: opts.ownSessionStoragePointers,
-    domSelectors: opts.ownDomSelectors
+    domSelectors: opts.ownDomSelectors,
+    graphqlOps: opts.ownGraphqlOps
   });
   const ownSessionNonce = fromB64(ownHello.sessionNonce);
   let extensionWs = null;
@@ -36513,9 +36834,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;
@@ -36527,10 +36851,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;
@@ -36542,6 +36899,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));
@@ -36577,6 +36936,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") {
@@ -36588,7 +36949,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 {
@@ -36601,6 +36962,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);
@@ -36654,6 +37027,9 @@ async function startHost(opts) {
       }
     });
     ws.on("close", () => {
+      closed = true;
+      if (extensionClaim === ws)
+        extensionClaim = null;
       if (identified === "extension" && extensionWs === ws) {
         extensionWs = null;
         extensionHello = null;
@@ -36727,7 +37103,8 @@ async function startPeer(opts) {
     indexedDbScopes: opts.indexedDbScopes,
     domSelectors: opts.domSelectors,
     localStoragePointers: opts.localStoragePointers,
-    sessionStoragePointers: opts.sessionStoragePointers
+    sessionStoragePointers: opts.sessionStoragePointers,
+    graphqlOps: opts.graphqlOps
   });
   const sessionNonce = fromB64(hello.sessionNonce);
   ws.send(JSON.stringify(hello));
@@ -36743,11 +37120,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);
@@ -36771,10 +37221,20 @@ async function startPeer(opts) {
           return;
         if (!session.acceptInboundSeq(frame.seq))
           return;
-        try {
-          const inner = await openEncryptedFrame(session.sessionKey, frame);
-          innerListeners.forEach((cb) => cb(inner));
-        } catch {
+        const result = await openEncryptedFrameDetailed(session.sessionKey, frame);
+        if (result.stage === "ok") {
+          innerListeners.forEach((cb) => cb(result.inner));
+        } else if (result.stage === "decrypt-failed") {
+        } else {
+          console.error("[fetchproxy] peer: received a frame that decrypted OK but failed validation:", result.error);
+          if (result.recoveredId !== void 0) {
+            innerListeners.forEach((cb) => cb({
+              type: "response",
+              id: result.recoveredId,
+              ok: false,
+              error: `malformed response failed protocol validation: ${String(result.error)}`
+            }));
+          }
         }
       }
     } catch (e) {
@@ -36818,57 +37278,6 @@ async function startPeer(opts) {
   return handle;
 }
 
-// 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";
-var SAFE_PLAIN = /^[A-Za-z0-9._-]+$/;
-var SAFE_SCOPED = /^@[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
-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;
-}
-
 // 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)) {
@@ -36950,6 +37359,39 @@ var FetchproxyBridgeDownError = class extends FetchproxyProtocolError {
     this.hint = hint;
   }
 };
+var 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;
+  }
+};
+var 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";
+  }
+};
+var 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";
+  }
+};
+var SCOPE_REJECTION = /not in declared/;
+var NO_TAB_REJECTION = /no tab matching (?!.*content script loaded)/;
+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);
+}
 var FetchproxyTimeoutError = class extends FetchproxyProtocolError {
   url;
   timeoutMs;
@@ -36979,6 +37421,17 @@ var FetchproxyTimeoutError = class extends FetchproxyProtocolError {
   }
 };
 var SUBDOMAIN_LABEL_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/i;
+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)}`);
@@ -37043,6 +37496,9 @@ var FetchproxyServer = class {
   // 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.
@@ -37051,6 +37507,10 @@ var FetchproxyServer = class {
   pendingIdb = /* @__PURE__ */ new Map();
   // download awaiters resolve the saved-file metadata (path + size + mime).
   pendingDownload = /* @__PURE__ */ new Map();
+  // 1.x+: graphql_query awaiters resolve the GraphQL `data` object. Its
+  // shape is operation-specific, so the awaiter resolves `unknown` and the
+  // caller narrows.
+  pendingGraphql = /* @__PURE__ */ new Map();
   mcpId = null;
   identity = null;
   // 0.5.3+: in-flight role-election / handle-start promise. Set the
@@ -37138,6 +37598,10 @@ var FetchproxyServer = class {
         selector: d.selector,
         ...d.attribute !== void 0 ? { attribute: d.attribute } : {}
       })),
+      graphqlOps: (opts.graphqlOps ?? []).map((d) => ({
+        name: d.name,
+        operationName: d.operationName
+      })),
       // 0.8.0+: timer + lazy-revive default to ON. Every realty MCP
       // adapter was about to set these to the same numbers anyway; the
       // back-door is `0` (explicit opt-out) if a caller genuinely wants
@@ -37161,6 +37625,8 @@ var FetchproxyServer = class {
       keepAliveIntervalMs: opts.keepAliveIntervalMs ?? 2e4,
       keepAliveMaxIdleMs: opts.keepAliveMaxIdleMs ?? 5 * 60 * 1e3,
       identityDir: opts.identityDir,
+      allowNewExtensionIdentity: opts.allowNewExtensionIdentity,
+      requireExtensionIdentity: opts.requireExtensionIdentity,
       onPairCode: opts.onPairCode
     };
   }
@@ -37259,7 +37725,9 @@ var FetchproxyServer = class {
         ownLocalStoragePointers: this.opts.localStoragePointers,
         ownSessionStoragePointers: this.opts.sessionStoragePointers,
         ownDomSelectors: this.opts.domSelectors,
-        onPairCode: this.opts.onPairCode
+        ownGraphqlOps: this.opts.graphqlOps,
+        onPairCode: this.opts.onPairCode,
+        extensionTrust: this.extensionTrust()
       });
       this.hostHandle.onOwnInner((inner) => this.onInner(inner));
       this.hostHandle.onExtensionDisconnect(() => {
@@ -37287,7 +37755,10 @@ var FetchproxyServer = class {
         indexedDbScopes: this.opts.indexedDbScopes,
         localStoragePointers: this.opts.localStoragePointers,
         sessionStoragePointers: this.opts.sessionStoragePointers,
-        domSelectors: this.opts.domSelectors
+        domSelectors: this.opts.domSelectors,
+        graphqlOps: this.opts.graphqlOps,
+        extensionTrust: this.extensionTrust(),
+        requireExtensionIdentity: this.opts.requireExtensionIdentity
       });
       this.peerHandle.onInner((inner) => this.onInner(inner));
       this.peerHandle.onRenegotiate(() => {
@@ -37426,6 +37897,23 @@ var FetchproxyServer = class {
   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)
@@ -37489,10 +37977,12 @@ var FetchproxyServer = class {
         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);
         this.pendingIdb.delete(id);
+        this.pendingGraphql.delete(id);
       }
       throw err;
     }
@@ -37609,7 +38099,7 @@ var FetchproxyServer = class {
         port: this.opts.port
       });
     }
-    return new FetchproxyProtocolError(result.error);
+    return protocolErrorFrom(result.error);
   }
   /**
    * Convenience wrapper around `fetch()`. Builds the URL from a path
@@ -37645,10 +38135,20 @@ var FetchproxyServer = class {
     }
     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
     };
@@ -37860,9 +38360,14 @@ var FetchproxyServer = class {
     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 {
@@ -37875,10 +38380,65 @@ var FetchproxyServer = class {
     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
@@ -38302,6 +38862,52 @@ var FetchproxyServer = class {
     await this.sendInnerFrame(inner);
     return this._withVerbTimeout(pending, this.pendingStorage, id, origin);
   }
+  /**
+   * 1.x+: run a declared GraphQL operation through the page's own Apollo
+   * client (`window.__APOLLO_CLIENT__`) in the signed-in tab's MAIN world.
+   * Requires `'graphql'` in capabilities AND `name` to match a declared
+   * `graphqlOps` entry. The extension resolves `name` → `operationName` →
+   * the live DocumentNode the page already observed, then invokes
+   * `client.query({ query, variables })` — the site's own request path, so
+   * per-request bot telemetry (Akamai etc.) runs automatically.
+   *
+   * Returns the GraphQL `data` object on success (shape is
+   * operation-specific; the caller narrows). Throws a plain `Error` on
+   * developer mistakes (undeclared capability, undeclared name) and a
+   * descriptive `Error` on the `ok:false` bridge path — which includes the
+   * typed "operation not yet observed on this tab" case (open the site's
+   * page and retry).
+   */
+  async graphqlQuery(opts) {
+    if (!this.opts.capabilities.includes("graphql")) {
+      throw new Error('FetchproxyServer.graphqlQuery(): MCP did not declare "graphql" in capabilities');
+    }
+    if (typeof opts.name !== "string" || opts.name.length === 0) {
+      throw new Error("FetchproxyServer.graphqlQuery: opts.name must be a non-empty string");
+    }
+    const declaredNames = this.opts.graphqlOps.map((d) => d.name);
+    if (!declaredNames.includes(opts.name)) {
+      throw new Error(`FetchproxyServer.graphqlQuery: operation ${JSON.stringify(opts.name)} not in declared graphqlOps [${declaredNames.map((n) => JSON.stringify(n)).join(", ")}]`);
+    }
+    await this.ensureConnected();
+    this.throwIfPendingPair();
+    const id = this.nextRequestId++;
+    const inner = {
+      type: "request",
+      id,
+      op: "graphql_query",
+      init: {
+        name: opts.name,
+        variables: opts.variables,
+        ...opts.tabUrl !== void 0 ? { tabUrl: opts.tabUrl } : {}
+      }
+    };
+    const pending = new Promise((resolve, reject) => {
+      this.pendingGraphql.set(id, { resolve, reject });
+    });
+    await this.sendInnerFrame(inner);
+    return this._withVerbTimeout(pending, this.pendingGraphql, id, opts.name);
+  }
   assertScopeSubset(requested, declared, label) {
     const undeclared = undeclaredKeys(requested, declared);
     if (undeclared.length > 0) {
@@ -38379,7 +38985,7 @@ var FetchproxyServer = class {
           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;
     }
@@ -38393,7 +38999,7 @@ var FetchproxyServer = class {
           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;
     }
@@ -38407,7 +39013,7 @@ var FetchproxyServer = class {
           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;
     }
@@ -38421,7 +39027,7 @@ var FetchproxyServer = class {
           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;
     }
@@ -38435,7 +39041,31 @@ var FetchproxyServer = class {
           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;
+    }
+    const graphqlCb = this.pendingGraphql.get(inner.id);
+    if (graphqlCb) {
+      this.pendingGraphql.delete(inner.id);
+      if (inner.ok) {
+        if (inner.op === "graphql_query") {
+          graphqlCb.resolve(inner.data);
+        } else {
+          graphqlCb.reject(new FetchproxyProtocolError(`unexpected ${String(inner.op)} response on graphql_query awaiter`));
+        }
+      } else {
+        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;
     }
@@ -38478,6 +39108,9 @@ var FetchproxyServer = class {
     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();
@@ -38490,6 +39123,9 @@ var FetchproxyServer = class {
     for (const { reject } of this.pendingDownload.values())
       reject(err);
     this.pendingDownload.clear();
+    for (const { reject } of this.pendingGraphql.values())
+      reject(err);
+    this.pendingGraphql.clear();
   }
   /**
    * 0.5.2+: read the current pair-pending pair code from whichever handle

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Single source of the server version. release-please bumps the literal below. */
-export const VERSION = '0.3.1'; // x-release-please-version
+export const VERSION = '0.3.3'; // x-release-please-version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrischall/tripadvisor-mcp",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "mcpName": "io.github.chrischall/tripadvisor-mcp",
   "description": "TripAdvisor Terra API MCP server for Claude — search locations, details, photos, and reviews. Developed and maintained by AI (Claude Code).",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -44,8 +44,8 @@
     "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@chrischall/mcp-utils": "^0.13.0",
-    "@fetchproxy/server": "^1.3.4",
+    "@chrischall/mcp-utils": "^0.14.0",
+    "@fetchproxy/server": "^2.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "dotenv": "^17.4.0",
     "zod": "^4.4.2"

package/server.json

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