@jackwener/opencli 1.6.7 → 1.6.9

package/dist/clis/zhihu/write-shared.test.js

@@ -0,0 +1,175 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { describe, expect, it, vi } from 'vitest';
+import { CliError } from '@jackwener/opencli/errors';
+import { __test__ } from './write-shared.js';
+class FakeNode {
+    attrs;
+    textContent;
+    hasAvatar;
+    constructor(attrs, textContent = null, hasAvatar = false) {
+        this.attrs = attrs;
+        this.textContent = textContent;
+        this.hasAvatar = hasAvatar;
+    }
+    getAttribute(name) {
+        return this.attrs[name] ?? null;
+    }
+    querySelector(selector) {
+        if (this.hasAvatar && selector.includes('img'))
+            return {};
+        return null;
+    }
+}
+class FakeRoot {
+    selectors;
+    constructor(selectors) {
+        this.selectors = selectors;
+    }
+    querySelectorAll(selector) {
+        return this.selectors[selector] ?? [];
+    }
+}
+function createPageForDom(documentRoot, state = undefined) {
+    return {
+        evaluate: vi.fn().mockImplementation(async (js) => {
+            const previousDocument = globalThis.document;
+            const previousWindow = globalThis.window;
+            const previousState = globalThis.__INITIAL_STATE__;
+            const windowObject = { __INITIAL_STATE__: state };
+            try {
+                Object.assign(globalThis, {
+                    document: documentRoot,
+                    window: windowObject,
+                    __INITIAL_STATE__: state,
+                });
+                return globalThis.eval(js);
+            }
+            finally {
+                Object.assign(globalThis, {
+                    document: previousDocument,
+                    window: previousWindow,
+                    __INITIAL_STATE__: previousState,
+                });
+            }
+        }),
+    };
+}
+describe('zhihu write shared helpers', () => {
+    it('rejects missing --execute', () => {
+        expect(() => __test__.requireExecute({})).toThrowError(CliError);
+    });
+    it('accepts a non-empty text payload', async () => {
+        await expect(__test__.resolvePayload({ text: 'hello' })).resolves.toBe('hello');
+    });
+    it('rejects whitespace-only payloads', async () => {
+        await expect(__test__.resolvePayload({ text: '   ' })).rejects.toMatchObject({ code: 'INVALID_INPUT' });
+    });
+    it('rejects missing file payloads as INVALID_INPUT', async () => {
+        await expect(__test__.resolvePayload({ file: join(tmpdir(), 'zhihu-write-shared-missing.txt') })).rejects.toMatchObject({
+            code: 'INVALID_INPUT',
+            message: expect.stringContaining('File not found'),
+        });
+    });
+    it('rejects invalid UTF-8 file payloads as INVALID_INPUT', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'zhihu-write-shared-'));
+        const file = join(dir, 'payload.txt');
+        await writeFile(file, Buffer.from([0xc3, 0x28]));
+        try {
+            await expect(__test__.resolvePayload({ file })).rejects.toMatchObject({
+                code: 'INVALID_INPUT',
+                message: expect.stringContaining('decoded as UTF-8'),
+            });
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it('rejects generic file read failures as INVALID_INPUT', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'zhihu-write-shared-'));
+        const file = join(dir, 'payload.txt');
+        await writeFile(file, 'hello');
+        try {
+            await expect(__test__.resolvePayload({ file }, {
+                stat: async () => ({ isFile: () => true }),
+                readFile: async () => {
+                    throw new Error('boom');
+                },
+                decodeUtf8: (raw) => new TextDecoder('utf-8', { fatal: true }).decode(raw),
+            })).rejects.toMatchObject({
+                code: 'INVALID_INPUT',
+                message: expect.stringContaining('could not be read'),
+            });
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it('prefers the state slug before DOM fallback', async () => {
+        const documentRoot = new FakeRoot({
+            'header, nav, [role="banner"], [role="navigation"]': [],
+            'a[href^="/people/"]': [new FakeNode({ href: '/people/not-used', 'data-testid': 'profile-link' }, null, true)],
+        });
+        expect(__test__.resolveCurrentUserSlugFromDom({ me: { slug: 'alice' } }, documentRoot)).toBe('alice');
+    });
+    it('accepts nav avatar links as a conservative fallback', async () => {
+        const navRoot = new FakeRoot({
+            'a[href^="/people/"]': [new FakeNode({ href: '/people/alice' }, null, true)],
+        });
+        const documentRoot = new FakeRoot({
+            'header, nav, [role="banner"], [role="navigation"]': [navRoot],
+            'a[href^="/people/"]': [],
+        });
+        expect(__test__.resolveCurrentUserSlugFromDom(undefined, documentRoot)).toBe('alice');
+    });
+    it('accepts document-wide fallback only for explicit account/profile signals', async () => {
+        const documentRoot = new FakeRoot({
+            'header, nav, [role="banner"], [role="navigation"]': [],
+            'a[href^="/people/"]': [
+                new FakeNode({ href: '/people/alice', 'data-testid': 'account-profile-link' }),
+            ],
+        });
+        expect(__test__.resolveCurrentUserSlugFromDom(undefined, documentRoot)).toBe('alice');
+    });
+    it('does not accept a document-wide author avatar link as current-user fallback', async () => {
+        const documentRoot = new FakeRoot({
+            'header, nav, [role="banner"], [role="navigation"]': [],
+            'a[href^="/people/"]': [new FakeNode({ href: '/people/author-1' }, 'Author', true)],
+        });
+        expect(__test__.resolveCurrentUserSlugFromDom(undefined, documentRoot)).toBeNull();
+    });
+    it('does not accept generic document metadata like user or dropdown alone', async () => {
+        const documentRoot = new FakeRoot({
+            'header, nav, [role="banner"], [role="navigation"]': [],
+            'a[href^="/people/"]': [
+                new FakeNode({ href: '/people/author-1', 'data-testid': 'user-menu-dropdown' }, 'Author'),
+            ],
+        });
+        expect(__test__.resolveCurrentUserSlugFromDom(undefined, documentRoot)).toBeNull();
+    });
+    it('freezes a stable current-user identity before write', async () => {
+        const navRoot = new FakeRoot({
+            'a[href^="/people/"]': [new FakeNode({ href: '/people/alice' }, null, true)],
+        });
+        const documentRoot = new FakeRoot({
+            'header, nav, [role="banner"], [role="navigation"]': [navRoot],
+            'a[href^="/people/"]': [],
+        });
+        const page = createPageForDom(documentRoot);
+        await expect(__test__.resolveCurrentUserIdentity(page)).resolves.toBe('alice');
+    });
+    it('rejects when current-user identity cannot be resolved', async () => {
+        const documentRoot = new FakeRoot({
+            'header, nav, [role="banner"], [role="navigation"]': [],
+            'a[href^="/people/"]': [],
+        });
+        const page = createPageForDom(documentRoot);
+        await expect(__test__.resolveCurrentUserIdentity(page)).rejects.toMatchObject({
+            code: 'ACTION_NOT_AVAILABLE',
+        });
+    });
+    it('rejects reserved buildResultRow extra keys', () => {
+        expect(() => __test__.buildResultRow('done', 'question', '123', 'applied', { status: 'oops' })).toThrowError(CliError);
+    });
+});

