mcp-browser-extension 0.9.35 → 0.9.38

package/dist/src/mcp/tools.js

@@ -492,6 +492,16 @@ async function gatedUrl(ex, tabId) {
  */
 async function gate(ctx, method, opts = {}) {
     const url = opts.url ?? ((0, policy_1.isUrlGated)(method) ? await gatedUrl(ctx.ex, opts.tabId) : '');
+    // New extensions own the local site mode and warning decisions. Check the
+    // capability gates here first, then ask that exact paired browser to authorise
+    // the URL. The browser checks again against the live page before execution.
+    if ((0, policy_1.isUrlGated)(method) && /^https?:\/\//i.test(url) && ctx.ex.checkSiteAccess) {
+        (0, policy_1.assertUrlAllowed)(url, method, { ...ctx.policy, allowDomains: [(0, policy_1.hostOf)(url)] });
+        if (await ctx.ex.checkSiteAccess(url)) {
+            (0, audit_1.noteGate)(url, true);
+            return;
+        }
+    }
     try {
         (0, policy_1.assertUrlAllowed)(url, method, ctx.policy);
     }
@@ -940,10 +950,13 @@ exports.TOOL_HANDLERS = {
     page_watch: async (a, ctx) => {
         const action = (0, validators_1.requireString)(a, 'action');
         const ws = (0, workspace_1.getActiveWorkspace)();
+        // Phones share a browser profile, but their saved page data belongs only
+        // to their own workspace. Desktop checkpoints remain profile-scoped.
+        const watchDir = (0, client_identity_1.currentClientIdentity)()?.profile ? ws.taskDir : ws.profileDir;
         if (action === 'list')
-            return (0, envelopes_1.jsonResult)({ watches: (0, page_watch_1.listWatches)(ws.profileDir) });
+            return (0, envelopes_1.jsonResult)({ watches: (0, page_watch_1.listWatches)(watchDir) });
         if (action === 'delete') {
-            (0, page_watch_1.removeWatch)(ws.profileDir, (0, validators_1.requireString)(a, 'watchId'));
+            (0, page_watch_1.removeWatch)(watchDir, (0, validators_1.requireString)(a, 'watchId'));
             return (0, envelopes_1.jsonResult)({ deleted: true });
         }
         await gate(ctx, 'get_text', { tabId: tabId(a) });
@@ -951,13 +964,13 @@ exports.TOOL_HANDLERS = {
         const clean = (0, page_watch_1.safeSnapshot)(snap, (s) => (0, redact_1.redactText)(s, redaction(ctx.policy)).value);
         if (action === 'create') {
             const name = (0, validators_1.requireWithinLength)((0, validators_1.requireString)(a, 'name'), 'name', 80);
-            const saved = (0, page_watch_1.createWatch)(ws.profileDir, name, clean);
-            return (0, envelopes_1.jsonResult)({ watchId: saved.id, name: saved.name, url: saved.url, title: clean.title, elements: clean.nodes.length, savedAt: new Date(saved.ts).toISOString(), note: 'Checkpoint saved locally for this Chrome profile. Form values are not stored.' });
+            const saved = (0, page_watch_1.createWatch)(watchDir, name, clean);
+            return (0, envelopes_1.jsonResult)({ watchId: saved.id, name: saved.name, url: saved.url, title: clean.title, elements: clean.nodes.length, savedAt: new Date(saved.ts).toISOString(), note: `Checkpoint saved locally for this ${(0, client_identity_1.currentClientIdentity)()?.profile ? 'phone' : 'Chrome profile'}. Form values are not stored.` });
         }
         if (action === 'compare') {
-            const previous = (0, page_watch_1.readWatch)(ws.profileDir, (0, validators_1.requireString)(a, 'watchId'));
+            const previous = (0, page_watch_1.readWatch)(watchDir, (0, validators_1.requireString)(a, 'watchId'));
             // The site's grant may have been revoked since the checkpoint was saved.
-            (0, policy_1.assertUrlAllowed)(previous.url, 'get_text', ctx.policy);
+            await gate(ctx, 'get_text', { url: previous.url });
             const diff = (0, page_watch_1.compareWatch)(previous, clean, (s) => (0, redact_1.redactText)(s, redaction(ctx.policy)).value);
             return (0, envelopes_1.jsonResult)({ watchId: previous.id, name: previous.name, previousUrl: previous.url, currentUrl: clean.url, previousAt: new Date(previous.ts).toISOString(), checkedAt: new Date().toISOString(), ...diff });
         }
@@ -1431,6 +1444,15 @@ function isRetryableFault(name, err) {
     return err instanceof types_1.ExecutorError && err.code === 'EXTENSION_DISCONNECTED' && RETRY_SAFE_TOOLS.has(name);
 }
 async function dispatchToolCall(name, rawArgs, opts = {}) {
+    const client = (0, client_identity_1.currentClientIdentity)();
+    try {
+        client?.assertAccess?.();
+    }
+    catch {
+        return (0, envelopes_1.errorResult)('Phone access was removed or expired.');
+    }
+    if (client?.profile && PHONE_DISABLED_TOOLS.has(name))
+        return (0, envelopes_1.errorResult)('This tool is not available to a paired phone.');
     // The allowlist is checked here, not only at registration, so a `batch` op
     // cannot reach a tool the operator kept off the surface.
     if (!isToolEnabled(name))
@@ -1520,9 +1542,10 @@ function modelFromMeta(meta) {
     return typeof model === 'string' ? model : undefined;
 }
 /** Register the tool surface; returns the names actually advertised. */
-function registerTools(server, policy, accessGuard = access_1.requireAccess) {
+const PHONE_DISABLED_TOOLS = new Set(['profile_use', 'profile_rename', 'task_new', 'tasks_list', 'task_status']);
+function registerTools(server, policy, accessGuard = access_1.requireAccess, phoneIdentity) {
     assertNoDrift();
-    const identity = (0, client_identity_1.createClientIdentity)(() => {
+    const identity = phoneIdentity ?? (0, client_identity_1.createClientIdentity)(() => {
         const client = server.server.getClientVersion();
         return client ? `${client.name} ${client.version}` : 'Unnamed app';
     });
@@ -1535,6 +1558,8 @@ function registerTools(server, policy, accessGuard = access_1.requireAccess) {
     for (const d of exports.TOOL_DEFINITIONS) {
         if (!isToolEnabled(d.name))
             continue;
+        if (phoneIdentity && PHONE_DISABLED_TOOLS.has(d.name))
+            continue;
         // A tool the policy has switched off can only ever answer POLICY_DENIED.
         // Don't pay for its schema on every turn, and don't invite a wasted call.
         if (!isToolPolicyUsable(d.name, policy)) {
@@ -1542,6 +1567,12 @@ function registerTools(server, policy, accessGuard = access_1.requireAccess) {
             continue;
         }
         server.registerTool(d.name, { description: d.description, inputSchema: d.inputSchema }, async (args, extra) => (0, client_identity_1.withClientIdentity)(identity, async () => {
+            try {
+                identity.assertAccess?.();
+            }
+            catch {
+                return (0, envelopes_1.errorResult)('Phone access was removed or expired.');
+            }
             (0, telemetry_1.noteMcpModel)(modelFromMeta(extra?._meta));
             let verifiedNow = false;
             const accessError = await accessGuard(server.server, (0, config_1.resolveDataDir)(), {
@@ -1556,9 +1587,15 @@ function registerTools(server, policy, accessGuard = access_1.requireAccess) {
             // Approval and site refusals run nothing, so the call waits for the
             // person here and continues once they click Approve or Allow.
             const result = await (0, person_wait_1.waitForPerson)(async (retry) => {
+                try {
+                    identity.assertAccess?.();
+                }
+                catch {
+                    return (0, envelopes_1.errorResult)('Phone access was removed or expired.');
+                }
                 if (profileBridge?.hasActiveExtension()) {
                     const active = (0, workspace_1.peekActiveWorkspace)()?.profile ?? 'default';
-                    const profile = profileBridge.hasConnection(active) ? active : profileBridge.pairedProfiles()[0]?.name;
+                    const profile = phoneIdentity?.profile ?? (profileBridge.hasConnection(active) ? active : profileBridge.pairedProfiles()[0]?.name);
                     try {
                         await profileBridge.sendCommand('ping_probe', { requireClientApproval: true }, { profile });
                     }

package/dist/src/native-host.js

@@ -31,6 +31,7 @@ const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const protocol_1 = require("../shared/protocol");
+const phone_control_1 = require("./remote/phone-control");
 /** The host's name, as the extension addresses it. */
 exports.NATIVE_HOST_NAME = 'com.mehmoodqureshi.mcp_browser_extension';
 function nativeHostPaths(dataDir, platform = process.platform) {
@@ -197,6 +198,7 @@ function frameMessage(msg) {
 function runNativeHost(dataDir, profile) {
     const chunks = [];
     let answered = false;
+    let pending = false;
     const answer = (reply) => {
         if (answered)
             return;
@@ -204,6 +206,8 @@ function runNativeHost(dataDir, profile) {
         process.stdout.write(frameMessage(reply), () => process.exit(0));
     };
     process.stdin.on('data', (c) => {
+        if (answered || pending)
+            return;
         chunks.push(c);
         const buf = Buffer.concat(chunks);
         if (buf.length < 4)
@@ -220,10 +224,16 @@ function runNativeHost(dataDir, profile) {
         catch {
             return answer({ ok: false, error: 'bad_request', message: 'not JSON' });
         }
+        if (msg.type === 'phone_pairing') {
+            pending = true;
+            void (0, phone_control_1.phoneControlReply)(dataDir, msg).then(answer, () => answer({ ok: false, message: 'Could not reach phone pairing.' }));
+            return;
+        }
         if (msg.type !== 'pairing')
             return answer({ ok: false, error: 'bad_request', message: 'unknown request' });
         answer(pairingReply(dataDir, profile));
     });
-    process.stdin.on('end', () => answer({ ok: false, error: 'bad_request', message: 'no request' }));
+    process.stdin.on('end', () => { if (!pending)
+        answer({ ok: false, error: 'bad_request', message: 'no request' }); });
 }
 //# sourceMappingURL=native-host.js.map

package/dist/src/remote/claude-chat.d.ts

@@ -0,0 +1,21 @@
+import type { Options, Query, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import { requireAccess } from '../access';
+import type { Policy } from '../security/policy';
+import type { PhonePairing } from './phone-pairing';
+import { type ChatRunner } from './phone-chat';
+/**
+ * The Claude Agent SDK bundles Claude Code (hundreds of MB), so it is an
+ * optional peer: only computers that offer Claude in phone chat install it.
+ */
+export declare function claudeChatAvailable(resolve?: (id: string) => string): boolean;
+type QueryFactory = (params: {
+    prompt: AsyncIterable<SDKUserMessage>;
+    options: Options;
+}) => Query;
+/**
+ * Phone chat through the local Claude Code sign-in. Claude only receives the
+ * paired phone's browser tools: no built-in tools, user settings, hooks,
+ * skills, other MCP servers or saved sessions.
+ */
+export declare function createClaudeChatRunner(pairing: PhonePairing, id: string, version: string, policy: Policy, accessGuard?: typeof requireAccess, queryFactory?: QueryFactory): ChatRunner;
+export {};

package/dist/src/remote/claude-chat.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeChatAvailable = claudeChatAvailable;
+exports.createClaudeChatRunner = createClaudeChatRunner;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const server_1 = require("../mcp/server");
+const access_1 = require("../access");
+const phone_chat_1 = require("./phone-chat");
+const SERVER = 'browser';
+const SDK = '@anthropic-ai/claude-agent-sdk';
+/**
+ * The Claude Agent SDK bundles Claude Code (hundreds of MB), so it is an
+ * optional peer: only computers that offer Claude in phone chat install it.
+ */
+function claudeChatAvailable(resolve = require.resolve) {
+    try {
+        resolve(SDK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const PREFIX = `mcp__${SERVER}__`;
+const models = () => ({
+    fast: process.env.MBE_PHONE_CLAUDE_FAST_MODEL || 'haiku',
+    smart: process.env.MBE_PHONE_CLAUDE_MODEL || 'sonnet',
+});
+/**
+ * Phone chat through the local Claude Code sign-in. Claude only receives the
+ * paired phone's browser tools: no built-in tools, user settings, hooks,
+ * skills, other MCP servers or saved sessions.
+ */
+function createClaudeChatRunner(pairing, id, version, policy, accessGuard = access_1.requireAccess, queryFactory) {
+    const identity = pairing.identity(id);
+    const cwd = (0, node_path_1.join)(pairing.dataDir, 'phone-chat');
+    (0, node_fs_1.mkdirSync)(cwd, { recursive: true, mode: 0o700 });
+    const server = (0, server_1.createServer)(version, policy, accessGuard, identity);
+    const abort = new AbortController();
+    const inbox = [];
+    let wakeInbox;
+    let closed = false;
+    let session;
+    let starting;
+    let model = models().smart;
+    let turn;
+    const prompt = async function* () {
+        while (!closed) {
+            const next = inbox.shift();
+            if (next) {
+                yield next;
+                continue;
+            }
+            await new Promise((resolve) => { wakeInbox = resolve; });
+            wakeInbox = undefined;
+        }
+    };
+    const shown = () => [...turn.parts.values(), turn.live].filter(Boolean).join('\n\n').slice(0, 24_000);
+    const canUseTool = async (name, input) => {
+        if (closed || !turn || !name.startsWith(PREFIX))
+            return { behavior: 'deny', message: 'This tool is not available.' };
+        try {
+            identity.assertAccess?.();
+        }
+        catch {
+            return { behavior: 'deny', message: 'Phone access was removed. Ask the user to check the extension.', interrupt: true };
+        }
+        turn.update(null, phone_chat_1.toolActivity.get(name.slice(PREFIX.length)) ?? 'Using the browser');
+        return { behavior: 'allow', updatedInput: input };
+    };
+    const handle = (message) => {
+        if (!turn)
+            return;
+        if (message.type === 'stream_event') {
+            const event = message.event;
+            if (event.type === 'message_start')
+                turn.live = '';
+            if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta' && typeof event.delta.text === 'string') {
+                turn.live = (turn.live + event.delta.text).slice(0, 24_000);
+                turn.update(shown(), 'Writing a reply');
+            }
+        }
+        else if (message.type === 'assistant') {
+            const text = message.message.content.filter((block) => block.type === 'text').map((block) => block.text).join('');
+            turn.live = '';
+            if (text)
+                turn.parts.set(message.message.id ?? message.uuid, text.slice(0, 24_000));
+            turn.update(shown(), message.message.content.some((block) => block.type === 'tool_use') ? 'Using the browser' : 'Writing a reply');
+        }
+        else if (message.type === 'result') {
+            const current = turn;
+            turn = undefined;
+            if (message.subtype === 'success' && !message.is_error)
+                current.resolve();
+            else
+                current.reject(new Error('Claude turn failed or stopped.'));
+        }
+    };
+    const start = async (initial) => {
+        model = initial;
+        const factory = queryFactory ?? await Promise.resolve(`${SDK}`).then(s => __importStar(require(s))).then((sdk) => sdk.query, () => {
+            throw new phone_chat_1.ChatRequestError(409, 'Claude is not set up on your computer. Install @anthropic-ai/claude-agent-sdk next to MCP Browser Extension, then start a new chat.');
+        });
+        const env = { PATH: process.env.PATH, CLAUDE_AGENT_SDK_CLIENT_APP: `mcp-browser-extension-mobile/${version}` };
+        // Claude Code owns its sign-in. Never forward API keys or tokens from this process.
+        for (const key of ['HOME', 'USER', 'TMPDIR', 'LANG', 'CLAUDE_CONFIG_DIR'])
+            if (process.env[key])
+                env[key] = process.env[key];
+        session = factory({ prompt: prompt(), options: {
+                cwd, env, abortController: abort, systemPrompt: phone_chat_1.chatInstructions,
+                model, effort: 'low',
+                tools: [], settingSources: [], strictMcpConfig: true, persistSession: false, includePartialMessages: true,
+                mcpServers: { [SERVER]: { type: 'sdk', name: SERVER, instance: server, timeout: 300_000 } },
+                permissionMode: 'default', canUseTool,
+                ...(process.env.MBE_CLAUDE_BIN ? { pathToClaudeCodeExecutable: process.env.MBE_CLAUDE_BIN } : {}),
+            } });
+        void (async () => {
+            try {
+                for await (const message of session) {
+                    if (closed)
+                        return;
+                    handle(message);
+                }
+            }
+            catch { /* Reported to the active turn below. */ }
+            if (!closed && turn) {
+                const current = turn;
+                turn = undefined;
+                current.reject(new phone_chat_1.ChatRequestError(409, 'Claude could not finish. Check that Claude Code is installed and signed in on your computer, then start a new chat.'));
+            }
+        })();
+    };
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        abort.abort();
+        wakeInbox?.();
+        turn?.reject(new Error('Stopped.'));
+        turn = undefined;
+        try {
+            session?.close();
+        }
+        catch { /* Already stopped. */ }
+        void server.close().catch(() => undefined);
+    };
+    return {
+        // Spawning Claude Code and loading the browser tools happens before the first message.
+        warm: () => { if (!closed) {
+            starting ??= start(models().smart);
+            starting.catch(() => undefined);
+        } },
+        run: async (text, update, speed = 'smart') => {
+            if (closed)
+                throw new Error('Closed chat.');
+            identity.assertAccess?.();
+            const wanted = models()[speed];
+            starting ??= start(wanted);
+            await starting;
+            if (closed)
+                throw new Error('Closed chat.');
+            if (model !== wanted) {
+                await session.setModel(wanted);
+                model = wanted;
+            }
+            await new Promise((resolve, reject) => {
+                turn = { resolve, reject, update, parts: new Map(), live: '' };
+                update(null, 'Working on your request');
+                inbox.push({ type: 'user', message: { role: 'user', content: text }, parent_tool_use_id: null });
+                wakeInbox?.();
+            });
+        }, close,
+    };
+}
+//# sourceMappingURL=claude-chat.js.map

package/dist/src/remote/codex-rpc.d.ts

@@ -0,0 +1,19 @@
+type Message = {
+    id?: number | string;
+    method?: string;
+    params?: any;
+    result?: any;
+    error?: {
+        message?: string;
+    };
+};
+export interface CodexRpc {
+    request(method: string, params: unknown): Promise<any>;
+    notify(method: string, params: unknown): void;
+    respond(id: number | string, result: unknown): void;
+    close(): void;
+}
+export declare const CODEX_DISABLED_FEATURES: string[];
+/** Local stdio only. Codex owns its sign-in; credentials never enter the phone protocol. */
+export declare function startCodexRpc(cwd: string, event: (message: Message) => void, failed: () => void): CodexRpc;
+export {};

package/dist/src/remote/codex-rpc.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODEX_DISABLED_FEATURES = void 0;
+exports.startCodexRpc = startCodexRpc;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+exports.CODEX_DISABLED_FEATURES = ['shell_tool', 'unified_exec', 'apps', 'plugins', 'remote_plugin', 'multi_agent', 'multi_agent_v2',
+    'browser_use', 'browser_use_external', 'computer_use', 'image_generation', 'view_image', 'code_mode',
+    'hooks', 'memories', 'skill_search', 'skill_mcp_dependency_install'];
+/** Local stdio only. Codex owns its sign-in; credentials never enter the phone protocol. */
+function startCodexRpc(cwd, event, failed) {
+    const overrides = { web_search: 'disabled', notify: [], project_doc_max_bytes: 0, model_provider: 'openai',
+        model_reasoning_effort: 'low', approval_policy: 'never', sandbox_mode: 'read-only', service_tier: 'default' };
+    const args = ['app-server', '--listen', 'stdio://', ...exports.CODEX_DISABLED_FEATURES.flatMap((name) => ['--disable', name]),
+        ...Object.entries(overrides).flatMap(([key, value]) => ['-c', `${key}=${JSON.stringify(value)}`])];
+    const env = { PATH: `${(0, node_path_1.dirname)(process.execPath)}:${process.env.PATH ?? '/usr/bin:/bin'}` };
+    for (const key of ['HOME', 'USER', 'TMPDIR', 'LANG', 'CODEX_HOME'])
+        if (process.env[key])
+            env[key] = process.env[key];
+    const child = (0, node_child_process_1.spawn)(process.env.MBE_CODEX_BIN || 'codex', args, { cwd, env, stdio: 'pipe' });
+    const pending = new Map();
+    let closed = false;
+    let sequence = 0;
+    let buffer = '';
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        child.kill();
+        const kill = setTimeout(() => { if (child.exitCode === null)
+            child.kill('SIGKILL'); }, 1500);
+        kill.unref();
+        for (const p of pending.values()) {
+            clearTimeout(p.timer);
+            p.reject(new Error('Codex connection closed.'));
+        }
+        pending.clear();
+        buffer = '';
+    };
+    const fail = () => { if (!closed) {
+        close();
+        failed();
+    } };
+    const write = (message) => { if (!closed)
+        child.stdin.write(JSON.stringify(message) + '\n'); };
+    child.stderr.resume(); // Do not log model text, browser content or account diagnostics.
+    child.on('error', fail);
+    child.on('exit', fail);
+    child.stdin.on('error', fail);
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+        buffer += chunk;
+        if (buffer.length > 8 * 1024 * 1024)
+            return fail();
+        let newline;
+        while ((newline = buffer.indexOf('\n')) >= 0) {
+            const line = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!message || typeof message !== 'object')
+                continue;
+            const request = typeof message.id === 'number' && !message.method ? pending.get(message.id) : undefined;
+            if (request) {
+                pending.delete(message.id);
+                clearTimeout(request.timer);
+                if (message.error)
+                    request.reject(new Error('Codex could not complete the request.'));
+                else
+                    request.resolve(message.result);
+            }
+            else
+                event(message);
+        }
+    });
+    return {
+        request: (method, params) => new Promise((resolve, reject) => {
+            if (closed)
+                return reject(new Error('Codex connection closed.'));
+            const id = ++sequence;
+            const timer = setTimeout(() => { pending.delete(id); reject(new Error('Codex took too long to connect.')); }, 45_000);
+            pending.set(id, { resolve, reject, timer });
+            write({ id, method, params });
+        }),
+        notify: (method, params) => write({ method, params }),
+        respond: (id, result) => write({ id, result }), close,
+    };
+}
+//# sourceMappingURL=codex-rpc.js.map

package/dist/src/remote/http.d.ts

@@ -14,6 +14,8 @@
 import { type IncomingMessage } from 'node:http';
 import { requireAccess } from '../access';
 import type { Policy } from '../security/policy';
+import type { PhonePairing } from './phone-pairing';
+import { PhoneChat } from './phone-chat';
 export interface HttpMcpOptions {
     port: number;
     key: string;
@@ -22,6 +24,9 @@ export interface HttpMcpOptions {
     log: (message: string) => void;
     /** Test seam; production callers use the Firebase-backed gate by default. */
     accessGuard?: typeof requireAccess;
+    phonePairing?: PhonePairing;
+    /** Personal, opt-in local Codex or Claude companion. Never runs on the relay host. */
+    phoneChat?: boolean | PhoneChat;
 }
 export interface HttpMcp {
     port: number;