@ractive-ch/tab-mcp 0.1.0 → 0.2.0

package/main.js

@@ -3,6 +3,7 @@
 
 // src/config.ts
 var MIN_MESSAGE_BYTES = 16384;
+var MAX_PAGE_WAIT_MS = 60000;
 var MAX_APP_NAME = 64;
 var DEFAULT_CONFIG = {
   port: 8080,
@@ -24,6 +25,7 @@ var DEFAULT_CONFIG = {
   heartbeatMs: 25000,
   helloTimeoutMs: 1e4,
   bodyTimeoutMs: 1e4,
+  pageWaitMs: 1e4,
   maxMessageBytes: 1048576,
   accessTokenTtlMs: 3600000,
   refreshTokenTtlMs: 2592000000,
@@ -107,6 +109,9 @@ function resolveConfig(input = {}) {
       throw new ConfigError(`${key} must be a positive number`);
     }
   }
+  if (typeof config.pageWaitMs !== "number" || !Number.isFinite(config.pageWaitMs) || config.pageWaitMs < 0 || config.pageWaitMs > MAX_PAGE_WAIT_MS) {
+    throw new ConfigError(`pageWaitMs must be 0-${MAX_PAGE_WAIT_MS} (0-${MAX_PAGE_WAIT_MS / 1000} seconds)`);
+  }
   if (config.maxMessageBytes < MIN_MESSAGE_BYTES) {
     throw new ConfigError(`maxMessageBytes must be at least ${MIN_MESSAGE_BYTES} (16 KiB)`);
   }
@@ -230,6 +235,16 @@ function seconds(env, name) {
   }
   return Math.round(n * 1000);
 }
