@mehmoodqureshi/chrome-mcp 0.5.2 → 0.6.1

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,66 +18,67 @@ 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");
 const envelopes_1 = require("./envelopes");
 const batch_1 = require("./batch");
 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: '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). */
@@ -99,7 +101,24 @@ const waitUntil = (args) => (0, validators_1.optionalString)(args, 'waitUntil');
 /** Tools that don't act on a single tab (so `tabId` is irrelevant) — exempt from
  *  the parallel-batch explicit-tabId requirement. Everything else falls back to
  *  the active tab when `tabId` is omitted, which races under concurrency. */
-const PARALLEL_TAB_EXEMPT = new Set(['tabs_list', 'tab_new', 'chrome_status', 'batch']);
+const PARALLEL_TAB_EXEMPT = new Set([
+    'tabs_list', 'tab_new', 'chrome_status', 'batch',
+    'profile_use', 'task_new', 'tasks_list', 'task_status',
+]);
+/** Server-side tools that manage the task workspace and need no browser backend. */
+const NO_BACKEND_TOOLS = new Set(['profile_use', 'task_new', 'tasks_list', 'task_status']);
+/** Project a Workspace to the path fields worth returning to the caller. */
+function workspaceView(w) {
+    return {
+        profile: w.profile,
+        task: w.task,
+        taskDir: w.taskDir,
+        downloadDir: w.downloadDir,
+        resultsDir: w.resultsDir,
+        screenshotsDir: w.screenshotsDir,
+        historyPath: w.historyPath,
+    };
+}
 /** A known tool that operates on a specific tab — needs an explicit tabId in a parallel batch. */
 function requiresExplicitTab(tool) {
     return tool in exports.TOOL_HANDLERS && !PARALLEL_TAB_EXEMPT.has(tool);
@@ -194,12 +213,15 @@ exports.TOOL_HANDLERS = {
             fullPage: (0, validators_1.optionalBoolean)(a, 'fullPage'),
             target: (0, validators_1.optionalTarget)(a),
         });
