@jackwener/opencli 1.6.9 → 1.7.0

package/dist/src/browser/bridge.js

@@ -45,7 +45,7 @@ export class BrowserBridge {
         if (this._state === 'closed')
             return;
         this._state = 'closing';
-        // We don't kill the daemon — it auto-exits on idle.
+        // We don't kill the daemon — it's persistent.
         // Just clean up our reference.
         this._page = null;
         this._state = 'closed';

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

@@ -7,6 +7,9 @@ import type { BrowserSessionInfo } from '../types.js';
 export interface DaemonCommand {
     id: string;
     action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'insert-text' | 'bind-current' | 'network-capture-start' | 'network-capture-read' | 'cdp';
+    /** Target page identity (targetId). Cross-layer contract — preferred over tabId. */
+    page?: string;
+    /** @deprecated Legacy tab ID — use `page` (targetId) instead. */
     tabId?: number;
     code?: string;
     workspace?: string;
@@ -29,12 +32,16 @@ export interface DaemonCommand {
     pattern?: string;
     cdpMethod?: string;
     cdpParams?: Record<string, unknown>;
+    /** When true, automation windows are created in the foreground */
+    windowFocused?: boolean;
 }
 export interface DaemonResult {
     id: string;
     ok: boolean;
     data?: unknown;
     error?: string;
+    /** Page identity (targetId) — present on page-scoped command responses */
+    page?: string;
 }
 export interface DaemonStatus {
     ok: boolean;
@@ -43,7 +50,6 @@ export interface DaemonStatus {
     extensionConnected: boolean;
     extensionVersion?: string;
     pending: number;
-    lastCliRequestTime: number;
     memoryMB: number;
     port: number;
 }
@@ -71,11 +77,17 @@ export declare function requestDaemonShutdown(opts?: {
     timeout?: number;
 }): Promise<boolean>;
 /**
- * Send a command to the daemon and wait for a result.
- * Retries up to 4 times: network errors retry at 500ms,
- * transient extension errors retry at 1500ms.
+ * Send a command to the daemon and return the result data.
  */
 export declare function sendCommand(action: DaemonCommand['action'], params?: Omit<DaemonCommand, 'id' | 'action'>): Promise<unknown>;
+/**
+ * Like sendCommand, but returns both data and page identity (targetId).
+ * Use this for page-scoped commands where the caller needs the page identity.
+ */
+export declare function sendCommandFull(action: DaemonCommand['action'], params?: Omit<DaemonCommand, 'id' | 'action'>): Promise<{
+    data: unknown;
+    page?: string;
+}>;
 export declare function listSessions(): Promise<BrowserSessionInfo[]>;
 export declare function bindCurrentTab(workspace: string, opts?: {
     matchDomain?: string;

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

@@ -5,7 +5,7 @@
  */
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 import { sleep } from '../utils.js';
-import { isTransientBrowserError } from './errors.js';
+import { classifyBrowserError } from './errors.js';
 const DAEMON_PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
 const OPENCLI_HEADERS = { 'X-OpenCLI': '1' };
@@ -61,16 +61,21 @@ export async function requestDaemonShutdown(opts) {
     }
 }
 /**
- * Send a command to the daemon and wait for a result.
- * Retries up to 4 times: network errors retry at 500ms,
- * transient extension errors retry at 1500ms.
+ * Internal: send a command to the daemon with retry logic.
+ * Returns the raw DaemonResult. All retry policy lives here — callers
+ * (sendCommand, sendCommandFull) only shape the return value.
+ *
+ * Retries up to 4 times:
+ * - Network errors (TypeError, AbortError): retry at 500ms
+ * - Transient browser errors: retry at the delay suggested by classifyBrowserError()
  */
-export async function sendCommand(action, params = {}) {
+async function sendCommandRaw(action, params) {
     const maxRetries = 4;
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
-        // Generate a fresh ID per attempt to avoid daemon-side duplicate detection
         const id = generateId();
-        const command = { id, action, ...params };
+        const wf = process.env.OPENCLI_WINDOW_FOCUSED;
+        const windowFocused = (wf === '1' || wf === 'true') ? true : undefined;
+        const command = { id, action, ...params, ...(windowFocused && { windowFocused }) };
         try {
             const res = await requestDaemon('/command', {
                 method: 'POST',
@@ -80,29 +85,42 @@ export async function sendCommand(action, params = {}) {
             });
             const result = (await res.json());
             if (!result.ok) {
-                // Check if error is a transient extension issue worth retrying
-                if (isTransientBrowserError(new Error(result.error ?? '')) && attempt < maxRetries) {
-                    // Longer delay for extension recovery (service worker restart)
-                    await sleep(1500);
+                const advice = classifyBrowserError(new Error(result.error ?? ''));
+                if (advice.retryable && attempt < maxRetries) {
+                    await sleep(advice.delayMs);
                     continue;
                 }
                 throw new Error(result.error ?? 'Daemon command failed');
             }
-            return result.data;
+            return result;
         }
         catch (err) {
-            const isRetryable = err instanceof TypeError // fetch network error
+            const isNetworkError = err instanceof TypeError
                 || (err instanceof Error && err.name === 'AbortError');
-            if (isRetryable && attempt < maxRetries) {
+            if (isNetworkError && attempt < maxRetries) {
                 await sleep(500);
                 continue;
             }
             throw err;
         }
     }
-    // Unreachable — the loop always returns or throws
     throw new Error('sendCommand: max retries exhausted');
 }
+/**
+ * Send a command to the daemon and return the result data.
+ */
+export async function sendCommand(action, params = {}) {
+    const result = await sendCommandRaw(action, params);
+    return result.data;
+}
+/**
+ * Like sendCommand, but returns both data and page identity (targetId).
+ * Use this for page-scoped commands where the caller needs the page identity.
+ */
+export async function sendCommandFull(action, params = {}) {
+    const result = await sendCommandRaw(action, params);
+    return { data: result.data, page: result.page };
+}
 export async function listSessions() {
     const result = await sendCommand('sessions');
     return Array.isArray(result) ? result : [];

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

@@ -15,7 +15,6 @@ describe('daemon-client', () => {
             extensionConnected: true,
             extensionVersion: '1.2.3',
             pending: 0,
-            lastCliRequestTime: Date.now(),
             memoryMB: 32,
             port: 19825,
         };
@@ -53,7 +52,6 @@ describe('daemon-client', () => {
             uptime: 10,
             extensionConnected: false,
             pending: 0,
-            lastCliRequestTime: Date.now(),
             memoryMB: 16,
             port: 19825,
         };
@@ -71,7 +69,6 @@ describe('daemon-client', () => {
             extensionConnected: true,
             extensionVersion: '1.2.3',
             pending: 0,
-            lastCliRequestTime: Date.now(),
             memoryMB: 32,
             port: 19825,
         };

package/dist/src/browser/dom-helpers.test.js

@@ -24,11 +24,12 @@ describe('waitForCaptureJs', () => {
     });
     it('resolves "captured" when __opencli_xhr is populated before deadline', async () => {
         const g = globalThis;
-        g.__opencli_xhr = [];
+        const captured = [];
+        g.__opencli_xhr = captured;
         g.window = g; // stub window for Node eval
         const code = waitForCaptureJs(1000);
         const promise = eval(code);
-        g.__opencli_xhr.push({ data: 'test' });
+        captured.push({ data: 'test' });
         await expect(promise).resolves.toBe('captured');
         delete g.__opencli_xhr;
         delete g.window;

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

@@ -6,7 +6,32 @@
  */
 import { BrowserConnectError, type BrowserConnectKind } from '../errors.js';
 /**
- * Check if an error message indicates a transient browser error worth retrying.
+ * Unified browser error classification.
+ *
+ * All transient error detection lives here — daemon-client, pipeline executor,
+ * and page retry logic all use this single system instead of maintaining
+ * separate pattern lists.
+ */
+/** Error category — determines which layer should retry. */
+export type BrowserErrorKind = 'extension-transient' | 'target-navigation' | 'non-retryable';
+/** How the caller should handle the error. */
+export interface RetryAdvice {
+    /** Error category — callers use this to decide whether *they* should retry. */
+    kind: BrowserErrorKind;
+    /** Whether the error is transient and worth retrying. */
+    retryable: boolean;
+    /** Suggested delay before retry (ms). */
+    delayMs: number;
+}
+/**
+ * Classify a browser error and return retry advice.
+ *
+ * Single source of truth for "is this error transient?" across all layers.
+ */
+export declare function classifyBrowserError(err: unknown): RetryAdvice;
+/**
+ * Check if an error is a transient browser error worth retrying.
+ * Convenience wrapper around classifyBrowserError().
  */
 export declare function isTransientBrowserError(err: unknown): boolean;
 export type ConnectFailureKind = BrowserConnectKind;

package/dist/src/browser/errors.js

@@ -7,24 +7,57 @@
 import { BrowserConnectError } from '../errors.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 /**
- * Transient browser error patterns — shared across daemon-client, pipeline executor,
- * and page retry logic. These errors indicate temporary conditions (extension restart,
- * service worker cycle, tab navigation) that are worth retrying.
+ * Extension/daemon transient patterns — service worker restarts, attach races,
+ * tab closure, daemon hiccups. These warrant a longer retry delay (~1500ms)
+ * because the extension needs time to recover.
  */
-const TRANSIENT_ERROR_PATTERNS = [
+const EXTENSION_TRANSIENT_PATTERNS = [
     'Extension disconnected',
     'Extension not connected',
     'attach failed',
     'no longer exists',
     'CDP connection',
     'Daemon command failed',
+    'No window with id',
 ];
 /**
- * Check if an error message indicates a transient browser error worth retrying.
+ * CDP target navigation patterns — SPA client-side redirects can invalidate the
+ * CDP target after chrome.tabs reports 'complete'. These warrant a shorter retry
+ * delay (~200ms) because the new document is usually available quickly.
+ */
+const TARGET_NAVIGATION_PATTERNS = [
+    'Inspected target navigated or closed',
+];
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/**
+ * 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 msg = errorMessage(err);
+    // Extension/daemon transient errors — longer recovery time
+    if (EXTENSION_TRANSIENT_PATTERNS.some(p => msg.includes(p))) {
+        return { kind: 'extension-transient', retryable: true, delayMs: 1500 };
+    }
+    // CDP target navigation errors — shorter recovery time
+    if (TARGET_NAVIGATION_PATTERNS.some(p => msg.includes(p))) {
+        return { kind: 'target-navigation', retryable: true, delayMs: 200 };
+    }
+    // CDP protocol error with target context (e.g., -32000 "target closed")
+    if (msg.includes('-32000') && msg.toLowerCase().includes('target')) {
+        return { kind: 'target-navigation', retryable: true, delayMs: 200 };
+    }
+    return { kind: 'non-retryable', retryable: false, delayMs: 0 };
+}
+/**
+ * Check if an error is a transient browser error worth retrying.
+ * Convenience wrapper around classifyBrowserError().
  */
 export function isTransientBrowserError(err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return TRANSIENT_ERROR_PATTERNS.some(pattern => msg.includes(pattern));
+    return classifyBrowserError(err).retryable;
 }
 export function formatBrowserConnectError(kind, detail) {
     switch (kind) {

package/dist/src/browser/errors.test.d.ts

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

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

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+import { classifyBrowserError, isTransientBrowserError } from './errors.js';
+describe('classifyBrowserError', () => {
+    it('classifies extension transient errors with 1500ms delay', () => {
+        for (const msg of [
+            'Extension disconnected',
+            'Extension not connected',
+            'attach failed',
+            'no longer exists',
+            'CDP connection reset',
+            'Daemon command failed',
+            'No window with id: 123',
+        ]) {
+            const advice = classifyBrowserError(new Error(msg));
+            expect(advice.kind, `expected "${msg}" → extension-transient`).toBe('extension-transient');
+            expect(advice.retryable).toBe(true);
+            expect(advice.delayMs).toBe(1500);
+        }
+    });
+    it('classifies CDP target navigation errors with 200ms delay', () => {
+        const advice = classifyBrowserError(new Error('Inspected target navigated or closed'));
+        expect(advice.kind).toBe('target-navigation');
+        expect(advice.retryable).toBe(true);
+        expect(advice.delayMs).toBe(200);
+    });
+    it('classifies CDP -32000 target errors with 200ms delay', () => {
+        const advice = classifyBrowserError(new Error('{"code":-32000,"message":"Target closed"}'));
+        expect(advice.kind).toBe('target-navigation');
+        expect(advice.retryable).toBe(true);
+        expect(advice.delayMs).toBe(200);
+    });
+    it('returns non-retryable for unrelated errors', () => {
+        for (const msg of ['Permission denied', 'malformed exec payload', 'SyntaxError']) {
+            const advice = classifyBrowserError(new Error(msg));
+            expect(advice.kind).toBe('non-retryable');
+            expect(advice.retryable).toBe(false);
+        }
+    });
+    it('handles non-Error values', () => {
+        expect(classifyBrowserError('Extension disconnected').kind).toBe('extension-transient');
+        expect(classifyBrowserError(42).kind).toBe('non-retryable');
+    });
+});
+describe('isTransientBrowserError (convenience wrapper)', () => {
+    it('returns true for transient errors', () => {
+        expect(isTransientBrowserError(new Error('No window with id: 123'))).toBe(true);
+    });
+    it('returns false for non-transient errors', () => {
+        expect(isTransientBrowserError(new Error('Permission denied'))).toBe(false);
+    });
+});

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

@@ -4,30 +4,31 @@
  * All browser operations are ultimately 'exec' (JS evaluation via CDP)
  * plus a few native Chrome Extension APIs (tabs, cookies, navigate).
  *
- * IMPORTANT: After goto(), we remember the tabId returned by the navigate
- * action and pass it to all subsequent commands. This avoids the issue
- * where resolveTabId() in the extension picks a chrome:// or
- * chrome-extension:// tab that can't be debugged.
+ * IMPORTANT: After goto(), we remember the page identity (targetId) returned
+ * by the navigate action and pass it to all subsequent commands. This ensures
+ * page-scoped operations target the correct page without guessing.
  */
 import type { BrowserCookie, ScreenshotOptions } from '../types.js';
 import { BasePage } from './base-page.js';
-export declare function isRetryableSettleError(err: unknown): boolean;
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
  */
 export declare class Page extends BasePage {
     private readonly workspace;
     constructor(workspace?: string);
-    /** Active tab ID, set after navigate and used in all subsequent commands */
-    private _tabId;
+    /** Active page identity (targetId), set after navigate and used in all subsequent commands */
+    private _page;
     /** Helper: spread workspace into command params */
     private _wsOpt;
-    /** Helper: spread workspace + tabId into command params */
+    /** Helper: spread workspace + page identity into command params */
     private _cmdOpts;
     goto(url: string, options?: {
         waitUntil?: 'load' | 'none';
         settleMs?: number;
     }): Promise<void>;
+    /** Get the active page identity (targetId) */
+    getActivePage(): string | undefined;
+    /** @deprecated Use getActivePage() instead */
     getActiveTabId(): number | undefined;
     evaluate(js: string): Promise<unknown>;
     getCookies(opts?: {

package/dist/src/browser/page.js

@@ -4,22 +4,17 @@
  * All browser operations are ultimately 'exec' (JS evaluation via CDP)
  * plus a few native Chrome Extension APIs (tabs, cookies, navigate).
  *
- * IMPORTANT: After goto(), we remember the tabId returned by the navigate
- * action and pass it to all subsequent commands. This avoids the issue
- * where resolveTabId() in the extension picks a chrome:// or
- * chrome-extension:// tab that can't be debugged.
+ * IMPORTANT: After goto(), we remember the page identity (targetId) returned
+ * by the navigate action and pass it to all subsequent commands. This ensures
+ * page-scoped operations target the correct page without guessing.
  */
-import { sendCommand } from './daemon-client.js';
+import { sendCommand, sendCommandFull } from './daemon-client.js';
 import { wrapForEval } from './utils.js';
 import { saveBase64ToFile } from '../utils.js';
 import { generateStealthJs } from './stealth.js';
 import { waitForDomStableJs } from './dom-helpers.js';
 import { BasePage } from './base-page.js';
-export function isRetryableSettleError(err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return message.includes('Inspected target navigated or closed')
-        || (message.includes('-32000') && message.toLowerCase().includes('target'));
-}
+import { classifyBrowserError } from './errors.js';
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
  */
@@ -29,27 +24,27 @@ export class Page extends BasePage {
         super();
         this.workspace = workspace;
     }
-    /** Active tab ID, set after navigate and used in all subsequent commands */
-    _tabId;
+    /** Active page identity (targetId), set after navigate and used in all subsequent commands */
+    _page;
     /** Helper: spread workspace into command params */
     _wsOpt() {
         return { workspace: this.workspace };
     }
-    /** Helper: spread workspace + tabId into command params */
+    /** Helper: spread workspace + page identity into command params */
     _cmdOpts() {
         return {
             workspace: this.workspace,
-            ...(this._tabId !== undefined && { tabId: this._tabId }),
+            ...(this._page !== undefined && { page: this._page }),
         };
     }
     async goto(url, options) {
-        const result = await sendCommand('navigate', {
+        const result = await sendCommandFull('navigate', {
             url,
             ...this._cmdOpts(),
         });
-        // Remember the tabId and URL for subsequent calls
-        if (result?.tabId) {
-            this._tabId = result.tabId;
+        // Remember the page identity (targetId) for subsequent calls
+        if (result.page) {
+            this._page = result.page;
         }
         this._lastUrl = url;
         // Inject stealth + settle in a single round-trip instead of two sequential exec calls.
@@ -65,17 +60,18 @@ export class Page extends BasePage {
                 await sendCommand('exec', combinedOpts);
             }
             catch (err) {
-                if (!isRetryableSettleError(err))
+                const advice = classifyBrowserError(err);
+                // Only settle-retry on target navigation (SPA client-side redirects).
+                // Extension/daemon errors are already retried by sendCommandRaw —
+                // retrying them here would silently swallow real failures.
+                if (advice.kind !== 'target-navigation')
                     throw err;
-                // SPA client-side redirects can invalidate the CDP target after
-                // chrome.tabs reports 'complete'. Wait briefly for the new document
-                // to load, then retry the settle probe once.
                 try {
-                    await new Promise((r) => setTimeout(r, 200));
+                    await new Promise((r) => setTimeout(r, advice.delayMs));
                     await sendCommand('exec', combinedOpts);
                 }
                 catch (retryErr) {
-                    if (!isRetryableSettleError(retryErr))
+                    if (classifyBrowserError(retryErr).kind !== 'target-navigation')
                         throw retryErr;
                 }
             }
@@ -93,8 +89,13 @@ export class Page extends BasePage {
             }
         }
     }
+    /** Get the active page identity (targetId) */
+    getActivePage() {
+        return this._page;
+    }
+    /** @deprecated Use getActivePage() instead */
     getActiveTabId() {
-        return this._tabId;
+        return undefined;
     }
     async evaluate(js) {
         const code = wrapForEval(js);
@@ -102,9 +103,10 @@ export class Page extends BasePage {
             return await sendCommand('exec', { code, ...this._cmdOpts() });
         }
         catch (err) {
-            if (!isRetryableSettleError(err))
+            const advice = classifyBrowserError(err);
+            if (advice.kind !== 'target-navigation')
                 throw err;
-            await new Promise((resolve) => setTimeout(resolve, 200));
+            await new Promise((resolve) => setTimeout(resolve, advice.delayMs));
             return sendCommand('exec', { code, ...this._cmdOpts() });
         }
     }
@@ -121,7 +123,7 @@ export class Page extends BasePage {
             // Window may already be closed or daemon may be down
         }
         finally {
-            this._tabId = undefined;
+            this._page = undefined;
             this._lastUrl = null;
         }
     }
@@ -130,9 +132,9 @@ export class Page extends BasePage {
         return Array.isArray(result) ? result : [];
     }
     async selectTab(index) {
-        const result = await sendCommand('tabs', { op: 'select', index, ...this._wsOpt() });
-        if (result?.selected)
-            this._tabId = result.selected;
+        const result = await sendCommandFull('tabs', { op: 'select', index, ...this._wsOpt() });
+        if (result.page)
+            this._page = result.page;
     }
     /**
      * Capture a screenshot via CDP Page.captureScreenshot.

package/dist/src/browser.test.js

@@ -3,7 +3,7 @@ import { BrowserBridge, generateStealthJs } from './browser/index.js';
 import { extractTabEntries, diffTabIndexes, appendLimited } from './browser/tabs.js';
 import { withTimeoutMs } from './runtime.js';
 import { __test__ as cdpTest } from './browser/cdp.js';
-import { isRetryableSettleError } from './browser/page.js';
+import { classifyBrowserError } from './browser/errors.js';
 import * as daemonClient from './browser/daemon-client.js';
 describe('browser helpers', () => {
     it('extracts tab entries from string snapshots', () => {
@@ -35,10 +35,18 @@ describe('browser helpers', () => {
     it('times out slow promises', async () => {
         await expect(withTimeoutMs(new Promise(() => { }), 10, 'timeout')).rejects.toThrow('timeout');
     });
-    it('retries settle only for target-invalidated errors', () => {
-        expect(isRetryableSettleError(new Error('{"code":-32000,"message":"Inspected target navigated or closed"}'))).toBe(true);
-        expect(isRetryableSettleError(new Error('attach failed: target no longer exists'))).toBe(false);
-        expect(isRetryableSettleError(new Error('malformed exec payload'))).toBe(false);
+    it('classifies browser errors with correct kind and retry advice', () => {
+        // CDP target navigation — page-level settle retry
+        const nav = classifyBrowserError(new Error('{"code":-32000,"message":"Inspected target navigated or closed"}'));
+        expect(nav.kind).toBe('target-navigation');
+        expect(nav.delayMs).toBe(200);
+        // Extension transient — daemon-client retry only, NOT page-level
+        const ext = classifyBrowserError(new Error('Extension disconnected'));
+        expect(ext.kind).toBe('extension-transient');
+        expect(ext.delayMs).toBe(1500);
+        // Non-transient errors — not retryable
+        expect(classifyBrowserError(new Error('malformed exec payload')).kind).toBe('non-retryable');
+        expect(classifyBrowserError(new Error('Permission denied')).kind).toBe('non-retryable');
     });
     it('prefers the real Electron app target over DevTools and blank pages', () => {
         const target = cdpTest.selectCDPTarget([
@@ -105,7 +113,18 @@ 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, 'getDaemonHealth').mockResolvedValue({ state: 'no-extension', status: { extensionConnected: false } });
+        vi.spyOn(daemonClient, 'getDaemonHealth').mockResolvedValue({
+            state: 'no-extension',
+            status: {
+                ok: true,
+                pid: 1,
+                uptime: 0,
+                extensionConnected: false,
+                pending: 0,
+                memoryMB: 0,
+                port: 0,
+            },
+        });
         const bridge = new BrowserBridge();
         await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser Bridge extension not connected');
     });

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

@@ -2,8 +2,8 @@
 /**
  * Build-time CLI manifest compiler.
  *
- * Scans all YAML/TS CLI definitions and pre-compiles them into a single
- * manifest.json for instant cold-start registration (no runtime YAML parsing).
+ * Scans all TS CLI definitions and pre-compiles them into a single
+ * manifest.json for instant cold-start registration.
  *
  * Usage: npx tsx src/build-manifest.ts
  * Output: cli-manifest.json at the package root
@@ -31,19 +31,13 @@ export interface ManifestEntry {
     timeout?: number;
     deprecated?: boolean | string;
     replacedBy?: string;
-    /** 'yaml' or 'ts' — determines how executeCommand loads the handler */
-    type: 'yaml' | 'ts';
-    /** Relative path from clis/ dir, e.g. 'bilibili/hot.yaml' or 'bilibili/search.js' */
+    type: 'ts';
+    /** Relative path from clis/ dir, e.g. 'bilibili/search.js' */
     modulePath?: string;
-    /** Relative path to the original source file from clis/ dir (for YAML: 'site/cmd.yaml') */
+    /** Relative path to the original source file from clis/ dir (e.g. 'site/cmd.ts') */
     sourceFile?: string;
     /** Pre-navigation control — see CliCommand.navigateBefore */
     navigateBefore?: boolean | string;
 }
 export declare function loadTsManifestEntries(filePath: string, site: string, importer?: (moduleHref: string) => Promise<unknown>): Promise<ManifestEntry[]>;
-/**
- * When both YAML and TS adapters exist for the same site/name,
- * prefer the TS version (it self-registers and typically has richer logic).
- */
-export declare function shouldReplaceManifestEntry(current: ManifestEntry, next: ManifestEntry): boolean;
 export declare function buildManifest(): Promise<ManifestEntry[]>;