@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/browser.test.js

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi } from 'vitest';
+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 * as daemonClient from './browser/daemon-client.js';
+describe('browser helpers', () => {
+    it('extracts tab entries from string snapshots', () => {
+        const entries = extractTabEntries('Tab 0 https://example.com\nTab 1 Chrome Extension');
+        expect(entries).toEqual([
+            { index: 0, identity: 'https://example.com' },
+            { index: 1, identity: 'Chrome Extension' },
+        ]);
+    });
+    it('extracts tab entries from MCP markdown format', () => {
+        const entries = extractTabEntries('- 0: (current) [Playwright MCP extension](chrome-extension://abc/connect.html)\n- 1: [知乎 - 首页](https://www.zhihu.com/)');
+        expect(entries).toEqual([
+            { index: 0, identity: '(current) [Playwright MCP extension](chrome-extension://abc/connect.html)' },
+            { index: 1, identity: '[知乎 - 首页](https://www.zhihu.com/)' },
+        ]);
+    });
+    it('closes only tabs that were opened during the session', () => {
+        const tabsToClose = diffTabIndexes(['https://example.com', 'Chrome Extension'], [
+            { index: 0, identity: 'https://example.com' },
+            { index: 1, identity: 'Chrome Extension' },
+            { index: 2, identity: 'https://target.example/page' },
+            { index: 3, identity: 'chrome-extension://bridge' },
+        ]);
+        expect(tabsToClose).toEqual([3, 2]);
+    });
+    it('keeps only the tail of stderr buffers', () => {
+        expect(appendLimited('12345', '67890', 8)).toBe('34567890');
+    });
+    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('prefers the real Electron app target over DevTools and blank pages', () => {
+        const target = cdpTest.selectCDPTarget([
+            {
+                type: 'page',
+                title: 'DevTools - localhost:9224',
+                url: 'devtools://devtools/bundled/inspector.html',
+                webSocketDebuggerUrl: 'ws://127.0.0.1:9224/devtools',
+            },
+            {
+                type: 'page',
+                title: '',
+                url: 'about:blank',
+                webSocketDebuggerUrl: 'ws://127.0.0.1:9224/blank',
+            },
+            {
+                type: 'app',
+                title: 'Antigravity',
+                url: 'http://localhost:3000/',
+                webSocketDebuggerUrl: 'ws://127.0.0.1:9224/app',
+            },
+        ]);
+        expect(target?.webSocketDebuggerUrl).toBe('ws://127.0.0.1:9224/app');
+    });
+    it('honors OPENCLI_CDP_TARGET when multiple inspectable targets exist', () => {
+        vi.stubEnv('OPENCLI_CDP_TARGET', 'codex');
+        const target = cdpTest.selectCDPTarget([
+            {
+                type: 'app',
+                title: 'Cursor',
+                url: 'http://localhost:3000/cursor',
+                webSocketDebuggerUrl: 'ws://127.0.0.1:9226/cursor',
+            },
+            {
+                type: 'app',
+                title: 'OpenAI Codex',
+                url: 'http://localhost:3000/codex',
+                webSocketDebuggerUrl: 'ws://127.0.0.1:9226/codex',
+            },
+        ]);
+        expect(target?.webSocketDebuggerUrl).toBe('ws://127.0.0.1:9226/codex');
+    });
+});
+describe('BrowserBridge state', () => {
+    it('transitions to closed after close()', async () => {
+        const bridge = new BrowserBridge();
+        expect(bridge.state).toBe('idle');
+        await bridge.close();
+        expect(bridge.state).toBe('closed');
+    });
+    it('rejects connect() after the session has been closed', async () => {
+        const bridge = new BrowserBridge();
+        await bridge.close();
+        await expect(bridge.connect()).rejects.toThrow('Session is closed');
+    });
+    it('rejects connect() while already connecting', async () => {
+        const bridge = new BrowserBridge();
+        bridge._state = 'connecting';
+        await expect(bridge.connect()).rejects.toThrow('Already connecting');
+    });
+    it('rejects connect() while closing', async () => {
+        const bridge = new BrowserBridge();
+        bridge._state = 'closing';
+        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 });
+        const bridge = new BrowserBridge();
+        await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser Extension is not connected');
+    });
+});
+describe('stealth anti-detection', () => {
+    it('generates non-empty JS string', () => {
+        const js = generateStealthJs();
+        expect(typeof js).toBe('string');
+        expect(js.length).toBeGreaterThan(100);
+    });
+    it('contains all 7 anti-detection patches', () => {
+        const js = generateStealthJs();
+        // 1. webdriver
+        expect(js).toContain('navigator');
+        expect(js).toContain('webdriver');
+        // 2. chrome stub
+        expect(js).toContain('window.chrome');
+        // 3. plugins
+        expect(js).toContain('plugins');
+        expect(js).toContain('PDF Viewer');
+        // 4. languages
+        expect(js).toContain('languages');
+        // 5. permissions
+        expect(js).toContain('Permissions');
+        expect(js).toContain('notifications');
+        // 6. automation artifacts (dynamic cdc_ scan)
+        expect(js).toContain('__playwright');
+        expect(js).toContain('__puppeteer');
+        expect(js).toContain('getOwnPropertyNames');
+        expect(js).toContain('cdc_');
+        // 7. CDP stack trace cleanup
+        expect(js).toContain('Error.prototype');
+        expect(js).toContain('puppeteer_evaluation_script');
+        expect(js).toContain('getOwnPropertyDescriptor');
+    });
+    it('includes guard flag to prevent double-injection', () => {
+        const js = generateStealthJs();
+        // Guard uses a non-enumerable property on a built-in prototype
+        expect(js).toContain("EventTarget.prototype");
+        // Guard should check early and return 'skipped'
+        expect(js).toContain("return 'skipped'");
+        // Normal path returns 'applied'
+        expect(js).toContain("return 'applied'");
+    });
+    it('generates syntactically valid JS', () => {
+        const js = generateStealthJs();
+        // Should not throw when parsed
+        expect(() => new Function(js)).not.toThrow();
+    });
+});