+        (0, workspace_1.saveScreenshot)(shot.dataBase64);
         const caption = shot.truncated ? `(truncated; full height ${shot.fullHeight}px)` : undefined;
         return (0, envelopes_1.imageResult)(shot.dataBase64, shot.mimeType, caption);
     },
     get_text: async (a, ctx) => {
         await gate(ctx, 'get_text');
-        return (0, envelopes_1.jsonResult)(await ctx.ex.getText((0, validators_1.optionalTarget)(a), { tabId: tabId(a) }));
+        const res = await ctx.ex.getText((0, validators_1.optionalTarget)(a), { tabId: tabId(a) });
+        (0, workspace_1.saveResult)('get_text', 'json', JSON.stringify(res, null, 2));
+        return (0, envelopes_1.jsonResult)(res);
     },
     get_html: async (a, ctx) => {
         await gate(ctx, 'get_html');
@@ -251,15 +273,19 @@ exports.TOOL_HANDLERS = {
     },
     extract_links: async (a, ctx) => {
         await gate(ctx, 'get_text'); // read of page content
-        return (0, envelopes_1.jsonResult)(await (0, helpers_1.extractLinks)(ctx.ex, {
+        const res = await (0, helpers_1.extractLinks)(ctx.ex, {
             selector: (0, validators_1.optionalString)(a, 'selector'),
             sameOriginOnly: (0, validators_1.optionalBoolean)(a, 'sameOriginOnly'),
             tabId: tabId(a),
-        }));
+        });
+        (0, workspace_1.saveResult)('extract_links', 'json', JSON.stringify(res, null, 2));
+        return (0, envelopes_1.jsonResult)(res);
     },
     read_as_markdown: async (a, ctx) => {
         await gate(ctx, 'get_text');
-        return (0, envelopes_1.textResult)(await (0, helpers_1.readAsMarkdown)(ctx.ex, { selector: (0, validators_1.optionalString)(a, 'selector'), tabId: tabId(a) }));
+        const md = await (0, helpers_1.readAsMarkdown)(ctx.ex, { selector: (0, validators_1.optionalString)(a, 'selector'), tabId: tabId(a) });
+        (0, workspace_1.saveResult)('read_as_markdown', 'md', md);
+        return (0, envelopes_1.textResult)(md);
     },
     fill_form: async (a, ctx) => {
         await gate(ctx, 'type'); // mutating
@@ -308,6 +334,11 @@ exports.TOOL_HANDLERS = {
         return (0, envelopes_1.jsonResult)(await ctx.ex.uploadFile(t, files, { tabId: tabId(a) }));
     },
     chrome_status: async (_a, ctx) => (0, envelopes_1.jsonResult)(ctx.ex.status()),
+    // --- task workspace management (server-side; no browser needed) ---
+    profile_use: async (a) => (0, envelopes_1.jsonResult)(workspaceView((0, workspace_1.switchWorkspace)({ profile: (0, validators_1.requireString)(a, 'name') }))),
+    task_new: async (a) => (0, envelopes_1.jsonResult)(workspaceView((0, workspace_1.switchWorkspace)({ task: (0, validators_1.requireString)(a, 'name') }))),
+    task_status: async () => (0, envelopes_1.jsonResult)(workspaceView((0, workspace_1.getActiveWorkspace)())),
+    tasks_list: async () => (0, envelopes_1.jsonResult)((0, tasks_1.listTasks)((0, workspace_1.getActiveWorkspace)().dataDir)),
     // Fan-out: each sub-op is routed back through `dispatchToolCall`, so it gets
     // the same policy gate, rate limit, and never-throw handling as a direct call.
     batch: async (a) => (0, batch_1.runBatch)(a, { dispatch: dispatchToolCall, requiresExplicitTab }),
@@ -351,6 +382,24 @@ function allowCall(now) {
     rateWindow.push(now);
     return true;
 }
+/** A compact, length-bounded summary of a call's args for the history log. */
+function summarizeArgs(rawArgs) {
+    if (typeof rawArgs !== 'object' || rawArgs === null)
+        return undefined;
+    const a = rawArgs;
+    const out = {};
+    for (const k of ['url', 'selector', 'ref', 'name', 'text', 'key', 'op', 'tabId']) {
+        const v = a[k];
+        if (v === undefined)
+            continue;
+        out[k] = typeof v === 'string' && v.length > 120 ? `${v.slice(0, 120)}…` : v;
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+/** Append one action record to the active task's history.jsonl (best-effort). */
+function recordHistory(tool, rawArgs, ok, error) {
+    (0, workspace_1.appendHistory)({ ts: new Date().toISOString(), tool, args: summarizeArgs(rawArgs), ok, ...(error ? { error } : {}) });
+}
 async function dispatchToolCall(name, rawArgs) {
     const handler = exports.TOOL_HANDLERS[name];
     if (!handler)
@@ -359,11 +408,17 @@ async function dispatchToolCall(name, rawArgs) {
         return (0, envelopes_1.errorResult)('rate limit exceeded; slow down');
     try {
         const mgr = (0, manager_1.getManager)();
-        const ex = await mgr.ensureReady();
-        return await handler((0, validators_1.asArgs)(rawArgs), { ex, policy: mgr.policy });
+        // Workspace-management tools run server-side and must work even with no
+        // browser paired, so they skip the executor readiness check.
+        const ex = NO_BACKEND_TOOLS.has(name) ? null : await mgr.ensureReady();
+        const result = await handler((0, validators_1.asArgs)(rawArgs), { ex, policy: mgr.policy });
+        recordHistory(name, rawArgs, !result.isError);
+        return result;
     }
     catch (err) {
-        return (0, envelopes_1.errorResult)(errMessage(err));
+        const message = errMessage(err);
+        recordHistory(name, rawArgs, false, message);
+        return (0, envelopes_1.errorResult)(message);
     }
 }
 /** Assert the catalog and the dispatch table describe the same tool set. */
@@ -382,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,12 +39,13 @@
     constructor(deps) {
       this.deps = deps;
     }
+    deps;
     ws = null;
     state = "idle";
     isConnected() {
       return this.state === "connected" && this.ws?.readyState === WebSocket.OPEN;
     }
-    connect(port, token) {
+    connect(port, token, profile) {
       if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
         return;
       }
@@ -62,7 +63,8 @@
           type: "hello",
           v: PROTOCOL_VERSION,
           token,
-          ext: { id: chrome.runtime.id, version: chrome.runtime.getManifest().version, chrome: chromeVersion() }
+          ext: { id: chrome.runtime.id, version: chrome.runtime.getManifest().version, chrome: chromeVersion() },
+          profile: profile && profile.trim() ? profile.trim() : void 0
         };
         ws2.send(JSON.stringify(hello));
       };
@@ -423,7 +425,38 @@
       super(message);
       this.code = code;
     }
+    code;
   };
+  var DOWNLOAD_TIMEOUT_MS = 12e4;
+  function waitForDownloadComplete(id) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const settle = (fn) => {
+        if (settled) return;
+        settled = true;
+        chrome.downloads.onChanged.removeListener(onChanged);
+        clearTimeout(timer);
+        fn();
+      };
+      const timer = setTimeout(
+        () => settle(() => reject(new CmdError("DOWNLOAD_FAILED", "download timed out"))),
+        DOWNLOAD_TIMEOUT_MS
+      );
+      const check = async () => {
+        const [item] = await chrome.downloads.search({ id });
+        if (!item) return;
+        if (item.state === "complete") settle(() => resolve(item));
+        else if (item.state === "interrupted") {
+          settle(() => reject(new CmdError("DOWNLOAD_FAILED", `download interrupted: ${item.error ?? "unknown"}`)));
+        }
+      };
+      const onChanged = (delta) => {
+        if (delta.id === id) void check();
+      };
+      chrome.downloads.onChanged.addListener(onChanged);
+      void check();
+    });
+  }
   var SESSION = crypto.randomUUID();
   var CONTENT_SCHEME = /^(https?|file):/i;
   var delay = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -494,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);
