@jackwener/opencli 1.6.9 → 1.6.10

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,19 @@ 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,
+                lastCliRequestTime: 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[]>;

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;