+function secondsOrZero(env, name) {
+  const raw = env[name];
+  if (raw === undefined || raw === "")
+    return;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0) {
+    throw new ConfigError(`${name} must be 0 or a positive number of seconds`);
+  }
+  return Math.round(n * 1000);
+}
 function integer(env, name) {
   const raw = env[name];
   if (raw === undefined || raw === "")
@@ -306,6 +321,7 @@ function configFromEnv(env) {
   set("sessionLifetimeMs", seconds(env, "TAB_MCP_SESSION_LIFETIME_S"));
   set("heartbeatMs", seconds(env, "TAB_MCP_HEARTBEAT_S"));
   set("bodyTimeoutMs", seconds(env, "TAB_MCP_BODY_TIMEOUT_S"));
+  set("pageWaitMs", secondsOrZero(env, "TAB_MCP_PAGE_WAIT_S"));
   set("maxMessageBytes", integer(env, "TAB_MCP_MAX_MESSAGE_BYTES"));
   set("accessTokenTtlMs", seconds(env, "TAB_MCP_ACCESS_TOKEN_TTL_S"));
   set("refreshTokenTtlMs", seconds(env, "TAB_MCP_REFRESH_TOKEN_TTL_S"));
@@ -509,7 +525,7 @@ function installCrashLogging(logger, exit = (code) => process.exit(code)) {
   };
 }
 // package.json
-var version = "0.1.0";
+var version = "0.2.0";
 
 // src/address.ts
 var BASE32_ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
@@ -705,6 +721,31 @@ class Exchange {
     this.#options.cancel("client_closed");
     this.#finish("client_closed", false);
   }
+  tabGone() {
+    if (this.#state === "done")
+      return;
+    const waiting = this.#state === "waiting";
+    const reply = this.#options.pageGone?.(waiting);
+    if (reply?.retry === true && waiting) {
+      clearTimeout(this.#startTimer);
+      this.#finish("page_gone_retry");
+      return;
+    }
+    const body = reply?.retry === false ? reply.body : undefined;
+    if (body === undefined) {
+      this.fail(503, RelayErrorCode.tabGone, "The page closed its connection to the relay.", false);
+      return;
+    }
+    if (waiting) {
+      this.#respond(new Response(body, {
+        status: 200,
+        headers: this.#headers({ "content-type": "application/json" })
+      }), 200);
+    } else if (this.#atBoundary) {
+      this.#write(sseEvent(body));
+    }
+    this.#finish("page_gone");
+  }
   fail(status, code, message, cancelTab) {
     if (this.#state === "done")
       return;
@@ -843,6 +884,233 @@ class Exchange {
   }
 }
 
+// src/protocol.ts
+var SUBPROTOCOL = "tab-mcp.v1";
+var MCP_PROTOCOL_VERSION = "2026-07-28";
+var PROTOCOL_VERSION_META_KEY = "io.modelcontextprotocol/protocolVersion";
+var CloseCode = {
+  normal: 1000,
+  policyViolation: 1008,
+  tooLarge: 1009,
+  sessionExpired: 4001,
+  idleTimeout: 4002,
+  heartbeatLost: 4003,
+  shuttingDown: 4004,
+  replaced: 4005,
+  rateLimited: 4008
+};
+var MAX_TITLE = 300;
+var MAX_NAME = 200;
+var MAX_ID = 128;
+var MAX_HEADER_COUNT = 32;
+var MAX_HEADER_VALUE = 8192;
+var FIELD_VALUE = /^[\t\x20-\x7E\x80-\xFF]*$/;
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isString(v, max) {
+  return typeof v === "string" && v.length <= max;
+}
+function isId(v) {
+  return typeof v === "string" && v.length > 0 && v.length <= MAX_ID;
+}
+function isStatus(v) {
+  return typeof v === "number" && Number.isInteger(v) && v >= 200 && v <= 599;
+}
+function isHeaders(v) {
+  if (!isObject(v))
+    return false;
+  const entries = Object.entries(v);
+  if (entries.length > MAX_HEADER_COUNT)
+    return false;
+  return entries.every(([k, val]) => /^[a-z0-9-]{1,64}$/.test(k) && isString(val, MAX_HEADER_VALUE) && FIELD_VALUE.test(val));
+}
+function idOf(v) {
+  return isId(v["id"]) ? v["id"] : undefined;
+}
+function parseTabMessage(text) {
+  let v;
+  try {
+    v = JSON.parse(text);
+  } catch {
+    return { ok: false, error: "not JSON" };
+  }
+  if (!isObject(v))
+    return { ok: false, error: "not a JSON object" };
+  const type = v["type"];
+  if (typeof type !== "string" || type.length === 0 || type.length > 64) {
+    return { ok: false, error: "missing type" };
+  }
+  const id = idOf(v);
+  const bad = (error) => id === undefined ? { ok: false, error } : { ok: false, error, id };
+  switch (type) {
+    case "hello": {
+      const library = v["library"];
+      const page = v["page"];
+      if (!isObject(library) || !isString(library["name"], MAX_NAME) || !isString(library["version"], MAX_NAME)) {
+        return bad("hello.library must be {name, version}");
+      }
+      if (!isObject(page) || !isString(page["title"], MAX_TITLE)) {
+        return bad("hello.page must be {title}");
+      }
+      if (typeof v["secret"] !== "string")
+        return bad("hello.secret missing");
+      const app = v["app"];
+      if (app !== undefined && (!isObject(app) || !isAppName(app["name"]))) {
+        return bad(`hello.app.name must be 1-${MAX_APP_NAME} characters`);
+      }
+      const hello = {
+        type,
+        library: { name: library["name"], version: library["version"] },
+        page: { title: page["title"] },
+        secret: v["secret"]
+      };
+      if (isObject(app) && isAppName(app["name"])) {
+        hello.app = { name: app["name"] };
+      }
+      return { ok: true, message: hello };
+    }
+    case "pong": {
+      const t = v["t"];
+      if (typeof t !== "number")
+        return bad("pong.t must be a number");
+      return { ok: true, message: { type, t } };
+    }
+    case "bye": {
+      const reason = v["reason"];
+      return {
+        ok: true,
+        message: {
+          type,
+          reason: isString(reason, MAX_NAME) ? reason : ""
+        }
+      };
+    }
+    case "http.response": {
+      if (id === undefined)
+        return bad("http.response.id missing");
+      const { status, headers, body } = v;
+      if (!isStatus(status))
+        return bad("http.response.status invalid");
+      if (!isHeaders(headers))
+        return bad("http.response.headers invalid");
+      if (typeof body !== "string")
+        return bad("http.response.body invalid");
+      return { ok: true, message: { type, id, status, headers, body } };
+    }
+    case "http.response.start": {
+      if (id === undefined)
+        return bad("http.response.start.id missing");
+      const { status, headers } = v;
+      if (!isStatus(status))
+        return bad("http.response.start.status invalid");
+      if (!isHeaders(headers))
+        return bad("http.response.start.headers invalid");
+      return { ok: true, message: { type, id, status, headers } };
+    }
+    case "http.response.chunk": {
+      if (id === undefined)
+        return bad("http.response.chunk.id missing");
+      const data = v["data"];
+      if (typeof data !== "string")
+        return bad("http.response.chunk.data invalid");
+      return { ok: true, message: { type, id, data } };
+    }
+    case "http.response.end": {
+      if (id === undefined)
+        return bad("http.response.end.id missing");
+      return { ok: true, message: { type, id } };
+    }
+    case "pairing.start":
+    case "pairing.stop":
+    case "grants.revokeAll":
+      return { ok: true, message: { type } };
+    case "grant.revoke": {
+      const grantId = v["grantId"];
+      if (!isId(grantId))
+        return bad("grant.revoke.grantId missing");
+      return { ok: true, message: { type, grantId } };
+    }
+    case "error": {
+      const code = v["code"];
+      const message = v["message"];
+      if (!isString(code, MAX_NAME))
+        return bad("error.code invalid");
+      const m = {
+        type,
+        code,
+        message: isString(message, 1000) ? message : ""
+      };
+      if (id !== undefined)
+        m.id = id;
+      return { ok: true, message: m };
+    }
+    default:
+      return id === undefined ? { ok: true, unknown: true, type } : { ok: true, unknown: true, type, id };
+  }
+}
+
+// src/notopen.ts
+var RETRYABLE = new Set(["tools/list"]);
+function isRetryable(method) {
+  return typeof method === "string" && RETRYABLE.has(method);
+}
+function pageName(appName) {
+  return appName ?? "the web page";
+}
+function notOpenText(appName) {
+  return `The page is not open, or not in front. Ask the user to open ${pageName(appName)} and keep it in front (on a phone, in split screen), then try again.`;
+}
+function goneDuringCallText(appName) {
+  return `The page closed while the tool was running, so it may or may not have finished. Ask the user to open ${pageName(appName)} and keep it in front (on a phone, in split screen), then check the result before trying again.`;
+}
+function notOpenAnswer(body, rpcId, appName, phase, relay) {
+  if (rpcId === undefined)
+    return;
+  const id = rpcId;
+  const method = body["method"];
+  if (method === "tools/call") {
+    const text = phase === "gone" ? goneDuringCallText(appName) : notOpenText(appName);
+    return JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        resultType: "complete",
+        content: [{ type: "text", text }],
+        isError: true
+      }
+    });
+  }
+  if (method === "server/discover") {
+    return JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        resultType: "complete",
+        supportedVersions: [MCP_PROTOCOL_VERSION],
+        capabilities: { tools: { listChanged: true } },
+        instructions: notOpenText(appName),
+        ttlMs: 0,
+        cacheScope: "private",
+        _meta: {
+          "io.modelcontextprotocol/serverInfo": {
+            name: relay.name,
+            version: relay.version
+          }
+        }
+      }
+    });
+  }
+  return JSON.stringify({
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: phase === "gone" ? RelayErrorCode.tabGone : RelayErrorCode.pageNotOpen,
+      message: notOpenText(appName)
+    }
+  });
+}
+
 // src/oauth/server.ts
 import { timingSafeEqual as timingSafeEqual2 } from "crypto";
 