package/dist/src/analysis.d.ts

@@ -29,6 +29,8 @@ export declare function inferStrategy(authIndicators: string[]): string;
 export declare function detectAuthFromHeaders(headers?: Record<string, string>): string[];
 /** Detect auth indicators from URL and response body (heuristic). */
 export declare function detectAuthFromContent(url: string, body: unknown): string[];
+/** Check whether a URL looks like tracking/telemetry noise rather than a business API. */
+export declare function isNoiseUrl(url: string): boolean;
 /** Extract non-volatile query params and classify them. */
 export declare function classifyQueryParams(url: string): {
     params: string[];

package/dist/src/analysis.js

@@ -148,6 +148,12 @@ export function detectAuthFromContent(url, body) {
         indicators.push('bearer');
     return indicators;
 }
+// ── Noise filtering ─────────────────────────────────────────────────────────
+const NOISE_URL_PATTERN = /\/(track|log|analytics|beacon|pixel|ping|heartbeat|keep.?alive)\b/i;
+/** Check whether a URL looks like tracking/telemetry noise rather than a business API. */
+export function isNoiseUrl(url) {
+    return NOISE_URL_PATTERN.test(url);
+}
 // ── Query param classification ──────────────────────────────────────────────
 /** Extract non-volatile query params and classify them. */
 export function classifyQueryParams(url) {

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

@@ -18,4 +18,6 @@ export declare class BrowserBridge implements IBrowserFactory {
     }): Promise<IPage>;
     close(): Promise<void>;
     private _ensureDaemon;
+    /** Poll getDaemonHealth() until state is 'ready' or deadline is reached. */
+    private _pollUntilReady;
 }

