@attson/atwebpilot-mcp 0.0.55 → 0.0.57

package/dist/index.js

@@ -217,6 +217,14 @@ var StepSchema = z4.object({
   tool: z4.string(),
   args: z4.unknown()
 });
+var DerivedTabFields = {
+  /** true when the receiving connection owns this tab */
+  mine: z4.boolean().optional(),
+  /** true when some *other* connection owns it */
+  busy: z4.boolean().optional(),
+  /** the owning session's label, present only when busy */
+  busy_label: z4.string().optional()
+};
 var HelloSchema = z4.object({
   ...EnvelopeFields,
   type: z4.literal("HELLO"),
@@ -227,12 +235,20 @@ var HelloSchema = z4.object({
     chrome: z4.string()
   }),
   capabilities: z4.array(z4.string()),
+  /**
+   * Tool names this worker can actually execute. Optional for backward
+   * compatibility: an extension predating Plan 32 does not send it, and the
+   * server then falls back to the legacy 19-tool surface rather than
+   * advertising tools that would fail at call time with "unknown tool".
+   */
+  supported_tools: z4.array(z4.string()).optional(),
   attended: z4.boolean(),
   available_tabs: z4.array(
     z4.object({
       tab_id: z4.string(),
       url: z4.string(),
-      title: z4.string().optional()
+      title: z4.string().optional(),
+      ...DerivedTabFields
     })
   ),
   saved_tools: z4.array(
@@ -383,6 +399,24 @@ var SidepanelStateReplySchema = z4.object({
     lastSystemNote: z4.string().optional()
   }).optional()
 });
+var SessionOpenedSchema = z4.object({
+  ...EnvelopeFields,
+  type: z4.literal("SESSION_OPENED"),
+  session_id: z4.string(),
+  tab_id: z4.string()
+});
+var TabsUpdateSchema = z4.object({
+  ...EnvelopeFields,
+  type: z4.literal("TABS_UPDATE"),
+  tabs: z4.array(
+    z4.object({
+      tab_id: z4.string(),
+      url: z4.string(),
+      title: z4.string().optional(),
+      ...DerivedTabFields
+    })
+  )
+});
 var ClientToServerSchema = z4.discriminatedUnion("type", [
   HelloSchema,
   PingSchema,
@@ -392,7 +426,8 @@ var ClientToServerSchema = z4.discriminatedUnion("type", [
   SessionEventSchema,
   StateSnapshotSchema,
   ChatEventSchema,
-  SidepanelStateReplySchema
+  SidepanelStateReplySchema,
+  TabsUpdateSchema
 ]);
 var ServerToClientSchema = z4.discriminatedUnion("type", [
   WelcomeSchema,
@@ -402,7 +437,8 @@ var ServerToClientSchema = z4.discriminatedUnion("type", [
   CloseSessionSchema,
   StartChatSessionSchema,
   AbortSessionSchema,
-  ReadSidepanelStateSchema
+  ReadSidepanelStateSchema,
+  SessionOpenedSchema
 ]);
 var ProtocolMessageSchema = z4.union([ClientToServerSchema, ServerToClientSchema]);
 
@@ -613,19 +649,26 @@ var CAPABILITIES = [
   "httpRequest:cookied",
   "runJS:scanned",
   "runJS:unsafe",
-  "tab:open"
+  "tab:open",
+  // Plan 32 — page-event recorder
+  "read:console",
+  "read:network",
+  "read:network-body"
 ];
 var IMPLICIT_CAPABILITIES = /* @__PURE__ */ new Set([
   "read:dom",
   "read:image",
-  "nav:tab"
+  "nav:tab",
+  "read:console"
 ]);
 var DANGEROUS_CAPABILITIES = /* @__PURE__ */ new Set([
   "read:storage",
   "submit:form",
   "upload:file",
   "httpRequest:cookied",
-  "runJS:unsafe"
+  "runJS:unsafe",
+  // response headers routinely carry Authorization / Set-Cookie / bearer tokens
+  "read:network-body"
 ]);
 function isCapability(s) {
   return CAPABILITIES.includes(s);
@@ -703,6 +746,26 @@ function capabilityForTool(tool, opts) {
     // can be added later if a finer distinction is needed.
     case "writeStorage":
       return "read:storage";
+    // Plan 32 — playwright parity
+    case "consoleMessages":
+      return "read:console";
+    case "networkRequests":
+      return "read:network";
+    case "networkRequestDetail":
+      return "read:network-body";
+    case "recorderConfig":
+      return opts?.recorderArmsBodies ? "read:network-body" : "read:network";
+    case "handleDialog":
+    case "drag":
+      return "interact:form";
+    case "drop":
+      return opts?.dropHasFiles ? "upload:file" : "interact:form";
+    case "navigateBack":
+    case "navigateForward":
+    case "resize":
+      return "nav:tab";
+    case "findElements":
+      return "read:dom";
     default: {
       const _exhaustive = tool;
       throw new Error(`capabilityForTool: unknown tool ${_exhaustive}`);
@@ -739,7 +802,11 @@ var Dispatcher = class {
       return fail("SessionExpired", `Session ${input.session_id} is expired`);
     if (session.state !== "active")
       return fail("InternalError", `Session ${input.session_id} state=${session.state}`);
-    const required = input.kind === "extension_tool" ? capabilityForTool(input.tool, { httpCookied: input.httpCookied }) : capabilityForRunJs(input.unsafe);
+    const required = input.kind === "extension_tool" ? capabilityForTool(input.tool, {
+      httpCookied: input.httpCookied,
+      dropHasFiles: input.dropHasFiles,
+      recorderArmsBodies: input.recorderArmsBodies
+    }) : input.kind === "capability" ? input.capability : capabilityForRunJs(input.unsafe);
     if (!scopeCovers(session.scope, required)) {
       return fail("PermissionDenied", `Capability ${required} not in session scope`, {
         denied_capability: required
@@ -780,8 +847,12 @@ var Coordinator = class {
   catalog;
   dispatcher;
   hub;
+  clock;
+  idGen;
   constructor(deps) {
     this.hub = deps.hub;
+    this.clock = deps.clock;
+    this.idGen = deps.idGen;
     this.sessions = new SessionManager(deps.clock, deps.idGen);
     this.workers = new WorkerRegistry(deps.clock);
     this.catalog = new Catalog(this.workers);
@@ -803,7 +874,17 @@ var Coordinator = class {
   }
   // === Session lifecycle ===
   openSession(input) {
-    return this.sessions.open(input);
+    const session = this.sessions.open(input);
+    void this.hub.send(session.worker_id, {
+      type: "SESSION_OPENED",
+      nonce: this.idGen.next("nonce"),
+      ts: this.clock.now(),
+      protocol_version: PROTOCOL_VERSION,
+      session_id: session.id,
+      tab_id: session.tab_id
+    }).catch(() => {
+    });
+    return session;
   }
   closeSession(id) {
     this.sessions.close(id);
@@ -835,232 +916,6 @@ var Coordinator = class {
   }
 };
 
-// src/loopback-ws-hub.ts
-import { WebSocketServer, WebSocket } from "ws";
-var HEARTBEAT_INTERVAL_MS = 2e4;
-var DEFAULT_KEEPALIVE_INTERVAL_MS = 15e3;
-var LoopbackWSHub = class {
-  constructor(opts) {
-    this.opts = opts;
-    this.execTimeoutMs = opts.execTimeoutMs ?? 3e4;
-    this.keepaliveIntervalMs = opts.keepaliveIntervalMs ?? DEFAULT_KEEPALIVE_INTERVAL_MS;
-    this.wss = new WebSocketServer({
-      port: opts.port,
-      path: "/worker",
-      handleProtocols: (protocols) => [...protocols][0] ?? false
-    });
-    this.wss.on("connection", (socket, req) => this.onConnection(socket, req));
-  }
-  opts;
-  wss;
-  byWorker = /* @__PURE__ */ new Map();
-  workerOf = /* @__PURE__ */ new Map();
-  pending = /* @__PURE__ */ new Map();
-  msgHandlers = [];
-  disconnectHandlers = [];
-  execTimeoutMs;
-  keepaliveIntervalMs;
-  keepaliveTimers = /* @__PURE__ */ new Map();
-  ready() {
-    return new Promise((resolve) => {
-      const addr = this.wss.address();
-      if (addr) return resolve(addr.port);
-      this.wss.on(
-        "listening",
-        () => resolve(this.wss.address().port)
-      );
-    });
-  }
-  close() {
-    for (const p of this.pending.values()) {
-      clearTimeout(p.timer);
-      p.reject(new Error("hub closing"));
-    }
-    this.pending.clear();
-    for (const timer of this.keepaliveTimers.values()) clearInterval(timer);
-    this.keepaliveTimers.clear();
-    for (const socket of this.wss.clients) {
-      socket.terminate();
-    }
-    return new Promise((resolve) => this.wss.close(() => resolve()));
-  }
-  tokenOk(req) {
-    if (!this.opts.token) return true;
-    const offered = String(req.headers["sec-websocket-protocol"] ?? "").split(",").map((s) => s.trim());
-    return offered.includes(`bearer.${this.opts.token}`);
-  }
-  onConnection(socket, req) {
-    if (!this.tokenOk(req)) {
-      socket.close(4401, "bad token");
-      return;
-    }
-    socket.on("message", (raw) => this.onMessageRaw(socket, raw.toString()));
-    socket.on("close", () => this.onSocketClose(socket));
-    socket.on("error", () => {
-    });
-  }
-  onMessageRaw(socket, raw) {
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      return;
-    }
-    const r = ClientToServerSchema.safeParse(parsed);
-    if (!r.success) return;
-    const msg = r.data;
-    if (msg.type === "HELLO") {
-      const existingSocket = this.byWorker.get(msg.worker_id);
-      if (existingSocket && existingSocket !== socket) {
-        this.workerOf.delete(existingSocket);
-        for (const [req_id, p] of [...this.pending]) {
-          if (p.worker_id === msg.worker_id) {
-            clearTimeout(p.timer);
-            this.pending.delete(req_id);
-            p.reject(new Error(`worker ${msg.worker_id} reconnected, exec cancelled`));
-          }
-        }
-        existingSocket.terminate();
-      }
-      this.byWorker.set(msg.worker_id, socket);
-      this.workerOf.set(socket, msg.worker_id);
-      this.rawSend(socket, {
-        type: "WELCOME",
-        nonce: this.opts.idGen.next("nonce"),
-        ts: this.opts.clock.now(),
-        protocol_version: PROTOCOL_VERSION,
-        server_time: this.opts.clock.now(),
-        heartbeat_interval_ms: HEARTBEAT_INTERVAL_MS
-      });
-      this.startKeepalive(socket);
-      for (const h of this.msgHandlers) h(msg.worker_id, msg);
-      return;
-    }
-    if (msg.type === "RESULT") {
-      const p = this.pending.get(msg.req_id);
-      if (p) {
-        clearTimeout(p.timer);
-        this.pending.delete(msg.req_id);
-        p.resolve(msg);
-      }
-      return;
-    }
-    if (msg.type === "PING") {
-      this.rawSend(socket, {
-        type: "PONG",
-        nonce: this.opts.idGen.next("nonce"),
-        ts: this.opts.clock.now(),
-        protocol_version: PROTOCOL_VERSION,
-        echo_nonce: msg.nonce
-      });
-    }
-    const wid = this.workerOf.get(socket);
-    if (wid) {
-      for (const h of this.msgHandlers) h(wid, msg);
-    }
-  }
-  onSocketClose(socket) {
-    this.stopKeepalive(socket);
-    const wid = this.workerOf.get(socket);
-    if (!wid) return;
-    this.workerOf.delete(socket);
-    this.byWorker.delete(wid);
-    for (const [req_id, p] of [...this.pending]) {
-      if (p.worker_id === wid) {
-        clearTimeout(p.timer);
-        this.pending.delete(req_id);
-        p.reject(new Error(`worker ${wid} disconnected`));
-      }
-    }
-    for (const h of this.disconnectHandlers) h(wid);
-  }
-  startKeepalive(socket) {
-    if (this.keepaliveIntervalMs <= 0) return;
-    if (this.keepaliveTimers.has(socket)) return;
-    const timer = setInterval(() => {
-      if (socket.readyState !== WebSocket.OPEN) return;
-      this.rawSend(socket, {
-        type: "PONG",
-        nonce: this.opts.idGen.next("nonce"),
-        ts: this.opts.clock.now(),
-        protocol_version: PROTOCOL_VERSION,
-        echo_nonce: "server-keepalive"
-      });
-    }, this.keepaliveIntervalMs);
-    if (typeof timer.unref === "function") {
-      timer.unref();
-    }
-    this.keepaliveTimers.set(socket, timer);
-  }
-  stopKeepalive(socket) {
-    const timer = this.keepaliveTimers.get(socket);
-    if (!timer) return;
-    clearInterval(timer);
-    this.keepaliveTimers.delete(socket);
-  }
-  rawSend(socket, msg) {
-    const r = ServerToClientSchema.safeParse(msg);
-    if (!r.success) {
-      console.error("[hub] outgoing failed schema", r.error);
-      return;
-    }
-    if (socket.readyState === WebSocket.OPEN) {
-      socket.send(JSON.stringify(msg));
-    }
-  }
-  exec(worker_id, params) {
-    const socket = this.byWorker.get(worker_id);
-    if (!socket)
-      return Promise.reject(new Error(`worker ${worker_id} not connected`));
-    const req_id = this.opts.idGen.next("req");
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.pending.delete(req_id);
-        reject(
-          new Error(`EXEC ${req_id} timeout after ${this.execTimeoutMs}ms`)
-        );
-      }, this.execTimeoutMs);
-      this.pending.set(req_id, { resolve, reject, timer, worker_id });
-      this.rawSend(socket, {
-        type: "EXEC",
-        nonce: this.opts.idGen.next("nonce"),
-        ts: this.opts.clock.now(),
-        protocol_version: PROTOCOL_VERSION,
-        req_id,
-        session_id: params.session_id,
-        tab_id: params.tab_id,
-        step: { kind: "tool", tool: params.step.tool, args: params.step.args }
-      });
-      if (this.byWorker.get(worker_id) !== socket) {
-        clearTimeout(timer);
-        this.pending.delete(req_id);
-        reject(new Error(`worker ${worker_id} disconnected`));
-      }
-    });
-  }
-  async send(worker_id, msg) {
-    const socket = this.byWorker.get(worker_id);
-    if (!socket) throw new Error(`worker ${worker_id} not connected`);
-    this.rawSend(socket, msg);
-  }
-  onMessage(handler) {
-    this.msgHandlers.push(handler);
-  }
-  onDisconnect(handler) {
-    this.disconnectHandlers.push(handler);
-  }
-  connectedWorkers() {
-    return [...this.byWorker.keys()];
-  }
-  // Intentionally fire-and-forget: actual cleanup (byWorker/workerOf removal and
-  // pending-exec rejection) happens asynchronously via the socket's close event.
-  // v1 callers do not await this method.
-  async disconnect(worker_id, _reason) {
-    const socket = this.byWorker.get(worker_id);
-    if (socket) socket.close();
-  }
-};
-
 // src/mcp-server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -1253,6 +1108,8 @@ var TOOL_DEFS = [
         ms: { type: "integer" },
         selector: { type: "string" },
         timeoutMs: { type: "integer", default: 5e3 },
+        text: { type: "string", description: "\u7B49\u5F85\u9875\u9762\u51FA\u73B0\u8BE5\u6587\u672C" },
+        textGone: { type: "string", description: "\u7B49\u5F85\u8BE5\u6587\u672C\u6D88\u5931" },
         tabId: TAB_ID_FIELD
       }
     }
@@ -1265,6 +1122,12 @@ var TOOL_DEFS = [
       properties: {
         selector: { type: "string" },
         required: { type: "boolean", default: true },
+        doubleClick: { type: "boolean", default: false },
+        button: { type: "string", enum: ["left", "right", "middle"], default: "left" },
+        modifiers: {
+          type: "array",
+          items: { type: "string", enum: ["Alt", "Control", "Meta", "Shift"] }
+        },
         tabId: TAB_ID_FIELD
       },
       required: ["selector"]
@@ -1308,6 +1171,12 @@ var TOOL_DEFS = [
         selector: { type: "string" },
         value: { type: "string" },
         clear: { type: "boolean", default: true },
+        slowly: {
+          type: "boolean",
+          default: false,
+          description: "\u9010\u5B57\u7B26\u89E6\u53D1 keydown/keypress/input/keyup\uFF0C\u5BF9\u4ED8\u53D7\u63A7\u7EC4\u4EF6"
+        },
+        submit: { type: "boolean", default: false, description: "\u586B\u5B8C\u6309\u4E00\u6B21 Enter" },
         tabId: TAB_ID_FIELD
       },
       required: ["selector", "value"]
@@ -1499,6 +1368,9 @@ var TOOL_DEFS = [
         blockId: { type: "string", description: "\u53EF\u9009\uFF1Apage-index \u8FD4\u56DE\u7684 blockId\uFF0C\u7528\u4E8E\u5C40\u90E8\u89C6\u89C9\u8BC1\u636E" },
         indexId: { type: "string", description: "\u53EF\u9009\uFF1A\u4EA7\u751F blockId \u7684 indexId\uFF0C\u907F\u514D refresh \u540E\u8BEF\u8BFB" },
         highlightMs: { type: "integer", default: 1500, description: "\u622A\u56FE\u524D\u76EE\u6807\u9AD8\u4EAE\u6301\u7EED\u65F6\u95F4\uFF0C250-5000ms" },
+        fullPage: { type: "boolean", default: false, description: "\u6EDA\u52A8\u5206\u6BB5\u622A\u56FE\u540E\u62FC\u63A5\u6574\u9875" },
+        format: { type: "string", enum: ["png", "jpeg"], default: "png" },
+        scale: { type: "number", default: 1, description: "0.1\u20131\uFF0C\u7F29\u5C0F\u53EF\u7701 token" },
         tabId: TAB_ID_FIELD
       }
     }
@@ -1757,89 +1629,318 @@ var TOOL_DEFS = [
       },
       required: ["store", "key", "value"]
     }
-  }
-];
-
-// src/tool-gen.ts
-var EXEC_TOOL_NAMES = [
-  "snapshotDOM",
-  "querySelector",
-  "querySelectorAll",
-  "extractText",
-  "extractImages",
-  "getValue",
-  "extractFormState",
-  "hover",
-  "focus",
-  "scroll",
-  "waitFor",
+  },
+  // ── Plan 32 — playwright parity ──────────────────────────────────────────
+  {
+    name: "consoleMessages",
+    description: "[OBSERVE] \u8BFB\u53D6\u672C\u9875 console \u65E5\u5FD7\u4E0E\u672A\u6355\u83B7\u9519\u8BEF\u3002\u8FD4\u56DE\u91CC\u5E26 backend \u5B57\u6BB5\uFF1Amain-world \u6863\u770B\u4E0D\u5230\u811A\u672C\u6CE8\u5165\u4E4B\u524D\u7684\u6D88\u606F\u548C\u6D4F\u89C8\u5668\u7EA7 CORS/CSP \u62A5\u9519\uFF0Ccdp \u6863\u80FD\u770B\u5230\u3002\n\u793A\u4F8B\uFF1A\u53EA\u770B\u62A5\u9519 { level: 'error', limit: 50 }\uFF1B\u589E\u91CF\u8F6E\u8BE2 { sinceId: \u4E0A\u6B21\u8FD4\u56DE\u7684\u6700\u5927 id }",
+    input_schema: {
+      type: "object",
+      properties: {
+        level: { type: "string", enum: ["log", "info", "warn", "error", "debug", "trace"] },
+        limit: { type: "integer", default: 100 },
+        sinceId: { type: "integer", description: "\u53EA\u8FD4\u56DE id \u5927\u4E8E\u6B64\u503C\u7684\u6D88\u606F\uFF0C\u7528\u4E8E\u589E\u91CF\u8BFB\u53D6" },
+        tabId: TAB_ID_FIELD
+      }
+    }
+  },
+  {
+    name: "networkRequests",
+    description: "[OBSERVE] \u5217\u51FA\u672C\u9875\u53D1\u51FA\u7684\u7F51\u7EDC\u8BF7\u6C42\u6458\u8981\uFF08method / url / status / \u8017\u65F6\uFF09\u3002\u9ED8\u8BA4\u9690\u85CF PerformanceObserver \u89C2\u6D4B\u5230\u7684\u9759\u6001\u8D44\u6E90\uFF0CincludeStatic:true \u624D\u5E26\u4E0A\u3002\n\u8981\u770B headers \u6216 body \u7528 networkRequestDetail\u3002",
+    input_schema: {
+      type: "object",
+      properties: {
+        urlPattern: { type: "string", description: "\u5B50\u4E32\u5339\u914D\uFF1B\u7528 /re/ \u6216 /re/i \u5305\u8D77\u6765\u5219\u6309\u6B63\u5219" },
+        method: { type: "string" },
+        status: { type: "integer" },
+        includeStatic: { type: "boolean", default: false },
+        limit: { type: "integer", default: 50 },
+        sinceId: { type: "integer" },
+        tabId: TAB_ID_FIELD
+      }
+    }
+  },
+  {
+    name: "networkRequestDetail",
+    description: "[OBSERVE] \u8BFB\u53D6\u5355\u6761\u8BF7\u6C42\u7684 headers \u4E0E body\u3002**dangerous**\uFF1A\u54CD\u5E94\u5934\u91CC\u53EF\u80FD\u6709 Authorization / Set-Cookie / token\u3002\nmain-world \u6863\u9700\u5148 recorderConfig({bodies:true}) \u624D\u4F1A\u8BB0\u5F55 body\uFF0C\u4E14\u53EA\u8BB0 256KB \u4EE5\u5185\u7684\u6587\u672C\u7C7B\u54CD\u5E94\uFF1Bcdp \u6863\u76F4\u63A5\u53EF\u53D6\u3002",
+    input_schema: {
+      type: "object",
+      properties: {
+        id: { type: "integer", description: "networkRequests \u8FD4\u56DE\u7684\u6761\u76EE id" },
+        part: {
+          type: "string",
+          enum: ["request-headers", "request-body", "response-headers", "response-body"],
+          description: "\u53EA\u53D6\u5176\u4E2D\u4E00\u90E8\u5206\uFF1B\u7701\u7565\u5219\u5168\u7ED9"
+        },
+        tabId: TAB_ID_FIELD
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "handleDialog",
+    description: "[OBSERVE] \u8BBE\u5B9A alert / confirm / prompt \u7684\u5E94\u7B54\u7B56\u7565\uFF0C\u5E76\u8FD4\u56DE\u5DF2\u8BB0\u5F55\u7684\u5F39\u7A97\u3002\nmain-world \u6863\u4E0B\u5F39\u7A97\u662F\u540C\u6B65\u7684\uFF0C\u65E0\u6CD5\u6302\u8D77\u7B49\u4F60\u51B3\u5B9A\uFF0C\u6240\u4EE5\u8FD9\u91CC\u8BBE\u7684\u662F**\u9884\u5148\u7B56\u7565**\uFF1A\u8C03\u7528\u4E4B\u540E\u53D1\u751F\u7684\u5F39\u7A97\u6309\u6B64\u5904\u7406\u3002cdp \u6863\u4E0B\u5F39\u7A97\u771F\u6302\u8D77\uFF0C\u672C\u8C03\u7528\u4F1A\u7ACB\u5373\u5E94\u7B54\u5F53\u524D\u6302\u8D77\u7684\u5F39\u7A97\u3002\n\u672A\u8C03\u7528\u8FC7\u672C\u5DE5\u5177\u65F6\u5F39\u7A97\u4FDD\u6301\u539F\u751F\u884C\u4E3A\uFF08passthrough\uFF09\uFF0C\u9875\u9762\u8868\u73B0\u4E0E\u6CA1\u88C5\u6269\u5C55\u4E00\u81F4\u3002",
+    input_schema: {
+      type: "object",
+      properties: {
+        accept: { type: "boolean", description: "true=\u786E\u5B9A\uFF0Cfalse=\u53D6\u6D88" },
+        promptText: { type: "string", description: "prompt \u5F39\u7A97\u586B\u5165\u7684\u6587\u672C" },
+        scope: { type: "string", enum: ["next", "all"], default: "next" },
+        tabId: TAB_ID_FIELD
+      },
+      required: ["accept"]
+    }
+  },
+  {
+    name: "recorderConfig",
+    description: "[OBSERVE] \u5F00\u5173\u9875\u9762\u4E8B\u4EF6\u5F55\u5236\u3002bodies:true \u6253\u5F00\u8BF7\u6C42/\u54CD\u5E94 body \u6355\u83B7\uFF08\u9ED8\u8BA4\u5173\uFF0C\u6709\u5185\u5B58\u4EE3\u4EF7\uFF09\uFF1Bdialog:true \u8BA9\u5F39\u7A97\u8D70\u7B56\u7565\u800C\u4E0D\u662F\u539F\u751F\u884C\u4E3A\uFF1Bclear \u6E05\u7A7A\u7F13\u51B2\u3002\u7701\u7565\u7684\u5B57\u6BB5\u4FDD\u6301\u539F\u6837\u3002",
+    input_schema: {
+      type: "object",
+      properties: {
+        console: { type: "boolean" },
+        network: { type: "boolean" },
+        bodies: { type: "boolean" },
+        dialog: { type: "boolean" },
+        clear: {
+          type: "array",
+          items: { type: "string", enum: ["console", "network", "dialog"] }
+        },
+        tabId: TAB_ID_FIELD
+      }
+    }
+  },
+  {
+    name: "navigateBack",
+    description: "[FLOW] \u540E\u9000\u4E00\u9875\u3002\u5DF2\u5728\u5386\u53F2\u8D77\u70B9\u65F6\u8FD4\u56DE { ok:false, reason }\uFF0C\u4E0D\u629B\u9519\u3002",
+    input_schema: { type: "object", properties: { tabId: TAB_ID_FIELD } }
+  },
+  {
+    name: "navigateForward",
+    description: "[FLOW] \u524D\u8FDB\u4E00\u9875\u3002\u5DF2\u5728\u5386\u53F2\u672B\u5C3E\u65F6\u8FD4\u56DE { ok:false, reason }\uFF0C\u4E0D\u629B\u9519\u3002",
+    input_schema: { type: "object", properties: { tabId: TAB_ID_FIELD } }
+  },
+  {
+    name: "resize",
+    description: "[FLOW] \u628A\u89C6\u53E3\u8C03\u6574\u5230\u6307\u5B9A\u5C3A\u5BF8\u3002main-world \u6863\u91CF\u53D6 outerWidth-innerWidth \u53CD\u63A8\u6D4F\u89C8\u5668\u8FB9\u6846\u540E\u6539\u7A97\u53E3\u5916\u6846\uFF0C\u89C6\u53E3\u7CBE\u786E\u4F46**\u7528\u6237\u7684\u7A97\u53E3\u4F1A\u771F\u7684\u53D8\u5927\u5C0F**\uFF1Bcdp \u6863\u7528 Emulation \u8986\u76D6\u8BBE\u5907\u5C3A\u5BF8\uFF0C\u4E0D\u52A8\u771F\u5B9E\u7A97\u53E3\u3002",
+    input_schema: {
+      type: "object",
+      properties: {
+        width: { type: "integer" },
+        height: { type: "integer" },
+        tabId: TAB_ID_FIELD
+      },
+      required: ["width", "height"]
+    }
+  },
+  {
+    name: "drag",
+    description: "[ACT] \u628A\u4E00\u4E2A\u5143\u7D20\u62D6\u5230\u53E6\u4E00\u4E2A\u5143\u7D20\u4E0A\u3002\u540C\u65F6\u53D1 pointer \u5E8F\u5217\u548C HTML5 DragEvent\uFF08\u5171\u7528\u4E00\u4E2A DataTransfer\uFF09\uFF0C\u517C\u5BB9\u539F\u751F\u62D6\u653E\u548C\u81EA\u5B9A\u4E49 pointer \u62D6\u653E\u3002\n\u8FD4\u56DE { consumed: { pointer, html5 } } \u8BF4\u660E\u76EE\u6807\u5B9E\u9645\u6D88\u8D39\u4E86\u54EA\u4E00\u7C7B\u4E8B\u4EF6\u2014\u2014\u90FD\u4E3A false \u8BF4\u660E\u8FD9\u4E2A\u62D6\u653E\u5B9E\u73B0\u4E24\u6761\u8DEF\u90FD\u4E0D\u5403\u3002",
+    input_schema: {
+      type: "object",
+      properties: {
+        fromSelector: { type: "string" },
+        fromUid: { type: "string", description: "takeSnapshot / findElements \u8FD4\u56DE\u7684 uid" },
+        toSelector: { type: "string" },
+        toUid: { type: "string" },
+        tabId: TAB_ID_FIELD
+      }
+    }
+  },
+  {
+    name: "drop",
+    description: "[ACT] \u6A21\u62DF\u4ECE\u6D4F\u89C8\u5668\u5916\u90E8\u628A\u6587\u4EF6\u6216\u6570\u636E\u62D6\u653E\u5230\u9875\u9762\u5143\u7D20\u4E0A\u3002\u5E26 files \u65F6\u7B49\u540C\u4E0A\u4F20\uFF08dangerous\uFF09\u3002\n\u793A\u4F8B\uFF1A{ selector:'#dropzone', files:[{ name:'a.csv', mimeType:'text/csv', base64:'...' }] }",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: { type: "string" },
+        uid: { type: "string" },
+        files: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              mimeType: { type: "string" },
+              base64: { type: "string" }
+            },
+            required: ["name", "base64"]
+          }
+        },
+        data: { type: "object", description: "MIME \u2192 \u5B57\u7B26\u4E32\uFF0C\u4F8B\u5982 { 'text/plain':'hi' }" },
+        tabId: TAB_ID_FIELD
+      }
+    }
+  },
+  {
+    name: "findElements",
+    description: "[READ] \u6309\u6587\u672C\u6216\u6B63\u5219\u5728\u53EF\u4EA4\u4E92\u5143\u7D20\u91CC\u627E\u76EE\u6807\uFF0C\u8FD4\u56DE uid / role / name / bounds\u3002\u4E0D\u9700\u8981\u5148 createPageIndex\u3002\n\u62FF\u5230 uid \u540E\u7528 clickByUid / fillByUid \u64CD\u4F5C\u6700\u7A33\u3002",
+    input_schema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "\u5927\u5C0F\u5199\u4E0D\u654F\u611F\u5B50\u4E32" },
+        regex: { type: "string", description: "\u4E0E text \u4E8C\u9009\u4E00" },
+        limit: { type: "integer", default: 20 },
+        tabId: TAB_ID_FIELD
+      }
+    }
+  }
+];
+
+// src/tool-gen.ts
+var BLOCKED_TOOLS = /* @__PURE__ */ new Set(["askUser", "attachTab", "detachTab"]);
+var PARITY_TOOLS = [
+  // page state and search
+  "takeSnapshot",
+  "findElements",
+  "getPageInfo",
+  // interaction
+  "clickByUid",
   "click",
   "fillInput",
-  "setCheckbox",
+  "fillForm",
   "selectOption",
-  "httpRequest",
-  "submitForm",
+  "setCheckbox",
+  "hover",
+  "pressKey",
+  "drag",
+  "drop",
   "uploadFile",
-  "readStorage"
+  // navigation and tabs
+  "navigate",
+  "navigateBack",
+  "listTabs",
+  "openTab",
+  "resize",
+  // observation
+  "screenshot",
+  "waitFor",
+  "runJS",
+  "consoleMessages",
+  "networkRequests"
 ];