@@ -2254,172 +2522,6 @@ ${cancel}
   }
 }
 
-// src/protocol.ts
-var SUBPROTOCOL = "tab-mcp.v1";
-var MCP_PROTOCOL_VERSION = "2026-07-28";
-var PROTOCOL_VERSION_META_KEY = "io.modelcontextprotocol/protocolVersion";
-var CloseCode = {
-  normal: 1000,
-  policyViolation: 1008,
-  tooLarge: 1009,
-  sessionExpired: 4001,
-  idleTimeout: 4002,
-  heartbeatLost: 4003,
-  shuttingDown: 4004,
-  replaced: 4005,
-  rateLimited: 4008
-};
-var MAX_TITLE = 300;
-var MAX_NAME = 200;
-var MAX_ID = 128;
-var MAX_HEADER_COUNT = 32;
-var MAX_HEADER_VALUE = 8192;
-var FIELD_VALUE = /^[\t\x20-\x7E\x80-\xFF]*$/;
-function isObject(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function isString(v, max) {
-  return typeof v === "string" && v.length <= max;
-}
-function isId(v) {
-  return typeof v === "string" && v.length > 0 && v.length <= MAX_ID;
-}
-function isStatus(v) {
-  return typeof v === "number" && Number.isInteger(v) && v >= 200 && v <= 599;
-}
-function isHeaders(v) {
-  if (!isObject(v))
-    return false;
-  const entries = Object.entries(v);
-  if (entries.length > MAX_HEADER_COUNT)
-    return false;
-  return entries.every(([k, val]) => /^[a-z0-9-]{1,64}$/.test(k) && isString(val, MAX_HEADER_VALUE) && FIELD_VALUE.test(val));
-}
-function idOf(v) {
-  return isId(v["id"]) ? v["id"] : undefined;
-}
-function parseTabMessage(text) {
-  let v;
-  try {
-    v = JSON.parse(text);
-  } catch {
-    return { ok: false, error: "not JSON" };
-  }
-  if (!isObject(v))
-    return { ok: false, error: "not a JSON object" };
-  const type = v["type"];
-  if (typeof type !== "string" || type.length === 0 || type.length > 64) {
-    return { ok: false, error: "missing type" };
-  }
-  const id = idOf(v);
-  const bad = (error) => id === undefined ? { ok: false, error } : { ok: false, error, id };
-  switch (type) {
-    case "hello": {
-      const library = v["library"];
-      const page = v["page"];
-      if (!isObject(library) || !isString(library["name"], MAX_NAME) || !isString(library["version"], MAX_NAME)) {
-        return bad("hello.library must be {name, version}");
-      }
-      if (!isObject(page) || !isString(page["title"], MAX_TITLE)) {
-        return bad("hello.page must be {title}");
-      }
-      if (typeof v["secret"] !== "string")
-        return bad("hello.secret missing");
-      const app = v["app"];
-      if (app !== undefined && (!isObject(app) || !isAppName(app["name"]))) {
-        return bad(`hello.app.name must be 1-${MAX_APP_NAME} characters`);
-      }
-      const hello = {
-        type,
-        library: { name: library["name"], version: library["version"] },
-        page: { title: page["title"] },
-        secret: v["secret"]
-      };
-      if (isObject(app) && isAppName(app["name"])) {
-        hello.app = { name: app["name"] };
-      }
-      return { ok: true, message: hello };
-    }
-    case "pong": {
-      const t = v["t"];
-      if (typeof t !== "number")
-        return bad("pong.t must be a number");
-      return { ok: true, message: { type, t } };
-    }
-    case "bye": {
-      const reason = v["reason"];
-      return {
-        ok: true,
-        message: {
-          type,
-          reason: isString(reason, MAX_NAME) ? reason : ""
-        }
-      };
-    }
-    case "http.response": {
-      if (id === undefined)
-        return bad("http.response.id missing");
-      const { status, headers, body } = v;
-      if (!isStatus(status))
-        return bad("http.response.status invalid");
-      if (!isHeaders(headers))
-        return bad("http.response.headers invalid");
-      if (typeof body !== "string")
-        return bad("http.response.body invalid");
-      return { ok: true, message: { type, id, status, headers, body } };
-    }
-    case "http.response.start": {
-      if (id === undefined)
-        return bad("http.response.start.id missing");
-      const { status, headers } = v;
-      if (!isStatus(status))
-        return bad("http.response.start.status invalid");
-      if (!isHeaders(headers))
-        return bad("http.response.start.headers invalid");
-      return { ok: true, message: { type, id, status, headers } };
-    }
-    case "http.response.chunk": {
-      if (id === undefined)
-        return bad("http.response.chunk.id missing");
-      const data = v["data"];
-      if (typeof data !== "string")
-        return bad("http.response.chunk.data invalid");
-      return { ok: true, message: { type, id, data } };
-    }
-    case "http.response.end": {
-      if (id === undefined)
-        return bad("http.response.end.id missing");
-      return { ok: true, message: { type, id } };
-    }
-    case "pairing.start":
-    case "pairing.stop":
-    case "grants.revokeAll":
-      return { ok: true, message: { type } };
-    case "grant.revoke": {
-      const grantId = v["grantId"];
-      if (!isId(grantId))
-        return bad("grant.revoke.grantId missing");
-      return { ok: true, message: { type, grantId } };
-    }
-    case "error": {
-      const code = v["code"];
-      const message = v["message"];
-      if (!isString(code, MAX_NAME))
-        return bad("error.code invalid");
-      const m = {
-        type,
-        code,
-        message: isString(message, 1000) ? message : ""
-      };
-      if (id !== undefined)
-        m.id = id;
-      return { ok: true, message: m };
-    }
-    default:
-      return id === undefined ? { ok: true, unknown: true, type } : { ok: true, unknown: true, type, id };
-  }
-}
-
 // src/session.ts
 function limitsOf(limits) {
   return {
@@ -2674,6 +2776,7 @@ class TabSession {
       library: `${library.name}@${library.version}`,
       replaced: replaced !== undefined
     });
+    this.#host.ready?.(this);
   }
   #tick() {
     if (this.#state !== "ready")
@@ -2712,7 +2815,8 @@ class TabSession {
         this.pending.delete(id);
         this.#lastRequestAt = Date.now();
         input.onDone(e);
-      }
+      },
+      ...input.pageGone === undefined ? {} : { pageGone: input.pageGone }
     });
     this.pending.set(id, exchange);
     const sent = this.send({
@@ -2751,10 +2855,9 @@ class TabSession {
     clearTimeout(this.#helloTimer);
     clearInterval(this.#heartbeatTimer);
     clearTimeout(this.#lifetimeTimer);
-    for (const exchange of [...this.pending.values()]) {
-      exchange.fail(503, RelayErrorCode.tabGone, "The page closed its connection to the relay.", false);
-    }
     this.#host.released(this);
+    for (const exchange of [...this.pending.values()])
+      exchange.tabGone();
     if (wasReady) {
       this.#host.logger.info("tab.closed", {
         session: this.sessionId,
@@ -3006,6 +3109,8 @@ class SqliteTokenStore {
 
 // src/relay.ts
 var VERSION = version;
+var RELAY_INFO = { name: "tab-mcp", version };
+var RETRY = Symbol("retry");
 var CLAUDE_MISMATCHED_HEADER = "2025-11-25";
 var FORWARDED_HEADERS = new Set([
   "content-type",
@@ -3066,6 +3171,9 @@ function startRelay(options, hooks) {
   const sessions = new Map;
   const allSessions = new Set;
   const perIp = new Map;
+  const waiters = new Map;
+  let waitingCount = 0;
+  const appNames = new Map;
   let claudeWorkarounds = 0;
   let publicUrl = config.publicUrl ?? "";
   const corsHeaders = config.cors ? {
@@ -3129,8 +3237,68 @@ function startRelay(options, hooks) {
         sessions.delete(session.addressId);
       }
       releaseIp(session.ip);
+    },
+    ready(session) {
+      const id = session.addressId;
+      if (id === undefined)
+        return;
+      if (session.appName !== undefined) {
+        appNames.delete(id);
+        appNames.set(id, session.appName);
+        if (appNames.size > config.maxSessions * 2) {
+          const oldest = appNames.keys().next().value;
+          if (oldest !== undefined)
+            appNames.delete(oldest);
+        }
+      }
+      const waiting = waiters.get(id);
+      if (waiting !== undefined)
+        for (const wake of [...waiting])
+          wake(session);
     }
   };
+  function readySession(addressId) {
+    const s = sessions.get(addressId);
+    return s?.ready === true ? s : undefined;
+  }
+  function waitForPage(addressId, signal, waitMs) {
+    const now = readySession(addressId);
+    if (now !== undefined)
+      return Promise.resolve(now);
+    if (waitMs === 0 || stopping !== undefined) {
+      return Promise.resolve(undefined);
+    }
+    const set = waiters.get(addressId) ?? new Set;
+    if (set.size >= config.maxConcurrentRequests || waitingCount >= config.maxSessions) {
+      return Promise.resolve(undefined);
+    }
+    return new Promise((resolve) => {
+      let timer;
+      let settled = false;
+      const done = (result) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        signal.removeEventListener("abort", onAbort);
+        set.delete(wake);
+        waitingCount--;
+        if (set.size === 0 && waiters.get(addressId) === set) {
+          waiters.delete(addressId);
+        }
+        resolve(result);
+      };
+      const wake = (session) => done(session);
+      const onAbort = () => done("aborted");
+      set.add(wake);
+      waiters.set(addressId, set);
+      waitingCount++;
+      timer = setTimeout(() => done(undefined), waitMs);
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted)
+        onAbort();
+    });
+  }
   function releaseIp(ip) {
     const n = (perIp.get(ip) ?? 1) - 1;
     if (n <= 0)
@@ -3334,15 +3502,6 @@ function startRelay(options, hooks) {
         "www-authenticate": wwwAuthenticate(addressId, auth === "invalid")
       });
     }
-    const session = sessions.get(addressId);
-    if (session === undefined || !session.ready) {
-      logDone(503, method, { reason: "page_not_open" });
-      return rpcError(503, rpcId, RelayErrorCode.pageNotOpen, 'The page is not open. Open the web page that offers these tools and click "Connect your AI app".', corsHeaders);
-    }
-    if (session.pending.size >= session.limits.maxConcurrentRequests) {
-      logDone(429, method);
-      return rpcError(429, rpcId, RelayErrorCode.overloaded, "Too many requests at once for this page.", corsHeaders);
-    }
     const headers = {};
     for (const [k, v] of req.headers) {
       const key = k.toLowerCase();
@@ -3357,33 +3516,89 @@ function startRelay(options, hooks) {
         return "";
       }
     })();
-    if (req.signal.aborted) {
+    const isListen = body.value["method"] === "subscriptions/listen";
+    const waitMs = body.value["method"] === "server/discover" || Buffer.byteLength(body.text) > MIN_MESSAGE_BYTES ? 0 : config.pageWaitMs;
+    const closed = () => {
       logDone(499, method, { outcome: "client_closed" });
       return new Response(null, { status: 499 });
+    };
+    if (readySession(addressId) === undefined && waitMs > 0) {
+      server.timeout(req, 0);
     }
-    server.timeout(req, 0);
-    const exchange = session.forward({
-      method: "POST",
-      headers,
-      body: body.text,
-      rpcId,
-      isListen: body.value["method"] === "subscriptions/listen",
-      grant: {
-        grantId: auth.grantId,
-        clientId: auth.clientId,
-        scopes: auth.scopes
-      },
-      extraHeaders: corsHeaders,
-      onDone: (e) => logDone(e.status, method, {
-        session: session.sessionId,
-        client: clientHostName,
-        outcome: e.outcome
-      })
-    });
-    req.signal.addEventListener("abort", () => exchange.clientClosed(), {
-      once: true
+    let retried = false;
+    for (;; ) {
+      const found = await waitForPage(addressId, req.signal, waitMs);
+      if (found === "aborted" || req.signal.aborted)
+        return closed();
+      if (found === undefined) {
+        return pageNotOpen(body.value, rpcId, addressId, logDone, method);
+      }
+      const session = found;
+      if (Buffer.byteLength(body.text) > session.limits.maxMessageBytes) {
+        logDone(413, method);
+        return rpcError(413, rpcId, -32600, "Request body too large.", corsHeaders);
+      }
+      if (session.pending.size >= session.limits.maxConcurrentRequests) {
+        logDone(429, method);
+        return rpcError(429, rpcId, RelayErrorCode.overloaded, "Too many requests at once for this page.", corsHeaders);
+      }
+      server.timeout(req, 0);
+      let retry = () => {};
+      const retrying = new Promise((resolve) => {
+        retry = () => resolve(RETRY);
+      });
+      const mayRetry = !retried && waitMs > 0 && isRetryable(body.value["method"]);
+      const exchange = session.forward({
+        method: "POST",
+        headers,
+        body: body.text,
+        rpcId,
+        isListen,
+        grant: {
+          grantId: auth.grantId,
+          clientId: auth.clientId,
+          scopes: auth.scopes
+        },
+        extraHeaders: corsHeaders,
+        onDone: (e) => {
+          if (e.outcome === "page_gone_retry")
+            return;
+          logDone(e.status, method, {
+            session: session.sessionId,
+            client: clientHostName,
+            outcome: e.outcome,
+            ...e.outcome === "page_gone" ? { reason: "page_not_open" } : {}
+          });
+        },
+        pageGone: (waiting) => {
+          if (waiting && mayRetry && !req.signal.aborted) {
+            retry();
+            return { retry: true };
+          }
+          const answer = notOpenAnswer(body.value, rpcId, session.appName, "gone", RELAY_INFO);
+          return answer === undefined ? { retry: false } : { retry: false, body: answer };
+        }
+      });
+      const onAbort = () => exchange.clientClosed();
+      req.signal.addEventListener("abort", onAbort, { once: true });
+      const result = await Promise.race([exchange.response, retrying]);
+      if (result !== RETRY)
+        return result;
+      req.signal.removeEventListener("abort", onAbort);
+      retried = true;
+    }
+  }
+  function pageNotOpen(value, rpcId, addressId, logDone, method) {
+    const answer = notOpenAnswer(value, rpcId, appNames.get(addressId), "not_open", RELAY_INFO);
+    if (answer === undefined) {
+      logDone(503, method, { reason: "page_not_open" });
+      return rpcError(503, rpcId, RelayErrorCode.pageNotOpen, "The page is not open.", corsHeaders);
+    }
+    logDone(200, method, { reason: "page_not_open" });
+    return new Response(answer, {
+      status: 200,
+      headers: { ...corsHeaders, "content-type": "application/json" }
     });
-    return exchange.response;
   }
   function preflight(req) {
     if (!config.cors)
@@ -3489,6 +3704,7 @@ function startRelay(options, hooks) {
       }
     }
   });
+  let stopping;
   const port = server.port ?? config.port;
   if (publicUrl === "")
     publicUrl = `http://localhost:${port}`;
@@ -3519,7 +3735,6 @@ function startRelay(options, hooks) {
     store: ownsStore ? config.store : "custom",
     origins: siteCount
   });
-  let stopping;
   return {
     url: publicUrl,
     port,
@@ -3531,6 +3746,10 @@ function startRelay(options, hooks) {
     stop() {
       stopping ??= (async () => {
         clearInterval(sweep);
+        for (const set of [...waiters.values()]) {
+          for (const wake of [...set])
+            wake(undefined);
+        }
         for (const session of [...allSessions]) {
           session.end(CloseCode.shuttingDown, "relay shutting down", "shutdown");
         }
@@ -3577,6 +3796,9 @@ Configuration is read from environment variables:
   TAB_MCP_SESSION_LIFETIME_S  absolute tab session lifetime (43200)
   TAB_MCP_HEARTBEAT_S         protocol ping interval (25)
   TAB_MCP_BODY_TIMEOUT_S      deadline for receiving an MCP request body (10)
+  TAB_MCP_PAGE_WAIT_S         how long an MCP request waits for its page to open or
+                              reconnect before the relay answers "the page is not
+                              open" (10; 0 = answer at once; at most 60)
   TAB_MCP_MAX_MESSAGE_BYTES   request body and WebSocket message limit (1048576;
                               at least 16384)
   TAB_MCP_ACCESS_TOKEN_TTL_S  access token lifetime (3600)
@@ -3623,5 +3845,5 @@ var shutdown = () => {
 process.on("SIGTERM", shutdown);
 process.on("SIGINT", shutdown);
 
-//# debugId=9CA2F401657AE02764756E2164756E21
+//# debugId=0C0FD94EFED0CA8064756E2164756E21
 //# sourceMappingURL=main.js.map