@jackwener/opencli 1.7.7 → 1.7.9

package/dist/src/adapter-source.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { resolveAdapterSourcePath } from './adapter-source.js';
+function makeCmd(overrides = {}) {
+    return {
+        site: 'test-site',
+        name: 'test-cmd',
+        description: 'test',
+        args: [],
+        ...overrides,
+    };
+}
+describe('resolveAdapterSourcePath', () => {
+    it('returns source when it is a real file path (not manifest:)', () => {
+        const cmd = makeCmd({ source: '/home/user/.opencli/clis/arxiv/search.js' });
+        expect(resolveAdapterSourcePath(cmd)).toBe('/home/user/.opencli/clis/arxiv/search.js');
+    });
+    it('skips manifest: pseudo-paths and falls back to _modulePath', () => {
+        const cmd = makeCmd({ source: 'manifest:arxiv/search', _modulePath: '/pkg/clis/arxiv/search.js' });
+        expect(resolveAdapterSourcePath(cmd)).toBe('/pkg/clis/arxiv/search.js');
+    });
+    it('returns undefined when only manifest: pseudo-path and no _modulePath', () => {
+        const cmd = makeCmd({ source: 'manifest:test/cmd' });
+        expect(resolveAdapterSourcePath(cmd)).toBeUndefined();
+    });
+    it('returns _modulePath when it is the only path available', () => {
+        const cmd = makeCmd({ _modulePath: '/project/clis/site/cmd.js' });
+        expect(resolveAdapterSourcePath(cmd)).toBe('/project/clis/site/cmd.js');
+    });
+});

package/dist/src/browser/base-page.d.ts

@@ -8,7 +8,7 @@
  * Subclasses implement the transport-specific methods: goto, evaluate,
  * getCookies, screenshot, tabs, etc.
  */