@@ -502,7 +535,7 @@
           setTimeout(tick, interval);
         };
         tick();
-      }),
+      })),
       [selector, timeoutMs, 120]
     );
     return found === true;
@@ -1003,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;
@@ -1018,12 +1051,14 @@
                 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 };
         }
-        // -- download (user's Downloads dir) --
+        // -- download (saved to the user's Downloads dir; the server then moves it
+        //    into the active task's downloads/). We wait for completion and report
+        //    the absolute on-disk path so the server can relocate it. --
         case "download_file": {
           const url = typeof cmd.params.url === "string" ? cmd.params.url : void 0;
           if (!url) throw new CmdError("DOWNLOAD_FAILED", "the extension download path requires a url");
@@ -1031,7 +1066,16 @@
             typeof cmd.params.suggestedName === "string" ? cmd.params.suggestedName : void 0
           );
           const downloadId = await chrome.downloads.download({ url, filename: name });
-          return { path: `(downloads)/${name}`, backend: "extension", bytes: 0, suggestedName: name };
+          const item = await waitForDownloadComplete(downloadId);
+          const bytes = item.fileSize > 0 ? item.fileSize : item.bytesReceived;
+          return {
+            path: item.filename,
+            sourcePath: item.filename,
+            downloadId,
+            backend: "extension",
+            bytes,
+            suggestedName: name
+          };
         }
         // -- upload: set local file(s) on a file <input> via CDP DOM.setFileInputFiles --
         case "upload_file": {
@@ -1071,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();
@@ -1117,9 +1162,10 @@
     log: (m) => console.debug("[chrome-mcp]", m)
   });
   async function getConfig() {
-    const { wsPort, token } = await chrome.storage.local.get(["wsPort", "token"]);
+    const { wsPort, token, profile } = await chrome.storage.local.get(["wsPort", "token", "profile"]);
     if (typeof wsPort === "number" && wsPort > 0 && typeof token === "string" && token.length > 0) {
-      return { wsPort, token };
+      const name = typeof profile === "string" && profile.trim() ? profile.trim() : "default";
+      return { wsPort, token, profile: name };
     }
     return null;
   }
