@mehmoodqureshi/chrome-mcp 0.9.5 → 0.9.7

package/dist/src/config.js

@@ -78,6 +78,7 @@ function parseArgs(argv) {
     let headless = false;
     let printPairing = false;
     let persistToken = false;
+    let noTelemetry = false;
     let showHelp = false;
     let showVersion = false;
     let showExtensionPath = false;
@@ -178,6 +179,9 @@ function parseArgs(argv) {
             case '--persist-token':
                 persistToken = true;
                 break;
+            case '--no-telemetry':
+                noTelemetry = true;
+                break;
             case '--tools':
                 toolsFlagSeen = true;
                 for (const name of splitList(requireValue(argv[++i], '--tools')))
@@ -234,6 +238,7 @@ function parseArgs(argv) {
         headless,
         printPairing,
         persistToken,
+        noTelemetry,
         showHelp,
         showVersion,
         showExtensionPath,
@@ -294,8 +299,10 @@ Connection:
   --profile <name>       Default browser profile / identity (default "default").
                          Artifacts live under profiles/<name>/. At runtime, switch
                          with the profile_use tool. Several browsers can pair to the
-                         SAME port+token at once, each declaring its own Profile in
-                         the extension Options; tools route to the active profile.
+                         SAME port+token at once; each is named automatically
+                         (default, profile-2, ...; rename with profile_rename) unless
+                         its extension Options pins a Profile. Tools route to the
+                         active profile.
   --task <name>          Task label (default "default"). Downloads and a meta.json
                          land in profiles/<profile>/tasks/<task>/.
   --print-pairing        Write the handshake, print its path, and keep the bridge
@@ -307,6 +314,10 @@ Connection:
   --persist-token        Reuse a stable on-disk token across restarts so the
                          extension never has to re-pair (default: fresh per boot).
                          CHROME_MCP_TOKEN env, if set, pins the token explicitly.
+  --no-telemetry         Send no anonymous usage statistics. Same as
+                         CHROME_MCP_TELEMETRY=0 or DO_NOT_TRACK=1. Only counts are
+                         ever sent (version, OS, tool calls, error codes) — never
+                         URLs, page content or arguments.
 
 Backend:
   This build is EXTENSION-ONLY — it drives ONLY your real Chrome via the paired

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

@@ -20,6 +20,9 @@ export declare class ExtensionExecutor implements Executor {
     status(): ExecutorStatus;
     ensureReady(): Promise<void>;
     ping(deadlineMs?: number): Promise<boolean>;
+    /** Why this executor can't serve the active profile right now: not paired, or
+     *  paired but not answering pings. Used for the selector's NO_BACKEND message. */
+    unavailableReason(): string;
     dispose(): Promise<void>;
     /** The active tab's URL as reported by the last command on this profile, if it
      *  is fresh enough to gate against. See `ACTIVE_URL_TTL_MS`. */

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

@@ -81,6 +81,15 @@ class ExtensionExecutor {
             return false;
         }
     }
+    /** Why this executor can't serve the active profile right now: not paired, or
+     *  paired but not answering pings. Used for the selector's NO_BACKEND message. */
+    unavailableReason() {
+        const profile = this.activeProfile();
+        if (!this.bridge.hasConnection(profile))
+            return this.bridge.noPairMessage(profile);
+        return (`The browser paired for profile "${profile}" is not responding. Open that Chrome, ` +
+            `or reload the chrome-mcp extension in chrome://extensions, then retry.`);
+    }
     async dispose() {
         // Never close the user's Chrome.
     }

package/dist/src/executor/select.js

@@ -73,7 +73,11 @@ function createSelector(deps) {
             if (c)
                 return c;
         }
-        throw new types_1.ExecutorError('NO_BACKEND', 'No Chrome available: pair the extension, attach a --cdp-endpoint, or enable the CDP fallback.');
+        // CDP is off in the published build, so the extension is the only way in:
+        // name the profile and the exact Options to set rather than suggest flags
+        // that are ignored.
+        const reason = ext.unavailableReason?.();
+        throw new types_1.ExecutorError('NO_BACKEND', reason ?? 'No Chrome available: pair the chrome-mcp extension (Options: Port, token, Profile).');
     };
 }
 //# sourceMappingURL=select.js.map

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

@@ -15,6 +15,7 @@ import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import type { Executor } from '../executor/types';
 import { type Policy } from '../security/policy';
+import type { BridgeServer } from '../bridge/server';
 export interface ToolDefinition {
     name: string;
     description: string;
@@ -48,6 +49,7 @@ interface ToolCtx {
     policy: Policy;
 }
 type ToolHandler = (args: Record<string, unknown>, ctx: ToolCtx) => Promise<CallToolResult>;
+export declare function setProfileBridge(bridge: BridgeServer | null): void;
 export declare const TOOL_HANDLERS: Record<string, ToolHandler>;
 /** Reset limiter state — for tests that exercise the ceiling. */
 export declare function resetRateLimiter(): void;

package/dist/src/mcp/tools.js

@@ -16,10 +16,12 @@ exports.TOOL_HANDLERS = exports.TOOL_NAMES = exports.TOOL_DEFINITIONS = void 0;
 exports.setToolAllowlist = setToolAllowlist;
 exports.isToolEnabled = isToolEnabled;
 exports.enabledToolNames = enabledToolNames;
+exports.setProfileBridge = setProfileBridge;
 exports.resetRateLimiter = resetRateLimiter;
 exports.dispatchToolCall = dispatchToolCall;
 exports.assertNoDrift = assertNoDrift;
 exports.registerTools = registerTools;
+const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const zod_1 = require("zod");
 const types_1 = require("../executor/types");
@@ -36,6 +38,8 @@ const auth_wall_1 = require("../../shared/auth-wall");
 const audit_1 = require("./audit");
 const log_1 = require("./log");
 const tasks_1 = require("../bridge/tasks");
+const telemetry_1 = require("../telemetry");
+const config_1 = require("../config");
 const workspace_1 = require("../bridge/workspace");
 const validators_1 = require("./validators");
 /**
@@ -179,9 +183,10 @@ exports.TOOL_DEFINITIONS = [
             tabId: tabIdField,
         },
     },
-    { name: 'chrome_status', description: 'Report backend/session status.', inputSchema: {} },
+    { name: 'chrome_status', description: 'Report backend/session status, including every paired browser profile and how it was named.', inputSchema: {} },
     { name: 'auth_check', description: 'Is the tab sitting on a sign-in wall? Reads the page (URL, title, password fields, sign-in controls) and returns { authRequired, confidence, signals }. Use it after a navigate, or whenever a step fails unexpectedly, to tell "the session expired" apart from "the agent got lost". Pass failOnAuthWall:true to get an [AUTH_REQUIRED] error instead of a verdict, so a harness can bucket the run as an auth failure.', inputSchema: { failOnAuthWall: authWallField, ...FRAME_PROPS, tabId: tabIdField } },
     { 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: 'profile_rename', description: 'Rename an automatically named browser profile (e.g. "profile-2" -> "work"). The name sticks across restarts; its saved artifacts move with it.', inputSchema: { from: zod_1.z.string().describe('Current profile name'), to: zod_1.z.string().describe('New profile 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: { 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: {} },
@@ -480,10 +485,21 @@ const waitUntil = (args) => (0, validators_1.optionalString)(args, 'waitUntil');
  *  the active tab when `tabId` is omitted, which races under concurrency. */
 const PARALLEL_TAB_EXEMPT = new Set([
     'tabs_list', 'tab_new', 'chrome_status', 'batch',
-    'profile_use', 'task_new', 'tasks_list', 'task_status',
+    'profile_use', 'profile_rename', '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']);
+const NO_BACKEND_TOOLS = new Set([
+    'profile_use', 'profile_rename', 'task_new', 'tasks_list', 'task_status',
+    // Must answer even when the active profile has no browser — that is exactly
+    // when you need it to see which profiles ARE paired.
+    'chrome_status',
+]);
+/** The bridge, for the profile tools that need live connection state. Set by
+ *  the CLI once the bridge is up; null in tests that don't run one. */
+let profileBridge = null;
+function setProfileBridge(bridge) {
+    profileBridge = bridge;
+}
 /** Project a Workspace to the path fields worth returning to the caller. */
 function workspaceView(w) {
     return {
@@ -911,7 +927,22 @@ exports.TOOL_HANDLERS = {
             ...(path ? {} : { note: 'no active task workspace, so the PDF was not saved to disk' }),
         });
     },
-    chrome_status: async (_a, ctx) => (0, envelopes_1.jsonResult)(ctx.ex.status()),
+    chrome_status: async () => {
+        const profiles = profileBridge ? { profiles: profileBridge.pairedProfiles() } : {};
+        try {
+            const ex = await (0, manager_1.getManager)().ensureReady();
+            return (0, envelopes_1.jsonResult)({ ...ex.status(), ...profiles });
+        }
+        catch (err) {
+            return (0, envelopes_1.jsonResult)({
+                ready: false,
+                backend: null,
+                detail: errMessage(err),
+                activeProfile: (0, workspace_1.peekActiveWorkspace)()?.profile ?? 'default',
+                ...profiles,
+            });
+        }
+    },
     auth_check: async (a, ctx) => {
         await gate(ctx, 'get_text', { tabId: tabId(a) }); // read of page structure
         const snap = await ctx.ex.snapshot({ tabId: tabId(a), ...frameOpts(a), interactiveOnly: true, max: 200 });
@@ -932,6 +963,44 @@ exports.TOOL_HANDLERS = {
         (0, snapdiff_1.resetSnapshots)();
         return (0, envelopes_1.jsonResult)(workspaceView((0, workspace_1.switchWorkspace)({ profile: (0, validators_1.requireString)(a, 'name') })));
     },
+    profile_rename: async (a) => {
+        if (!profileBridge)
+            throw new types_1.ExecutorError('NO_BACKEND', 'profile_rename needs the chrome-mcp bridge running');
+        let from;
+        let to;
+        try {
+            // Sanitize once so the folder move and the active-profile check below
+            // use the same name the bridge routes by.
+            from = (0, config_1.sanitizeName)((0, validators_1.requireString)(a, 'from'), 'profile');
+            to = await profileBridge.renameProfile(from, (0, validators_1.requireString)(a, 'to'));
+        }
+        catch (err) {
+            // A refusal (typed-in name, name taken, bad name) is the caller's to fix, not a crash.
+            throw new validators_1.McpToolError(err instanceof Error ? err.message : String(err));
+        }
+        // Carry the profile's saved artifacts over, unless the new name already has
+        // a folder of its own (never merge or overwrite).
+        const ws = (0, workspace_1.getActiveWorkspace)();
+        const oldDir = (0, config_1.resolveProfileDir)(ws.dataDir, from);
+        const newDir = (0, config_1.resolveProfileDir)(ws.dataDir, to);
+        let artifactsMoved = false;
+        if (to !== from && (0, node_fs_1.existsSync)(oldDir) && !(0, node_fs_1.existsSync)(newDir)) {
+            try {
+                (0, node_fs_1.renameSync)(oldDir, newDir);
+                artifactsMoved = true;
+            }
+            catch {
+                /* leave them where they are; the rename itself already succeeded */
+            }
+        }
+        // Keep routing to the same browser if it was the active one.
+        let active;
+        if (ws.profile === from) {
+            (0, snapdiff_1.resetSnapshots)();
+            active = workspaceView((0, workspace_1.switchWorkspace)({ profile: to }));
+        }
+        return (0, envelopes_1.jsonResult)({ from, to, artifactsMoved, ...(active ? { active } : {}) });
+    },
     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)),
@@ -1007,6 +1076,8 @@ function summarizeArgs(rawArgs) {
  */
 function recordHistory(tool, rawArgs, ok, extra = {}) {
     const a = extra.audit ?? {};
+    // Counts only — the tool name and error code, never the args or URL below.
+    (0, telemetry_1.noteToolCall)(tool, ok, extra.error);
     (0, workspace_1.appendHistory)({
         ts: new Date().toISOString(),
         tool,

package/dist/src/telemetry.d.ts

@@ -0,0 +1,53 @@
+/**
+ * src/telemetry.ts — anonymous usage statistics from the chrome-mcp SERVER.
+ *
+ * What it sends, to PostHog: a random per-install id, the chrome-mcp version,
+ * OS, CPU architecture and Node major version, whether this session owns the
+ * port or shares it, how many browsers are paired, and per-tool call and error
+ * COUNTS. Never URLs, domains, tool arguments, page content, profile names,
+ * tokens, file paths, or anything typed. Events are marked personless and ask
+ * PostHog not to geolocate them.
+ *
+ * The browser extension sends nothing; this lives only in the npm server.
+ *
+ * On by default with a one-time notice on first run. Off with
+ * CHROME_MCP_TELEMETRY=0 (or false/off), DO_NOT_TRACK=1, or --no-telemetry.
+ * Every failure is swallowed: telemetry can never break or slow a tool call.
+ */
+/** PostHog project key. Public by design: it can only WRITE events, never read them. */
+export declare const POSTHOG_KEY = "phc_CG5QX5JEkRokfUN87rZQnPa3URdLWePCZnfqW6MCyCdU";
+export declare const POSTHOG_HOST = "https://us.i.posthog.com";
+export declare const TELEMETRY_NOTICE: string;
+interface Event {
+    event: string;
+    distinct_id: string;
+    timestamp: string;
+    properties: Record<string, unknown>;
+}
+export interface TelemetryOptions {
+    dataDir: string;
+    version: string;
+    /** --no-telemetry */
+    disabledByFlag?: boolean;
+    env?: NodeJS.ProcessEnv;
+    /** Override the project key (tests, forks). Empty = telemetry off. */
+    key?: string;
+    log?: (message: string) => void;
+    /** Test seam: replaces the HTTP POST. */
+    send?: (events: Event[]) => Promise<void>;
+    /** Live context added to each summary (role, paired browsers). */
+    context?: () => Record<string, unknown>;
+}
+/** Whether the user has turned telemetry off, by env or flag. */
+export declare function telemetryDisabled(env: NodeJS.ProcessEnv, disabledByFlag?: boolean): boolean;
+/** Pull the `[CODE]` prefix off a tool error message, if any. */
+export declare function errorCodeOf(message: string | undefined): string;
+/** Start telemetry for this server process, unless turned off or unconfigured. */
+export declare function initTelemetry(opts: TelemetryOptions): boolean;
+/** Count one tool call. A no-op when telemetry is off. */
+export declare function noteToolCall(tool: string, ok: boolean, error?: string): void;
+/** Flush and send session_ended. Safe to call when telemetry is off. */
+export declare function stopTelemetry(): Promise<void>;
+/** Test seam: forget the active instance. */
+export declare function resetTelemetryForTesting(): void;
+export {};

package/dist/src/telemetry.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * src/telemetry.ts — anonymous usage statistics from the chrome-mcp SERVER.
+ *
+ * What it sends, to PostHog: a random per-install id, the chrome-mcp version,
+ * OS, CPU architecture and Node major version, whether this session owns the
+ * port or shares it, how many browsers are paired, and per-tool call and error
+ * COUNTS. Never URLs, domains, tool arguments, page content, profile names,
+ * tokens, file paths, or anything typed. Events are marked personless and ask
+ * PostHog not to geolocate them.
+ *
+ * The browser extension sends nothing; this lives only in the npm server.
+ *
+ * On by default with a one-time notice on first run. Off with
+ * CHROME_MCP_TELEMETRY=0 (or false/off), DO_NOT_TRACK=1, or --no-telemetry.
+ * Every failure is swallowed: telemetry can never break or slow a tool call.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEMETRY_NOTICE = exports.POSTHOG_HOST = exports.POSTHOG_KEY = void 0;
+exports.telemetryDisabled = telemetryDisabled;
+exports.errorCodeOf = errorCodeOf;
+exports.initTelemetry = initTelemetry;
+exports.noteToolCall = noteToolCall;
+exports.stopTelemetry = stopTelemetry;
+exports.resetTelemetryForTesting = resetTelemetryForTesting;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+/** PostHog project key. Public by design: it can only WRITE events, never read them. */
+exports.POSTHOG_KEY = 'phc_CG5QX5JEkRokfUN87rZQnPa3URdLWePCZnfqW6MCyCdU';
+exports.POSTHOG_HOST = 'https://us.i.posthog.com';
+/** How often the aggregated counts are sent while a session runs. */
+const FLUSH_INTERVAL_MS = 10 * 60_000;
+/** A send never holds up the process longer than this. */
+const SEND_TIMEOUT_MS = 3_000;
+const STATE_FILE = 'telemetry.json';
+exports.TELEMETRY_NOTICE = 'chrome-mcp collects anonymous usage statistics (version, OS, tool call and error counts; never URLs, ' +
+    'page content or arguments) to see how it is used. Turn it off with CHROME_MCP_TELEMETRY=0 or DO_NOT_TRACK=1. ' +
+    'Details: https://github.com/Mehmoodqureshi/chrome-mcp#telemetry';
+/** Whether the user has turned telemetry off, by env or flag. */
+function telemetryDisabled(env, disabledByFlag = false) {
+    if (disabledByFlag)
+        return true;
+    const own = (env.CHROME_MCP_TELEMETRY ?? '').trim().toLowerCase();
+    if (['0', 'false', 'off', 'no'].includes(own))
+        return true;
+    const dnt = (env.DO_NOT_TRACK ?? '').trim().toLowerCase();
+    return dnt !== '' && dnt !== '0' && dnt !== 'false';
+}
+/** Pull the `[CODE]` prefix off a tool error message, if any. */
+function errorCodeOf(message) {
+    const m = /^\[([A-Z_]+)\]/.exec(message ?? '');
+    return m ? m[1] : 'OTHER';
+}
+class Telemetry {
+    opts;
+    installId;
+    calls = new Map();
+    errorCodes = new Map();
+    timer = null;
+    base;
+    /** Sends still on the wire, so a quick exit doesn't cut session_started off. */
+    inflight = new Set();
+    constructor(opts) {
+        this.opts = opts;
+        this.installId = this.loadInstallId();
+        this.base = {
+            version: opts.version,
+            os: (0, node_os_1.platform)(),
+            arch: (0, node_os_1.arch)(),
+            node: process.versions.node.split('.')[0],
+            // Anonymous: no person profile, no GeoIP lookup from the request IP.
+            $process_person_profile: false,
+            $geoip_disable: true,
+        };
+    }
+    start() {
+        void this.capture('session_started', this.opts.context?.() ?? {});
+        this.timer = setInterval(() => void this.flush(), FLUSH_INTERVAL_MS);
+        this.timer.unref();
+    }
+    noteCall(tool, ok, error) {
+        const c = this.calls.get(tool) ?? { calls: 0, errors: 0 };
+        c.calls++;
+        if (!ok) {
+            c.errors++;
+            const code = errorCodeOf(error);
+            this.errorCodes.set(code, (this.errorCodes.get(code) ?? 0) + 1);
+        }
+        this.calls.set(tool, c);
+    }
+    /** Send the counts gathered since the last flush (skipped when idle). */
+    async flush() {
+        const summary = this.takeSummary();
+        if (summary)
+            await this.send([summary]);
+    }
+    /** The counts since the last summary as an event, resetting them; null when idle. */
+    takeSummary() {
+        if (this.calls.size === 0)
+            return null;
+        const tools = Object.fromEntries(this.calls);
+        const errors = Object.fromEntries(this.errorCodes);
+        let total = 0;
+        let failed = 0;
+        for (const c of this.calls.values()) {
+            total += c.calls;
+            failed += c.errors;
+        }
+        this.calls = new Map();
+        this.errorCodes = new Map();
+        return this.event('usage_summary', { ...(this.opts.context?.() ?? {}), calls: total, errors: failed, tools, error_codes: errors });
+    }
+    /** Last summary and session_ended in ONE request, so both fit the shutdown deadline. */
+    async stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        const summary = this.takeSummary();
+        const final = this.send([...(summary ? [summary] : []), this.event('session_ended', {})]);
+        // Also wait for anything already sent (session_started on a short session).
+        await Promise.allSettled([...this.inflight, final]);
+    }
+    capture(event, props) {
+        return this.send([this.event(event, props)]);
+    }
+    event(event, props) {
+        return {
+            event,
+            distinct_id: this.installId,
+            timestamp: new Date().toISOString(),
+            properties: { ...this.base, ...props },
+        };
+    }
+    send(batch) {
+        const p = (async () => {
+            try {
+                await (this.opts.send ?? ((b) => this.post(b)))(batch);
+            }
+            catch {
+                /* offline, blocked, or PostHog down — never matters to the user */
+            }
+        })();
+        this.inflight.add(p);
+        void p.finally(() => this.inflight.delete(p));
+        return p;
+    }
+    async post(batch) {
+        await fetch(`${exports.POSTHOG_HOST}/batch/`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ api_key: this.opts.key, batch }),
+            signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
+        });
+    }
+    /** The random install id, created (with the first-run notice) on first use. */
+    loadInstallId() {
+        const path = (0, node_path_1.join)(this.opts.dataDir, STATE_FILE);
+        try {
+            if ((0, node_fs_1.existsSync)(path)) {
+                const saved = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8'));
+                if (typeof saved.installId === 'string' && saved.installId.length > 0)
+                    return saved.installId;
+            }
+        }
+        catch {
+            /* unreadable: start over with a new id */
+        }
+        const installId = (0, node_crypto_1.randomUUID)();
+        this.opts.log?.(exports.TELEMETRY_NOTICE);
+        try {
+            const tmp = `${path}.tmp`;
+            (0, node_fs_1.writeFileSync)(tmp, JSON.stringify({ installId, noticeShownAt: new Date().toISOString() }, null, 2), { mode: 0o600 });
+            (0, node_fs_1.renameSync)(tmp, path);
+        }
+        catch {
+            /* read-only data dir: a new id (and notice) next boot is harmless */
+        }
+        return installId;
+    }
+}
+let active = null;
+/** Start telemetry for this server process, unless turned off or unconfigured. */
+function initTelemetry(opts) {
+    const key = opts.key ?? exports.POSTHOG_KEY;
+    if (!key || telemetryDisabled(opts.env ?? process.env, opts.disabledByFlag))
+        return false;
+    active = new Telemetry({ ...opts, key });
+    active.start();
+    return true;
+}
+/** Count one tool call. A no-op when telemetry is off. */
+function noteToolCall(tool, ok, error) {
+    active?.noteCall(tool, ok, error);
+}
+/** Flush and send session_ended. Safe to call when telemetry is off. */
+async function stopTelemetry() {
+    const t = active;
+    active = null;
+    await t?.stop();
+}
+/** Test seam: forget the active instance. */
+function resetTelemetryForTesting() {
+    active = null;
+}
+//# sourceMappingURL=telemetry.js.map

package/extension-dist/background.js

@@ -48,7 +48,7 @@
     isConnected() {
       return this.state === "connected" && this.ws?.readyState === WebSocket.OPEN;
     }
-    connect(port, token, profile) {
+    connect(port, token, profile, installId) {
       if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
         return;
       }
@@ -68,6 +68,7 @@
           token,
           ext: { id: chrome.runtime.id, version: chrome.runtime.getManifest().version, chrome: chromeVersion() },
           profile: profile && profile.trim() ? profile.trim() : void 0,
+          installId,
           // This build gates fail-closed and reports tab URLs on results, so the
           // server may skip its pre-flight tabs_list. An older build omits this and
           // the server keeps fetching the URL itself.
@@ -85,6 +86,7 @@
         switch (frame.type) {
           case "welcome":
             this.deps.onPolicy(frame.policy);
+            if (typeof frame.profile === "string") this.deps.onProfile?.(frame.profile);
             this.setState("connected");
             this.deps.log("paired with server");
             break;
@@ -1859,6 +1861,8 @@
       currentPolicy = policy;
       void syncObserverScript(policy, (m) => console.debug("[chrome-mcp]", m));
     },
+    // Shown on the Options page, so you can tell which name this browser got.
+    onProfile: (profile) => void chrome.storage.local.set({ pairedProfile: profile }),
     log: (m) => console.debug("[chrome-mcp]", m)
   });
   var router = new CommandRouter({
@@ -1903,11 +1907,22 @@
     } catch {
     }
   }
