@agentrhq/webcmd 0.1.2 → 0.2.0

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

@@ -1,11 +1,14 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { fetchDaemonStatus, getDaemonHealth, requestDaemonShutdown, sendCommand, } from './daemon-client.js';
+import { fetchDaemonStatus, getDaemonHealth, requestDaemonShutdown, sendCommand, setDaemonCommandTimeoutSeconds, } from './daemon-client.js';
 import * as daemonLifecycle from './daemon-lifecycle.js';
 describe('daemon-client', () => {
     beforeEach(() => {
         vi.stubGlobal('fetch', vi.fn());
     });
     afterEach(() => {
+        if (typeof setDaemonCommandTimeoutSeconds === 'function') {
+            setDaemonCommandTimeoutSeconds(null);
+        }
         vi.restoreAllMocks();
         vi.unstubAllEnvs();
     });
@@ -180,27 +183,19 @@ describe('daemon-client', () => {
         const body = JSON.parse(String(vi.mocked(fetch).mock.calls[0][1]?.body));
         expect(body.windowMode).toBe('background');
     });
-    it('sendCommand retries with a new id when daemon reports a duplicate pending id', async () => {
+    it('sendCommand treats duplicate pending ids from an old daemon as unknown instead of minting a new id', async () => {
         vi.spyOn(Date, 'now').mockReturnValue(1_763_000_000_123);
         const fetchMock = vi.mocked(fetch);
-        fetchMock
-            .mockResolvedValueOnce({
+        fetchMock.mockResolvedValueOnce({
             ok: false,
             status: 409,
             json: () => Promise.resolve({ ok: false, error: 'Duplicate command id already pending; retry' }),
-        })
-            .mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            json: () => Promise.resolve({ id: 'server', ok: true, data: 42 }),
         });
-        await expect(sendCommand('exec', { code: '6 * 7' })).resolves.toBe(42);
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-        const ids = fetchMock.mock.calls.map(([, init]) => {
-            const body = JSON.parse(String(init?.body));
-            return body.id;
+        await expect(sendCommand('exec', { code: '6 * 7' })).rejects.toMatchObject({
+            name: 'BrowserCommandError',
+            code: 'command_result_unknown',
         });
-        expect(ids[0]).not.toBe(ids[1]);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
     });
     it('sendCommand does not retry command_result_unknown even when the message looks transient', async () => {
         const fetchMock = vi.mocked(fetch);
@@ -222,7 +217,7 @@ describe('daemon-client', () => {
         });
         expect(fetchMock).toHaveBeenCalledTimes(1);
     });
-    it('sendCommand runs full bridge ensure on a pre-dispatch failure, then resends with a fresh id', async () => {
+    it('sendCommand runs full bridge ensure on a pre-dispatch failure, then resends with the same id', async () => {
         vi.spyOn(Date, 'now').mockReturnValue(1_763_000_000_321);
         const ensureSpy = vi.spyOn(daemonLifecycle, 'ensureBrowserBridgeReady').mockResolvedValue({
             health: {
@@ -260,9 +255,9 @@ describe('daemon-client', () => {
         expect(ensureSpy).toHaveBeenCalledWith(expect.objectContaining({ contextId: 'work', verbose: false }));
         const ids = fetchMock.mock.calls.map(([, init]) => JSON.parse(String(init?.body)).id);
         expect(ids).toHaveLength(2);
-        expect(ids[0]).not.toBe(ids[1]);
+        expect(ids[0]).toBe(ids[1]);
     });
-    it('sendCommand runs full bridge ensure on a local TypeError before resending', async () => {
+    it('sendCommand runs full bridge ensure on a pre-connect TypeError before resending', async () => {
         const ensureSpy = vi.spyOn(daemonLifecycle, 'ensureBrowserBridgeReady').mockResolvedValue({
             health: {
                 state: 'ready',
@@ -279,9 +274,11 @@ describe('daemon-client', () => {
             },
             spawnedProcess: null,
         });
+        const refused = new TypeError('fetch failed');
+        refused.cause = Object.assign(new Error('connect ECONNREFUSED 127.0.0.1:19825'), { code: 'ECONNREFUSED' });
         const fetchMock = vi.mocked(fetch);
         fetchMock
-            .mockRejectedValueOnce(new TypeError('fetch failed'))
+            .mockRejectedValueOnce(refused)
             .mockResolvedValueOnce({
             ok: true,
             status: 200,
@@ -291,6 +288,33 @@ describe('daemon-client', () => {
         expect(ensureSpy).toHaveBeenCalledWith(expect.objectContaining({ verbose: false }));
         expect(fetchMock).toHaveBeenCalledTimes(2);
     });
+    it('sendCommand does not resend a post-connect TypeError because the command may have been dispatched', async () => {
+        const ensureSpy = vi.spyOn(daemonLifecycle, 'ensureBrowserBridgeReady').mockResolvedValue({
+            health: {
+                state: 'ready',
+                status: {
+                    ok: true,
+                    pid: 1,
+                    uptime: 1,
+                    runtimeConnected: true,
+                    runtimeName: 'fake',
+                    pending: 0,
+                    memoryMB: 0,
+                    port: 19825,
+                },
+            },
+            spawnedProcess: null,
+        });
+        const reset = new TypeError('fetch failed');
+        reset.cause = Object.assign(new Error('read ECONNRESET'), { code: 'ECONNRESET' });
+        vi.mocked(fetch).mockRejectedValueOnce(reset);
+        await expect(sendCommand('navigate', { url: 'https://example.com' })).rejects.toMatchObject({
+            name: 'BrowserCommandError',
+            code: 'command_result_unknown',
+        });
+        expect(ensureSpy).toHaveBeenCalledTimes(1);
+        expect(fetch).toHaveBeenCalledTimes(1);
+    });
     it('sendCommand does NOT wait when the bridge reports profile_required', async () => {
         const ensureSpy = vi.spyOn(daemonLifecycle, 'ensureBrowserBridgeReady');
         const fetchMock = vi.mocked(fetch);
@@ -323,4 +347,65 @@ describe('daemon-client', () => {
         expect(ensureSpy).not.toHaveBeenCalled();
         expect(fetch).toHaveBeenCalledTimes(1);
     });
+    it('sendCommand plumbs the default command timeout and absolute deadline into the request body', async () => {
+        vi.spyOn(Date, 'now').mockReturnValue(1_763_000_000_000);
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ id: 'server', ok: true, data: 1 }),
+        });
+        await expect(sendCommand('exec', { code: '1' })).resolves.toBe(1);
+        const body = JSON.parse(String(fetchMock.mock.calls[0][1]?.body));
+        expect(body.timeout).toBe(120);
+        expect(body.deadlineAt).toBe(1_763_000_120_000);
+    });
+    it('sendCommand extends the daemon deadline past a runtime-side timeoutMs', async () => {
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ id: 'server', ok: true, data: { downloaded: true } }),
+        });
+        await sendCommand('wait-download', { timeoutMs: 240_000 });
+        const body = JSON.parse(String(fetchMock.mock.calls[0][1]?.body));
+        expect(body.timeout).toBe(255);
+    });
+    it('setDaemonCommandTimeoutSeconds raises the transport deadline for a user timeout', async () => {
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ id: 'server', ok: true, data: 1 }),
+        });
+        setDaemonCommandTimeoutSeconds(300);
+        await sendCommand('exec', { code: '1' });
+        const body = JSON.parse(String(fetchMock.mock.calls[0][1]?.body));
+        expect(body.timeout).toBe(300);
+    });
+    it('client HTTP abort fires only after the daemon timeout margin', async () => {
+        vi.useFakeTimers();
+        try {
+            const fetchMock = vi.mocked(fetch);
+            let aborted = false;
+            fetchMock.mockImplementationOnce((_url, init) => new Promise((_, reject) => {
+                init?.signal?.addEventListener('abort', () => {
+                    aborted = true;
+                    reject(Object.assign(new Error('This operation was aborted'), { name: 'AbortError' }));
+                });
+            }));
+            const pending = sendCommand('exec', { code: '1' }).catch((err) => err);
+            await vi.advanceTimersByTimeAsync(120_000 + 9_999);
+            expect(aborted).toBe(false);
+            await vi.advanceTimersByTimeAsync(1);
+            expect(aborted).toBe(true);
+            await expect(pending).resolves.toMatchObject({
+                name: 'BrowserCommandError',
+                code: 'command_result_unknown',
+            });
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
 });

package/dist/src/browser/errors.js

@@ -34,12 +34,23 @@ const TARGET_NAVIGATION_PATTERNS = [
 function errorMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }
+const ERROR_CODE_ADVICE = {
+    attach_failed: { kind: 'extension-transient', retryable: true, delayMs: 1500 },
+    tab_gone: { kind: 'extension-transient', retryable: true, delayMs: 1500 },
+    target_navigated: { kind: 'target-navigation', retryable: true, delayMs: 200 },
+    detached_mid_command: { kind: 'non-retryable', retryable: false, delayMs: 0 },
+    cdp_timeout: { kind: 'non-retryable', retryable: false, delayMs: 0 },
+};
 /**
  * Classify a browser error and return retry advice.
  *
  * Single source of truth for "is this error transient?" across all layers.
  */
 export function classifyBrowserError(err) {
+    const code = err && typeof err === 'object' ? err.code : undefined;
+    if (typeof code === 'string' && ERROR_CODE_ADVICE[code]) {
+        return ERROR_CODE_ADVICE[code];
+    }
     const msg = errorMessage(err);
     // Runtime/daemon transient errors — longer recovery time
     if (EXTENSION_TRANSIENT_PATTERNS.some(p => msg.includes(p))) {

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

@@ -26,6 +26,8 @@ export interface BrowserRuntimeCommand {
     timeoutMs?: number;
     /** Daemon command timeout in seconds. Preserves the existing daemon protocol field. */
     timeout?: number;
+    /** Absolute command deadline in epoch milliseconds. Preferred by newer daemons. */
+    deadlineAt?: number;
     cdpMethod?: string;
     cdpParams?: Record<string, unknown>;
     windowMode?: BrowserWindowMode;

package/dist/src/browser.test.js

@@ -18,10 +18,10 @@ describe('browser helpers', () => {
         ]);
     });
     it('extracts tab entries from MCP markdown format', () => {
-        const entries = extractTabEntries('- 0: (current) [Playwright MCP extension](chrome-extension://abc/connect.html)\n- 1: [知乎 - 首页](https://www.zhihu.com/)');
+        const entries = extractTabEntries('- 0: (current) [Playwright MCP extension](chrome-extension://abc/connect.html)\n- 1: [Example - Home](https://example.com/)');
         expect(entries).toEqual([
             { index: 0, identity: '(current) [Playwright MCP extension](chrome-extension://abc/connect.html)' },
-            { index: 1, identity: '[知乎 - 首页](https://www.zhihu.com/)' },
+            { index: 1, identity: '[Example - Home](https://example.com/)' },
         ]);
     });
     it('closes only tabs that were opened during the session', () => {

package/dist/src/cli-argv-preprocess.d.ts

@@ -52,9 +52,9 @@ export interface DashPositionalManifestEntry {
     browser?: boolean;
 }
 /**
- * `webcmd boss detail -abc123def` fails because commander parses
+ * `webcmd openreview paper -abc123def` fails because commander parses
  * `-abc123def` as an unknown option rather than the required
- * `<security-id>` positional. BOSS 直聘 securityId tokens are opaque
+ * `<id>` positional. Some adapter identifiers are opaque
  * strings that can legitimately start with `-` (issue #1160), and the
  * same shape can show up in any adapter that takes an opaque-id
  * positional. Insert a `--` separator so commander treats the next

package/dist/src/cli-argv-preprocess.js

@@ -217,9 +217,9 @@ function consumeKnownOption(argv, index, options) {
     return { values: [token], nextIndex: index + 1 };
 }
 /**
- * `webcmd boss detail -abc123def` fails because commander parses
+ * `webcmd openreview paper -abc123def` fails because commander parses
  * `-abc123def` as an unknown option rather than the required
- * `<security-id>` positional. BOSS 直聘 securityId tokens are opaque
+ * `<id>` positional. Some adapter identifiers are opaque
  * strings that can legitimately start with `-` (issue #1160), and the
  * same shape can show up in any adapter that takes an opaque-id
  * positional. Insert a `--` separator so commander treats the next

package/dist/src/cli-argv-preprocess.test.js

@@ -226,70 +226,70 @@ describe('rewriteBrowserArgv', () => {
 import { escapeLeadingDashPositional } from './cli-argv-preprocess.js';
 describe('escapeLeadingDashPositional', () => {
     const manifest = [
-        { site: 'boss', name: 'detail', browser: true, args: [{ name: 'security-id', positional: true, required: true }, { name: 'retry', positional: false, valueRequired: true }] },
-        { site: 'boss', name: 'search', args: [{ name: 'query', positional: true, required: false }, { name: 'limit', positional: false }] },
+        { site: 'openreview', name: 'paper', browser: true, args: [{ name: 'id', positional: true, required: true }, { name: 'retry', positional: false, valueRequired: true }] },
+        { site: 'openreview', name: 'search', args: [{ name: 'query', positional: true, required: false }, { name: 'limit', positional: false }] },
         { site: 'twitter', name: 'follow', args: [{ name: 'username', positional: true, required: true }] },
         { site: 'twitter', name: 'lists', args: [{ name: 'limit', positional: false }] },
     ];
     it('inserts -- before a required positional starting with `-`', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-abc123def'], manifest))
-            .toEqual(['boss', 'detail', '--', '-abc123def']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-abc123def'], manifest))
+            .toEqual(['openreview', 'paper', '--', '-abc123def']);
     });
     it('preserves trailing flags after the dash-leading positional', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-xyz', '-f', 'json'], manifest))
-            .toEqual(['boss', 'detail', '-f', 'json', '--', '-xyz']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-xyz', '-f', 'json'], manifest))
+            .toEqual(['openreview', 'paper', '-f', 'json', '--', '-xyz']);
     });
     it('preserves attached short option values like commander does', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-fjson', '-xyz'], manifest))
-            .toEqual(['boss', 'detail', '-fjson', '--', '-xyz']);
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-xyz', '-fjson'], manifest))
-            .toEqual(['boss', 'detail', '-fjson', '--', '-xyz']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-fjson', '-xyz'], manifest))
+            .toEqual(['openreview', 'paper', '-fjson', '--', '-xyz']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-xyz', '-fjson'], manifest))
+            .toEqual(['openreview', 'paper', '-fjson', '--', '-xyz']);
     });
     it('handles known options before a dash-leading positional', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '--format', 'json', '--trace=on', '-xyz'], manifest))
-            .toEqual(['boss', 'detail', '--format', 'json', '--trace=on', '--', '-xyz']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '--format', 'json', '--trace=on', '-xyz'], manifest))
+            .toEqual(['openreview', 'paper', '--format', 'json', '--trace=on', '--', '-xyz']);
     });
     it('keeps adapter and browser options parseable when they follow the positional', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-xyz', '--retry', '2', '--window', 'foreground'], manifest))
-            .toEqual(['boss', 'detail', '--retry', '2', '--window', 'foreground', '--', '-xyz']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-xyz', '--retry', '2', '--window', 'foreground'], manifest))
+            .toEqual(['openreview', 'paper', '--retry', '2', '--window', 'foreground', '--', '-xyz']);
     });
     it('protects negative numeric positionals too', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-42'], manifest))
-            .toEqual(['boss', 'detail', '--', '-42']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-42'], manifest))
+            .toEqual(['openreview', 'paper', '--', '-42']);
     });
     it('leaves unknown dash options untouched instead of hiding them behind --', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '--unknown', 'value'], manifest))
-            .toEqual(['boss', 'detail', '--unknown', 'value']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '--unknown', 'value'], manifest))
+            .toEqual(['openreview', 'paper', '--unknown', 'value']);
     });
     it('does not touch positional values that do not start with -', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', 'normal-id'], manifest))
-            .toEqual(['boss', 'detail', 'normal-id']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', 'normal-id'], manifest))
+            .toEqual(['openreview', 'paper', 'normal-id']);
     });
     it('does not touch the recognised short flags -f / -v / -h', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-f', 'json'], manifest))
-            .toEqual(['boss', 'detail', '-f', 'json']);
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-v'], manifest))
-            .toEqual(['boss', 'detail', '-v']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-f', 'json'], manifest))
+            .toEqual(['openreview', 'paper', '-f', 'json']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-v'], manifest))
+            .toEqual(['openreview', 'paper', '-v']);
     });
     it('does not touch long flags (--*)', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '--format', 'json'], manifest))
-            .toEqual(['boss', 'detail', '--format', 'json']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '--format', 'json'], manifest))
+            .toEqual(['openreview', 'paper', '--format', 'json']);
     });
     it('does not touch already-escaped --', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '--', '-already-escaped'], manifest))
-            .toEqual(['boss', 'detail', '--', '-already-escaped']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '--', '-already-escaped'], manifest))
+            .toEqual(['openreview', 'paper', '--', '-already-escaped']);
     });
     it('does not touch commands without a required positional', () => {
-        expect(escapeLeadingDashPositional(['boss', 'search', '-something'], manifest))
-            .toEqual(['boss', 'search', '-something']);
+        expect(escapeLeadingDashPositional(['openreview', 'search', '-something'], manifest))
+            .toEqual(['openreview', 'search', '-something']);
         expect(escapeLeadingDashPositional(['twitter', 'lists', '-something'], manifest))
             .toEqual(['twitter', 'lists', '-something']);
     });
     it('works when --profile or another root flag precedes the site', () => {
-        expect(escapeLeadingDashPositional(['--profile', 'work', 'boss', 'detail', '-abc'], manifest))
-            .toEqual(['--profile', 'work', 'boss', 'detail', '--', '-abc']);
+        expect(escapeLeadingDashPositional(['--profile', 'work', 'openreview', 'paper', '-abc'], manifest))
+            .toEqual(['--profile', 'work', 'openreview', 'paper', '--', '-abc']);
     });
-    it('works for any adapter, not just boss', () => {
+    it('works for another adapter with a required positional', () => {
         expect(escapeLeadingDashPositional(['twitter', 'follow', '-someuser'], manifest))
             .toEqual(['twitter', 'follow', '--', '-someuser']);
     });
@@ -298,7 +298,7 @@ describe('escapeLeadingDashPositional', () => {
             .toEqual(['unknown', 'cmd', '-arg']);
     });
     it('returns argv unchanged when argv is too short', () => {
-        expect(escapeLeadingDashPositional(['boss'], manifest)).toEqual(['boss']);
-        expect(escapeLeadingDashPositional(['boss', 'detail'], manifest)).toEqual(['boss', 'detail']);
+        expect(escapeLeadingDashPositional(['openreview'], manifest)).toEqual(['openreview']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper'], manifest)).toEqual(['openreview', 'paper']);
     });
 });

package/dist/src/cli.js

@@ -2980,7 +2980,7 @@ cli({
     adapterCmd
         .command('eject')
         .description('Copy an official adapter to ~/.webcmd/clis/ for local editing')
-        .argument('<site>', 'Site name (e.g. twitter, bilibili)')
+        .argument('<site>', 'Site name (e.g. twitter, youtube)')
         .action(async (site) => {
         const os = await import('node:os');
         const userClisDir = path.join(os.homedir(), '.webcmd', 'clis');
@@ -3009,7 +3009,7 @@ cli({
     adapterCmd
         .command('reset')
         .description('Remove local override and restore official adapter version')
-        .argument('[site]', 'Site name (e.g. twitter, bilibili)')
+        .argument('[site]', 'Site name (e.g. twitter, youtube)')
         .option('--all', 'Reset all local overrides')
         .action(async (site, opts) => {
         const os = await import('node:os');