package/dist/src/browser/bridge.js

@@ -6,8 +6,9 @@ import { fileURLToPath } from 'node:url';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { Page } from './page.js';
-import { fetchDaemonStatus, isExtensionConnected } from './daemon-client.js';
+import { getDaemonHealth } from './daemon-client.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
+import { BrowserConnectError } from '../errors.js';
 const DAEMON_SPAWN_TIMEOUT = 10000; // 10s to wait for daemon + extension
 /**
  * Browser factory: manages daemon lifecycle and provides IPage instances.
@@ -52,25 +53,22 @@ export class BrowserBridge {
     async _ensureDaemon(timeoutSeconds) {
         const effectiveSeconds = (timeoutSeconds && timeoutSeconds > 0) ? timeoutSeconds : Math.ceil(DAEMON_SPAWN_TIMEOUT / 1000);
         const timeoutMs = effectiveSeconds * 1000;
-        // Single status check instead of two separate fetchDaemonStatus() calls
-        const status = await fetchDaemonStatus();
-        // Fast path: extension already connected
-        if (status?.extensionConnected)
+        const health = await getDaemonHealth();
+        // Fast path: everything ready
+        if (health.state === 'ready')
             return;
         // Daemon running but no extension — wait for extension with progress
-        if (status !== null) {
+        if (health.state === 'no-extension') {
             if (process.env.OPENCLI_VERBOSE || process.stderr.isTTY) {
                 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');
             }
-            const deadline = Date.now() + timeoutMs;
-            while (Date.now() < deadline) {
-                await new Promise(resolve => setTimeout(resolve, 200));
-                if (await isExtensionConnected())
-                    return;
-            }
-            throw new Error('Daemon is running but the Browser Extension is not connected.\n' +
-                'Please install and enable the opencli Browser Bridge extension in Chrome or Chromium.');
+            if (await this._pollUntilReady(timeoutMs))
+                return;
+            throw new BrowserConnectError('Browser Bridge extension not connected', 'Install the Browser Bridge:\n' +
+                '  1. Download: https://github.com/jackwener/opencli/releases\n' +
+                '  2. In Chrome or Chromium, open chrome://extensions → Developer Mode → Load unpacked\n' +
+                '  Then run: opencli doctor', 'extension-not-connected');
         }
         // No daemon — spawn one
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -91,19 +89,27 @@ export class BrowserBridge {
             env: { ...process.env },
         });
         this._daemonProc.unref();
-        // Wait for daemon + extension with faster polling
+        // Wait for daemon + extension
+        if (await this._pollUntilReady(timeoutMs))
+            return;
+        const finalHealth = await getDaemonHealth();
+        if (finalHealth.state === 'no-extension') {
+            throw new BrowserConnectError('Browser Bridge extension not connected', 'Install the Browser Bridge:\n' +
+                '  1. Download: https://github.com/jackwener/opencli/releases\n' +
+                '  2. In Chrome or Chromium, open chrome://extensions → Developer Mode → Load unpacked\n' +
+                '  Then run: opencli doctor', 'extension-not-connected');
+        }
+        throw new BrowserConnectError('Failed to start opencli daemon', `Try running manually:\n  node ${daemonPath}\nMake sure port ${DEFAULT_DAEMON_PORT} is available.`, 'daemon-not-running');
+    }
+    /** Poll getDaemonHealth() until state is 'ready' or deadline is reached. */
+    async _pollUntilReady(timeoutMs) {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
             await new Promise(resolve => setTimeout(resolve, 200));
-            if (await isExtensionConnected())
-                return;
-        }
-        if ((await fetchDaemonStatus()) !== null) {
-            throw new Error('Daemon is running but the Browser Extension is not connected.\n' +
-                'Please install and enable the opencli Browser Bridge extension in Chrome or Chromium.');
+            const h = await getDaemonHealth();
+            if (h.state === 'ready')
+                return true;
         }
