@jackwener/opencli 1.7.19 → 1.7.21

package/clis/twitter/trending.js

@@ -17,7 +17,6 @@ cli({
     domain: 'x.com',
     strategy: Strategy.COOKIE,
     browser: true,
-    siteSession: 'persistent',
     args: [
         { name: 'limit', type: 'int', default: 20, help: 'Number of trends to show' },
     ],

package/clis/twitter/tweets.js

@@ -221,7 +221,6 @@ cli({
     domain: 'x.com',
     strategy: Strategy.COOKIE,
     browser: true,
-    siteSession: 'persistent',
     args: [
         { name: 'username', type: 'string', positional: true, help: 'Twitter screen name (with or without @). Defaults to the logged-in user when omitted.' },
         { name: 'limit', type: 'int', default: 20, help: 'Max tweets to return' },

package/clis/xiaohongshu/search.js

@@ -6,7 +6,7 @@
  * Ref: https://github.com/jackwener/opencli/issues/10
  */
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { ArgumentError, AuthRequiredError } from '@jackwener/opencli/errors';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 /**
  * Wait for search results or login wall using MutationObserver (max 5s).
  * Returns 'content' if note items appeared, 'login_wall' if login gate
@@ -60,6 +60,26 @@ export function stripXhsAuthorDateSuffix(value) {
     const stripped = text.replace(/\s*(?:\d{1,2}天前|\d+小时前|\d+分钟前|\d+秒前|刚刚|昨天|前天|\d+周前|\d+个月前|\d{1,2}-\d{1,2}|\d{4}-\d{1,2}-\d{1,2})$/u, '').trim();
     return stripped || text;
 }
+/**
+ * `page.evaluate` may return either the raw IIFE value or a
+ * `{ session, data }` envelope depending on the browser-bridge version.
+ * Adapter code that called `Array.isArray(payload)` directly on the
+ * envelope silently received [] for every search. This helper normalizes
+ * both shapes so callers can keep their Array.isArray checks unchanged.
+ */
+export function unwrapEvaluateResult(payload) {
+    if (payload && !Array.isArray(payload) && typeof payload === 'object' && 'session' in payload && 'data' in payload) {
+        return payload.data;
+    }
+    return payload;
+}
+function requireSearchRows(payload, phase) {
+    const rows = unwrapEvaluateResult(payload);
+    if (!Array.isArray(rows)) {
+        throw new CommandExecutionError(`Unexpected Xiaohongshu search ${phase} payload shape; expected an array of rows.`);
+    }
+    return rows;
+}
 export function parseLimit(raw) {
     const parsed = Number(raw ?? 20);
     if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
@@ -267,7 +287,7 @@ export const command = cli({
         // Wait for search results to render (or login wall to appear).
         // Uses MutationObserver to resolve as soon as content appears,
         // instead of a fixed delay + blind retry.
-        const waitResult = await page.evaluate(WAIT_FOR_CONTENT_JS);
+        const waitResult = unwrapEvaluateResult(await page.evaluate(WAIT_FOR_CONTENT_JS));
         if (waitResult === 'login_wall') {
             throw new AuthRequiredError('www.xiaohongshu.com', 'Xiaohongshu search results are blocked behind a login wall');
         }
@@ -275,25 +295,23 @@ export const command = cli({
         // layout, so scrolling to the bottom can evict the initially visible
         // note cards from the DOM and make extraction return [] even though the
         // browser rendered results correctly.
-        const initialPayload = await page.evaluate(buildSearchExtractJs('www.xiaohongshu.com'));
-        let payload = Array.isArray(initialPayload) ? initialPayload : [];
+        const initialPayload = requireSearchRows(await page.evaluate(buildSearchExtractJs('www.xiaohongshu.com')), 'initial extraction');
+        const payload = [...initialPayload];
         if (payload.length < limit) {
             // Scroll until enough rows are rendered or the lazy-load plateaus.
             // Replaces the previous fixed `autoScroll({ times: 2 })` which capped
             // extraction at ~13 notes regardless of `--limit` (#1471).
             await page.evaluate(buildScrollUntilJs(limit));
-            const scrolledPayload = await page.evaluate(buildSearchExtractJs('www.xiaohongshu.com'));
-            if (Array.isArray(scrolledPayload)) {
-                const seen = new Set(payload.map((item) => item.url).filter(Boolean));
-                for (const item of scrolledPayload) {
-                    if (item?.url && seen.has(item.url))
-                        continue;
-                    if (item?.url)
-                        seen.add(item.url);
-                    payload.push(item);
-                    if (payload.length >= limit)
-                        break;
-                }
+            const scrolledPayload = requireSearchRows(await page.evaluate(buildSearchExtractJs('www.xiaohongshu.com')), 'post-scroll extraction');
+            const seen = new Set(payload.map((item) => item.url).filter(Boolean));
+            for (const item of scrolledPayload) {
+                if (item?.url && seen.has(item.url))
+                    continue;
+                if (item?.url)
+                    seen.add(item.url);
+                payload.push(item);
+                if (payload.length >= limit)
+                    break;
             }
         }
         const data = payload;

package/clis/xiaohongshu/search.test.js

@@ -1,7 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
 import { JSDOM } from 'jsdom';
-import { __test__, buildScrollUntilJs, noteIdToDate } from './search.js';
+import { __test__, buildScrollUntilJs, noteIdToDate, unwrapEvaluateResult } from './search.js';
 
 function markVisible(el) {
     el.getBoundingClientRect = () => ({ width: 100, height: 100 });
@@ -57,24 +57,37 @@ describe('xiaohongshu search', () => {
         expect(page.evaluate).toHaveBeenCalledTimes(1);
         expect(page.autoScroll).not.toHaveBeenCalled();
     });
+    it('unwraps a browser-bridge envelope before handling login-wall wait result', async () => {
+        const cmd = getRegistry().get('xiaohongshu/search');
+        const page = createPageMock([
+            { session: 'site:xiaohongshu', data: 'login_wall' },
+        ]);
+
+        await expect(cmd.func(page, { query: '特斯拉', limit: 5 })).rejects.toMatchObject({
+            code: 'AUTH_REQUIRED',
+            message: expect.stringContaining('blocked behind a login wall'),
+        });
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+    });
     it('returns ranked results with search_result url and author_url preserved', async () => {
         const cmd = getRegistry().get('xiaohongshu/search');
         expect(cmd?.func).toBeTypeOf('function');
         const detailUrl = 'https://www.xiaohongshu.com/search_result/68e90be80000000004022e66?xsec_token=test-token&xsec_source=';
         const authorUrl = 'https://www.xiaohongshu.com/user/profile/635a9c720000000018028b40?xsec_token=user-token&xsec_source=pc_search';
+        const rows = [
+            {
+                title: '某鱼买FSD被坑了4万',
+                author: '随风',
+                likes: '261',
+                url: detailUrl,
+                author_url: authorUrl,
+            },
+        ];
         const page = createPageMock([
             // First evaluate: MutationObserver wait (content appeared)
             'content',
-            // Second evaluate: initial DOM extraction (already enough results)
-            [
-                {
-                    title: '某鱼买FSD被坑了4万',
-                    author: '随风',
-                    likes: '261',
-                    url: detailUrl,
-                    author_url: authorUrl,
-                },
-            ],
+            // Second evaluate: initial DOM extraction (already enough results) through Browser Bridge envelope.
+            { session: 'site:xiaohongshu', data: rows },
         ]);
         const result = await cmd.func(page, { query: '特斯拉', limit: 1 });
         // Should only do one goto (the search page itself), no per-note detail navigation
@@ -91,6 +104,18 @@ describe('xiaohongshu search', () => {
             },
         ]);
     });
+    it('fails typed instead of silently returning [] for malformed extraction payloads', async () => {
+        const cmd = getRegistry().get('xiaohongshu/search');
+        const page = createPageMock([
+            'content',
+            { session: 'site:xiaohongshu', data: { rows: [] } },
+        ]);
+
+        await expect(cmd.func(page, { query: '测试', limit: 1 })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('payload shape'),
+        });
+    });
     it('filters out results with no title and respects the limit', async () => {
         const cmd = getRegistry().get('xiaohongshu/search');
         expect(cmd?.func).toBeTypeOf('function');
@@ -135,6 +160,10 @@ describe('xiaohongshu search', () => {
             'content',
             // Second evaluate: initial extraction (no rows rendered)
             [],
+            // Third evaluate: scroll-until row count
+            0,
+            // Fourth evaluate: post-scroll extraction (still no rows)
+            [],
         ]);
         const result = (await cmd.func(page, { query: '测试等待', limit: 5 }));
         expect(result).toHaveLength(0);
@@ -268,3 +297,29 @@ describe('noteIdToDate (ObjectID timestamp parsing)', () => {
         expect(noteIdToDate('https://www.xiaohongshu.com/search_result/000000000000000000000000')).toBe('');
     });
 });
+describe('unwrapEvaluateResult (browser-bridge envelope normalization)', () => {
+    it('returns the raw array unchanged when payload is already an array', () => {
+        const arr = [{ title: 'a' }, { title: 'b' }];
+        expect(unwrapEvaluateResult(arr)).toBe(arr);
+    });
+    it('unwraps { session, data: [...] } envelope to the inner array', () => {
+        const arr = [{ title: 'a' }];
+        const env = { session: 'site:xiaohongshu:abc', data: arr };
+        expect(unwrapEvaluateResult(env)).toBe(arr);
+    });
+    it('unwraps primitive data from Browser Bridge envelopes', () => {
+        expect(unwrapEvaluateResult({ session: 'site:xiaohongshu:abc', data: 'login_wall' })).toBe('login_wall');
+    });
+    it('passes non-envelope objects through unchanged', () => {
+        const obj = { results: [], loginWall: true };
+        expect(unwrapEvaluateResult(obj)).toBe(obj);
+    });
+    it('handles null and undefined safely', () => {
+        expect(unwrapEvaluateResult(null)).toBe(null);
+        expect(unwrapEvaluateResult(undefined)).toBe(undefined);
+    });
+    it('unwraps non-array envelope data so callers can validate the payload shape', () => {
+        const env = { session: 'x', data: { not: 'an array' } };
+        expect(unwrapEvaluateResult(env)).toEqual({ not: 'an array' });
+    });
+});

package/clis/yahoo/search.js

@@ -0,0 +1,92 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+  emptySearchResults,
+  requireBoundedInteger,
+  requireRows,
+  requireSearchQuery,
+  runBrowserStep,
+  toHttpsUrl,
+} from '../_shared/search-adapter.js';
+
+function decodeYahooUrl(href) {
+  if (!href) return '';
+  if (href.indexOf('RU=') !== -1 && href.indexOf('/RK=') !== -1) {
+    var match = href.match(/RU=([^/]+)\/RK=/);
+    if (match && match[1]) {
+      try {
+        return toHttpsUrl(decodeURIComponent(match[1]), 'https://search.yahoo.com');
+      } catch {
+        return toHttpsUrl(href, 'https://search.yahoo.com');
+      }
+    }
+  }
+  return toHttpsUrl(href, 'https://search.yahoo.com');
+}
+
+function buildExtractorJs(limit) {
+  return `
+(function() {
+  var results = [];
+  var seen = {};
+  var items = document.querySelectorAll('.algo');
+  for (var i = 0; i < items.length; i++) {
+    if (results.length >= ${limit}) break;
+    var el = items[i];
+    var h3 = el.querySelector('h3');
+    var linkEl = el.querySelector('.compTitle a');
+    var snippetEl = el.querySelector('.compText');
+    if (!h3 || !linkEl) continue;
+    var title = h3.textContent.trim();
+    var href = linkEl.getAttribute('href') || '';
+    var snippet = snippetEl ? snippetEl.textContent.trim() : '';
+    if (!title || !href || seen[href]) continue;
+    seen[href] = true;
+    results.push([title, href, snippet]);
+  }
+  return results;
+})()`;
+}
+
+const command = cli({
+  site: 'yahoo',
+  name: 'search',
+  access: 'read',
+  description: 'Search Yahoo (powered by Bing)',
+  domain: 'search.yahoo.com',
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [
+    { name: 'keyword', positional: true, required: true, help: 'Search query' },
+    { name: 'limit', type: 'int', default: 7, help: 'Number of results per page (max 7)' },
+    { name: 'page', type: 'int', default: 1, help: 'Page number (1, 2, 3...). Yahoo returns ~7 results per page' },
+  ],
+  columns: ['rank', 'title', 'url', 'snippet'],
+  func: async (page, kwargs) => {
+    const limit = requireBoundedInteger(kwargs.limit, 7, 1, 7, '--limit');
+    const query = requireSearchQuery(kwargs.keyword);
+    const keyword = encodeURIComponent(query);
+    const pageNum = requireBoundedInteger(kwargs.page, 1, 1, 100, '--page');
+    var url = `https://search.yahoo.com/search?p=${keyword}`;
+    if (pageNum > 1) url += `&b=${(pageNum - 1) * 7 + 1}`;
+    await runBrowserStep('yahoo search navigation', () => page.goto(url));
+    try {
+      await page.wait({ selector: '.algo', timeout: 10 });
+    } catch {
+      await page.wait(3).catch(function() {});
+    }
+    const raw = await runBrowserStep('yahoo search extraction', () => page.evaluate(buildExtractorJs(limit)));
+    const results = requireRows(raw, 'yahoo search');
+    if (results.length === 0) {
+      throw emptySearchResults('Yahoo', query);
+    }
+    const rows = results
+      .map(function(r, index) {
+        return { rank: index + 1 + (pageNum - 1) * 7, title: r[0], url: decodeYahooUrl(r[1]), snippet: r[2] };
+      })
+      .filter((row) => row.url);
+    if (rows.length === 0) throw emptySearchResults('Yahoo', query);
+    return rows;
+  },
+});
+
+export const __test__ = { command };

package/clis/yahoo/search.test.js

@@ -0,0 +1,94 @@
+import { describe, it, expect, vi } from 'vitest';
+
+const { __test__ } = await import('./search.js');
+const command = __test__.command;
+
+function createPageMock(evaluateResult = []) {
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue(evaluateResult),
+  };
+}
+
+describe('yahoo search', () => {
+  it('should register as a valid command', () => {
+    expect(command).toBeDefined();
+    expect(command.site).toBe('yahoo');
+    expect(command.name).toBe('search');
+    expect(command.access).toBe('read');
+    expect(command.browser).toBe(true);
+    expect(command.strategy).toBe('public');
+    expect(command.domain).toBe('search.yahoo.com');
+  });
+
+  it('should define keyword positional arg', () => {
+    const kwArg = command.args.find(a => a.name === 'keyword');
+    expect(kwArg).toBeDefined();
+    expect(kwArg.positional).toBe(true);
+    expect(kwArg.required).toBe(true);
+  });
+
+  it('should define limit arg with default 7', () => {
+    const limitArg = command.args.find(a => a.name === 'limit');
+    expect(limitArg).toBeDefined();
+    expect(limitArg.type).toBe('int');
+    expect(limitArg.default).toBe(7);
+  });
+
+  it('should define output columns', () => {
+    expect(command.columns).toContain('rank');
+    expect(command.columns).toContain('title');
+    expect(command.columns).toContain('url');
+    expect(command.columns).toContain('snippet');
+  });
+
+  it('rejects empty query, invalid limit, and invalid page before navigation', async () => {
+    const page = createPageMock();
+    await expect(command.func(page, { keyword: ' ', limit: 5 })).rejects.toMatchObject({ code: 'ARGUMENT' });
+    await expect(command.func(page, { keyword: 'opencli', limit: 8 })).rejects.toMatchObject({ code: 'ARGUMENT' });
+    await expect(command.func(page, { keyword: 'opencli', limit: 5, page: 0 })).rejects.toMatchObject({ code: 'ARGUMENT' });
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it('decodes Yahoo redirect URLs and assigns listing rank', async () => {
+    const page = createPageMock({
+      session: 'site:yahoo',
+      data: [[
+        'OpenCLI',
+        'https://r.search.yahoo.com/_ylt=x/RU=https%3A%2F%2Fgithub.com%2Fjackwener%2FOpenCLI/RK=2/RS=x',
+        'CLI browser tooling',
+      ]],
+    });
+
+    await expect(command.func(page, { keyword: 'opencli', limit: 1, page: 2 })).resolves.toEqual([{
+      rank: 8,
+      title: 'OpenCLI',
+      url: 'https://github.com/jackwener/OpenCLI',
+      snippet: 'CLI browser tooling',
+    }]);
+  });
+
+  it('drops decoded Yahoo redirect targets that are not http(s) URLs', async () => {
+    const page = createPageMock([
+      [
+        'Bad redirect',
+        'https://r.search.yahoo.com/_ylt=x/RU=javascript%3Aalert(1)/RK=2/RS=x',
+        'should not be emitted',
+      ],
+    ]);
+
+    await expect(command.func(page, { keyword: 'opencli', limit: 1 })).rejects.toMatchObject({
+      code: 'EMPTY_RESULT',
+    });
+  });
+
+  it('fails typed instead of silently returning [] for malformed extraction payloads', async () => {
+    const page = createPageMock({ rows: [] });
+
+    await expect(command.func(page, { keyword: 'opencli', limit: 1 })).rejects.toMatchObject({
+      code: 'COMMAND_EXEC',
+      message: expect.stringContaining('payload shape'),
+    });
+  });
+});

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

@@ -73,6 +73,7 @@ export interface DaemonStatus {
     profileDisconnected?: boolean;
     profiles?: BrowserProfileStatus[];
     pending: number;
+    commandResultUnknown?: number;
     memoryMB: number;
     port: number;
 }

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

@@ -105,6 +105,9 @@ async function sendCommandRaw(action, params) {
             });
             const result = (await res.json());
             if (!result.ok) {
+                if (result.errorCode === 'command_result_unknown') {
+                    throw new BrowserCommandError(result.error ?? 'Browser command result is unknown', result.errorCode, result.errorHint);
+                }
                 const isDuplicateCommandId = res.status === 409
                     || (result.error ?? '').includes('Duplicate command id');
                 if (isDuplicateCommandId && attempt < maxRetries) {

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

@@ -176,4 +176,24 @@ describe('daemon-client', () => {
         });
         expect(ids[0]).not.toBe(ids[1]);
     });
+    it('sendCommand does not retry command_result_unknown even when the message looks transient', async () => {
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({
+            ok: false,
+            status: 503,
+            json: () => Promise.resolve({
+                id: 'server',
+                ok: false,
+                errorCode: 'command_result_unknown',
+                error: 'Extension disconnected after command timeout',
+                errorHint: 'Inspect state before retrying.',
+            }),
+        });
+        await expect(sendCommand('exec', { code: 'window.__mutate = true' })).rejects.toMatchObject({
+            name: 'BrowserCommandError',
+            code: 'command_result_unknown',
+            hint: 'Inspect state before retrying.',
+        });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
 });

package/dist/src/cli.js

@@ -15,7 +15,7 @@ import { serializeCommand, formatArgSummary } from './serialization.js';
 import { render as renderOutput } from './output.js';
 import { PKG_VERSION } from './version.js';
 import { printCompletionScript } from './completion.js';
-import { loadExternalClis, executeExternalCli, installExternalCli, registerExternalCli, isBinaryInstalled } from './external.js';
+import { loadExternalClis, executeExternalCli, installExternalCli, registerExternalCli, isBinaryInstalled, formatExternalCliLabel } from './external.js';
 import { registerAllCommands } from './commanderAdapter.js';
 import { classifyAdapter, formatRootAdapterHelpText, installCommanderNamespaceStructuredHelp, installStructuredHelp, leadingPositionalFromUsage, rootHelpData } from './help.js';
 import { EXIT_CODES, getErrorMessage, BrowserConnectError } from './errors.js';
@@ -3005,6 +3005,7 @@ cli({
         .action((opts) => {
         const rows = loadExternalClis().map((ext) => ({
             name: ext.name,
+            package: ext.package ?? '',
             binary: ext.binary,
             installed: isBinaryInstalled(ext.binary),
             description: ext.description ?? '',
@@ -3013,7 +3014,7 @@ cli({
         }));
         renderOutput(rows, {
             fmt: opts.format,
-            columns: ['name', 'binary', 'installed', 'description', 'homepage', 'tags'],
+            columns: ['name', 'package', 'binary', 'installed', 'description', 'homepage', 'tags'],
             title: 'opencli/external/list',
             source: 'opencli external list',
         });
@@ -3067,6 +3068,10 @@ cli({
     // Classification derives from each adapter's `domain` field — see classifyAdapter.
     // External CLIs are taken from the externalClis registry (passthrough binaries).
     const externalNames = externalClis.map(ext => ext.name);
+    const externalHelpEntries = externalClis.map(ext => ({
+        name: ext.name,
+        label: formatExternalCliLabel(ext),
+    }));
     const siteDomains = new Map();
     for (const [, cmd] of getRegistry()) {
         if (!siteDomains.has(cmd.site))
@@ -3080,7 +3085,7 @@ cli({
         else
             sites.push(site);
     }
-    const adapterGroups = { external: externalNames, apps, sites };
+    const adapterGroups = { external: externalHelpEntries, apps, sites };
     const adapterNameSet = new Set([...externalNames, ...siteNames]);
     installCommanderNamespaceStructuredHelp(browser, { globalCommand: program, description: originalBrowserDescription });
     installCommanderNamespaceStructuredHelp(daemonCmd, { globalCommand: program, description: originalDaemonDescription });

package/dist/src/cli.test.js

@@ -168,6 +168,7 @@ describe('createProgram root help descriptions', () => {
             expect(data.site_adapters.sites).toEqual(['bilibili']);
             expect(data.external_clis.count).toBeGreaterThanOrEqual(0);
             expect(Array.isArray(data.external_clis.clis)).toBe(true);
+            expect(Array.isArray(data.external_clis.display)).toBe(true);
             // Adapters must NOT leak into the core commands list
             const commandNames = data.commands.map((cmd) => cmd.name);
             expect(commandNames).not.toContain('bilibili');

package/dist/src/daemon-utils.d.ts

@@ -0,0 +1,18 @@
+export declare const COMMAND_RESULT_UNKNOWN_CODE = "command_result_unknown";
+export declare const COMMAND_RESULT_UNKNOWN_HINT = "Inspect the browser/session state before retrying. Do not blindly retry write commands such as navigate, click, type, or eval.";
+export declare const PROFILE_DISCONNECTED_HINT = "Open that Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.";
+export type DaemonFailureContract = {
+    message: string;
+    errorCode: string;
+    errorHint: string;
+    status: number;
+    countAsCommandResultUnknown: boolean;
+};
+export declare function commandResultUnknownMessage(action: string): string;
+export declare function buildExtensionDisconnectFailure(input: {
+    contextId: string;
+    action: string;
+    dispatched: boolean;
+}): DaemonFailureContract;
+export declare function buildCommandDispatchFailure(contextId: string): DaemonFailureContract;
+export declare function getResponseCorsHeaders(pathname: string, origin?: string): Record<string, string> | undefined;

package/dist/src/daemon-utils.js

@@ -0,0 +1,37 @@
+export const COMMAND_RESULT_UNKNOWN_CODE = 'command_result_unknown';
+export const COMMAND_RESULT_UNKNOWN_HINT = 'Inspect the browser/session state before retrying. Do not blindly retry write commands such as navigate, click, type, or eval.';
+export const PROFILE_DISCONNECTED_HINT = 'Open that Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.';
+export function commandResultUnknownMessage(action) {
+    return `Browser connection dropped after the ${action} command was dispatched; it may have completed.`;
+}
+export function buildExtensionDisconnectFailure(input) {
+    if (input.dispatched) {
+        return {
+            message: commandResultUnknownMessage(input.action),
+            errorCode: COMMAND_RESULT_UNKNOWN_CODE,
+            errorHint: COMMAND_RESULT_UNKNOWN_HINT,
+            status: 503,
+            countAsCommandResultUnknown: true,
+        };
+    }
+    return buildCommandDispatchFailure(input.contextId);
+}
+export function buildCommandDispatchFailure(contextId) {
+    return {
+        message: `Browser profile "${contextId}" disconnected before command dispatch`,
+        errorCode: 'profile_disconnected',
+        errorHint: PROFILE_DISCONNECTED_HINT,
+        status: 503,
+        countAsCommandResultUnknown: false,
+    };
+}
+export function getResponseCorsHeaders(pathname, origin) {
+    if (pathname !== '/ping')
+        return undefined;
+    if (!origin || !origin.startsWith('chrome-extension://'))
+        return undefined;
+    return {
+        'Access-Control-Allow-Origin': origin,
+        Vary: 'Origin',
+    };
+}

package/dist/src/daemon.d.ts

@@ -19,4 +19,4 @@
  *   - Persistent — stays alive until explicit shutdown, SIGTERM, or uninstall
  *   - Listens on localhost:19825
  */
-export declare function getResponseCorsHeaders(pathname: string, origin?: string): Record<string, string> | undefined;
+export {};

package/dist/src/daemon.js

@@ -27,9 +27,11 @@ import { log } from './logger.js';
 import { PKG_VERSION } from './version.js';
 import { DEFAULT_CONTEXT_ID } from './browser/profile.js';
 import { recordExtensionVersion } from './update-check.js';
+import { buildCommandDispatchFailure, buildExtensionDisconnectFailure, getResponseCorsHeaders, } from './daemon-utils.js';
 const PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 const extensionProfiles = new Map();
 const pending = new Map();
+let commandResultUnknownCount = 0;
 const LOG_BUFFER_SIZE = 200;
 const logBuffer = [];
 class DaemonCommandFailure extends Error {
@@ -110,7 +112,16 @@ function unregisterExtensionConnection(ws) {
             if (p.contextId !== contextId)
                 continue;
             clearTimeout(p.timer);
-            p.reject(new DaemonCommandFailure(`Browser profile "${contextId}" disconnected`, 'profile_disconnected', 'Open that Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.', 503));
+            const failure = buildExtensionDisconnectFailure({
+                contextId,
+                action: p.action,
+                dispatched: p.dispatched,
+            });
+            if (failure.countAsCommandResultUnknown) {
+                commandResultUnknownCount++;
+                log.warn(`[daemon] Command result unknown after extension disconnect (id=${id}, action=${p.action}, context=${contextId})`);
+            }
+            p.reject(new DaemonCommandFailure(failure.message, failure.errorCode, failure.errorHint, failure.status));
             pending.delete(id);
         }
     }
@@ -142,16 +153,6 @@ function jsonResponse(res, status, data, extraHeaders) {
     res.writeHead(status, { 'Content-Type': 'application/json', ...extraHeaders });
     res.end(JSON.stringify(data));
 }
-export function getResponseCorsHeaders(pathname, origin) {
-    if (pathname !== '/ping')
-        return undefined;
-    if (!origin || !origin.startsWith('chrome-extension://'))
-        return undefined;
-    return {
-        'Access-Control-Allow-Origin': origin,
-        Vary: 'Origin',
-    };
-}
 async function handleRequest(req, res) {
     // ─── Security: Origin & custom-header check ──────────────────────
     // Block browser-based CSRF: browsers always send an Origin header on
@@ -219,6 +220,7 @@ async function handleRequest(req, res) {
             profileDisconnected: route.errorCode === 'profile_disconnected',
             profiles,
             pending: pending.size,
+            commandResultUnknown: commandResultUnknownCount,
             memoryMB: Math.round(mem.rss / 1024 / 1024 * 10) / 10,
             port: PORT,
         });
@@ -277,8 +279,37 @@ async function handleRequest(req, res) {
                     pending.delete(body.id);
                     reject(new Error(`Command timeout (${timeoutMs / 1000}s)`));
                 }, timeoutMs);
-                pending.set(body.id, { contextId: route.connection.contextId, resolve, reject, timer });
-                route.connection.ws.send(JSON.stringify(body));
+                const entry = {
+                    contextId: route.connection.contextId,
+                    action: typeof body.action === 'string' ? body.action : 'unknown',
+                    dispatched: false,
+                    resolve,
+                    reject,
+                    timer,
+                };
+                pending.set(body.id, entry);
+                const failBeforeDispatch = (err) => {
+                    if (pending.get(body.id) !== entry)
+                        return;
+                    const failure = buildCommandDispatchFailure(entry.contextId);
+                    clearTimeout(timer);
+                    pending.delete(body.id);
+                    reject(new DaemonCommandFailure(failure.message, failure.errorCode, failure.errorHint, failure.status));
+                    log.warn(`[daemon] Failed to dispatch command ${body.id}: ${err instanceof Error ? err.message : String(err)}`);
+                };
+                try {
+                    route.connection.ws.send(JSON.stringify(body), (err) => {
+                        if (err && !entry.dispatched)
+                            failBeforeDispatch(err);
+                    });
+                    // Once ws accepts the frame, the command may execute even if the
+                    // result is later lost; do not downgrade later disconnects to a
+                    // pre-dispatch failure just because no result/ack has arrived yet.
+                    entry.dispatched = true;
+                }
+                catch (err) {
+                    failBeforeDispatch(err);
+                }
             });
             jsonResponse(res, 200, result);
         }