+var IMAGE_RESULT_TOOLS = /* @__PURE__ */ new Set(["screenshot"]);
+var JS_STEP_TOOLS = /* @__PURE__ */ new Set(["runJS"]);
 function rebuildSchema(src) {
   const s = src;
   const properties = { ...s.properties ?? {} };
   delete properties.tabId;
-  properties.session_id = { type: "string", description: "open_session \u8FD4\u56DE\u7684\u4F1A\u8BDD id\uFF08\u51B3\u5B9A\u76EE\u6807 worker \u4E0E tab\uFF09" };
+  properties.session_id = {
+    type: "string",
+    description: "open_session \u8FD4\u56DE\u7684\u4F1A\u8BDD id\uFF08\u51B3\u5B9A\u76EE\u6807 worker \u4E0E tab\uFF09"
+  };
   const required = [.../* @__PURE__ */ new Set([...(s.required ?? []).filter((r) => r !== "tabId"), "session_id"])];
   return { type: "object", properties, required };
 }
-function generateBrowserTools() {
-  const allow = new Set(EXEC_TOOL_NAMES);
-  return TOOL_DEFS.filter((t) => allow.has(t.name)).map((t) => ({
+function generateBrowserTools(mode = "full") {
+  const parity = new Set(PARITY_TOOLS);
+  return TOOL_DEFS.filter((t) => {
+    if (BLOCKED_TOOLS.has(t.name)) return false;
+    return mode === "full" || parity.has(t.name);
+  }).map((t) => ({
     name: `browser_${t.name}`,
     builtinTool: t.name,
     description: t.description,
+    resultKind: IMAGE_RESULT_TOOLS.has(t.name) ? "image" : "json",
+    stepKind: JS_STEP_TOOLS.has(t.name) ? "js" : "tool",
     inputSchema: rebuildSchema(t.input_schema)
   }));
 }
+function readToolMode(env) {
+  const raw = env.ATWEBPILOT_MCP_TOOLS;
+  if (raw == null || raw === "") return "full";
+  if (raw === "full" || raw === "parity") return raw;
+  process.stderr.write(
+    `[atwebpilot-mcp] ATWEBPILOT_MCP_TOOLS="${raw}" is not recognised; using "full"
+`
+  );
+  return "full";
+}
 
 // src/handlers.ts
-function singleWorkerId(c) {
+function singleWorkerId(c, pairUrl) {
   const workers = c.workers.list();
-  if (workers.length === 0) throw new Error("\u6CA1\u6709\u6D4F\u89C8\u5668\u8FDE\u5165\uFF0C\u8BF7\u5728\u6269\u5C55\u8BBE\u7F6E\u9875\u586B ws://127.0.0.1:<port>/worker \u8FDE\u63A5");
+  if (workers.length === 0) {
+    throw new Error(
+      "\u6CA1\u6709\u6D4F\u89C8\u5668\u8FDE\u5165\u3002\u5DF2\u4E3A\u4F60\u6253\u5F00\u914D\u5BF9\u9875" + (pairUrl ? ` ${pairUrl}` : "") + "\uFF0C\u5728\u6D4F\u89C8\u5668\u91CC\u786E\u8BA4\u540E\u91CD\u8BD5\u672C\u6B21\u8C03\u7528\u3002\uFF08\u5982\u679C\u9ED8\u8BA4\u6D4F\u89C8\u5668\u4E0D\u662F\u88C5\u4E86\u6269\u5C55\u7684\u90A3\u4E2A\uFF0C\u8BF7\u628A\u8BE5\u5730\u5740\u7C98\u8D34\u8FC7\u53BB\u6253\u5F00\uFF09"
+    );
+  }
   if (workers.length > 1) throw new Error("\u68C0\u6D4B\u5230\u591A\u4E2A\u6D4F\u89C8\u5668\u8FDE\u5165\uFF1Bv1 \u4EC5\u652F\u6301\u5355 worker\uFF0C\u8BF7\u53EA\u4FDD\u7559\u4E00\u4E2A\u8FDE\u63A5");
   return workers[0].id;
 }
-function handleListTabs(deps) {
-  const w = deps.coordinator.workers.get(singleWorkerId(deps.coordinator));
+async function handleListTabs(deps) {
+  const { coordinator } = await deps.ensure();
+  const w = coordinator.workers.get(singleWorkerId(coordinator, deps.pairUrl()));
   return { tabs: w.available_tabs };
 }
-function handleOpenSession(deps, args) {
-  const worker_id = singleWorkerId(deps.coordinator);
+async function handleOpenSession(deps, args) {
+  const { coordinator } = await deps.ensure();
+  const worker_id = singleWorkerId(coordinator, deps.pairUrl());
   const tab_id = String(args.tab_id);
   const requested = Array.isArray(args.capabilities) ? args.capabilities.map(String).filter(isCapability) : [];
   const scope = new Set(requested.length ? requested : CAPABILITIES);
   const idle_timeout_ms = typeof args.idle_timeout_min === "number" ? args.idle_timeout_min * 6e4 : void 0;
-  const s = deps.coordinator.openSession({ ai_client_fingerprint: "mcp-local", worker_id, tab_id, scope, idle_timeout_ms });
+  const s = coordinator.openSession({ ai_client_fingerprint: "mcp-local", worker_id, tab_id, scope, idle_timeout_ms });
   return { session_id: s.id };
 }
-function handleCloseSession(deps, args) {
-  deps.coordinator.closeSession(String(args.session_id));
+async function handleCloseSession(deps, args) {
+  const { coordinator } = await deps.ensure();
+  coordinator.closeSession(String(args.session_id));
   return { ok: true };
 }
-function handleGetQuota(deps, args) {
-  const q = deps.coordinator.quotaFor(String(args.session_id));
+async function handleGetQuota(deps, args) {
+  const { coordinator } = await deps.ensure();
+  const q = coordinator.quotaFor(String(args.session_id));
   if (!q) throw new Error(`session ${String(args.session_id)} not found`);
   return q;
 }
+var NON_BUILTIN_CAPABILITY = {
+  listTabs: "tab:open",
+  openTab: "tab:open"
+};
 async function handleBrowserTool(deps, gen, args) {
+  const { coordinator, hub } = await deps.ensure();
   const session_id = String(args.session_id);
-  const session = deps.coordinator.sessions.get(session_id);
+  const session = coordinator.sessions.get(session_id);
   if (!session) throw new Error(`session ${session_id} not found`);
   const { session_id: _omit, ...toolArgs } = args;
   const tool = gen.builtinTool;
-  const httpCookied = tool === "httpRequest" ? Boolean(toolArgs.withCredentials) : void 0;
-  const v = deps.coordinator.validateCall({ session_id, kind: "extension_tool", tool, httpCookied });
-  if (!v.ok) throw new Error(`${v.error.code}: ${v.error.message}`);
-  deps.coordinator.recordCall(session_id, v.dangerous);
-  const result = await deps.hub.exec(session.worker_id, { session_id, tab_id: session.tab_id, step: { kind: "tool", tool, args: toolArgs } });
+  if (gen.stepKind === "js") {
+    const source = String(toolArgs.source ?? "");
+    if (!source) throw new Error("browser_runJS: source required");
+    const v = coordinator.validateCall({ session_id, kind: "runJS", unsafe: true });
+    if (!v.ok) throw new Error(`${v.error.code}: ${v.error.message}`);
+    coordinator.recordCall(session_id, v.dangerous);
+    const jsResult = await hub.exec(session.worker_id, {
+      session_id,
+      tab_id: session.tab_id,
+      step: { kind: "js", source }
+    });
+    if (!jsResult.ok) {
+      throw new Error(
+        jsResult.error ? `${jsResult.error.code}: ${jsResult.error.message}` : "EXEC failed"
+      );
+    }
+    return jsResult.return ?? null;
+  }
+  const override = NON_BUILTIN_CAPABILITY[gen.builtinTool];
+  if (override) {
+    const v = coordinator.validateCall({ session_id, kind: "capability", capability: override });
+    if (!v.ok) throw new Error(`${v.error.code}: ${v.error.message}`);
+    coordinator.recordCall(session_id, v.dangerous);
+  } else {
+    const raw = toolArgs;
+    const v = coordinator.validateCall({
+      session_id,
+      kind: "extension_tool",
+      tool,
+      httpCookied: tool === "httpRequest" ? Boolean(raw.withCredentials) : void 0,
+      dropHasFiles: tool === "drop" ? Array.isArray(raw.files) && raw.files.length > 0 : void 0,
+      recorderArmsBodies: tool === "recorderConfig" ? raw.bodies === true : void 0
+    });
+    if (!v.ok) throw new Error(`${v.error.code}: ${v.error.message}`);
+    coordinator.recordCall(session_id, v.dangerous);
+  }
+  const result = await hub.exec(session.worker_id, { session_id, tab_id: session.tab_id, step: { kind: "tool", tool, args: toolArgs } });
   if (!result.ok) throw new Error(result.error ? `${result.error.code}: ${result.error.message}` : "EXEC failed");
   return result.return ?? null;
 }
@@ -1886,16 +1987,57 @@ var SKILL_TOOL = {
 };
 
 // src/mcp-server.ts
-var BROWSER_TOOLS = generateBrowserTools();
+var TOOL_MODE = readToolMode(process.env);
+var BROWSER_TOOLS = generateBrowserTools(TOOL_MODE);
 var BROWSER_BY_NAME = new Map(BROWSER_TOOLS.map((t) => [t.name, t]));
-function buildToolList() {
+var LEGACY_TOOLS = [
+  "snapshotDOM",
+  "querySelector",
+  "querySelectorAll",
+  "extractText",
+  "extractImages",
+  "getValue",
+  "extractFormState",
+  "hover",
+  "focus",
+  "scroll",
+  "waitFor",
+  "click",
+  "fillInput",
+  "setCheckbox",
+  "selectOption",
+  "httpRequest",
+  "submitForm",
+  "uploadFile",
+  "readStorage"
+];
+function workerToolSupport(deps) {
+  const bundle = deps?.peek();
+  if (!bundle) return void 0;
+  const workers = bundle.coordinator.workers.list();
+  if (workers.length === 0) return void 0;
+  const supported = workers[0].supported_tools;
+  return supported ?? new Set(LEGACY_TOOLS);
+}
+function buildToolList(deps) {
+  const supported = workerToolSupport(deps);
+  const browser = supported ? BROWSER_TOOLS.filter((t) => supported.has(t.builtinTool)) : BROWSER_TOOLS;
   return [
     { name: SKILL_TOOL.name, description: SKILL_TOOL.description, inputSchema: SKILL_TOOL.inputSchema },
     ...CONTROL_TOOLS.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })),
-    ...BROWSER_TOOLS.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }))
+    ...browser.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }))
   ];
 }
-var ok = (data) => ({ content: [{ type: "text", text: JSON.stringify(data ?? null) }] });
+var ok = (data) => ({
+  content: [{ type: "text", text: JSON.stringify(data ?? null) }]
+});
+function toolResult(gen, data) {
+  if (gen.resultKind !== "image") return ok(data);
+  const d = data ?? {};
+  if (typeof d.data !== "string") return ok(data);
+  const mimeType = typeof d.media_type === "string" ? d.media_type : "image/png";
+  return { content: [{ type: "image", data: d.data, mimeType }] };
+}
 var fail2 = (message) => ({ content: [{ type: "text", text: message }], isError: true });
 async function dispatchCall(deps, name, args) {
   try {
@@ -1903,12 +2045,12 @@ async function dispatchCall(deps, name, args) {
       const bundle = readSkillBundle();
       return { content: [{ type: "text", text: bundle.content }] };
     }
-    if (name === "list_tabs") return ok(handleListTabs(deps));
-    if (name === "open_session") return ok(handleOpenSession(deps, args));
-    if (name === "close_session") return ok(handleCloseSession(deps, args));
-    if (name === "get_quota") return ok(handleGetQuota(deps, args));
+    if (name === "list_tabs") return ok(await handleListTabs(deps));
+    if (name === "open_session") return ok(await handleOpenSession(deps, args));
+    if (name === "close_session") return ok(await handleCloseSession(deps, args));
+    if (name === "get_quota") return ok(await handleGetQuota(deps, args));
     const gen = BROWSER_BY_NAME.get(name);
-    if (gen) return ok(await handleBrowserTool(deps, gen, args));
+    if (gen) return toolResult(gen, await handleBrowserTool(deps, gen, args));
     return fail2(`unknown tool: ${name}`);
   } catch (e) {
     return fail2(e instanceof Error ? e.message : String(e));
@@ -1916,7 +2058,7 @@ async function dispatchCall(deps, name, args) {
 }
 function createMcpServer(deps) {
   const server = new Server({ name: "atwebpilot-mcp", version: "0.1.0" }, { capabilities: { tools: {} } });
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: buildToolList() }));
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: buildToolList(deps) }));
   server.setRequestHandler(CallToolRequestSchema, async (req) => {
     const args = req.params.arguments ?? {};
     return dispatchCall(deps, req.params.name, args);
@@ -1924,12 +2066,325 @@ function createMcpServer(deps) {
   return server;
 }
 
+// src/loopback-ws-hub.ts
+import { WebSocketServer, WebSocket } from "ws";
+import { createServer } from "http";
+
+// ../shared/src/pairing/types.ts
+var GRACEFUL_CLOSE_CODE = 4e3;
+var GRACEFUL_CLOSE_REASON = "server-shutting-down";
+
+// src/pair-page.ts
+function renderPairPage(payload) {
+  const json = JSON.stringify(payload).replace(/</g, "\\u003c");
+  return `<!doctype html>
+<meta charset="utf-8">
+<title>AtWebPilot \u914D\u5BF9</title>
+<body style="font:14px/1.6 system-ui,sans-serif;padding:2rem;max-width:32rem;margin:auto;color:#222">
+<h1 style="font-size:1.1rem;margin:0 0 1rem">AtWebPilot \u914D\u5BF9</h1>
+<p id="atwebpilot-status">\u6B63\u5728\u8054\u7CFB\u6269\u5C55\u2026</p>
+<p style="color:#666;font-size:13px">\u4F1A\u8BDD\uFF1A${escapeHtml(payload.label)} \xB7 pid ${payload.pid} \xB7 \u7AEF\u53E3 ${payload.port}</p>
+<p style="color:#666;font-size:13px">\u6CA1\u6709\u53CD\u5E94\uFF1F\u8BF7\u786E\u8BA4\u8FD9\u4E2A\u6D4F\u89C8\u5668\u5DF2\u5B89\u88C5\u5E76\u542F\u7528 AtWebPilot \u6269\u5C55\uFF0C\u7136\u540E\u5237\u65B0\u672C\u9875\u3002</p>
+<script>
+(function () {
+  var payload = ${json};
+  window.postMessage({ source: "atwebpilot-pair", payload: payload }, "*");
+  window.addEventListener("message", function (e) {
+    if (!e.data || e.data.source !== "atwebpilot-pair-result") return;
+    var el = document.getElementById("atwebpilot-status");
+    if (e.data.ok) {
+      el.textContent = e.data.trusted ? "\u5DF2\u4FE1\u4EFB\uFF0C\u8FDE\u63A5\u4E2D\u2026" : "\u5DF2\u8FDE\u63A5";
+      setTimeout(function () { window.close(); }, 1200);
+    } else {
+      el.textContent = "\u5DF2\u62D2\u7EDD\u3002\u53EF\u4EE5\u5173\u95ED\u672C\u9875\u3002";
+    }
+  });
+})();
+</script>
+`;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/loopback-ws-hub.ts
+var HEARTBEAT_INTERVAL_MS = 2e4;
+var DEFAULT_KEEPALIVE_INTERVAL_MS = 15e3;
+var LoopbackWSHub = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.execTimeoutMs = opts.execTimeoutMs ?? 3e4;
+    this.keepaliveIntervalMs = opts.keepaliveIntervalMs ?? DEFAULT_KEEPALIVE_INTERVAL_MS;
+    this.http = createServer((req, res) => this.onHttpRequest(req, res));
+    this.readyPromise = new Promise((resolve, reject) => {
+      this.http.once("listening", () => resolve(this.http.address().port));
+      this.http.once("error", (err) => {
+        reject(
+          err.code === "EADDRINUSE" ? new Error(
+            `port ${opts.port} is already in use \u2014 another atwebpilot-mcp may be running; set ATWEBPILOT_WS_PORT to choose another port`
+          ) : err
+        );
+      });
+    });
+    this.wss = new WebSocketServer({
+      server: this.http,
+      path: "/worker",
+      handleProtocols: (protocols) => [...protocols][0] ?? false
+    });
+    this.wss.on("connection", (socket, req) => this.onConnection(socket, req));
+    this.http.on("error", () => void 0);
+    this.wss.on("error", () => void 0);
+    this.http.listen(opts.port);
+  }
+  opts;
+  http;
+  wss;
+  /** Settled by the constructor so ready() cannot race the listen outcome. */
+  readyPromise;
+  byWorker = /* @__PURE__ */ new Map();
+  workerOf = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  msgHandlers = [];
+  disconnectHandlers = [];
+  execTimeoutMs;
+  keepaliveIntervalMs;
+  keepaliveTimers = /* @__PURE__ */ new Map();
+  ready() {
+    return this.readyPromise;
+  }
+  /** Serves the pairing page; everything else is a 404. */
+  onHttpRequest(req, res) {
+    const path = (req.url ?? "").split("?")[0];
+    if (path !== "/pair") {
+      res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+      res.end("not found");
+      return;
+    }
+    const payload = this.opts.pairPayload?.();
+    if (!payload) {
+      res.writeHead(503, { "content-type": "text/plain; charset=utf-8" });
+      res.end("pairing unavailable");
+      return;
+    }
+    res.writeHead(200, {
+      "content-type": "text/html; charset=utf-8",
+      "cache-control": "no-store"
+    });
+    res.end(renderPairPage(payload));
+  }
+  /**
+   * Tells connected extensions this shutdown is deliberate, so they drop the
+   * endpoint instead of retrying it for the rest of the browser session.
+   */
+  async shutdown() {
+    for (const socket of this.wss.clients) {
+      try {
+        socket.close(GRACEFUL_CLOSE_CODE, GRACEFUL_CLOSE_REASON);
+      } catch {
+      }
+    }
+    await new Promise((r) => setTimeout(r, 50));
+    await this.close();
+  }
+  close() {
+    for (const p of this.pending.values()) {
+      clearTimeout(p.timer);
+      p.reject(new Error("hub closing"));
+    }
+    this.pending.clear();
+    for (const timer of this.keepaliveTimers.values()) clearInterval(timer);
+    this.keepaliveTimers.clear();
+    for (const socket of this.wss.clients) {
+      socket.terminate();
+    }
+    return new Promise(
+      (resolve) => this.wss.close(() => this.http.close(() => resolve()))
+    );
+  }
+  tokenOk(req) {
+    if (!this.opts.token) return true;
+    const offered = String(req.headers["sec-websocket-protocol"] ?? "").split(",").map((s) => s.trim());
+    return offered.includes(`bearer.${this.opts.token}`);
+  }
+  onConnection(socket, req) {
+    if (!this.tokenOk(req)) {
+      socket.close(4401, "bad token");
+      return;
+    }
+    socket.on("message", (raw) => this.onMessageRaw(socket, raw.toString()));
+    socket.on("close", () => this.onSocketClose(socket));
+    socket.on("error", () => {
+    });
+  }
+  onMessageRaw(socket, raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const r = ClientToServerSchema.safeParse(parsed);
+    if (!r.success) return;
+    const msg = r.data;
+    if (msg.type === "HELLO") {
+      const existingSocket = this.byWorker.get(msg.worker_id);
+      if (existingSocket && existingSocket !== socket) {
+        this.workerOf.delete(existingSocket);
+        for (const [req_id, p] of [...this.pending]) {
+          if (p.worker_id === msg.worker_id) {
+            clearTimeout(p.timer);
+            this.pending.delete(req_id);
+            p.reject(new Error(`worker ${msg.worker_id} reconnected, exec cancelled`));
+          }
+        }
+        existingSocket.terminate();
+      }
+      this.byWorker.set(msg.worker_id, socket);
+      this.workerOf.set(socket, msg.worker_id);
+      this.rawSend(socket, {
+        type: "WELCOME",
+        nonce: this.opts.idGen.next("nonce"),
+        ts: this.opts.clock.now(),
+        protocol_version: PROTOCOL_VERSION,
+        server_time: this.opts.clock.now(),
+        heartbeat_interval_ms: HEARTBEAT_INTERVAL_MS
+      });
+      this.startKeepalive(socket);
+      for (const h of this.msgHandlers) h(msg.worker_id, msg);
+      return;
+    }
+    if (msg.type === "RESULT") {
+      const p = this.pending.get(msg.req_id);
+      if (p) {
+        clearTimeout(p.timer);
+        this.pending.delete(msg.req_id);
+        p.resolve(msg);
+      }
+      return;
+    }
+    if (msg.type === "PING") {
+      this.rawSend(socket, {
+        type: "PONG",
+        nonce: this.opts.idGen.next("nonce"),
+        ts: this.opts.clock.now(),
+        protocol_version: PROTOCOL_VERSION,
+        echo_nonce: msg.nonce
+      });
+    }
+    const wid = this.workerOf.get(socket);
+    if (wid) {
+      for (const h of this.msgHandlers) h(wid, msg);
+    }
+  }
+  onSocketClose(socket) {
+    this.stopKeepalive(socket);
+    const wid = this.workerOf.get(socket);
+    if (!wid) return;
+    this.workerOf.delete(socket);
+    this.byWorker.delete(wid);
+    for (const [req_id, p] of [...this.pending]) {
+      if (p.worker_id === wid) {
+        clearTimeout(p.timer);
+        this.pending.delete(req_id);
+        p.reject(new Error(`worker ${wid} disconnected`));
+      }
+    }
+    for (const h of this.disconnectHandlers) h(wid);
+  }
+  startKeepalive(socket) {
+    if (this.keepaliveIntervalMs <= 0) return;
+    if (this.keepaliveTimers.has(socket)) return;
+    const timer = setInterval(() => {
+      if (socket.readyState !== WebSocket.OPEN) return;
+      this.rawSend(socket, {
+        type: "PONG",
+        nonce: this.opts.idGen.next("nonce"),
+        ts: this.opts.clock.now(),
+        protocol_version: PROTOCOL_VERSION,
+        echo_nonce: "server-keepalive"
+      });
+    }, this.keepaliveIntervalMs);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+    this.keepaliveTimers.set(socket, timer);
+  }
+  stopKeepalive(socket) {
+    const timer = this.keepaliveTimers.get(socket);
+    if (!timer) return;
+    clearInterval(timer);
+    this.keepaliveTimers.delete(socket);
+  }
+  rawSend(socket, msg) {
+    const r = ServerToClientSchema.safeParse(msg);
+    if (!r.success) {
+      console.error("[hub] outgoing failed schema", r.error);
+      return;
+    }
+    if (socket.readyState === WebSocket.OPEN) {
+      socket.send(JSON.stringify(msg));
+    }
+  }
+  exec(worker_id, params) {
+    const socket = this.byWorker.get(worker_id);
+    if (!socket)
+      return Promise.reject(new Error(`worker ${worker_id} not connected`));
+    const req_id = this.opts.idGen.next("req");
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(req_id);
+        reject(
+          new Error(`EXEC ${req_id} timeout after ${this.execTimeoutMs}ms`)
+        );
+      }, this.execTimeoutMs);
+      this.pending.set(req_id, { resolve, reject, timer, worker_id });
+      this.rawSend(socket, {
+        type: "EXEC",
+        nonce: this.opts.idGen.next("nonce"),
+        ts: this.opts.clock.now(),
+        protocol_version: PROTOCOL_VERSION,
+        req_id,
+        session_id: params.session_id,
+        tab_id: params.tab_id,
+        step: { kind: "tool", tool: params.step.tool, args: params.step.args }
+      });
+      if (this.byWorker.get(worker_id) !== socket) {
+        clearTimeout(timer);
+        this.pending.delete(req_id);
+        reject(new Error(`worker ${worker_id} disconnected`));
+      }
+    });
+  }
+  async send(worker_id, msg) {
+    const socket = this.byWorker.get(worker_id);
+    if (!socket) throw new Error(`worker ${worker_id} not connected`);
+    this.rawSend(socket, msg);
+  }
+  onMessage(handler) {
+    this.msgHandlers.push(handler);
+  }
+  onDisconnect(handler) {
+    this.disconnectHandlers.push(handler);
+  }
+  connectedWorkers() {
+    return [...this.byWorker.keys()];
+  }
+  // Intentionally fire-and-forget: actual cleanup (byWorker/workerOf removal and
+  // pending-exec rejection) happens asynchronously via the socket's close event.
+  // v1 callers do not await this method.
+  async disconnect(worker_id, _reason) {
+    const socket = this.byWorker.get(worker_id);
+    if (socket) socket.close();
+  }
+};
+
 // src/wire.ts
 function helloToWorker(h, now) {
   return {
     id: h.worker_id,
     fingerprint: h.fingerprint,
     capabilities: new Set(h.capabilities.filter(isCapability)),
+    supported_tools: h.supported_tools ? new Set(h.supported_tools) : void 0,
     attended: h.attended,
     labels: new Set(h.labels),
     available_tabs: h.available_tabs,
@@ -1949,6 +2404,11 @@ function installWire(hub, coordinator, clock) {
       case "PING":
         coordinator.heartbeatWorker(worker_id);
         break;
+      case "TABS_UPDATE": {
+        const w = coordinator.workers.get(worker_id);
+        if (w) w.available_tabs = msg.tabs.map((t) => ({ ...t }));
+        break;
+      }
       default:
         break;
     }
@@ -1956,19 +2416,150 @@ function installWire(hub, coordinator, clock) {
   hub.onDisconnect((worker_id) => coordinator.unregisterWorker(worker_id));
 }
 
+// src/identity.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { randomBytes, randomUUID } from "crypto";
+var FILE = "identity.json";
+function defaultIdentityDir() {
+  return join2(homedir(), ".atwebpilot");
+}
+function read(dir) {
+  try {
+    const raw = readFileSync2(join2(dir, FILE), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.installId !== "string" || typeof parsed.secret !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function write(dir, data) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  writeFileSync(join2(dir, FILE), `${JSON.stringify(data, null, 2)}
+`, { mode: 384 });
+}
+function loadOrCreateIdentity(dir = defaultIdentityDir()) {
+  const existing = read(dir);
+  if (existing) return { installId: existing.installId, secret: existing.secret };
+  const created = {
+    installId: `inst_${randomUUID().replace(/-/g, "").slice(0, 16)}`,
+    secret: randomBytes(24).toString("base64url")
+  };
+  write(dir, created);
+  return { installId: created.installId, secret: created.secret };
+}
+function loadLastPort(dir = defaultIdentityDir()) {
+  const existing = read(dir);
+  return typeof existing?.lastPort === "number" ? existing.lastPort : void 0;
+}
+function saveLastPort(port, dir = defaultIdentityDir()) {
+  const existing = read(dir);
+  const base = existing ?? { ...loadOrCreateIdentity(dir) };
+  write(dir, { ...base, lastPort: port });
+}
+function processInfo(cwd = process.cwd()) {
+  const home = homedir();
+  const label = home && cwd.startsWith(home) ? `~${cwd.slice(home.length)}` : cwd;
+  return {
+    sessionId: `sess_${randomUUID().replace(/-/g, "").slice(0, 12)}`,
+    label,
+    pid: process.pid
+  };
+}
+
+// src/ensure-hub.ts
+function createHubEnsurer(d) {
+  let bundle = null;
+  let inflight = null;
+  let pairUrlValue = null;
+  let opened = false;
+  const info = d.processInfo ?? processInfo();
+  async function bind() {
+    const identity = loadOrCreateIdentity(d.identityDir);
+    const preferred = d.explicitPort ?? loadLastPort(d.identityDir) ?? 0;
+    let hub;
+    let port;
+    const pairPayload = () => ({
+      v: 1,
+      installId: identity.installId,
+      secret: identity.secret,
+      sessionId: info.sessionId,
+      label: info.label,
+      pid: info.pid,
+      port
+    });
+    try {
+      hub = new LoopbackWSHub({ ...common(), port: preferred, pairPayload });
+      port = await hub.ready();
+    } catch (e) {
+      if (d.explicitPort != null) throw e;
+      hub = new LoopbackWSHub({ ...common(), port: 0, pairPayload });
+      port = await hub.ready();
+    }
+    saveLastPort(port, d.identityDir);
+    const coordinator = new Coordinator({ hub, clock: d.clock, idGen: d.idGen });
+    installWire(hub, coordinator, d.clock);
+    pairUrlValue = `http://127.0.0.1:${port}/pair`;
+    return { coordinator, hub, port };
+    function common() {
+      return { token: d.token, clock: d.clock, idGen: d.idGen };
+    }
+  }
+  async function ensure() {
+    if (bundle) return bundle;
+    inflight ??= bind().then((b2) => {
+      bundle = b2;
+      return b2;
+    });
+    const b = await inflight;
+    if (!opened) {
+      opened = true;
+      if (pairUrlValue) d.openUrl?.(pairUrlValue);
+    }
+    return b;
+  }
+  return {
+    ensure,
+    peek: () => bundle,
+    pairUrl: () => pairUrlValue,
+    bound: () => bundle != null
+  };
+}
+function defaultOpenUrl(url) {
+  void import("child_process").then(({ spawn }) => {
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    try {
+      spawn(cmd, [url], { stdio: "ignore", detached: true, shell: process.platform === "win32" }).unref();
+    } catch {
+    }
+  });
+}
+
 // src/index.ts
 async function main() {
-  const port = Number(process.env.ATWEBPILOT_WS_PORT ?? 8787);
+  const explicitPort = process.env.ATWEBPILOT_WS_PORT ? Number(process.env.ATWEBPILOT_WS_PORT) : void 0;
   const token = process.env.ATWEBPILOT_WS_TOKEN || void 0;
   const clock = new DefaultClock();
   const idGen = new DefaultIdGen();
-  const hub = new LoopbackWSHub({ port, token, clock, idGen });
-  await hub.ready();
-  const coordinator = new Coordinator({ hub, clock, idGen });
-  installWire(hub, coordinator, clock);
-  const server = createMcpServer({ coordinator, hub });
+  const deps = createHubEnsurer({
+    clock,
+    idGen,
+    explicitPort,
+    token,
+    openUrl: defaultOpenUrl
+  });
+  const server = createMcpServer(deps);
   await server.connect(new StdioServerTransport());
-  console.error(`[atwebpilot-mcp] ws://127.0.0.1:${port}/worker ready; stdio MCP connected`);
+  console.error("[atwebpilot-mcp] stdio MCP connected; ws port binds on first browser use");
+  const shutdown = () => {
+    const bundle = deps.peek();
+    void (bundle?.hub.shutdown?.() ?? Promise.resolve()).finally(() => process.exit(0));
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  process.stdin.on("close", shutdown);
 }
 main().catch((e) => {
   console.error("[atwebpilot-mcp] fatal", e);