-        throw new Error('Failed to start opencli daemon. Try running manually:\n' +
-            `  node ${daemonPath}\n` +
-            `Make sure port ${DEFAULT_DAEMON_PORT} is available.`);
+        return false;
     }
 }

package/dist/src/browser/cdp.js

@@ -136,6 +136,14 @@ export class CDPBridge {
 class CDPPage extends BasePage {
     bridge;
     _pageEnabled = false;
+    // Network capture state (mirrors extension/src/cdp.ts NetworkCaptureEntry shape)
+    _networkCapturing = false;
+    _networkCapturePattern = '';
+    _networkEntries = [];
+    _pendingRequests = new Map(); // requestId → index in _networkEntries
+    _pendingBodyFetches = new Set(); // track in-flight getResponseBody calls
+    _consoleMessages = [];
+    _consoleCapturing = false;
     constructor(bridge) {
         super();
         this.bridge = bridge;
@@ -186,6 +194,94 @@ class CDPPage extends BasePage {
         }
         return base64;
     }
+    async startNetworkCapture(pattern = '') {
+        this._networkCapturePattern = pattern;
+        this._networkEntries = [];
+        this._pendingRequests.clear();
+        this._pendingBodyFetches.clear();
+        if (!this._networkCapturing) {
+            await this.bridge.send('Network.enable');
+            // Step 1: Record request method/url on requestWillBeSent
+            this.bridge.on('Network.requestWillBeSent', (params) => {
+                const p = params;
+                if (!pattern || p.request.url.includes(pattern)) {
+                    const idx = this._networkEntries.push({
+                        url: p.request.url,
+                        method: p.request.method,
+                        timestamp: p.timestamp,
+                    }) - 1;
+                    this._pendingRequests.set(p.requestId, idx);
+                }
+            });
+            // Step 2: Fill in response metadata on responseReceived
+            this.bridge.on('Network.responseReceived', (params) => {
+                const p = params;
+                const idx = this._pendingRequests.get(p.requestId);
+                if (idx !== undefined) {
+                    this._networkEntries[idx].responseStatus = p.response.status;
+                    this._networkEntries[idx].responseContentType = p.response.mimeType || '';
+                }
+            });
+            // Step 3: Fetch body on loadingFinished (body is only reliably available after this)
+            this.bridge.on('Network.loadingFinished', (params) => {
+                const p = params;
+                const idx = this._pendingRequests.get(p.requestId);
+                if (idx !== undefined) {
+                    const bodyFetch = this.bridge.send('Network.getResponseBody', { requestId: p.requestId }).then((result) => {
+                        const r = result;
+                        if (typeof r?.body === 'string') {
+                            this._networkEntries[idx].responsePreview = r.base64Encoded
+                                ? `base64:${r.body.slice(0, 4000)}`
+                                : r.body.slice(0, 4000);
+                        }
+                    }).catch(() => {
+                        // Body unavailable for some requests (e.g. uploads) — non-fatal
+                    }).finally(() => {
+                        this._pendingBodyFetches.delete(bodyFetch);
+                    });
+                    this._pendingBodyFetches.add(bodyFetch);
+                    this._pendingRequests.delete(p.requestId);
+                }
+            });
+            this._networkCapturing = true;
+        }
+    }
+    async readNetworkCapture() {
+        // Await all in-flight body fetches so entries have responsePreview populated
+        if (this._pendingBodyFetches.size > 0) {
+            await Promise.all([...this._pendingBodyFetches]);
+        }
+        const entries = [...this._networkEntries];
+        this._networkEntries = [];
+        return entries;
+    }
+    async consoleMessages(level = 'all') {
+        if (!this._consoleCapturing) {
+            await this.bridge.send('Runtime.enable');
+            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 });
+                if (this._consoleMessages.length > 500)
+                    this._consoleMessages.shift();
+            });
+            // Capture uncaught exceptions as error-level messages
+            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 });
+                if (this._consoleMessages.length > 500)
+                    this._consoleMessages.shift();
+            });
+            this._consoleCapturing = true;
+        }
+        if (level === 'all')
+            return [...this._consoleMessages];
+        // 'error' level includes both console.error() and uncaught exceptions
+        if (level === 'error')
+            return this._consoleMessages.filter(m => m.type === 'error' || m.type === 'warning');
+        return this._consoleMessages.filter(m => m.type === level);
+    }
     async tabs() {
         return [];
     }

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

