@mehmoodqureshi/chrome-mcp 0.1.0 → 0.3.0

package/dist/src/executor/extension-executor.js

@@ -81,10 +81,13 @@ class ExtensionExecutor {
     }
     // -- interaction --------------------------------------------------------
     async click(t, opts) {
-        return (await this.send('click', { ...targetParams(t), button: opts?.button, clickCount: opts?.clickCount }, { tabId: opts?.tabId }));
+        return (await this.send('click', { ...targetParams(t), button: opts?.button, clickCount: opts?.clickCount, trusted: opts?.trusted }, { tabId: opts?.tabId }));
     }
     async type(t, text, opts) {
-        return (await this.send('type', { ...targetParams(t), text, clear: opts?.clear, pressEnter: opts?.pressEnter, keyEvents: opts?.keyEvents }, { tabId: opts?.tabId }));
+        return (await this.send('type', { ...targetParams(t), text, clear: opts?.clear, pressEnter: opts?.pressEnter, keyEvents: opts?.keyEvents, trusted: opts?.trusted }, { tabId: opts?.tabId }));
+    }
+    async selectOption(t, values, opts) {
+        return (await this.send('select_option', { ...targetParams(t), values }, { tabId: opts?.tabId }));
     }
     async fill(t, value, opts) {
         // No dedicated wire method: a cleared insertText is the fill primitive.
@@ -106,6 +109,15 @@ class ExtensionExecutor {
     async getHtml(t, opts) {
         return (await this.send('get_html', { ...targetParams(t), outer: opts?.outer }, { tabId: opts?.tabId }));
     }
+    async snapshot(opts) {
+        return (await this.send('snapshot', { interactiveOnly: opts?.interactiveOnly, max: opts?.max }, { tabId: opts?.tabId }));
+    }
+    async getCookies(opts) {
+        return (await this.send('get_cookies', { url: opts?.url }, { tabId: opts?.tabId }));
+    }
+    async storage(args) {
+        return (await this.send('storage', { op: args.op, key: args.key, value: args.value, session: args.session }, { tabId: args.tabId }));
+    }
     async screenshot(opts) {
         return (await this.send('screenshot', { fullPage: opts?.fullPage, ...targetParams(opts?.target) }, { tabId: opts?.tabId }));
     }

package/dist/src/executor/stub-executor.d.ts

@@ -7,7 +7,7 @@
  *   2. Drives the dispatch/policy/envelope tests with deterministic, canned
  *      values (and a couple of forced-failure switches).
  */
-import { type ActionOk, type BackendKind, type DownloadResult, type EvalResult, type Executor, type ExecutorStatus, type NavResult, type ScreenshotResult, type TabId, type TabInfo, type Target, type WaitResult } from './types';
+import { type ActionOk, type BackendKind, type CookieItem, type DownloadResult, type EvalResult, type Executor, type ExecutorStatus, type NavResult, type ScreenshotResult, type SnapshotResult, type StorageOp, type StorageResult, type TabId, type TabInfo, type Target, type WaitResult } from './types';
 export interface StubOptions {
     /** URL of the (single) active tab — used to exercise the domain policy gate. */
     activeUrl?: string;
@@ -43,6 +43,7 @@ export declare class StubExecutor implements Executor {
     fill(): Promise<ActionOk>;
     press(): Promise<ActionOk>;
     hover(): Promise<ActionOk>;
+    selectOption(): Promise<ActionOk>;
     scroll(): Promise<ActionOk>;
     getText(_t?: Target): Promise<{
         text: string;
@@ -51,6 +52,14 @@ export declare class StubExecutor implements Executor {
     getHtml(): Promise<{
         html: string;
     }>;
+    snapshot(): Promise<SnapshotResult>;
+    getCookies(): Promise<{
+        cookies: CookieItem[];
+    }>;
+    storage(args: {
+        op: StorageOp;
+        key?: string;
+    }): Promise<StorageResult>;
     screenshot(): Promise<ScreenshotResult>;
     eval(expression: string): Promise<EvalResult>;
     waitFor(): Promise<WaitResult>;

package/dist/src/executor/stub-executor.js

@@ -85,6 +85,9 @@ class StubExecutor {
     async hover() {
         return ok;
     }
+    async selectOption() {
+        return ok;
+    }
     async scroll() {
         return ok;
     }
@@ -94,6 +97,22 @@ class StubExecutor {
     async getHtml() {
         return { html: '<html><body><a href="https://example.com">Example</a></body></html>' };
     }
+    async snapshot() {
+        return {
+            url: this.url,
+            title: 'Stub Page',
+            nodes: [{ ref: 'e1', role: 'link', name: 'Example', tag: 'a' }],
+            truncated: false,
+        };
+    }
+    async getCookies() {
+        return { cookies: [{ name: 'stub', value: '1', domain: 'example.com', path: '/', secure: true, httpOnly: false }] };
+    }
+    async storage(args) {
+        if (args.op === 'get')
+            return { ok: true, value: args.key ? 'stub-value' : null, entries: args.key ? undefined : { k: 'stub-value' } };
+        return { ok: true };
+    }
     async screenshot() {
         return { dataBase64: TINY_PNG, mimeType: 'image/png', width: 1, height: 1, truncated: false };
     }

package/dist/src/executor/types.d.ts

@@ -75,6 +75,39 @@ export interface DownloadResult {
     mimeType?: string;
     suggestedName?: string;
 }
+/** One interactive/landmark element in an accessibility snapshot. `ref` is stable until the tab navigates. */
+export interface SnapshotNode {
+    ref: string;
+    role: string;
+    name: string;
+    tag: string;
+    value?: string;
+    disabled?: boolean;
+    checked?: boolean;
+}
+export interface SnapshotResult {
+    url: string;
+    title: string;
+    nodes: SnapshotNode[];
+    truncated: boolean;
+}
+export interface CookieItem {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    secure: boolean;
+    httpOnly: boolean;
+    expires?: number;
+}
+export type StorageOp = 'get' | 'set' | 'remove' | 'clear';
+export interface StorageResult {
+    ok: boolean;
+    /** For `get`: the value (or null if absent). For others: omitted. */
+    value?: string | null;
+    /** For a keyless `get`: the whole store as a flat object. */
+    entries?: Record<string, string>;
+}
 export interface ExecutorStatus {
     ready: boolean;
     backend: BackendKind | null;
@@ -119,12 +152,18 @@ export interface Executor {
         tabId?: TabId;
         button?: MouseButton;
         clickCount?: number;
+        trusted?: boolean;
     }): Promise<ActionOk>;
     type(t: Target, text: string, opts?: {
         tabId?: TabId;
         clear?: boolean;
         pressEnter?: boolean;
         keyEvents?: boolean;
+        trusted?: boolean;
+    }): Promise<ActionOk>;
+    /** Choose option(s) of a <select> by value or visible label. */
+    selectOption(t: Target, values: string[], opts?: {
+        tabId?: TabId;
     }): Promise<ActionOk>;
     /** Value-set + input/change events (used by fill_form). */
     fill(t: Target, value: string, opts?: {
@@ -157,6 +196,27 @@ export interface Executor {
     }): Promise<{
         html: string;
     }>;
+    /** Accessibility snapshot: interactive/landmark elements with stable refs the model can target. */
+    snapshot(opts?: {
+        tabId?: TabId;
+        interactiveOnly?: boolean;
+        max?: number;
+    }): Promise<SnapshotResult>;
+    /** Read cookies visible to the active tab's URL (or a given url). */
+    getCookies(opts?: {
+        tabId?: TabId;
+        url?: string;
+    }): Promise<{
+        cookies: CookieItem[];
+    }>;
+    /** localStorage/sessionStorage get/set/remove/clear for the active tab. */
+    storage(args: {
+        op: StorageOp;
+        key?: string;
+        value?: string;
+        session?: boolean;
+        tabId?: TabId;
+    }): Promise<StorageResult>;
     screenshot(opts?: {
         tabId?: TabId;
         fullPage?: boolean;

package/dist/src/mcp/tools.js

@@ -41,14 +41,18 @@ exports.TOOL_DEFINITIONS = [
     { 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.', inputSchema: obj({ ...TARGET_PROPS, tabId: { type: 'string' }, button: { type: 'string', enum: ['left', 'right', 'middle'] }, clickCount: { type: 'number' } }) },
-    { name: 'type', description: 'Type text into an element.', inputSchema: obj({ ...TARGET_PROPS, text: { type: 'string' }, tabId: { type: 'string' }, clear: { type: 'boolean' }, pressEnter: { type: 'boolean' }, keyEvents: { type: 'boolean' } }, ['text']) },
+    { 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' } }) },
@@ -112,6 +116,7 @@ exports.TOOL_HANDLERS = {
             tabId: tabId(a),
             button: (0, validators_1.optionalString)(a, 'button'),
             clickCount: (0, validators_1.optionalNumber)(a, 'clickCount', { min: 1, max: 3 }),
+            trusted: (0, validators_1.optionalBoolean)(a, 'trusted'),
         }));
     },
     type: async (a, ctx) => {
@@ -122,8 +127,17 @@ exports.TOOL_HANDLERS = {
             clear: (0, validators_1.optionalBoolean)(a, 'clear'),
             pressEnter: (0, validators_1.optionalBoolean)(a, 'pressEnter'),
             keyEvents: (0, validators_1.optionalBoolean)(a, 'keyEvents'),
+            trusted: (0, validators_1.optionalBoolean)(a, 'trusted'),
         }));
     },
+    select_option: async (a, ctx) => {
+        const t = (0, validators_1.requireTarget)(a);
+        await gate(ctx, 'type'); // mutating
+        const values = (0, validators_1.optionalStringArray)(a, 'values');
+        if (!values || values.length === 0)
+            throw new validators_1.McpToolError('"values" must be a non-empty array of strings');
+        return (0, envelopes_1.jsonResult)(await ctx.ex.selectOption(t, values, { tabId: tabId(a) }));
+    },
     press: async (a, ctx) => {
         await gate(ctx, 'press');
         return (0, envelopes_1.jsonResult)(await ctx.ex.press((0, validators_1.requireString)(a, 'key'), {
@@ -165,6 +179,33 @@ exports.TOOL_HANDLERS = {
         await gate(ctx, 'get_html');
         return (0, envelopes_1.jsonResult)(await ctx.ex.getHtml((0, validators_1.optionalTarget)(a), { tabId: tabId(a), outer: (0, validators_1.optionalBoolean)(a, 'outer') }));
     },
+    snapshot: async (a, ctx) => {
+        await gate(ctx, 'get_text'); // read of page structure
+        return (0, envelopes_1.jsonResult)(await ctx.ex.snapshot({
+            tabId: tabId(a),
+            interactiveOnly: (0, validators_1.optionalBoolean)(a, 'interactiveOnly'),
+            max: (0, validators_1.optionalNumber)(a, 'max', { min: 1, max: 1000 }),
+        }));
+    },
+    get_cookies: async (a, ctx) => {
+        await gate(ctx, 'get_text'); // reads tab-scoped secrets; same domain gate as content reads
+        return (0, envelopes_1.jsonResult)(await ctx.ex.getCookies({ tabId: tabId(a), url: (0, validators_1.optionalString)(a, 'url') }));
+    },
+    storage: async (a, ctx) => {
+        const op = (0, validators_1.requireString)(a, 'op');
+        // get is a read; set/remove/clear mutate.
+        await gate(ctx, op === 'get' ? 'get_text' : 'type');
+        if ((op === 'set' || op === 'remove') && !(0, validators_1.optionalString)(a, 'key')) {
+            throw new validators_1.McpToolError(`storage "${op}" requires a "key"`);
+        }
+        return (0, envelopes_1.jsonResult)(await ctx.ex.storage({
+            op,
+            key: (0, validators_1.optionalString)(a, 'key'),
+            value: (0, validators_1.optionalString)(a, 'value'),
+            session: (0, validators_1.optionalBoolean)(a, 'session'),
+            tabId: tabId(a),
+        }));
+    },
     eval: async (a, ctx) => {
         await gate(ctx, 'eval');
         return (0, envelopes_1.jsonResult)(await ctx.ex.eval((0, validators_1.requireString)(a, 'expression'), {