@mehmoodqureshi/chrome-mcp 0.6.0 → 0.6.1

package/README.md

@@ -1,5 +1,9 @@
 # chrome-mcp
 
+[![CI](https://github.com/Mehmoodqureshi/chrome-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/Mehmoodqureshi/chrome-mcp/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/%40mehmoodqureshi%2Fchrome-mcp?label=npm)](https://www.npmjs.com/package/@mehmoodqureshi/chrome-mcp)
+[![license](https://img.shields.io/npm/l/%40mehmoodqureshi%2Fchrome-mcp?label=license)](LICENSE)
+
 Drive a **real Chrome browser** from Claude (or any MCP host). One pluggable
 `Executor` interface, two backends:
 

package/dist/src/mcp/server.d.ts

@@ -6,11 +6,11 @@
  * NOTHING may be written to stdout except the JSON-RPC stream — all diagnostics
  * go to stderr via `logErr`.
  */
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 /** stderr only — never stdout in stdio mode. */
 export declare function logErr(message: string): void;
 /** Build a fresh `Server` with the full tool surface registered (no transport). */
-export declare function createServer(version?: string): Server;
+export declare function createServer(version?: string): McpServer;
 /** Start over stdio. Idempotent. */
 export declare function startMcpServer(version?: string): Promise<void>;
 /** Stop and release the transport. Idempotent, best-effort. */

package/dist/src/mcp/server.js

@@ -13,7 +13,7 @@ exports.createServer = createServer;
 exports.startMcpServer = startMcpServer;
 exports.stopMcpServer = stopMcpServer;
 exports.isMcpServerRunning = isMcpServerRunning;
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const tools_1 = require("./tools");
 const SERVER_NAME = 'chrome-mcp';
@@ -28,9 +28,10 @@ function logErr(message) {
 }
 /** Build a fresh `Server` with the full tool surface registered (no transport). */
 function createServer(version = DEFAULT_VERSION) {
-    const srv = new index_js_1.Server({ name: SERVER_NAME, version }, { capabilities: { tools: {} } });
+    const srv = new mcp_js_1.McpServer({ name: SERVER_NAME, version }, { capabilities: { tools: {} } });
     (0, tools_1.registerTools)(srv);
-    srv.onerror = (err) => {
+    // `McpServer` wraps the low-level `Server`, which owns the `onerror` hook.
+    srv.server.onerror = (err) => {
         logErr(`server error: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
     };
     return srv;

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

@@ -1,22 +1,25 @@
 /**
  * src/mcp/tools.ts — the MCP tool surface: the advertised catalog
- * (`TOOL_DEFINITIONS`), the name→handler dispatch (`TOOL_HANDLERS`), the
- * never-throw firewall (`dispatchToolCall`), and `registerTools()` which wires
- * both onto a `Server`.
+ * (`TOOL_DEFINITIONS`, each with a zod `inputSchema`), the name→handler dispatch
+ * (`TOOL_HANDLERS`), the never-throw firewall (`dispatchToolCall`), and
+ * `registerTools()` which registers every tool on an `McpServer` via
+ * `registerTool` — the SDK validates the zod schema before dispatch runs.
  *
  * Each handler: validate args → **policy-gate against the relevant URL** → call
  * the active Executor (or a server-side helper) → serialize via an envelope.
  * Nothing here throws to the transport: `dispatchToolCall` renders any thrown
  * `Error` as an `isError` result.
  */
-import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
 import type { Executor } from '../executor/types';
 import { type Policy } from '../security/policy';
 export interface ToolDefinition {
     name: string;
     description: string;
-    inputSchema: Record<string, unknown>;
+    /** zod raw shape passed to `McpServer.registerTool`; the SDK validates it before dispatch. */
+    inputSchema: z.ZodRawShape;
 }
 export declare const TOOL_DEFINITIONS: ToolDefinition[];
 interface ToolCtx {
@@ -30,5 +33,5 @@ export declare function resetRateLimiter(): void;
 export declare function dispatchToolCall(name: string, rawArgs: unknown): Promise<CallToolResult>;
 /** Assert the catalog and the dispatch table describe the same tool set. */
 export declare function assertNoDrift(): void;
-export declare function registerTools(server: Server): void;
+export declare function registerTools(server: McpServer): void;
 export {};

package/dist/src/mcp/tools.js

@@ -1,9 +1,10 @@
 "use strict";
 /**
  * src/mcp/tools.ts — the MCP tool surface: the advertised catalog
- * (`TOOL_DEFINITIONS`), the name→handler dispatch (`TOOL_HANDLERS`), the
- * never-throw firewall (`dispatchToolCall`), and `registerTools()` which wires
- * both onto a `Server`.
+ * (`TOOL_DEFINITIONS`, each with a zod `inputSchema`), the name→handler dispatch
+ * (`TOOL_HANDLERS`), the never-throw firewall (`dispatchToolCall`), and
+ * `registerTools()` which registers every tool on an `McpServer` via
+ * `registerTool` — the SDK validates the zod schema before dispatch runs.
  *
  * Each handler: validate args → **policy-gate against the relevant URL** → call
  * the active Executor (or a server-side helper) → serialize via an envelope.
@@ -17,7 +18,7 @@ exports.dispatchToolCall = dispatchToolCall;
 exports.assertNoDrift = assertNoDrift;
 exports.registerTools = registerTools;
 const node_path_1 = require("node:path");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const zod_1 = require("zod");
 const types_1 = require("../executor/types");
 const manager_1 = require("../executor/manager");
 const policy_1 = require("../security/policy");
@@ -27,62 +28,57 @@ const helpers_1 = require("./helpers");
 const tasks_1 = require("../bridge/tasks");
 const workspace_1 = require("../bridge/workspace");
 const validators_1 = require("./validators");
+/** Shared selector|ref target — both optional; a handler that needs one calls `requireTarget`. */
 const TARGET_PROPS = {
-    selector: { type: 'string', description: 'CSS selector (exactly one of selector|ref)' },
-    ref: { type: 'string', description: 'Element ref from a prior read (exactly one of selector|ref)' },
+    selector: zod_1.z.string().describe('CSS selector (exactly one of selector|ref)').optional(),
+    ref: zod_1.z.string().describe('Element ref from a prior read (exactly one of selector|ref)').optional(),
 };
-const obj = (properties, required = []) => ({
-    type: 'object',
-    properties,
-    required,
-    additionalProperties: false,
-});
+const tabIdField = zod_1.z.string().describe('Target tab id (defaults to the active tab)').optional();
+const waitUntilField = zod_1.z.enum(['load', 'domcontentloaded', 'networkidle']).describe('When to consider navigation done').optional();
 exports.TOOL_DEFINITIONS = [
-    { name: 'tabs_list', description: 'List open browser tabs.', inputSchema: obj({}) },
-    { name: 'tab_select', description: 'Make a tab active by tabId.', inputSchema: obj({ tabId: { type: 'string' } }, ['tabId']) },
-    { name: 'tab_new', description: 'Open a NEW tab (optionally at a URL) and focus it. Prefer this over `navigate` when the user says "open"/"go to" a site — `navigate` REPLACES the current tab. Pass active:false to open in the background (used by parallel batches).', inputSchema: obj({ url: { type: 'string' }, active: { type: 'boolean' } }) },
-    { name: 'tab_close', description: 'Close a tab by tabId.', inputSchema: obj({ tabId: { type: 'string' } }, ['tabId']) },
-    { name: 'navigate', description: 'Navigate a tab to a URL, REPLACING its current page. Acts on the active tab unless tabId is given — to open a site without losing the current page, use `tab_new` instead.', inputSchema: obj({ url: { type: 'string' }, tabId: { type: 'string' }, waitUntil: { type: 'string', enum: ['load', 'domcontentloaded', 'networkidle'] } }, ['url']) },
-    { name: 'back', description: 'Go back in history.', inputSchema: obj({ tabId: { type: 'string' } }) },
-    { name: 'forward', description: 'Go forward in history.', inputSchema: obj({ tabId: { type: 'string' } }) },
-    { name: 'reload', description: 'Reload the active (or given) tab.', inputSchema: obj({ tabId: { type: 'string' }, waitUntil: { type: 'string', enum: ['load', 'domcontentloaded', 'networkidle'] } }) },
-    { name: 'click', description: 'Click an element (target by selector or a snapshot ref). trusted=true uses real OS-level input.', inputSchema: obj({ ...TARGET_PROPS, tabId: { type: 'string' }, button: { type: 'string', enum: ['left', 'right', 'middle'] }, clickCount: { type: 'number' }, trusted: { type: 'boolean' } }) },
-    { name: 'type', description: 'Type text into an element. trusted=true sends real keystrokes (works on React/Vue controlled inputs).', inputSchema: obj({ ...TARGET_PROPS, text: { type: 'string' }, tabId: { type: 'string' }, clear: { type: 'boolean' }, pressEnter: { type: 'boolean' }, keyEvents: { type: 'boolean' }, trusted: { type: 'boolean' } }, ['text']) },
-    { name: 'select_option', description: 'Select option(s) of a <select> by value or visible label.', inputSchema: obj({ ...TARGET_PROPS, values: { type: 'array', items: { type: 'string' } }, tabId: { type: 'string' } }, ['values']) },
-    { name: 'press', description: 'Press a key (with optional modifiers).', inputSchema: obj({ key: { type: 'string' }, modifiers: { type: 'array', items: { type: 'string' } }, tabId: { type: 'string' } }, ['key']) },
-    { name: 'hover', description: 'Hover over an element.', inputSchema: obj({ ...TARGET_PROPS, tabId: { type: 'string' } }) },
-    { name: 'scroll', description: 'Scroll the page or to an element.', inputSchema: obj({ ...TARGET_PROPS, x: { type: 'number' }, y: { type: 'number' }, deltaX: { type: 'number' }, deltaY: { type: 'number' }, tabId: { type: 'string' } }) },
-    { name: 'screenshot', description: 'Capture a PNG screenshot (page or element).', inputSchema: obj({ ...TARGET_PROPS, fullPage: { type: 'boolean' }, tabId: { type: 'string' } }) },
-    { name: 'get_text', description: 'Get visible text of the page or an element.', inputSchema: obj({ ...TARGET_PROPS, tabId: { type: 'string' } }) },
-    { name: 'get_html', description: 'Get HTML of the page or an element.', inputSchema: obj({ ...TARGET_PROPS, outer: { type: 'boolean' }, tabId: { type: 'string' } }) },
-    { name: 'snapshot', description: 'Accessibility snapshot: interactive elements with stable refs to target by `ref` (more reliable than guessing CSS selectors).', inputSchema: obj({ interactiveOnly: { type: 'boolean' }, max: { type: 'number' }, tabId: { type: 'string' } }) },
-    { name: 'get_cookies', description: "Read cookies visible to the tab's URL (or a given url).", inputSchema: obj({ url: { type: 'string' }, tabId: { type: 'string' } }) },
-    { name: 'storage', description: 'Read/write localStorage (or sessionStorage). op: get|set|remove|clear.', inputSchema: obj({ op: { type: 'string', enum: ['get', 'set', 'remove', 'clear'] }, key: { type: 'string' }, value: { type: 'string' }, session: { type: 'boolean' }, tabId: { type: 'string' } }, ['op']) },
-    { name: 'eval', description: 'Evaluate JavaScript in the page (disabled in safe-mode).', inputSchema: obj({ expression: { type: 'string' }, awaitPromise: { type: 'boolean' }, tabId: { type: 'string' } }, ['expression']) },
-    { name: 'wait_for', description: 'Wait for a selector or text to appear/disappear.', inputSchema: obj({ selector: { type: 'string' }, textContains: { type: 'string' }, gone: { type: 'boolean' }, timeoutMs: { type: 'number' }, tabId: { type: 'string' } }) },
-    { name: 'extract_links', description: 'Extract anchors from the page or a subtree.', inputSchema: obj({ selector: { type: 'string' }, sameOriginOnly: { type: 'boolean' }, tabId: { type: 'string' } }) },
-    { name: 'read_as_markdown', description: 'Read the page (or subtree) as readable markdown.', inputSchema: obj({ selector: { type: 'string' }, tabId: { type: 'string' } }) },
-    { name: 'fill_form', description: 'Fill multiple fields (keyed by selector) and optionally submit.', inputSchema: obj({ fields: { type: 'object' }, submitSelector: { type: 'string' }, tabId: { type: 'string' } }, ['fields']) },
-    { name: 'download_file', description: 'Download a file by URL or from a link element.', inputSchema: obj({ url: { type: 'string' }, ...TARGET_PROPS, suggestedName: { type: 'string' }, tabId: { type: 'string' } }) },
-    { name: 'upload_file', description: 'Set local file(s) on a file <input> (target by selector or ref) — uploads without the OS dialog. Requires --enable-uploads. `files` are absolute local paths.', inputSchema: obj({ ...TARGET_PROPS, files: { type: 'array', items: { type: 'string' } }, tabId: { type: 'string' } }, ['files']) },
-    { name: 'chrome_status', description: 'Report backend/session status.', inputSchema: obj({}) },
-    { name: 'profile_use', description: 'Switch the active browser profile (identity). Subsequent downloads, results, screenshots, and the action log are stored under profiles/<name>/. Resets the active task to "default" unless you then call task_new.', inputSchema: obj({ name: { type: 'string', description: 'Profile name (becomes a folder; sanitized to a safe path segment).' } }, ['name']) },
-    { name: 'task_new', description: 'Start a new task (run) under the active profile. Creates profiles/<profile>/tasks/<name>/ with downloads/, results/, screenshots/ and makes it the active task so all captured artifacts land there.', inputSchema: obj({ name: { type: 'string', description: 'Task name (becomes a folder; sanitized to a safe path segment).' } }, ['name']) },
-    { name: 'tasks_list', description: 'List every task across all profiles under the data dir, with sizes and download counts.', inputSchema: obj({}) },
-    { name: 'task_status', description: 'Report the active profile/task and the folder paths where this run\'s artifacts are stored.', inputSchema: obj({}) },
+    { name: 'tabs_list', description: 'List open browser tabs.', inputSchema: {} },
+    { name: 'tab_select', description: 'Make a tab active by tabId.', inputSchema: { tabId: zod_1.z.string() } },
+    { name: 'tab_new', description: 'Open a NEW tab (optionally at a URL) and focus it. Prefer this over `navigate` when the user says "open"/"go to" a site — `navigate` REPLACES the current tab. Pass active:false to open in the background (used by parallel batches).', inputSchema: { url: zod_1.z.string().optional(), active: zod_1.z.boolean().optional() } },
+    { name: 'tab_close', description: 'Close a tab by tabId.', inputSchema: { tabId: zod_1.z.string() } },
+    { name: 'navigate', description: 'Navigate a tab to a URL, REPLACING its current page. Acts on the active tab unless tabId is given — to open a site without losing the current page, use `tab_new` instead.', inputSchema: { url: zod_1.z.string(), tabId: tabIdField, waitUntil: waitUntilField } },
+    { name: 'back', description: 'Go back in history.', inputSchema: { tabId: tabIdField } },
+    { name: 'forward', description: 'Go forward in history.', inputSchema: { tabId: tabIdField } },
+    { name: 'reload', description: 'Reload the active (or given) tab.', inputSchema: { tabId: tabIdField, waitUntil: waitUntilField } },
+    { name: 'click', description: 'Click an element (target by selector or a snapshot ref). trusted=true uses real OS-level input.', inputSchema: { ...TARGET_PROPS, tabId: tabIdField, button: zod_1.z.enum(['left', 'right', 'middle']).optional(), clickCount: zod_1.z.number().optional(), trusted: zod_1.z.boolean().optional() } },
+    { name: 'type', description: 'Type text into an element. trusted=true sends real keystrokes (works on React/Vue controlled inputs).', inputSchema: { ...TARGET_PROPS, text: zod_1.z.string(), tabId: tabIdField, clear: zod_1.z.boolean().optional(), pressEnter: zod_1.z.boolean().optional(), keyEvents: zod_1.z.boolean().optional(), trusted: zod_1.z.boolean().optional() } },
+    { name: 'select_option', description: 'Select option(s) of a <select> by value or visible label.', inputSchema: { ...TARGET_PROPS, values: zod_1.z.array(zod_1.z.string()), tabId: tabIdField } },
+    { name: 'press', description: 'Press a key (with optional modifiers).', inputSchema: { key: zod_1.z.string(), modifiers: zod_1.z.array(zod_1.z.string()).optional(), tabId: tabIdField } },
+    { name: 'hover', description: 'Hover over an element.', inputSchema: { ...TARGET_PROPS, tabId: tabIdField } },
+    { name: 'scroll', description: 'Scroll the page or to an element.', inputSchema: { ...TARGET_PROPS, x: zod_1.z.number().optional(), y: zod_1.z.number().optional(), deltaX: zod_1.z.number().optional(), deltaY: zod_1.z.number().optional(), tabId: tabIdField } },
+    { name: 'screenshot', description: 'Capture a PNG screenshot (page or element).', inputSchema: { ...TARGET_PROPS, fullPage: zod_1.z.boolean().optional(), tabId: tabIdField } },
+    { name: 'get_text', description: 'Get visible text of the page or an element.', inputSchema: { ...TARGET_PROPS, tabId: tabIdField } },
+    { name: 'get_html', description: 'Get HTML of the page or an element.', inputSchema: { ...TARGET_PROPS, outer: zod_1.z.boolean().optional(), tabId: tabIdField } },
+    { name: 'snapshot', description: 'Accessibility snapshot: interactive elements with stable refs to target by `ref` (more reliable than guessing CSS selectors).', inputSchema: { interactiveOnly: zod_1.z.boolean().optional(), max: zod_1.z.number().optional(), tabId: tabIdField } },
+    { name: 'get_cookies', description: "Read cookies visible to the tab's URL (or a given url).", inputSchema: { url: zod_1.z.string().optional(), tabId: tabIdField } },
+    { name: 'storage', description: 'Read/write localStorage (or sessionStorage). op: get|set|remove|clear.', inputSchema: { op: zod_1.z.enum(['get', 'set', 'remove', 'clear']), key: zod_1.z.string().optional(), value: zod_1.z.string().optional(), session: zod_1.z.boolean().optional(), tabId: tabIdField } },
+    { name: 'eval', description: 'Evaluate JavaScript in the page (disabled in safe-mode).', inputSchema: { expression: zod_1.z.string(), awaitPromise: zod_1.z.boolean().optional(), tabId: tabIdField } },
+    { name: 'wait_for', description: 'Wait for a selector or text to appear/disappear.', inputSchema: { selector: zod_1.z.string().optional(), textContains: zod_1.z.string().optional(), gone: zod_1.z.boolean().optional(), timeoutMs: zod_1.z.number().optional(), tabId: tabIdField } },
+    { name: 'extract_links', description: 'Extract anchors from the page or a subtree.', inputSchema: { selector: zod_1.z.string().optional(), sameOriginOnly: zod_1.z.boolean().optional(), tabId: tabIdField } },
+    { name: 'read_as_markdown', description: 'Read the page (or subtree) as readable markdown.', inputSchema: { selector: zod_1.z.string().optional(), tabId: tabIdField } },
+    { name: 'fill_form', description: 'Fill multiple fields (keyed by selector) and optionally submit.', inputSchema: { fields: zod_1.z.record(zod_1.z.string(), zod_1.z.union([zod_1.z.string(), zod_1.z.boolean()])), submitSelector: zod_1.z.string().optional(), tabId: tabIdField } },
+    { name: 'download_file', description: 'Download a file by URL or from a link element.', inputSchema: { url: zod_1.z.string().optional(), ...TARGET_PROPS, suggestedName: zod_1.z.string().optional(), tabId: tabIdField } },
+    { name: 'upload_file', description: 'Set local file(s) on a file <input> (target by selector or ref) — uploads without the OS dialog. Requires --enable-uploads. `files` are absolute local paths.', inputSchema: { ...TARGET_PROPS, files: zod_1.z.array(zod_1.z.string()), tabId: tabIdField } },
+    { name: 'chrome_status', description: 'Report backend/session status.', inputSchema: {} },
+    { name: 'profile_use', description: 'Switch the active browser profile (identity). Subsequent downloads, results, screenshots, and the action log are stored under profiles/<name>/. Resets the active task to "default" unless you then call task_new.', inputSchema: { name: zod_1.z.string().describe('Profile name (becomes a folder; sanitized to a safe path segment).') } },
+    { name: 'task_new', description: 'Start a new task (run) under the active profile. Creates profiles/<profile>/tasks/<name>/ with downloads/, results/, screenshots/ and makes it the active task so all captured artifacts land there.', inputSchema: { name: zod_1.z.string().describe('Task name (becomes a folder; sanitized to a safe path segment).') } },
+    { name: 'tasks_list', description: 'List every task across all profiles under the data dir, with sizes and download counts.', inputSchema: {} },
+    { name: 'task_status', description: 'Report the active profile/task and the folder paths where this run\'s artifacts are stored.', inputSchema: {} },
     {
         name: 'batch',
         description: 'Run multiple tool calls in one request — parallel (default) or serial. Each op is { tool, args } and goes through the same policy gate, rate limit, and error handling as a direct call. In parallel mode, tab-scoped ops MUST pass an explicit tabId (the active-tab default is unsafe under concurrency). Use to drive several tabs at once (e.g. open tabs, then batch get_text across them). Cannot be nested.',
-        inputSchema: obj({
-            ops: {
-                type: 'array',
-                description: 'Operations to run; each is a tool name + its args.',
-                items: obj({ tool: { type: 'string' }, args: { type: 'object' } }, ['tool']),
-            },
-            mode: { type: 'string', enum: ['parallel', 'serial'], description: 'Default "parallel".' },
-            stopOnError: { type: 'boolean', description: 'Serial mode only: stop after the first failing op (the rest are skipped).' },
-            maxConcurrency: { type: 'number', description: 'Parallel mode: max ops in flight at once (default 6).' },
-        }, ['ops']),
+        inputSchema: {
+            ops: zod_1.z
+                .array(zod_1.z.object({ tool: zod_1.z.string(), args: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional() }))
+                .describe('Operations to run; each is a tool name + its args.'),
+            mode: zod_1.z.enum(['parallel', 'serial']).describe('Default "parallel".').optional(),
+            stopOnError: zod_1.z.boolean().describe('Serial mode only: stop after the first failing op (the rest are skipped).').optional(),
+            maxConcurrency: zod_1.z.number().describe('Parallel mode: max ops in flight at once (default 6).').optional(),
+        },
     },
 ];
 /** Resolve the URL the policy should be evaluated against (the active tab). */
@@ -441,13 +437,12 @@ function assertNoDrift() {
 // ---------------------------------------------------------------------------
 function registerTools(server) {
     assertNoDrift();
-    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-        tools: exports.TOOL_DEFINITIONS.map((d) => ({
-            name: d.name,
-            description: d.description,
-            inputSchema: d.inputSchema,
-        })),
-    }));
-    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => dispatchToolCall(req.params.name, req.params.arguments));
+    // Register each tool with its zod `inputSchema`. The SDK advertises it in
+    // `tools/list` and validates arguments before invoking the handler, which
+    // just routes back through `dispatchToolCall` — our never-throw firewall that
+    // applies the rate limit, executor readiness, policy gate, and history log.
+    for (const d of exports.TOOL_DEFINITIONS) {
+        server.registerTool(d.name, { description: d.description, inputSchema: d.inputSchema }, async (args) => dispatchToolCall(d.name, args));
+    }
 }
 //# sourceMappingURL=tools.js.map

package/extension-dist/background.js

@@ -39,6 +39,7 @@
     constructor(deps) {
       this.deps = deps;
     }
+    deps;
     ws = null;
     state = "idle";
     isConnected() {
@@ -424,6 +425,7 @@
       super(message);
       this.code = code;
     }
+    code;
   };
   var DOWNLOAD_TIMEOUT_MS = 12e4;
   function waitForDownloadComplete(id) {
@@ -525,7 +527,7 @@
   async function waitForSelector(tabId, selector, timeoutMs = 5e3) {
     const found = await execInTab(
       tabId,
-      (s, timeout, interval) => new Promise((resolve) => {
+      ((s, timeout, interval) => new Promise((resolve) => {
         const deadline = Date.now() + timeout;
         const tick = () => {
           if (document.querySelector(s)) return resolve(true);
@@ -533,7 +535,7 @@
           setTimeout(tick, interval);
         };
         tick();
-      }),
+      })),
       [selector, timeoutMs, 120]
     );
     return found === true;
@@ -1034,7 +1036,7 @@
           const start = Date.now();
           const matched = await execInTab(
             id,
-            (sel, text, gone, timeoutMs, interval) => new Promise((resolve) => {
+            ((sel, text, gone, timeoutMs, interval) => new Promise((resolve) => {
               const deadline = Date.now() + timeoutMs;
               const hit = () => {
                 let present;
@@ -1049,7 +1051,7 @@
                 setTimeout(tick, interval);
               };
               tick();
-            }),
+            })),
             [cmd.params.selector ?? null, cmd.params.textContains ?? null, cmd.params.gone === true, timeout, 150]
           );
           return { matched: matched === true, waitedMs: Date.now() - start };
@@ -1113,6 +1115,7 @@
         if (!HANDLED.has(m)) throw new Error(`router drift: no handler for wire method "${m}"`);
       }
     }
+    deps;
     async dispatch(cmd) {
       try {
         const policy = this.deps.getPolicy();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mehmoodqureshi/chrome-mcp",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Drive a real Chrome browser over MCP. A stdio MCP server (CLI) plus an MV3 extension, behind one pluggable Executor (extension via chrome.scripting, or a Playwright CDP fallback).",
   "author": "Mehmood Ur Rehman Qureshi",
   "license": "MIT",
@@ -45,15 +45,16 @@
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "typecheck:ext": "tsc -p tsconfig.ext.json",
     "clean": "rimraf dist extension-dist",
-    "test": "npm run clean && npm run build && npm run build:ext && node --test dist/test",
+    "test": "npm run clean && npm run build && npm run build:ext && node --test dist/test/*.test.js",
     "test:hitl": "npm run build && node dist/hitl/index.js",
     "prepack": "npm run clean && npm run build && npm run build:ext",
     "postinstall": "node scripts/postinstall.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.4",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "playwright": "^1.49.1",
-    "ws": "^8.18.0"
+    "ws": "^8.18.0",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/chrome": "^0.0.287",