package/vendor/opencli/dist/build-manifest.d.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ * 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).
+ *
+ * Usage: npx tsx src/build-manifest.ts
+ * Output: dist/cli-manifest.json
+ */
+export interface ManifestEntry {
+    site: string;
+    name: string;
+    aliases?: string[];
+    description: string;
+    domain?: string;
+    strategy: string;
+    browser: boolean;
+    args: Array<{
+        name: string;
+        type?: string;
+        default?: unknown;
+        required?: boolean;
+        valueRequired?: boolean;
+        positional?: boolean;
+        help?: string;
+        choices?: string[];
+    }>;
+    columns?: string[];
+    pipeline?: Record<string, unknown>[];
+    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' */
+    modulePath?: 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/vendor/opencli/dist/build-manifest.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+/**
+ * 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).
+ *
+ * Usage: npx tsx src/build-manifest.ts
+ * Output: dist/cli-manifest.json
+ */
+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';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLIS_DIR = path.resolve(__dirname, 'clis');
+const OUTPUT = path.resolve(__dirname, '..', 'dist', 'cli-manifest.json');
+import { parseYamlArgs } from './yaml-schema.js';
+import { isRecord } from './utils.js';
+const CLI_MODULE_PATTERN = /\bcli\s*\(/;
+function toManifestArgs(args) {
+    return args.map(arg => ({
+        name: arg.name,
+        type: arg.type ?? 'str',
+        default: arg.default,
+        required: !!arg.required,
+        valueRequired: !!arg.valueRequired || undefined,
+        positional: arg.positional || undefined,
+        help: arg.help ?? '',
+        choices: arg.choices,
+    }));
+}
+function toTsModulePath(filePath, site) {
+    const baseName = path.basename(filePath, path.extname(filePath));
+    return `${site}/${baseName}.js`;
+}
+function isCliCommandValue(value, site) {
+    return isRecord(value)
+        && typeof value.site === 'string'
+        && value.site === site
+        && typeof value.name === 'string'
+        && Array.isArray(value.args);
+}
+function toManifestEntry(cmd, modulePath) {
+    return {
+        site: cmd.site,
+        name: cmd.name,
+        aliases: cmd.aliases,
+        description: cmd.description ?? '',
+        domain: cmd.domain,
+        strategy: (cmd.strategy ?? 'public').toString().toLowerCase(),
+        browser: cmd.browser ?? true,
+        args: toManifestArgs(cmd.args),
+        columns: cmd.columns,
+        timeout: cmd.timeoutSeconds,
+        deprecated: cmd.deprecated,
+        replacedBy: cmd.replacedBy,
+        type: 'ts',
+        modulePath,
+        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',
+            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');
+        // Helper/test modules should not appear as CLI commands in the manifest.
+        if (!CLI_MODULE_PATTERN.test(src))
+            return [];
+        const modulePath = toTsModulePath(filePath, site);
+        const registry = getRegistry();
+        const before = new Map(registry.entries());
+        const mod = await importer(pathToFileURL(filePath).href);
+        const exportedCommands = Object.values(isRecord(mod) ? mod : {})
+            .filter(value => isCliCommandValue(value, site));
+        const runtimeCommands = exportedCommands.length > 0
+            ? exportedCommands
+            : [...registry.entries()]
+                .filter(([key, cmd]) => {
+                if (cmd.site !== site)
+                    return false;
+                const previous = before.get(key);
+                return !previous || previous !== cmd;
+            })
+                .map(([, cmd]) => cmd);
+        const seen = new Set();
+        return runtimeCommands
+            .filter((cmd) => {
+            const key = fullName(cmd);
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        })
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map(cmd => toManifestEntry(cmd, modulePath));
+    }
+    catch (err) {
+        // If parsing fails, log a warning (matching scanYaml behaviour) and skip the entry.
+        process.stderr.write(`Warning: failed to scan ${filePath}: ${getErrorMessage(err)}\n`);
+        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)) {
+        for (const site of fs.readdirSync(CLIS_DIR)) {
+            const siteDir = path.join(CLIS_DIR, site);
+            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') ||
+                    (file.endsWith('.js') && !file.endsWith('.d.js') && !file.endsWith('.test.js') && file !== 'index.js')) {
+                    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);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return [...manifest.values()].sort((a, b) => a.site.localeCompare(b.site) || a.name.localeCompare(b.name));
+}
+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}`);
+    // 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".
+    // See: https://github.com/jackwener/opencli/issues/446
+    if (process.platform !== 'win32') {
+        const pkgPath = path.resolve(__dirname, '..', 'package.json');
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            const bins = typeof pkg.bin === 'string'
+                ? { [pkg.name ?? 'cli']: pkg.bin }
+                : pkg.bin ?? {};
+            for (const binPath of Object.values(bins)) {
+                const abs = path.resolve(__dirname, '..', binPath);
+                if (fs.existsSync(abs)) {
+                    fs.chmodSync(abs, 0o755);
+                    console.log(`✅ Restored executable permission: ${binPath}`);
+                }
+            }
+        }
+        catch {
+            // Best-effort; never break the build for a permission fix.
+        }
+    }
+}
+const entrypoint = process.argv[1] ? pathToFileURL(path.resolve(process.argv[1])).href : null;
+if (entrypoint === import.meta.url) {
+    void main();
+}

package/vendor/opencli/dist/build-manifest.test.d.ts

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

package/vendor/opencli/dist/build-manifest.test.js

@@ -0,0 +1,176 @@
+import { afterEach, describe, expect, it } from 'vitest';
+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';
+describe('manifest helper rules', () => {
+    const tempDirs = [];
+    afterEach(() => {
+        for (const dir of tempDirs.splice(0)) {
+            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);
+        const file = path.join(dir, 'utils.ts');
+        fs.writeFileSync(file, `export function helper() { return 'noop'; }`);
+        return expect(loadTsManifestEntries(file, 'demo', async () => ({}))).resolves.toEqual([]);
+    });
+    it('builds TS manifest entries from exported runtime commands', async () => {
+        const site = `manifest-hydrate-${Date.now()}`;
+        const key = `${site}/dynamic`;
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-manifest-'));
+        tempDirs.push(dir);
+        const file = path.join(dir, `${site}.ts`);
+        fs.writeFileSync(file, `export const command = cli({ site: '${site}', name: 'dynamic' });`);
+        const entries = await loadTsManifestEntries(file, site, async () => ({
+            command: cli({
+                site,
+                name: 'dynamic',
+                description: 'dynamic command',
+                strategy: Strategy.PUBLIC,
+                browser: false,
+                aliases: ['metadata'],
+                args: [
+                    {
+                        name: 'model',
+                        required: true,
+                        positional: true,
+                        help: 'Choose a model',
+                        choices: ['auto', 'thinking'],
+                        default: '30',
+                    },
+                ],
+                domain: 'localhost',
+                navigateBefore: 'https://example.com/session',
+                deprecated: 'legacy command',
+                replacedBy: 'opencli demo new',
+            }),
+        }));
+        expect(entries).toEqual([
+            {
+                site,
+                name: 'dynamic',
+                description: 'dynamic command',
+                domain: 'localhost',
+                strategy: 'public',
+                browser: false,
+                aliases: ['metadata'],
+                args: [
+                    {
+                        name: 'model',
+                        type: 'str',
+                        required: true,
+                        positional: true,
+                        help: 'Choose a model',
+                        choices: ['auto', 'thinking'],
+                        default: '30',
+                    },
+                ],
+                type: 'ts',
+                modulePath: `${site}/${site}.js`,
+                navigateBefore: 'https://example.com/session',
+                deprecated: 'legacy command',
+                replacedBy: 'opencli demo new',
+            },
+        ]);
+        getRegistry().delete(key);
+    });
+    it('falls back to registry delta for side-effect-only cli modules', async () => {
+        const site = `manifest-side-effect-${Date.now()}`;
+        const key = `${site}/legacy`;
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-manifest-'));
+        tempDirs.push(dir);
+        const file = path.join(dir, `${site}.ts`);
+        fs.writeFileSync(file, `cli({ site: '${site}', name: 'legacy' });`);
+        const entries = await loadTsManifestEntries(file, site, async () => {
+            cli({
+                site,
+                name: 'legacy',
+                description: 'legacy command',
+                deprecated: 'legacy is deprecated',
+                replacedBy: 'opencli demo new',
+            });
+            return {};
+        });
+        expect(entries).toEqual([
+            {
+                site,
+                name: 'legacy',
+                description: 'legacy command',
+                strategy: 'cookie',
+                browser: true,
+                args: [],
+                type: 'ts',
+                modulePath: `${site}/${site}.js`,
+                deprecated: 'legacy is deprecated',
+                replacedBy: 'opencli demo new',
+            },
+        ]);
+        getRegistry().delete(key);
+    });
+    it('keeps every command a module exports instead of guessing by site', async () => {
+        const site = `manifest-multi-${Date.now()}`;
+        const screenKey = `${site}/screen`;
+        const statusKey = `${site}/status`;
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-manifest-'));
+        tempDirs.push(dir);
+        const file = path.join(dir, `${site}.ts`);
+        fs.writeFileSync(file, `export const screen = cli({ site: '${site}', name: 'screen' });`);
+        const entries = await loadTsManifestEntries(file, site, async () => ({
+            screen: cli({
+                site,
+                name: 'screen',
+                description: 'capture screen',
+            }),
+            status: cli({
+                site,
+                name: 'status',
+                description: 'show status',
+            }),
+        }));
+        expect(entries.map(entry => entry.name)).toEqual(['screen', 'status']);
+        getRegistry().delete(screenKey);
+        getRegistry().delete(statusKey);
+    });
+});

package/vendor/opencli/dist/capabilityRouting.d.ts

@@ -0,0 +1,4 @@
+import { type CliCommand } from './registry.js';
+/** Pipeline steps that require a live browser session. */
+export declare const BROWSER_ONLY_STEPS: Set<string>;
+export declare function shouldUseBrowserSession(cmd: CliCommand): boolean;

package/vendor/opencli/dist/capabilityRouting.js

@@ -0,0 +1,31 @@
+import { Strategy } from './registry.js';
+/** Pipeline steps that require a live browser session. */
+export const BROWSER_ONLY_STEPS = new Set([
+    'navigate',
+    'click',
+    'type',
+    'wait',
+    'press',
+    'snapshot',
+    'evaluate',
+    'intercept',
+    'tap',
+]);
+function pipelineNeedsBrowserSession(pipeline) {
+    return pipeline.some((step) => {
+        if (!step || typeof step !== 'object')
+            return false;
+        return Object.keys(step).some((op) => BROWSER_ONLY_STEPS.has(op));
+    });
+}
+export function shouldUseBrowserSession(cmd) {
+    if (!cmd.browser)
+        return false;
+    if (cmd.func)
+        return true;
+    if (!cmd.pipeline || cmd.pipeline.length === 0)
+        return true;
+    if (cmd.strategy !== Strategy.PUBLIC)
+        return true;
+    return pipelineNeedsBrowserSession(cmd.pipeline);
+}

package/vendor/opencli/dist/capabilityRouting.test.d.ts

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