@jackwener/opencli 1.7.3 → 1.7.5

package/dist/src/cli.test.js

@@ -1,97 +1,22 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
-const { mockExploreUrl, mockRenderExploreSummary, mockGenerateVerifiedFromUrl, mockRenderGenerateVerifiedSummary, mockRecordSession, mockRenderRecordSummary, mockCascadeProbe, mockRenderCascadeResult, mockGetBrowserFactory, mockBrowserSession, } = vi.hoisted(() => ({
-    mockExploreUrl: vi.fn(),
-    mockRenderExploreSummary: vi.fn(),
-    mockGenerateVerifiedFromUrl: vi.fn(),
-    mockRenderGenerateVerifiedSummary: vi.fn(),
-    mockRecordSession: vi.fn(),
-    mockRenderRecordSummary: vi.fn(),
-    mockCascadeProbe: vi.fn(),
-    mockRenderCascadeResult: vi.fn(),
-    mockGetBrowserFactory: vi.fn(() => ({ name: 'BrowserFactory' })),
-    mockBrowserSession: vi.fn(),
+const { mockBrowserConnect, mockBrowserClose, browserState, } = vi.hoisted(() => ({
+    mockBrowserConnect: vi.fn(),
+    mockBrowserClose: vi.fn(),
+    browserState: { page: null },
 }));
-vi.mock('./explore.js', () => ({
-    exploreUrl: mockExploreUrl,
-    renderExploreSummary: mockRenderExploreSummary,
-}));
-vi.mock('./generate-verified.js', () => ({
-    generateVerifiedFromUrl: mockGenerateVerifiedFromUrl,
-    renderGenerateVerifiedSummary: mockRenderGenerateVerifiedSummary,
-}));
-vi.mock('./record.js', () => ({
-    recordSession: mockRecordSession,
-    renderRecordSummary: mockRenderRecordSummary,
-}));
-vi.mock('./cascade.js', () => ({
-    cascadeProbe: mockCascadeProbe,
-    renderCascadeResult: mockRenderCascadeResult,
-}));
-vi.mock('./runtime.js', () => ({
-    getBrowserFactory: mockGetBrowserFactory,
-    browserSession: mockBrowserSession,
-}));
-import { createProgram, findPackageRoot, resolveBrowserVerifyInvocation } from './cli.js';
-describe('built-in browser commands verbose wiring', () => {
-    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-    beforeEach(() => {
-        delete process.env.OPENCLI_VERBOSE;
-        process.exitCode = undefined;
-        mockExploreUrl.mockReset().mockResolvedValue({ ok: true });
-        mockRenderExploreSummary.mockReset().mockReturnValue('explore-summary');
-        mockGenerateVerifiedFromUrl.mockReset().mockResolvedValue({ status: 'success' });
-        mockRenderGenerateVerifiedSummary.mockReset().mockReturnValue('generate-summary');
-        mockRecordSession.mockReset().mockResolvedValue({ candidateCount: 1 });
-        mockRenderRecordSummary.mockReset().mockReturnValue('record-summary');
-        mockCascadeProbe.mockReset().mockResolvedValue({ ok: true });
-        mockRenderCascadeResult.mockReset().mockReturnValue('cascade-summary');
-        mockGetBrowserFactory.mockClear();
-        mockBrowserSession.mockReset().mockImplementation(async (_factory, fn) => {
-            const page = {
-                goto: vi.fn(),
-                wait: vi.fn(),
-            };
-            return fn(page);
-        });
-    });
-    it('enables OPENCLI_VERBOSE for explore via the real CLI command', async () => {
-        const program = createProgram('', '');
-        await program.parseAsync(['node', 'opencli', 'explore', 'https://example.com', '-v']);
-        expect(process.env.OPENCLI_VERBOSE).toBe('1');
-        expect(mockExploreUrl).toHaveBeenCalledWith('https://example.com', expect.objectContaining({ workspace: 'explore:example.com' }));
-    });
-    it('enables OPENCLI_VERBOSE for generate via the real CLI command', async () => {
-        const program = createProgram('', '');
-        await program.parseAsync(['node', 'opencli', 'generate', 'https://example.com', '-v']);
-        expect(process.env.OPENCLI_VERBOSE).toBe('1');
-        expect(mockGenerateVerifiedFromUrl).toHaveBeenCalledWith(expect.objectContaining({ url: 'https://example.com', workspace: 'generate:example.com', noRegister: false }));
-    });
-    it('passes --no-register through the real CLI command', async () => {
-        const program = createProgram('', '');
-        await program.parseAsync(['node', 'opencli', 'generate', 'https://example.com', '--no-register']);
-        expect(mockGenerateVerifiedFromUrl).toHaveBeenCalledWith(expect.objectContaining({ url: 'https://example.com', workspace: 'generate:example.com', noRegister: true }));
-    });
-    it('enables OPENCLI_VERBOSE for record via the real CLI command', async () => {
-        const program = createProgram('', '');
-        await program.parseAsync(['node', 'opencli', 'record', 'https://example.com', '-v']);
-        expect(process.env.OPENCLI_VERBOSE).toBe('1');
-        expect(mockRecordSession).toHaveBeenCalledWith(expect.objectContaining({ url: 'https://example.com' }));
-    });
-    it('enables OPENCLI_VERBOSE for cascade via the real CLI command', async () => {
-        const program = createProgram('', '');
-        await program.parseAsync(['node', 'opencli', 'cascade', 'https://example.com', '-v']);
-        expect(process.env.OPENCLI_VERBOSE).toBe('1');
-        expect(mockBrowserSession).toHaveBeenCalled();
-        expect(mockCascadeProbe).toHaveBeenCalledWith(expect.any(Object), 'https://example.com');
-    });
-    it('leaves OPENCLI_VERBOSE unset when verbose is omitted', async () => {
-        const program = createProgram('', '');
-        await program.parseAsync(['node', 'opencli', 'explore', 'https://example.com']);
-        expect(process.env.OPENCLI_VERBOSE).toBeUndefined();
-    });
-    consoleLogSpy.mockClear();
+vi.mock('./browser/index.js', () => {
+    mockBrowserConnect.mockImplementation(async () => browserState.page);
+    return {
+        BrowserBridge: class {
+            connect = mockBrowserConnect;
+            close = mockBrowserClose;
+        },
+    };
 });
+import { createProgram, findPackageRoot, resolveBrowserVerifyInvocation } from './cli.js';
 describe('resolveBrowserVerifyInvocation', () => {
     it('prefers the built entry declared in package metadata', () => {
         const projectRoot = path.join('repo-root');
@@ -156,6 +81,158 @@ describe('resolveBrowserVerifyInvocation', () => {
         });
     });
 });
+describe('browser tab targeting commands', () => {
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+    const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    function getBrowserStateFile(cacheDir) {
+        return path.join(cacheDir, 'browser-state', 'browser_default.json');
+    }
+    beforeEach(() => {
+        process.exitCode = undefined;
+        process.env.OPENCLI_CACHE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-browser-tab-state-'));
+        consoleLogSpy.mockClear();
+        stderrSpy.mockClear();
+        mockBrowserConnect.mockClear();
+        mockBrowserClose.mockReset().mockResolvedValue(undefined);
+        browserState.page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            setActivePage: vi.fn(),
+            getActivePage: vi.fn().mockReturnValue('tab-1'),
+            getCurrentUrl: vi.fn().mockResolvedValue('https://one.example'),
+            startNetworkCapture: vi.fn().mockResolvedValue(true),
+            evaluate: vi.fn().mockResolvedValue({ ok: true }),
+            tabs: vi.fn().mockResolvedValue([
+                { index: 0, page: 'tab-1', url: 'https://one.example', title: 'one', active: true },
+                { index: 1, page: 'tab-2', url: 'https://two.example', title: 'two', active: false },
+            ]),
+            selectTab: vi.fn().mockResolvedValue(undefined),
+            newTab: vi.fn().mockResolvedValue('tab-3'),
+            closeTab: vi.fn().mockResolvedValue(undefined),
+            frames: vi.fn().mockResolvedValue([
+                { index: 0, frameId: 'frame-1', url: 'https://x.example/embed', name: 'x-embed' },
+            ]),
+            evaluateInFrame: vi.fn().mockResolvedValue('inside frame'),
+            readNetworkCapture: vi.fn().mockResolvedValue([]),
+        };
+    });
+    it('binds browser commands to an explicit target tab via --tab', async () => {
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'eval', '--tab', 'tab-2', 'document.title']);
+        expect(browserState.page?.setActivePage).toHaveBeenCalledWith('tab-2');
+        expect(browserState.page?.evaluate).toHaveBeenCalledWith('document.title');
+    });
+    it('rejects an explicit --tab target that is no longer in the current session', async () => {
+        browserState.page = {
+            setActivePage: vi.fn(),
+            getActivePage: vi.fn(),
+            tabs: vi.fn().mockResolvedValue([]),
+            evaluate: vi.fn(),
+        };
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'eval', '--tab', 'tab-stale', 'document.title']);
+        expect(process.exitCode).toBeDefined();
+        expect(browserState.page?.setActivePage).not.toHaveBeenCalled();
+        expect(browserState.page?.evaluate).not.toHaveBeenCalled();
+        expect(stderrSpy.mock.calls.flat().join('\n')).toContain('Target tab tab-stale is not part of the current browser session');
+    });
+    it('lists tabs with target IDs via browser tab list', async () => {
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'tab', 'list']);
+        expect(browserState.page?.tabs).toHaveBeenCalledTimes(1);
+        expect(consoleLogSpy.mock.calls.flat().join('\n')).toContain('"page": "tab-1"');
+        expect(consoleLogSpy.mock.calls.flat().join('\n')).toContain('"page": "tab-2"');
+    });
+    it('creates a new tab and prints its target ID', async () => {
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'tab', 'new', 'https://three.example']);
+        expect(browserState.page?.newTab).toHaveBeenCalledWith('https://three.example');
+        expect(consoleLogSpy.mock.calls.flat().join('\n')).toContain('"page": "tab-3"');
+    });
+    it('prints the resolved target ID when browser open creates or navigates a tab', async () => {
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'open', 'https://example.com']);
+        expect(browserState.page?.goto).toHaveBeenCalledWith('https://example.com');
+        expect(consoleLogSpy.mock.calls.flat().join('\n')).toContain('"url": "https://one.example"');
+        expect(consoleLogSpy.mock.calls.flat().join('\n')).toContain('"page": "tab-1"');
+    });
+    it('lists cross-origin frames via browser frames', async () => {
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'frames']);
+        expect(browserState.page?.frames).toHaveBeenCalledTimes(1);
+        expect(consoleLogSpy.mock.calls.flat().join('\n')).toContain('"frameId": "frame-1"');
+        expect(consoleLogSpy.mock.calls.flat().join('\n')).toContain('"url": "https://x.example/embed"');
+    });
+    it('routes browser eval --frame through frame-targeted evaluation', async () => {
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'eval', '--frame', '0', 'document.title']);
+        expect(browserState.page?.evaluateInFrame).toHaveBeenCalledWith('document.title', 0);
+        expect(browserState.page?.evaluate).not.toHaveBeenCalled();
+        expect(consoleLogSpy.mock.calls.flat().join('\n')).toContain('inside frame');
+    });
+    it('does not promote a newly created tab to the persisted default target', async () => {
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'tab', 'new', 'https://three.example']);
+        await program.parseAsync(['node', 'opencli', 'browser', 'eval', 'document.title']);
+        expect(browserState.page?.newTab).toHaveBeenCalledWith('https://three.example');
+        expect(browserState.page?.setActivePage).not.toHaveBeenCalled();
+        expect(browserState.page?.evaluate).toHaveBeenCalledWith('document.title');
+    });
+    it('persists an explicitly selected tab as the default target for later untargeted commands', async () => {
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'tab', 'select', 'tab-2']);
+        await program.parseAsync(['node', 'opencli', 'browser', 'eval', 'document.title']);
+        expect(browserState.page?.selectTab).toHaveBeenCalledWith('tab-2');
+        expect(browserState.page?.setActivePage).toHaveBeenCalledWith('tab-2');
+        expect(browserState.page?.evaluate).toHaveBeenCalledWith('document.title');
+        expect(consoleLogSpy.mock.calls.flat().join('\n')).toContain('"selected": "tab-2"');
+    });
+    it('clears a saved default target when it is no longer present in the current session', async () => {
+        const cacheDir = String(process.env.OPENCLI_CACHE_DIR);
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'tab', 'select', 'tab-2']);
+        expect(fs.existsSync(getBrowserStateFile(cacheDir))).toBe(true);
+        browserState.page = {
+            setActivePage: vi.fn(),
+            getActivePage: vi.fn(),
+            tabs: vi.fn().mockResolvedValue([]),
+            evaluate: vi.fn().mockResolvedValue({ ok: true }),
+            readNetworkCapture: vi.fn().mockResolvedValue([]),
+        };
+        await program.parseAsync(['node', 'opencli', 'browser', 'eval', 'document.title']);
+        expect(browserState.page?.setActivePage).not.toHaveBeenCalled();
+        expect(browserState.page?.evaluate).toHaveBeenCalledWith('document.title');
+        expect(fs.existsSync(getBrowserStateFile(cacheDir))).toBe(false);
+    });
+    it('clears the persisted default target when that tab is closed', async () => {
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'tab', 'select', 'tab-2']);
+        await program.parseAsync(['node', 'opencli', 'browser', 'tab', 'close', 'tab-2']);
+        vi.mocked(browserState.page?.setActivePage).mockClear();
+        vi.mocked(browserState.page?.evaluate).mockClear();
+        await program.parseAsync(['node', 'opencli', 'browser', 'eval', 'document.title']);
+        expect(browserState.page?.closeTab).toHaveBeenCalledWith('tab-2');
+        expect(browserState.page?.setActivePage).not.toHaveBeenCalled();
+        expect(browserState.page?.evaluate).toHaveBeenCalledWith('document.title');
+    });
+    it('closes a tab by target ID', async () => {
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'tab', 'close', 'tab-2']);
+        expect(browserState.page?.closeTab).toHaveBeenCalledWith('tab-2');
+        expect(consoleLogSpy.mock.calls.flat().join('\n')).toContain('"closed": "tab-2"');
+    });
+    it('rejects closing a stale tab target ID that is no longer in the current session', async () => {
+        browserState.page = {
+            tabs: vi.fn().mockResolvedValue([]),
+            closeTab: vi.fn(),
+        };
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'browser', 'tab', 'close', 'tab-stale']);
+        expect(process.exitCode).toBeDefined();
+        expect(browserState.page?.closeTab).not.toHaveBeenCalled();
+        expect(stderrSpy.mock.calls.flat().join('\n')).toContain('Target tab tab-stale is not part of the current browser session');
+    });
+});
 describe('findPackageRoot', () => {
     it('walks up from dist/src to the package root', () => {
         const packageRoot = path.join('repo-root');

package/dist/src/commanderAdapter.d.ts

@@ -11,7 +11,6 @@
  */
 import { Command } from 'commander';
 import { type CliCommand } from './registry.js';
-export declare function normalizeArgValue(argType: string | undefined, value: unknown, name: string): unknown;
 /**
  * Register a single CliCommand as a Commander subcommand.
  */

package/dist/src/commanderAdapter.js

@@ -15,22 +15,8 @@ import { fullName, getRegistry } from './registry.js';
 import { formatRegistryHelpText } from './serialization.js';
 import { render as renderOutput } from './output.js';
 import { executeCommand, prepareCommandArgs } from './execution.js';
-import { CliError, EXIT_CODES, ArgumentError, toEnvelope, } from './errors.js';
+import { CliError, EXIT_CODES, toEnvelope, } from './errors.js';
 import { isDiagnosticEnabled } from './diagnostic.js';
-export function normalizeArgValue(argType, value, name) {
-    if (argType !== 'bool' && argType !== 'boolean')
-        return value;
-    if (typeof value === 'boolean')
-        return value;
-    if (value == null || value === '')
-        return false;
-    const normalized = String(value).trim().toLowerCase();
-    if (normalized === 'true')
-        return true;
-    if (normalized === 'false')
-        return false;
-    throw new ArgumentError(`"${name}" must be either "true" or "false".`);
-}
 /**
  * Register a single CliCommand as a Commander subcommand.
  */
@@ -83,7 +69,7 @@ export function registerCommandToProgram(siteCmd, cmd) {
                 const camelName = arg.name.replace(/-([a-z])/g, (_m, ch) => ch.toUpperCase());
                 const v = optionsRecord[arg.name] ?? optionsRecord[camelName];
                 if (v !== undefined)
-                    rawKwargs[arg.name] = normalizeArgValue(arg.type, v, arg.name);
+                    rawKwargs[arg.name] = v;
             }
             const kwargs = prepareCommandArgs(cmd, rawKwargs);
             const verbose = optionsRecord.verbose === true;

package/dist/src/commanderAdapter.test.js

@@ -61,7 +61,7 @@ describe('commanderAdapter arg passing', () => {
         const siteCmd = program.command('paperreview');
         registerCommandToProgram(siteCmd, cmd);
         await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'maybe']);
-        // normalizeArgValue validates bools eagerly; executeCommand should not be reached
+        // prepareCommandArgs validates bools before dispatch; executeCommand should not be reached
         expect(mockExecuteCommand).not.toHaveBeenCalled();
     });
 });