-import type { BrowserCookie, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
+import type { BrowserCookie, FetchJsonOptions, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
 import { type ResolveOptions, type TargetMatchLevel } from './target-resolver.js';
 export interface ResolveSuccess {
     matches_n: number;
@@ -26,6 +26,7 @@ export declare abstract class BasePage implements IPage {
     abstract goto(url: string, options?: {
         waitUntil?: 'load' | 'none';
         settleMs?: number;
+        allowBoundNavigation?: boolean;
     }): Promise<void>;
     abstract evaluate(js: string): Promise<unknown>;
     /**
@@ -37,6 +38,7 @@ export declare abstract class BasePage implements IPage {
      *   page.evaluateWithArgs(`(async () => { return sym; })()`, { sym: userInput })
      */
     evaluateWithArgs(js: string, args: Record<string, unknown>): Promise<unknown>;
+    fetchJson(url: string, opts?: FetchJsonOptions): Promise<unknown>;
     abstract getCookies(opts?: {
         domain?: string;
         url?: string;

package/dist/src/browser/base-page.js

@@ -12,6 +12,8 @@ import { generateSnapshotJs, getFormStateJs } from './dom-snapshot.js';
 import { pressKeyJs, waitForTextJs, waitForCaptureJs, waitForSelectorJs, scrollJs, autoScrollJs, networkRequestsJs, waitForDomStableJs, } from './dom-helpers.js';
 import { resolveTargetJs, clickResolvedJs, typeResolvedJs, scrollResolvedJs, } from './target-resolver.js';
 import { TargetError } from './target-errors.js';
+import { CliError } from '../errors.js';
+import { formatSnapshot } from '../snapshotFormatter.js';
 /**
  * Execute `resolveTargetJs` once, throw structured `TargetError` on failure.
  * Single helper so click/typeText/scrollTo share one resolution pathway,
@@ -30,7 +32,10 @@ async function runResolve(page, ref, opts = {}) {
     }
     return { matches_n: resolution.matches_n, match_level: resolution.match_level };
 }
-import { formatSnapshot } from '../snapshotFormatter.js';
+function previewText(text) {
+    const preview = (text ?? '').replace(/\s+/g, ' ').trim().slice(0, 300);
+    return preview ? `Response preview: ${preview}` : undefined;
+}
 export class BasePage {
     _lastUrl = null;
     /** Cached previous snapshot hashes for incremental diff marking */
@@ -54,6 +59,76 @@ export class BasePage {
             .join('\n');
         return this.evaluate(`${declarations}\n${js}`);
     }
+    async fetchJson(url, opts = {}) {
+        const request = {
+            url,
+            method: opts.method ?? 'GET',
+            headers: opts.headers ?? {},
+            body: opts.body,
+            hasBody: opts.body !== undefined,
+            timeoutMs: opts.timeoutMs ?? 15_000,
+        };
+        const result = await this.evaluateWithArgs(`
+      (async () => {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), request.timeoutMs);
+        try {
+          const headers = { Accept: 'application/json', ...request.headers };
+          const init = {
+            method: request.method,
+            credentials: 'include',
+            headers,
+            signal: ctrl.signal,
+          };
+          if (request.hasBody) {
+            if (!Object.keys(headers).some((key) => key.toLowerCase() === 'content-type')) {
+              headers['Content-Type'] = 'application/json';
+            }
+            init.body = JSON.stringify(request.body);
+          }
+          const resp = await fetch(request.url, init);
+          const text = await resp.text();
+          return {
+            ok: resp.ok,
+            status: resp.status,
+            statusText: resp.statusText,
+            url: resp.url,
+            contentType: resp.headers.get('content-type') || '',
+            text,
+          };
+        } catch (error) {
+          return {
+            ok: false,
+            status: 0,
+            statusText: '',
+            url: request.url,
+            contentType: '',
+            text: '',
+            error: error instanceof Error ? error.message : String(error),
+          };
+        } finally {
+          clearTimeout(timer);
+        }
+      })()
+    `, { request });
+        const targetUrl = result.url || url;
+        if (result.error) {
+            throw new CliError('FETCH_ERROR', `Browser fetch failed for ${targetUrl}: ${result.error}`, 'Check that the page is reachable and the current browser profile has access.');
+        }
+        if (!result.ok) {
+            throw new CliError('FETCH_ERROR', `HTTP ${result.status ?? 0}${result.statusText ? ` ${result.statusText}` : ''} from ${targetUrl}`, previewText(result.text));
+        }
+        const text = result.text ?? '';
+        if (!text.trim())
+            return null;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            const contentType = result.contentType ? ` (${result.contentType})` : '';
+            throw new CliError('FETCH_ERROR', `Expected JSON from ${targetUrl}${contentType}`, previewText(text));
+        }
+    }
     // ── Shared DOM helper implementations ──
     async click(ref, opts = {}) {
         // Phase 1: Resolve target with fingerprint verification

package/dist/src/browser/base-page.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/browser/base-page.test.js

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+import { CliError } from '../errors.js';
+import { BasePage } from './base-page.js';
+class TestPage extends BasePage {
+    result;
+    args;
+    async goto() { }
+    async evaluate() { return null; }
+    async evaluateWithArgs(_js, args) {
+        this.args = args;
+        return this.result;
+    }
+    async getCookies() { return []; }
+    async screenshot() { return ''; }
+    async tabs() { return []; }
+    async selectTab() { }
+}
+describe('BasePage.fetchJson', () => {
+    it('passes a narrow browser-context JSON request and parses the response in Node', async () => {
+        const page = new TestPage();
+        page.result = {
+            ok: true,
+            status: 200,
+            url: 'https://api.example.com/items',
+            contentType: 'application/json',
+            text: '{"items":[1]}',
+        };
+        await expect(page.fetchJson('https://api.example.com/items', {
+            method: 'POST',
+            headers: { 'X-Test': '1' },
+            body: { q: 'opencli' },
+            timeoutMs: 1234,
+        })).resolves.toEqual({ items: [1] });
+        expect(page.args).toEqual({
+            request: {
+                url: 'https://api.example.com/items',
+                method: 'POST',
+                headers: { 'X-Test': '1' },
+                body: { q: 'opencli' },
+                hasBody: true,
+                timeoutMs: 1234,
+            },
+        });
+    });
+    it('throws a CliError for non-JSON responses', async () => {
+        const page = new TestPage();
+        page.result = {
+            ok: true,
+            status: 200,
+            url: 'https://api.example.com/items',
+            contentType: 'text/html',
+            text: '<html>blocked</html>',
+        };
+        const err = await page.fetchJson('https://api.example.com/items').catch((error) => error);
+        expect(err).toBeInstanceOf(CliError);
+        expect(err.code).toBe('FETCH_ERROR');
+        expect(err.message).toContain('Expected JSON');
+        expect(err.hint).toContain('blocked');
+    });
+    it('throws a CliError for browser fetch transport errors', async () => {
+        const page = new TestPage();
+        page.result = {
+            ok: false,
+            status: 0,
+            url: 'https://api.example.com/items',
+            text: '',
+            error: 'The operation was aborted.',
+        };
+        await expect(page.fetchJson('https://api.example.com/items')).rejects.toMatchObject({
+            code: 'FETCH_ERROR',
+            message: expect.stringContaining('The operation was aborted.'),
+        });
+    });
+});

package/dist/src/browser/bridge.d.ts

@@ -16,6 +16,7 @@ export declare class BrowserBridge implements IBrowserFactory {
         timeout?: number;
         workspace?: string;
         idleTimeout?: number;
+        contextId?: string;
     }): Promise<IPage>;
     close(): Promise<void>;
     private _ensureDaemon;

package/dist/src/browser/bridge.js

@@ -10,6 +10,7 @@ import { getDaemonHealth, requestDaemonShutdown } from './daemon-client.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 import { BrowserConnectError } from '../errors.js';
 import { PKG_VERSION } from '../version.js';
+import { resolveProfileContextId } from './profile.js';
 const DAEMON_SPAWN_TIMEOUT = 10000; // 10s to wait for daemon + extension
 /**
  * Browser factory: manages daemon lifecycle and provides IPage instances.
@@ -32,8 +33,9 @@ export class BrowserBridge {
             throw new Error('Session is closed');
         this._state = 'connecting';
         try {
-            await this._ensureDaemon(opts.timeout);
-            this._page = new Page(opts.workspace, opts.idleTimeout);
+            const contextId = opts.contextId ?? resolveProfileContextId();
+            await this._ensureDaemon(opts.timeout, contextId);
+            this._page = new Page(opts.workspace, opts.idleTimeout, contextId);
             this._state = 'connected';
             return this._page;
         }
@@ -51,13 +53,21 @@ export class BrowserBridge {
         this._page = null;
         this._state = 'closed';
     }
-    async _ensureDaemon(timeoutSeconds) {
+    async _ensureDaemon(timeoutSeconds, contextId) {
         const effectiveSeconds = (timeoutSeconds && timeoutSeconds > 0) ? timeoutSeconds : Math.ceil(DAEMON_SPAWN_TIMEOUT / 1000);
         const timeoutMs = effectiveSeconds * 1000;
-        const health = await getDaemonHealth();
+        const health = await getDaemonHealth({ contextId });
         // Fast path: everything ready
         if (health.state === 'ready')
             return;
+        if (health.state === 'profile-required') {
+            throw new BrowserConnectError('Multiple Browser Bridge profiles are connected', 'Select one with --profile <name>, OPENCLI_PROFILE=<name>, or opencli profile use <name>.\n' +
+                'Run opencli profile list to see connected profiles.', 'profile-required');
+        }
+        if (health.state === 'profile-disconnected') {
+            const label = contextId ?? health.status.contextId ?? 'unknown';
+            throw new BrowserConnectError(`Browser profile "${label}" is not connected`, 'Open the matching Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.', 'profile-disconnected');
+        }
         // Daemon running but no extension
         if (health.state === 'no-extension') {
             // Detect stale daemon: version mismatch OR missing daemonVersion (pre-version daemon)
@@ -86,8 +96,17 @@ export class BrowserBridge {
                     process.stderr.write('⏳ Waiting for Chrome/Chromium extension to connect...\n');
                     process.stderr.write('   Make sure Chrome or Chromium is open and the OpenCLI extension is enabled.\n');
                 }
-                if (await this._pollUntilReady(timeoutMs))
+                if (await this._pollUntilReady(timeoutMs, contextId))
                     return;
+                const finalHealth = await getDaemonHealth({ contextId });
+                if (finalHealth.state === 'profile-required') {
+                    throw new BrowserConnectError('Multiple Browser Bridge profiles are connected', 'Select one with --profile <name>, OPENCLI_PROFILE=<name>, or opencli profile use <name>.\n' +
+                        'Run opencli profile list to see connected profiles.', 'profile-required');
+                }
+                if (finalHealth.state === 'profile-disconnected') {
+                    const label = contextId ?? finalHealth.status.contextId ?? 'unknown';
+                    throw new BrowserConnectError(`Browser profile "${label}" is not connected`, 'Open the matching Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.', 'profile-disconnected');
+                }
                 throw new BrowserConnectError('Browser Bridge extension not connected', 'Make sure Chrome/Chromium is open and the extension is enabled.\n' +
                     'If the extension is installed, try: opencli daemon stop && opencli doctor\n' +
                     'If not installed:\n' +
@@ -115,9 +134,17 @@ export class BrowserBridge {
         });
         this._daemonProc.unref();
         // Wait for daemon + extension
-        if (await this._pollUntilReady(timeoutMs))
+        if (await this._pollUntilReady(timeoutMs, contextId))
             return;
-        const finalHealth = await getDaemonHealth();
+        const finalHealth = await getDaemonHealth({ contextId });
+        if (finalHealth.state === 'profile-required') {
+            throw new BrowserConnectError('Multiple Browser Bridge profiles are connected', 'Select one with --profile <name>, OPENCLI_PROFILE=<name>, or opencli profile use <name>.\n' +
+                'Run opencli profile list to see connected profiles.', 'profile-required');
+        }
+        if (finalHealth.state === 'profile-disconnected') {
+            const label = contextId ?? finalHealth.status.contextId ?? 'unknown';
+            throw new BrowserConnectError(`Browser profile "${label}" is not connected`, 'Open the matching Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.', 'profile-disconnected');
+        }
         if (finalHealth.state === 'no-extension') {
             throw new BrowserConnectError('Browser Bridge extension not connected', 'Make sure Chrome/Chromium is open and the extension is enabled.\n' +
                 'If the extension is installed, try: opencli daemon stop && opencli doctor\n' +
@@ -139,11 +166,11 @@ export class BrowserBridge {
         return false;
     }
     /** Poll getDaemonHealth() until state is 'ready' or deadline is reached. */
-    async _pollUntilReady(timeoutMs) {
+    async _pollUntilReady(timeoutMs, contextId) {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
             await new Promise(resolve => setTimeout(resolve, 200));
-            const h = await getDaemonHealth();
+            const h = await getDaemonHealth({ contextId });
             if (h.state === 'ready')
                 return true;
         }

package/dist/src/browser/cdp.d.ts

@@ -25,6 +25,7 @@ export declare class CDPBridge implements IBrowserFactory {
         timeout?: number;
         workspace?: string;
         cdpEndpoint?: string;
+        contextId?: string;
     }): Promise<IPage>;
     close(): Promise<void>;
     send(method: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<unknown>;

package/dist/src/browser/cdp.js

@@ -229,7 +229,7 @@ class CDPPage extends BasePage {
                     const idx = this._networkEntries.push({
                         url: p.request.url,
                         method: p.request.method,
-                        timestamp: p.timestamp,
+                        timestamp: Date.now(),
                     }) - 1;
                     this._pendingRequests.set(p.requestId, idx);
                 }
@@ -290,7 +290,7 @@ class CDPPage extends BasePage {
             this.bridge.on('Runtime.consoleAPICalled', (params) => {
                 const p = params;
                 const text = (p.args || []).map(a => a.value !== undefined ? String(a.value) : (a.description || '')).join(' ');
-                this._consoleMessages.push({ type: p.type, text, timestamp: p.timestamp });
+                this._consoleMessages.push({ type: p.type, text, timestamp: Date.now() });
                 if (this._consoleMessages.length > 500)
                     this._consoleMessages.shift();
             });
@@ -298,7 +298,7 @@ class CDPPage extends BasePage {
             this.bridge.on('Runtime.exceptionThrown', (params) => {
                 const p = params;
                 const desc = p.exceptionDetails?.exception?.description || p.exceptionDetails?.text || 'Unknown exception';
-                this._consoleMessages.push({ type: 'error', text: desc, timestamp: p.timestamp });
+                this._consoleMessages.push({ type: 'error', text: desc, timestamp: Date.now() });
                 if (this._consoleMessages.length > 500)
                     this._consoleMessages.shift();
             });

package/dist/src/browser/daemon-client.d.ts

@@ -6,7 +6,7 @@
 import type { BrowserSessionInfo } from '../types.js';
 export interface DaemonCommand {
     id: string;
-    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'insert-text' | 'bind-current' | 'network-capture-start' | 'network-capture-read' | 'cdp' | 'frames';
+    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'insert-text' | 'bind' | 'network-capture-start' | 'network-capture-read' | 'cdp' | 'frames';
     /** Target page identity (targetId). Cross-layer contract with the extension. */
     page?: string;
     code?: string;
@@ -30,21 +30,32 @@ export interface DaemonCommand {
     pattern?: string;
     cdpMethod?: string;
     cdpParams?: Record<string, unknown>;
-    /** When true, automation windows are created in the foreground */
+    /** When true, the owned automation container is created in the foreground */
     windowFocused?: boolean;
     /** Custom idle timeout in seconds for this workspace session. Overrides the default. */
     idleTimeout?: number;
+    /** Explicitly allow navigation inside a borrowed bound tab. */
+    allowBoundNavigation?: boolean;
     /** Frame index for cross-frame operations (0-based, from 'frames' action) */
     frameIndex?: number;
+    /** Browser profile/context to route the command to. */
+    contextId?: string;
 }
 export interface DaemonResult {
     id: string;
     ok: boolean;
     data?: unknown;
     error?: string;
+    errorCode?: string;
+    errorHint?: string;
     /** Page identity (targetId) — present on page-scoped command responses */
     page?: string;
 }
+export declare class BrowserCommandError extends Error {
+    readonly code?: string | undefined;
+    readonly hint?: string | undefined;
+    constructor(message: string, code?: string | undefined, hint?: string | undefined);
+}
 export interface DaemonStatus {
     ok: boolean;
     pid: number;
@@ -53,12 +64,25 @@ export interface DaemonStatus {
     extensionConnected: boolean;
     extensionVersion?: string;
     extensionCompatRange?: string;
+    contextId?: string;
+    profileRequired?: boolean;
+    profileDisconnected?: boolean;
+    profiles?: BrowserProfileStatus[];
     pending: number;
     memoryMB: number;
     port: number;
 }
+export interface BrowserProfileStatus {
+    contextId: string;
+    extensionConnected: boolean;
+    extensionVersion?: string;
+    extensionCompatRange?: string;
+    pending: number;
+    lastSeenAt?: number;
+}
 export declare function fetchDaemonStatus(opts?: {
     timeout?: number;
+    contextId?: string;
 }): Promise<DaemonStatus | null>;
 export type DaemonHealth = {
     state: 'stopped';
@@ -66,6 +90,12 @@ export type DaemonHealth = {
 } | {
     state: 'no-extension';
     status: DaemonStatus;
+} | {
+    state: 'profile-required';
+    status: DaemonStatus;
+} | {
+    state: 'profile-disconnected';
+    status: DaemonStatus;
 } | {
     state: 'ready';
     status: DaemonStatus;
@@ -76,6 +106,7 @@ export type DaemonHealth = {
  */
 export declare function getDaemonHealth(opts?: {
     timeout?: number;
+    contextId?: string;
 }): Promise<DaemonHealth>;
 export declare function requestDaemonShutdown(opts?: {
     timeout?: number;
@@ -92,8 +123,11 @@ export declare function sendCommandFull(action: DaemonCommand['action'], params?
     data: unknown;
     page?: string;
 }>;
-export declare function listSessions(): Promise<BrowserSessionInfo[]>;
-export declare function bindCurrentTab(workspace: string, opts?: {
+export declare function listSessions(opts?: {
+    contextId?: string;
+}): Promise<BrowserSessionInfo[]>;
+export declare function bindTab(workspace: string, opts?: {
     matchDomain?: string;
     matchPathPrefix?: string;
+    contextId?: string;
 }): Promise<unknown>;

package/dist/src/browser/daemon-client.js

@@ -6,6 +6,7 @@
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 import { sleep } from '../utils.js';
 import { classifyBrowserError } from './errors.js';
+import { resolveProfileContextId } from './profile.js';
 const DAEMON_PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
 const OPENCLI_HEADERS = { 'X-OpenCLI': '1' };
@@ -13,6 +14,16 @@ let _idCounter = 0;
 function generateId() {
     return `cmd_${process.pid}_${Date.now()}_${++_idCounter}`;
 }
+export class BrowserCommandError extends Error {
+    code;
+    hint;
+    constructor(message, code, hint) {
+        super(message);
+        this.code = code;
+        this.hint = hint;
+        this.name = 'BrowserCommandError';
+    }
+}
 async function requestDaemon(pathname, init) {
     const { timeout = 2000, headers, ...rest } = init ?? {};
     const controller = new AbortController();
@@ -30,7 +41,8 @@ async function requestDaemon(pathname, init) {
 }
 export async function fetchDaemonStatus(opts) {
     try {
-        const res = await requestDaemon('/status', { timeout: opts?.timeout ?? 2000 });
+        const params = opts?.contextId ? `?contextId=${encodeURIComponent(opts.contextId)}` : '';
+        const res = await requestDaemon(`/status${params}`, { timeout: opts?.timeout ?? 2000 });
         if (!res.ok)
             return null;
         return await res.json();
@@ -47,6 +59,10 @@ export async function getDaemonHealth(opts) {
     const status = await fetchDaemonStatus(opts);
     if (!status)
         return { state: 'stopped', status: null };
+    if (status.profileRequired)
+        return { state: 'profile-required', status };
+    if (status.profileDisconnected)
+        return { state: 'profile-disconnected', status };
     if (!status.extensionConnected)
         return { state: 'no-extension', status };
     return { state: 'ready', status };
@@ -75,7 +91,8 @@ async function sendCommandRaw(action, params) {
         const id = generateId();
         const wf = process.env.OPENCLI_WINDOW_FOCUSED;
         const windowFocused = (wf === '1' || wf === 'true') ? true : undefined;
-        const command = { id, action, ...params, ...(windowFocused && { windowFocused }) };
+        const contextId = params.contextId ?? resolveProfileContextId();
+        const command = { id, action, ...params, ...(contextId && { contextId }), ...(windowFocused && { windowFocused }) };
         try {
             const res = await requestDaemon('/command', {
                 method: 'POST',
@@ -95,7 +112,7 @@ async function sendCommandRaw(action, params) {
                     await sleep(advice.delayMs);
                     continue;
                 }
-                throw new Error(result.error ?? 'Daemon command failed');
+                throw new BrowserCommandError(result.error ?? 'Daemon command failed', result.errorCode, result.errorHint);
             }
             return result;
         }
@@ -126,10 +143,10 @@ export async function sendCommandFull(action, params = {}) {
     const result = await sendCommandRaw(action, params);
     return { data: result.data, page: result.page };
 }
-export async function listSessions() {
-    const result = await sendCommand('sessions');
+export async function listSessions(opts) {
+    const result = await sendCommand('sessions', { ...(opts?.contextId && { contextId: opts.contextId }) });
     return Array.isArray(result) ? result : [];
 }
-export async function bindCurrentTab(workspace, opts = {}) {
-    return sendCommand('bind-current', { workspace, ...opts });
+export async function bindTab(workspace, opts = {}) {
+    return sendCommand('bind', { workspace, ...opts });
 }

package/dist/src/browser/daemon-client.test.js

@@ -6,6 +6,7 @@ describe('daemon-client', () => {
     });
     afterEach(() => {
         vi.restoreAllMocks();
+        vi.unstubAllEnvs();
     });
     it('fetchDaemonStatus sends the shared status request and returns parsed data', async () => {
         const status = {
@@ -78,6 +79,43 @@ describe('daemon-client', () => {
         });
         await expect(getDaemonHealth()).resolves.toEqual({ state: 'ready', status });
     });
+    it('getDaemonHealth returns profile-required when multiple profiles are connected without a selection', async () => {
+        const status = {
+            ok: true,
+            pid: 123,
+            uptime: 10,
+            extensionConnected: false,
+            profileRequired: true,
+            profiles: [
+                { contextId: 'work', extensionConnected: true, pending: 0 },
+                { contextId: 'personal', extensionConnected: true, pending: 0 },
+            ],
+            pending: 0,
+            memoryMB: 32,
+            port: 19825,
+        };
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(status),
+        });
+        await expect(getDaemonHealth()).resolves.toEqual({ state: 'profile-required', status });
+    });
+    it('fetchDaemonStatus includes contextId in the status query', async () => {
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                ok: true,
+                pid: 1,
+                uptime: 0,
+                extensionConnected: true,
+                pending: 0,
+                memoryMB: 1,
+                port: 19825,
+            }),
+        });
+        await fetchDaemonStatus({ contextId: 'work' });
+        expect(vi.mocked(fetch).mock.calls[0][0]).toMatch(/\/status\?contextId=work$/);
+    });
     it('sendCommand includes the current pid in generated command ids', async () => {
         vi.spyOn(Date, 'now').mockReturnValue(1_763_000_000_000);
         vi.mocked(fetch).mockResolvedValue({
@@ -95,6 +133,17 @@ describe('daemon-client', () => {
         expect(ids[1]).toMatch(new RegExp(`^cmd_${process.pid}_1763000000000_\\d+$`));
         expect(ids[0]).not.toBe(ids[1]);
     });
+    it('sendCommand forwards OPENCLI_PROFILE as command contextId', async () => {
+        vi.stubEnv('OPENCLI_PROFILE', 'work');
+        vi.spyOn(Date, 'now').mockReturnValue(1_763_000_000_000);
+        vi.mocked(fetch).mockResolvedValue({
+            status: 200,
+            json: () => Promise.resolve({ id: 'server', ok: true, data: 'ok' }),
+        });
+        await sendCommand('exec', { code: '1 + 1' });
+        const body = JSON.parse(String(vi.mocked(fetch).mock.calls[0][1]?.body));
+        expect(body.contextId).toBe('work');
+    });
     it('sendCommand retries with a new id when daemon reports a duplicate pending id', async () => {
         vi.spyOn(Date, 'now').mockReturnValue(1_763_000_000_123);
         const fetchMock = vi.mocked(fetch);

package/dist/src/browser/errors.js

@@ -15,7 +15,10 @@ const EXTENSION_TRANSIENT_PATTERNS = [
     'Extension disconnected',
     'Extension not connected',
     'attach failed',
+    'Detached while handling command',
+    'Debugger is not attached to the tab',
     'no longer exists',
+    'No tab with id',
     'CDP connection',
     'Daemon command failed',
     'No window with id',

package/dist/src/browser/errors.test.js

@@ -6,7 +6,10 @@ describe('classifyBrowserError', () => {
             'Extension disconnected',
             'Extension not connected',
             'attach failed',
+            'Detached while handling command',
+            'Debugger is not attached to the tab: 123',
             'no longer exists',
+            'No tab with id: 456',
             'CDP connection reset',
             'Daemon command failed',
             'No window with id: 123',

package/dist/src/browser/network-cache.d.ts

@@ -25,6 +25,7 @@ export interface CachedNetworkEntry {
      */
     body_truncated?: boolean;
     body_full_size?: number;
+    timestamp?: number;
 }
 export interface NetworkCacheFile {
     version: 1;