+  async function ensureInstallId(installId) {
+    if (typeof installId === "string" && installId.length > 0) return installId;
+    const fresh = crypto.randomUUID();
+    await chrome.storage.local.set({ installId: fresh });
+    return fresh;
+  }
   async function getConfig() {
-    const { wsPort, token, profile } = await chrome.storage.local.get(["wsPort", "token", "profile"]);
+    const { wsPort, token, profile, installId } = await chrome.storage.local.get([
+      "wsPort",
+      "token",
+      "profile",
+      "installId"
+    ]);
     if (typeof wsPort === "number" && wsPort > 0 && typeof token === "string" && token.length > 0) {
-      const name = typeof profile === "string" && profile.trim() ? profile.trim() : "default";
-      return { wsPort, token, profile: name };
+      const label = typeof profile === "string" ? profile.trim() : "";
+      return { wsPort, token, profile: label, installId: await ensureInstallId(installId) };
     }
     return null;
   }
@@ -1934,7 +1949,7 @@
     if (ws.isConnected() || ws.state === "unauthorized") return;
     const cfg = await getConfig();
     if (!cfg) return;
-    ws.connect(cfg.wsPort, cfg.token, cfg.profile);
+    ws.connect(cfg.wsPort, cfg.token, cfg.profile, cfg.installId);
   }
   async function keepalivePulse() {
     await chrome.storage.local.get("connState");

package/extension-dist/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "MCP Extension for Chrome",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "Lets a local chrome-mcp server drive this browser. Pair it with the server's handshake token.",
   "homepage_url": "https://chrome-mcp-omega.vercel.app",
   "minimum_chrome_version": "116",

package/extension-dist/options.html

@@ -25,14 +25,16 @@
     <label for="port">Port</label>
     <input id="port" type="number" inputmode="numeric" placeholder="38017" />
     <label for="token">Token</label>
-    <input id="token" type="password" placeholder="paste the handshake token" />
+    <input id="token" type="password" placeholder="leave blank to keep the current token" />
     <label for="profile">Profile</label>
-    <input id="profile" type="text" placeholder="default" />
+    <input id="profile" type="text" placeholder="automatic" />
     <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>.
+      Optional. Leave blank and the server names this browser for you — the first is
+      <code>default</code>, then <code>profile-2</code>, <code>profile-3</code>… — and
+      remembers it. Rename one with <code>profile_rename</code>, switch with
+      <code>profile_use</code>. Type a name here only to pin one yourself.
     </p>
+    <p class="hint" id="paired-as"></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

@@ -10,13 +10,19 @@
   var saveEl = document.getElementById("save");
   var statusEl = document.getElementById("status");
   var sourceEl = document.getElementById("source");
+  var pairedAsEl = document.getElementById("paired-as");
+  function renderPairedAs(name) {
+    pairedAsEl.textContent = typeof name === "string" && name ? `This browser is paired as "${name}".` : "";
+  }
   async function loadExisting() {
-    const { wsPort, profile, connState, pairingSource } = await chrome.storage.local.get([
+    const { wsPort, profile, connState, pairingSource, pairedProfile } = await chrome.storage.local.get([
       "wsPort",
       "profile",
       "connState",
-      "pairingSource"
+      "pairingSource",
+      "pairedProfile"
     ]);
+    renderPairedAs(pairedProfile);
     sourceEl.textContent = pairingSource === "auto" ? "Paired automatically from the pairing.json the server wrote into this extension folder. Saving here overrides it." : pairingSource === "manual" ? "Paired by hand. Saved values take precedence over the bundled pairing.json." : typeof wsPort === "number" && wsPort > 0 && connState !== "idle" ? "Paired with values saved by an earlier version. Saving here keeps them manual." : "Not paired yet. If you loaded this extension from the chrome-mcp package folder, start the server once and it pairs itself; otherwise paste the values below.";
     portEl.value = typeof wsPort === "number" && wsPort > 0 ? String(wsPort) : String(DEFAULT_WS_PORT);
     profileEl.value = typeof profile === "string" ? profile : "";
@@ -33,8 +39,9 @@
   }
   saveEl.addEventListener("click", async () => {
     const wsPort = Number(portEl.value);
-    const token = tokenEl.value.trim();
-    const profile = profileEl.value.trim() || "default";
+    const stored = await chrome.storage.local.get("token");
+    const token = tokenEl.value.trim() || (typeof stored.token === "string" ? stored.token : "");
+    const profile = profileEl.value.trim();
     if (!Number.isInteger(wsPort) || wsPort <= 0 || !token) {
       statusEl.textContent = "Status: enter a valid port (> 0) and token";
       return;
@@ -45,6 +52,7 @@
   });
   chrome.storage.onChanged.addListener((changes, area) => {
     if (area === "local" && changes.connState) render(String(changes.connState.newValue));
+    if (area === "local" && changes.pairedProfile) renderPairedAs(changes.pairedProfile.newValue);
   });
   void loadExisting();
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mehmoodqureshi/chrome-mcp",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "Drive your real Chrome browser over MCP — real logins, real cookies. A stdio MCP server (CLI) plus an MV3 extension, driving Chrome via chrome.scripting/chrome.tabs. Multi-tab batch automation, accessibility snapshots, deny-all security by default.",
   "author": "Mehmood Ur Rehman Qureshi",
   "license": "MIT",