package/dist/src/commands/daemon.d.ts

@@ -1,5 +1,7 @@
 /**
- * CLI command for daemon lifecycle:
- *   opencli daemon stop — graceful shutdown
+ * CLI commands for daemon lifecycle:
+ *   opencli daemon status — show daemon state
+ *   opencli daemon stop   — graceful shutdown
  */
+export declare function daemonStatus(): Promise<void>;
 export declare function daemonStop(): Promise<void>;

package/dist/src/commands/daemon.js

@@ -1,9 +1,29 @@
 /**
- * CLI command for daemon lifecycle:
- *   opencli daemon stop — graceful shutdown
+ * CLI commands for daemon lifecycle:
+ *   opencli daemon status — show daemon state
+ *   opencli daemon stop   — graceful shutdown
  */
+import { styleText } from 'node:util';
 import { fetchDaemonStatus, requestDaemonShutdown } from '../browser/daemon-client.js';
+import { formatDuration } from '../download/progress.js';
 import { log } from '../logger.js';
+export async function daemonStatus() {
+    const status = await fetchDaemonStatus();
+    if (!status) {
+        console.log(`Daemon: ${styleText('dim', 'not running')}`);
+        return;
+    }
+    const extensionLabel = !status.extensionConnected
+        ? styleText('yellow', 'disconnected')
+        : status.extensionVersion
+            ? `${styleText('green', 'connected')} ${styleText('dim', `(v${status.extensionVersion})`)}`
+            : `${styleText('yellow', 'connected')} ${styleText('dim', '(version unknown)')}`;
+    console.log(`Daemon: ${styleText('green', 'running')} (PID ${status.pid})`);
+    console.log(`Uptime: ${formatDuration(Math.round(status.uptime * 1000))}`);
+    console.log(`Extension: ${extensionLabel}`);
+    console.log(`Memory: ${status.memoryMB} MB`);
+    console.log(`Port: ${status.port}`);
+}
 export async function daemonStop() {
     const status = await fetchDaemonStatus();
     if (!status) {

package/dist/src/commands/daemon.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 const { fetchDaemonStatusMock, requestDaemonShutdownMock, } = vi.hoisted(() => ({
     fetchDaemonStatusMock: vi.fn(),
     requestDaemonShutdownMock: vi.fn(),
@@ -7,7 +7,70 @@ vi.mock('../browser/daemon-client.js', () => ({
     fetchDaemonStatus: fetchDaemonStatusMock,
     requestDaemonShutdown: requestDaemonShutdownMock,
 }));
-import { daemonStop } from './daemon.js';
+import { daemonStatus, daemonStop } from './daemon.js';
+describe('daemonStatus', () => {
+    let stdoutSpy;
+    beforeEach(() => {
+        stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        fetchDaemonStatusMock.mockReset();
+        requestDaemonShutdownMock.mockReset();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('reports "not running" when daemon is unreachable', async () => {
+        fetchDaemonStatusMock.mockResolvedValue(null);
+        await daemonStatus();
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
+    });
+    it('shows daemon info when running', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 12345,
+            uptime: 3661,
+            extensionConnected: true,
+            extensionVersion: '1.6.8',
+            pending: 0,
+            memoryMB: 64,
+            port: 19825,
+        });
+        await daemonStatus();
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('running'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('PID 12345'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('1h 1m'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('connected'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('v1.6.8'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('64 MB'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('19825'));
+    });
+    it('shows disconnected when extension is not connected', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 99,
+            uptime: 120,
+            extensionConnected: false,
+            pending: 0,
+            memoryMB: 32,
+            port: 19825,
+        });
+        await daemonStatus();
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('disconnected'));
+    });
+    it('shows version unknown when the connected extension does not report one', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 99,
+            uptime: 120,
+            extensionConnected: true,
+            extensionVersion: undefined,
+            pending: 0,
+            memoryMB: 32,
+            port: 19825,
+        });
+        await daemonStatus();
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('version unknown'));
+    });
+});
 describe('daemonStop', () => {
     let stderrSpy;
     beforeEach(() => {

package/dist/src/completion-shared.js

@@ -11,11 +11,8 @@ export const BUILTIN_COMMANDS = [
     'list',
     'validate',
     'verify',
-    'explore',
-    'probe', // alias for explore
-    'synthesize',
-    'generate',
-    'cascade',
+    'browser',
+    'tab',
     'doctor',
     'plugin',
     'install',

package/dist/src/daemon.js

@@ -23,6 +23,7 @@ import { WebSocketServer, WebSocket } from 'ws';
 import { DEFAULT_DAEMON_PORT } from './constants.js';
 import { EXIT_CODES } from './errors.js';
 import { log } from './logger.js';
+import { PKG_VERSION } from './version.js';
 const PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 // ─── State ───────────────────────────────────────────────────────────
 let extensionWs = null;
@@ -110,6 +111,7 @@ async function handleRequest(req, res) {
             ok: true,
             pid: process.pid,
             uptime,
+            daemonVersion: PKG_VERSION,
             extensionConnected: extensionWs?.readyState === WebSocket.OPEN,
             extensionVersion,
             extensionCompatRange,
@@ -152,6 +154,14 @@ async function handleRequest(req, res) {
             const timeoutMs = typeof body.timeout === 'number' && body.timeout > 0
                 ? body.timeout * 1000
                 : 120000;
+            if (pending.has(body.id)) {
+                jsonResponse(res, 409, {
+                    id: body.id,
+                    ok: false,
+                    error: 'Duplicate command id already pending; retry',
+                });
+                return;
+            }
             const result = await new Promise((resolve, reject) => {
                 const timer = setTimeout(() => {
                     pending.delete(body.id);

package/dist/src/doctor.d.ts

@@ -18,6 +18,7 @@ export type DoctorReport = {
     cliVersion?: string;
     daemonRunning: boolean;
     daemonFlaky?: boolean;
+    daemonVersion?: string;
     extensionConnected: boolean;
     extensionFlaky?: boolean;
     extensionVersion?: string;

package/dist/src/doctor.js

@@ -87,6 +87,7 @@ export async function runBrowserDoctor(opts = {}) {
     const sessions = opts.sessions && health.state === 'ready'
         ? await listSessions()
         : undefined;
+    const extensionVersion = health.status?.extensionVersion;
     const issues = [];
     if (daemonFlaky) {
         issues.push('Daemon connectivity is unstable. The live browser test succeeded, but the daemon was no longer running immediately afterward.\n' +
@@ -100,16 +101,33 @@ export async function runBrowserDoctor(opts = {}) {
             'This usually means the Browser Bridge service worker is reconnecting slowly or Chrome suspended it.');
     }
     else if (daemonRunning && !extensionConnected) {
-        issues.push('Daemon is running but the Chrome/Chromium extension is not connected.\n' +
-            'Please install the opencli Browser Bridge extension:\n' +
-            '  1. Download from https://github.com/jackwener/opencli/releases\n' +
-            '  2. Open chrome://extensions/ → Enable Developer Mode\n' +
-            '  3. Click "Load unpacked" → select the extension folder');
+        const daemonVersion = health.status?.daemonVersion;
+        const isStale = opts.cliVersion && (!daemonVersion || daemonVersion !== opts.cliVersion);
+        if (isStale) {
+            const reason = daemonVersion
+                ? `daemon v${daemonVersion} ≠ CLI v${opts.cliVersion}`
+                : `daemon predates version reporting, CLI is v${opts.cliVersion}`;
+            issues.push(`Stale daemon detected: ${reason}.\n` +
+                'The daemon was started by an older CLI version and may have missed the extension registration.\n' +
+                '  Quick fix: opencli daemon stop && opencli doctor');
+        }
+        else {
+            issues.push('Daemon is running but the Chrome/Chromium extension is not connected.\n' +
+                'If the extension is already installed, try: opencli daemon stop && opencli doctor\n' +
+                'If the extension is not installed:\n' +
+                '  1. Download from https://github.com/jackwener/opencli/releases\n' +
+                '  2. Open chrome://extensions/ → Enable Developer Mode\n' +
+                '  3. Click "Load unpacked" → select the extension folder');
+        }
+    }
+    if (extensionConnected && !extensionVersion) {
+        issues.push('Extension is connected but did not report a version.\n' +
+            '  This usually means an outdated Browser Bridge extension.\n' +
+            '  Reload or reinstall the extension from: https://github.com/jackwener/opencli/releases');
     }
     if (connectivity && !connectivity.ok) {
         issues.push(`Browser connectivity test failed: ${connectivity.error ?? 'unknown'}`);
     }
-    const extensionVersion = health.status?.extensionVersion;
     const extensionCompatRange = health.status?.extensionCompatRange;
     if (extensionVersion && opts.cliVersion && extensionCompatRange) {
         if (!satisfiesRange(opts.cliVersion, extensionCompatRange)) {
@@ -137,6 +155,7 @@ export async function runBrowserDoctor(opts = {}) {
         cliVersion: opts.cliVersion,
         daemonRunning,
         daemonFlaky,
+        daemonVersion: health.status?.daemonVersion,
         extensionConnected,
         extensionFlaky,
         extensionVersion,
@@ -154,16 +173,20 @@ export function renderBrowserDoctorReport(report) {
         : report.daemonRunning ? styleText('green', '[OK]') : styleText('red', '[MISSING]');
     const daemonLabel = report.daemonFlaky
         ? 'unstable (running during live check, then stopped)'
-        : report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` : 'not running';
+        : report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` + (report.daemonVersion ? ` (v${report.daemonVersion})` : '') : 'not running';
     lines.push(`${daemonIcon} Daemon: ${daemonLabel}`);
     // Extension status
-    const extIcon = report.extensionFlaky
+    const extIcon = report.extensionFlaky || (report.extensionConnected && !report.extensionVersion)
         ? styleText('yellow', '[WARN]')
         : report.extensionConnected ? styleText('green', '[OK]') : styleText('yellow', '[MISSING]');
     const extUpdateHint = report.extensionVersion && report.latestExtensionVersion && isNewerVersion(report.latestExtensionVersion, report.extensionVersion)
         ? styleText('yellow', ` → v${report.latestExtensionVersion} available`)
         : '';
-    const extVersion = report.extensionVersion ? styleText('dim', ` (v${report.extensionVersion})`) + extUpdateHint : '';
+    const extVersion = !report.extensionConnected
+        ? ''
+        : report.extensionVersion
+            ? styleText('dim', ` (v${report.extensionVersion})`) + extUpdateHint
+            : styleText('dim', ' (version unknown)');
     const extLabel = report.extensionFlaky
         ? 'unstable (connected during live check, then disconnected)'
         : report.extensionConnected ? 'connected' : 'not connected';