@@ -50,17 +50,26 @@ export interface DaemonStatus {
 export declare function fetchDaemonStatus(opts?: {
     timeout?: number;
 }): Promise<DaemonStatus | null>;
+export type DaemonHealth = {
+    state: 'stopped';
+    status: null;
+} | {
+    state: 'no-extension';
+    status: DaemonStatus;
+} | {
+    state: 'ready';
+    status: DaemonStatus;
+};
+/**
+ * Unified daemon health check — single entry point for all status queries.
+ * Replaces isDaemonRunning(), isExtensionConnected(), and checkDaemonStatus().
+ */
+export declare function getDaemonHealth(opts?: {
+    timeout?: number;
+}): Promise<DaemonHealth>;
 export declare function requestDaemonShutdown(opts?: {
     timeout?: number;
 }): Promise<boolean>;
-/**
- * Check if daemon is running.
- */
-export declare function isDaemonRunning(): Promise<boolean>;
-/**
- * Check if daemon is running AND the extension is connected.
- */
-export declare function isExtensionConnected(): Promise<boolean>;
 /**
  * Send a command to the daemon and wait for a result.
  * Retries up to 4 times: network errors retry at 500ms,

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

@@ -39,6 +39,18 @@ export async function fetchDaemonStatus(opts) {
         return null;
     }
 }
+/**
+ * Unified daemon health check — single entry point for all status queries.
+ * Replaces isDaemonRunning(), isExtensionConnected(), and checkDaemonStatus().
+ */
+export async function getDaemonHealth(opts) {
+    const status = await fetchDaemonStatus(opts);
+    if (!status)
+        return { state: 'stopped', status: null };
+    if (!status.extensionConnected)
+        return { state: 'no-extension', status };
+    return { state: 'ready', status };
+}
 export async function requestDaemonShutdown(opts) {
     try {
         const res = await requestDaemon('/shutdown', { method: 'POST', timeout: opts?.timeout ?? 5000 });
@@ -48,19 +60,6 @@ export async function requestDaemonShutdown(opts) {
         return false;
     }
 }
-/**
- * Check if daemon is running.
- */
-export async function isDaemonRunning() {
-    return (await fetchDaemonStatus()) !== null;
-}
-/**
- * Check if daemon is running AND the extension is connected.
- */
-export async function isExtensionConnected() {
-    const status = await fetchDaemonStatus();
-    return !!status?.extensionConnected;
-}
 /**
  * Send a command to the daemon and wait for a result.
  * Retries up to 4 times: network errors retry at 500ms,

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

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { fetchDaemonStatus, isDaemonRunning, isExtensionConnected, requestDaemonShutdown, } from './daemon-client.js';
+import { fetchDaemonStatus, getDaemonHealth, requestDaemonShutdown, } from './daemon-client.js';
 describe('daemon-client', () => {
     beforeEach(() => {
         vi.stubGlobal('fetch', vi.fn());
@@ -42,36 +42,43 @@ describe('daemon-client', () => {
             headers: expect.objectContaining({ 'X-OpenCLI': '1' }),
         }));
     });
-    it('isDaemonRunning reflects shared status availability', async () => {
+    it('getDaemonHealth returns stopped when daemon is not reachable', async () => {
+        vi.mocked(fetch).mockRejectedValue(new Error('ECONNREFUSED'));
+        await expect(getDaemonHealth()).resolves.toEqual({ state: 'stopped', status: null });
+    });
+    it('getDaemonHealth returns no-extension when daemon is running but extension disconnected', async () => {
+        const status = {
+            ok: true,
+            pid: 123,
+            uptime: 10,
+            extensionConnected: false,
+            pending: 0,
+            lastCliRequestTime: Date.now(),
+            memoryMB: 16,
+            port: 19825,
+        };
         vi.mocked(fetch).mockResolvedValue({
             ok: true,
-            json: () => Promise.resolve({
-                ok: true,
-                pid: 123,
-                uptime: 10,
-                extensionConnected: false,
-                pending: 0,
-                lastCliRequestTime: Date.now(),
-                memoryMB: 16,
-                port: 19825,
-            }),
+            json: () => Promise.resolve(status),
         });
-        await expect(isDaemonRunning()).resolves.toBe(true);
+        await expect(getDaemonHealth()).resolves.toEqual({ state: 'no-extension', status });
     });
-    it('isExtensionConnected reflects shared status payload', async () => {
+    it('getDaemonHealth returns ready when daemon and extension are both connected', async () => {
+        const status = {
+            ok: true,
+            pid: 123,
+            uptime: 10,
+            extensionConnected: true,
+            extensionVersion: '1.2.3',
+            pending: 0,
+            lastCliRequestTime: Date.now(),
+            memoryMB: 32,
+            port: 19825,
+        };
         vi.mocked(fetch).mockResolvedValue({
             ok: true,
-            json: () => Promise.resolve({
-                ok: true,
-                pid: 123,
-                uptime: 10,
-                extensionConnected: false,
-                pending: 0,
-                lastCliRequestTime: Date.now(),
-                memoryMB: 16,
-                port: 19825,
-            }),
+            json: () => Promise.resolve(status),
         });
-        await expect(isExtensionConnected()).resolves.toBe(false);
+        await expect(getDaemonHealth()).resolves.toEqual({ state: 'ready', status });
     });
 });

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

@@ -7,7 +7,8 @@
 export { Page } from './page.js';
 export { BrowserBridge } from './bridge.js';
 export { CDPBridge } from './cdp.js';
-export { isDaemonRunning } from './daemon-client.js';
+export { getDaemonHealth } from './daemon-client.js';
+export type { DaemonHealth } from './daemon-client.js';
 export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 export { generateStealthJs } from './stealth.js';
 export type { DomSnapshotOptions } from './dom-snapshot.js';

package/dist/src/browser/index.js

@@ -7,6 +7,6 @@
 export { Page } from './page.js';
 export { BrowserBridge } from './bridge.js';
 export { CDPBridge } from './cdp.js';
-export { isDaemonRunning } from './daemon-client.js';
+export { getDaemonHealth } from './daemon-client.js';
 export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 export { generateStealthJs } from './stealth.js';

package/dist/src/browser.test.js

@@ -105,10 +105,9 @@ describe('BrowserBridge state', () => {
         await expect(bridge.connect()).rejects.toThrow('Session is closing');
     });
     it('fails fast when daemon is running but extension is disconnected', async () => {
-        vi.spyOn(daemonClient, 'isExtensionConnected').mockResolvedValue(false);
-        vi.spyOn(daemonClient, 'fetchDaemonStatus').mockResolvedValue({ extensionConnected: false });
+        vi.spyOn(daemonClient, 'getDaemonHealth').mockResolvedValue({ state: 'no-extension', status: { extensionConnected: false } });
         const bridge = new BrowserBridge();
-        await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser Extension is not connected');
+        await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser Bridge extension not connected');
     });
 });
 describe('stealth anti-detection', () => {

package/dist/src/build-manifest.d.ts

@@ -6,7 +6,7 @@
  * manifest.json for instant cold-start registration (no runtime YAML parsing).
  *
  * Usage: npx tsx src/build-manifest.ts
- * Output: dist/cli-manifest.json
+ * Output: cli-manifest.json at the package root
  */
 export interface ManifestEntry {
     site: string;
@@ -35,6 +35,8 @@ export interface ManifestEntry {
     type: 'yaml' | 'ts';
     /** Relative path from clis/ dir, e.g. 'bilibili/hot.yaml' or 'bilibili/search.js' */
     modulePath?: string;
+    /** Relative path to the original source file from clis/ dir (for YAML: 'site/cmd.yaml') */
+    sourceFile?: string;
     /** Pre-navigation control — see CliCommand.navigateBefore */
     navigateBefore?: boolean | string;
 }