@@ -1146,7 +1192,7 @@
     if (ws.isConnected() || ws.state === "unauthorized") return;
     const cfg = await getConfig();
     if (!cfg) return;
-    ws.connect(cfg.wsPort, cfg.token);
+    ws.connect(cfg.wsPort, cfg.token, cfg.profile);
   }
   async function keepalivePulse() {
     await chrome.storage.local.get("connState");
@@ -1158,8 +1204,9 @@
     if (alarm.name === KEEPALIVE_ALARM) void keepalivePulse();
   });
   chrome.storage.onChanged.addListener((changes, area) => {
-    if (area === "local" && (changes.wsPort || changes.token)) {
+    if (area === "local" && (changes.wsPort || changes.token || changes.profile)) {
       if (ws.state === "unauthorized") ws.state = "idle";
+      if (changes.profile) ws.close();
       void ensureConnected();
     }
   });

package/extension-dist/options.html

@@ -25,6 +25,13 @@
     <input id="port" type="number" inputmode="numeric" placeholder="38017" />
     <label for="token">Token</label>
     <input id="token" type="password" placeholder="paste the handshake token" />
+    <label for="profile">Profile</label>
+    <input id="profile" type="text" placeholder="default" />
+    <p class="hint">
+      A name for this browser (e.g. <code>mehmood</code>). Several browsers can pair to the
+      same port &amp; token at once, each with its own profile — switch between them with
+      <code>profile_use</code>. Leave blank for <code>default</code>.
+    </p>
     <button id="save">Save & connect</button>
     <div class="status" id="status">Status: unknown</div>
     <script src="options.js"></script>

package/extension-dist/options.js

@@ -6,11 +6,13 @@
   // extension/src/options/options.ts
   var portEl = document.getElementById("port");
   var tokenEl = document.getElementById("token");
+  var profileEl = document.getElementById("profile");
   var saveEl = document.getElementById("save");
   var statusEl = document.getElementById("status");
   async function loadExisting() {
-    const { wsPort, connState } = await chrome.storage.local.get(["wsPort", "connState"]);
+    const { wsPort, profile, connState } = await chrome.storage.local.get(["wsPort", "profile", "connState"]);
     portEl.value = typeof wsPort === "number" && wsPort > 0 ? String(wsPort) : String(DEFAULT_WS_PORT);
+    profileEl.value = typeof profile === "string" ? profile : "";
     render(typeof connState === "string" ? connState : "idle");
   }
   function render(state) {
@@ -25,11 +27,12 @@
   saveEl.addEventListener("click", async () => {
     const wsPort = Number(portEl.value);
     const token = tokenEl.value.trim();
+    const profile = profileEl.value.trim() || "default";
     if (!Number.isInteger(wsPort) || wsPort <= 0 || !token) {
       statusEl.textContent = "Status: enter a valid port (> 0) and token";
       return;
     }
-    await chrome.storage.local.set({ wsPort, token });
+    await chrome.storage.local.set({ wsPort, token, profile });
     await chrome.runtime.sendMessage({ type: "reconnect" }).catch(() => void 0);
     statusEl.textContent = "Status: \u2026 connecting";
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mehmoodqureshi/chrome-mcp",
-  "version": "0.5.2",
+  "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",