@jackwener/opencli 1.6.8 → 1.6.10

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,10 +113,21 @@ 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: {
+                ok: true,
+                pid: 1,
+                uptime: 0,
+                extensionConnected: false,
+                pending: 0,
+                lastCliRequestTime: 0,
+                memoryMB: 0,
+                port: 0,
+            },
+        });
         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

@@ -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[]>;

package/dist/src/build-manifest.js

@@ -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
@@ -11,14 +11,12 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import yaml from 'js-yaml';
 import { getErrorMessage } from './errors.js';
 import { fullName, getRegistry } from './registry.js';
 import { findPackageRoot, getCliManifestPath } from './package-paths.js';
 const PACKAGE_ROOT = findPackageRoot(fileURLToPath(import.meta.url));
 const CLIS_DIR = path.join(PACKAGE_ROOT, 'clis');
 const OUTPUT = getCliManifestPath(CLIS_DIR);
-import { parseYamlArgs } from './yaml-schema.js';
 import { isRecord } from './utils.js';
 const CLI_MODULE_PATTERN = /\bcli\s*\(/;
 function toManifestArgs(args) {
@@ -64,43 +62,6 @@ function toManifestEntry(cmd, modulePath, sourceFile) {
         navigateBefore: cmd.navigateBefore,
     };
 }
-function scanYaml(filePath, site) {
-    try {
-        const raw = fs.readFileSync(filePath, 'utf-8');
-        const def = yaml.load(raw);
-        if (!isRecord(def))
-            return null;
-        const cliDef = def;
-        const strategyStr = cliDef.strategy ?? (cliDef.browser === false ? 'public' : 'cookie');
-        const strategy = strategyStr.toUpperCase();
-        const browser = cliDef.browser ?? (strategy !== 'PUBLIC');
-        const args = parseYamlArgs(cliDef.args);
-        return {
-            site: cliDef.site ?? site,
-            name: cliDef.name ?? path.basename(filePath, path.extname(filePath)),
-            description: cliDef.description ?? '',
-            domain: cliDef.domain,
-            strategy: strategy.toLowerCase(),
-            browser,
-            aliases: isRecord(cliDef) && Array.isArray(cliDef.aliases)
-                ? cliDef.aliases.filter((value) => typeof value === 'string')
-                : undefined,
-            args,
-            columns: cliDef.columns,
-            pipeline: cliDef.pipeline,
-            timeout: cliDef.timeout,
-            deprecated: cliDef.deprecated,
-            replacedBy: cliDef.replacedBy,
-            type: 'yaml',
-            sourceFile: path.relative(CLIS_DIR, filePath),
-            navigateBefore: cliDef.navigateBefore,
-        };
-    }
-    catch (err) {
-        process.stderr.write(`Warning: failed to parse ${filePath}: ${getErrorMessage(err)}\n`);
-        return null;
-    }
-}
 export async function loadTsManifestEntries(filePath, site, importer = moduleHref => import(moduleHref)) {
     try {
         const src = fs.readFileSync(filePath, 'utf-8');
@@ -141,15 +102,6 @@ export async function loadTsManifestEntries(filePath, site, importer = moduleHre
         return [];
     }
 }
-/**
- * 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 function shouldReplaceManifestEntry(current, next) {
-    if (current.type === next.type)
-        return false;
-    return current.type === 'yaml' && next.type === 'ts';
-}
 export async function buildManifest() {
     const manifest = new Map();
     if (fs.existsSync(CLIS_DIR)) {
@@ -158,32 +110,13 @@ export async function buildManifest() {
             if (!fs.statSync(siteDir).isDirectory())
                 continue;
             for (const file of fs.readdirSync(siteDir)) {
-                const filePath = path.join(siteDir, file);
-                if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-                    const entry = scanYaml(filePath, site);
-                    if (entry) {
-                        const key = `${entry.site}/${entry.name}`;
-                        const existing = manifest.get(key);
-                        if (!existing || shouldReplaceManifestEntry(existing, entry)) {
-                            if (existing && existing.type !== entry.type) {
-                                process.stderr.write(`⚠️  Duplicate adapter ${key}: ${existing.type} superseded by ${entry.type}\n`);
-                            }
-                            manifest.set(key, entry);
-                        }
-                    }
-                }
-                else if ((file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts') && file !== 'index.ts') ||
+                if ((file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts') && file !== 'index.ts') ||
                     (file.endsWith('.js') && !file.endsWith('.d.js') && !file.endsWith('.test.js') && file !== 'index.js')) {
+                    const filePath = path.join(siteDir, file);
                     const entries = await loadTsManifestEntries(filePath, site);
                     for (const entry of entries) {
                         const key = `${entry.site}/${entry.name}`;
-                        const existing = manifest.get(key);
-                        if (!existing || shouldReplaceManifestEntry(existing, entry)) {
-                            if (existing && existing.type !== entry.type) {
-                                process.stderr.write(`⚠️  Duplicate adapter ${key}: ${existing.type} superseded by ${entry.type}\n`);
-                            }
-                            manifest.set(key, entry);
-                        }
+                        manifest.set(key, entry);
                     }
                 }
             }
@@ -195,9 +128,7 @@ async function main() {
     const manifest = await buildManifest();
     fs.mkdirSync(path.dirname(OUTPUT), { recursive: true });
     fs.writeFileSync(OUTPUT, JSON.stringify(manifest, null, 2));
-    const yamlCount = manifest.filter(e => e.type === 'yaml').length;
-    const tsCount = manifest.filter(e => e.type === 'ts').length;
-    console.log(`✅ Manifest compiled: ${manifest.length} entries (${yamlCount} YAML, ${tsCount} TS) → ${OUTPUT}`);
+    console.log(`✅ Manifest compiled: ${manifest.length} entries → ${OUTPUT}`);
     // Restore executable permissions on bin entries.
     // tsc does not preserve the +x bit, so after a clean rebuild the CLI
     // entry-point loses its executable permission, causing "Permission denied".

package/dist/src/build-manifest.test.js

@@ -3,7 +3,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { cli, getRegistry, Strategy } from './registry.js';
-import { loadTsManifestEntries, shouldReplaceManifestEntry } from './build-manifest.js';
+import { loadTsManifestEntries } from './build-manifest.js';
 describe('manifest helper rules', () => {
     const tempDirs = [];
     afterEach(() => {
@@ -11,44 +11,6 @@ describe('manifest helper rules', () => {
             fs.rmSync(dir, { recursive: true, force: true });
         }
     });
-    it('prefers TS adapters over duplicate YAML adapters', () => {
-        expect(shouldReplaceManifestEntry({
-            site: 'demo',
-            name: 'search',
-            description: 'yaml',
-            strategy: 'public',
-            browser: false,
-            args: [],
-            type: 'yaml',
-        }, {
-            site: 'demo',
-            name: 'search',
-            description: 'ts',
-            strategy: 'public',
-            browser: false,
-            args: [],
-            type: 'ts',
-            modulePath: 'demo/search.js',
-        })).toBe(true);
-        expect(shouldReplaceManifestEntry({
-            site: 'demo',
-            name: 'search',
-            description: 'ts',
-            strategy: 'public',
-            browser: false,
-            args: [],
-            type: 'ts',
-            modulePath: 'demo/search.js',
-        }, {
-            site: 'demo',
-            name: 'search',
-            description: 'yaml',
-            strategy: 'public',
-            browser: false,
-            args: [],
-            type: 'yaml',
-        })).toBe(false);
-    });
     it('skips TS files that do not register a cli', () => {
         const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-manifest-'));
         tempDirs.push(dir);

package/dist/src/cascade.js

@@ -72,13 +72,14 @@ export async function probeEndpoint(page, url, strategy, _opts = {}) {
     try {
         const opts = PROBE_OPTIONS[strategy];
         if (opts) {
-            const resp = await page.evaluate(buildFetchProbeJs(url, opts));
+            const resp = (await page.evaluate(buildFetchProbeJs(url, opts)));
             result.statusCode = resp?.status;
-            result.success = resp?.ok && resp?.hasData;
+            result.success = !!(resp?.ok && resp?.hasData);
             result.hasData = resp?.hasData;
             result.responsePreview = resp?.preview;
         }
         else {
+            // INTERCEPT / UI require site-specific implementation.
             result.error = `Strategy ${strategy} requires site-specific implementation`;
         }
     }

package/dist/src/cli.d.ts

@@ -8,16 +8,16 @@ import { Command } from 'commander';
 import { findPackageRoot } from './package-paths.js';
 export declare function createProgram(BUILTIN_CLIS: string, USER_CLIS: string): Command;
 export declare function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void;
-export interface OperateVerifyInvocation {
+export interface BrowserVerifyInvocation {
     binary: string;
     args: string[];
     cwd: string;
     shell?: boolean;
 }
 export { findPackageRoot };
-export declare function resolveOperateVerifyInvocation(opts?: {
+export declare function resolveBrowserVerifyInvocation(opts?: {
     projectRoot?: string;
     platform?: NodeJS.Platform;
     fileExists?: (path: string) => boolean;
     readFile?: (path: string) => string;
-}): OperateVerifyInvocation;
+}): BrowserVerifyInvocation;