@huyuan-ai/cli 1.0.0 → 1.0.2

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

@@ -0,0 +1,310 @@
+/**
+ * CDP client — implements IPage by connecting directly to a Chrome/Electron CDP WebSocket.
+ *
+ * Fixes applied:
+ * - send() now has a 30s timeout guard (P0 #4)
+ * - goto() waits for Page.loadEventFired instead of hardcoded 1s sleep (P1 #3)
+ * - Implemented scroll, autoScroll, screenshot, networkRequests (P1 #2)
+ * - Shared DOM helper methods extracted to reduce duplication with Page (P1 #5)
+ */
+import { WebSocket } from 'ws';
+import { request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { wrapForEval } from './utils.js';
+import { generateStealthJs } from './stealth.js';
+import { waitForDomStableJs } from './dom-helpers.js';
+import { isRecord, saveBase64ToFile } from '../utils.js';
+import { getAllElectronApps } from '../electron-apps.js';
+import { BasePage } from './base-page.js';
+const CDP_SEND_TIMEOUT = 30_000;
+export class CDPBridge {
+    _ws = null;
+    _idCounter = 0;
+    _pending = new Map();
+    _eventListeners = new Map();
+    async connect(opts) {
+        if (this._ws)
+            throw new Error('CDPBridge is already connected. Call close() before reconnecting.');
+        const endpoint = opts?.cdpEndpoint ?? process.env.OPENCLI_CDP_ENDPOINT;
+        if (!endpoint)
+            throw new Error('CDP endpoint not provided (pass cdpEndpoint or set OPENCLI_CDP_ENDPOINT)');
+        let wsUrl = endpoint;
+        if (endpoint.startsWith('http')) {
+            const targets = await fetchJsonDirect(`${endpoint.replace(/\/$/, '')}/json`);
+            const target = selectCDPTarget(targets);
+            if (!target || !target.webSocketDebuggerUrl) {
+                throw new Error('No inspectable targets found at CDP endpoint');
+            }
+            wsUrl = target.webSocketDebuggerUrl;
+        }
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(wsUrl);
+            const timeoutMs = (opts?.timeout ?? 10) * 1000;
+            const timeout = setTimeout(() => reject(new Error('CDP connect timeout')), timeoutMs);
+            ws.on('open', async () => {
+                clearTimeout(timeout);
+                this._ws = ws;
+                try {
+                    await this.send('Page.enable');
+                    await this.send('Page.addScriptToEvaluateOnNewDocument', { source: generateStealthJs() });
+                }
+                catch { }
+                resolve(new CDPPage(this));
+            });
+            ws.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+            ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.id && this._pending.has(msg.id)) {
+                        const entry = this._pending.get(msg.id);
+                        clearTimeout(entry.timer);
+                        this._pending.delete(msg.id);
+                        if (msg.error) {
+                            entry.reject(new Error(msg.error.message));
+                        }
+                        else {
+                            entry.resolve(msg.result);
+                        }
+                    }
+                    if (msg.method) {
+                        const listeners = this._eventListeners.get(msg.method);
+                        if (listeners) {
+                            for (const fn of listeners)
+                                fn(msg.params);
+                        }
+                    }
+                }
+                catch { }
+            });
+        });
+    }
+    async close() {
+        if (this._ws) {
+            this._ws.close();
+            this._ws = null;
+        }
+        for (const p of this._pending.values()) {
+            clearTimeout(p.timer);
+            p.reject(new Error('CDP connection closed'));
+        }
+        this._pending.clear();
+        this._eventListeners.clear();
+    }
+    async send(method, params = {}, timeoutMs = CDP_SEND_TIMEOUT) {
+        if (!this._ws || this._ws.readyState !== WebSocket.OPEN) {
+            throw new Error('CDP connection is not open');
+        }
+        const id = ++this._idCounter;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this._pending.delete(id);
+                reject(new Error(`CDP command '${method}' timed out after ${timeoutMs / 1000}s`));
+            }, timeoutMs);
+            this._pending.set(id, { resolve, reject, timer });
+            this._ws.send(JSON.stringify({ id, method, params }));
+        });
+    }
+    on(event, handler) {
+        let set = this._eventListeners.get(event);
+        if (!set) {
+            set = new Set();
+            this._eventListeners.set(event, set);
+        }
+        set.add(handler);
+    }
+    off(event, handler) {
+        this._eventListeners.get(event)?.delete(handler);
+    }
+    waitForEvent(event, timeoutMs = 15_000) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.off(event, handler);
+                reject(new Error(`Timed out waiting for CDP event '${event}'`));
+            }, timeoutMs);
+            const handler = (params) => {
+                clearTimeout(timer);
+                this.off(event, handler);
+                resolve(params);
+            };
+            this.on(event, handler);
+        });
+    }
+}
+class CDPPage extends BasePage {
+    bridge;
+    _pageEnabled = false;
+    constructor(bridge) {
+        super();
+        this.bridge = bridge;
+    }
+    async goto(url, options) {
+        if (!this._pageEnabled) {
+            await this.bridge.send('Page.enable');
+            this._pageEnabled = true;
+        }
+        const loadPromise = this.bridge.waitForEvent('Page.loadEventFired', 30_000).catch(() => { });
+        await this.bridge.send('Page.navigate', { url });
+        await loadPromise;
+        this._lastUrl = url;
+        if (options?.waitUntil !== 'none') {
+            const maxMs = options?.settleMs ?? 1000;
+            await this.evaluate(waitForDomStableJs(maxMs, Math.min(500, maxMs)));
+        }
+    }
+    async evaluate(js) {
+        const expression = wrapForEval(js);
+        const result = await this.bridge.send('Runtime.evaluate', {
+            expression,
+            returnByValue: true,
+            awaitPromise: true,
+        });
+        if (result.exceptionDetails) {
+            throw new Error('Evaluate error: ' + (result.exceptionDetails.exception?.description || 'Unknown exception'));
+        }
+        return result.result?.value;
+    }
+    async getCookies(opts = {}) {
+        const result = await this.bridge.send('Network.getCookies', opts.url ? { urls: [opts.url] } : {});
+        const cookies = isRecord(result) && Array.isArray(result.cookies) ? result.cookies : [];
+        const domain = opts.domain;
+        return domain
+            ? cookies.filter((cookie) => isCookie(cookie) && matchesCookieDomain(cookie.domain, domain))
+            : cookies;
+    }
+    async screenshot(options = {}) {
+        const result = await this.bridge.send('Page.captureScreenshot', {
+            format: options.format ?? 'png',
+            quality: options.format === 'jpeg' ? (options.quality ?? 80) : undefined,
+            captureBeyondViewport: options.fullPage ?? false,
+        });
+        const base64 = isRecord(result) && typeof result.data === 'string' ? result.data : '';
+        if (options.path) {
+            await saveBase64ToFile(base64, options.path);
+        }
+        return base64;
+    }
+    async tabs() {
+        return [];
+    }
+    async selectTab(_index) {
+        // Not supported in direct CDP mode
+    }
+}
+function isCookie(value) {
+    return isRecord(value)
+        && typeof value.name === 'string'
+        && typeof value.value === 'string'
+        && typeof value.domain === 'string';
+}
+function matchesCookieDomain(cookieDomain, targetDomain) {
+    const normalizedCookieDomain = cookieDomain.replace(/^\./, '').toLowerCase();
+    const normalizedTargetDomain = targetDomain.replace(/^\./, '').toLowerCase();
+    return normalizedTargetDomain === normalizedCookieDomain
+        || normalizedTargetDomain.endsWith(`.${normalizedCookieDomain}`);
+}
+function selectCDPTarget(targets) {
+    const preferredPattern = compilePreferredPattern(process.env.OPENCLI_CDP_TARGET);
+    const ranked = targets
+        .map((target, index) => ({ target, index, score: scoreCDPTarget(target, preferredPattern) }))
+        .filter(({ score }) => Number.isFinite(score))
+        .sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        return a.index - b.index;
+    });
+    return ranked[0]?.target;
+}
+function scoreCDPTarget(target, preferredPattern) {
+    if (!target.webSocketDebuggerUrl)
+        return Number.NEGATIVE_INFINITY;
+    const type = (target.type ?? '').toLowerCase();
+    const url = (target.url ?? '').toLowerCase();
+    const title = (target.title ?? '').toLowerCase();
+    const haystack = `${title} ${url}`;
+    if (!haystack.trim() && !type)
+        return Number.NEGATIVE_INFINITY;
+    if (haystack.includes('devtools'))
+        return Number.NEGATIVE_INFINITY;
+    if (type === 'background_page' || type === 'service_worker')
+        return Number.NEGATIVE_INFINITY;
+    let score = 0;
+    if (preferredPattern && preferredPattern.test(haystack))
+        score += 1000;
+    if (type === 'app')
+        score += 120;
+    else if (type === 'webview')
+        score += 100;
+    else if (type === 'page')
+        score += 80;
+    else if (type === 'iframe')
+        score += 20;
+    if (url.startsWith('http://localhost') || url.startsWith('https://localhost'))
+        score += 90;
+    if (url.startsWith('file://'))
+        score += 60;
+    if (url.startsWith('http://127.0.0.1') || url.startsWith('https://127.0.0.1'))
+        score += 50;
+    if (url.startsWith('about:blank'))
+        score -= 120;
+    if (url === '' || url === 'about:blank')
+        score -= 40;
+    if (title && title !== 'devtools')
+        score += 25;
+    // Boost score for known Electron app names from the registry (builtin + user-defined)
+    const appNames = Object.values(getAllElectronApps()).map(a => (a.displayName ?? a.processName).toLowerCase());
+    for (const name of appNames) {
+        if (title.includes(name)) {
+            score += 120;
+            break;
+        }
+    }
+    for (const name of appNames) {
+        if (url.includes(name)) {
+            score += 100;
+            break;
+        }
+    }
+    return score;
+}
+function compilePreferredPattern(raw) {
+    const value = raw?.trim();
+    if (!value)
+        return undefined;
+    return new RegExp(escapeRegExp(value.toLowerCase()));
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export const __test__ = {
+    selectCDPTarget,
+    scoreCDPTarget,
+};
+function fetchJsonDirect(url) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const request = (parsed.protocol === 'https:' ? httpsRequest : httpRequest)(parsed, (res) => {
+            const statusCode = res.statusCode ?? 0;
+            if (statusCode < 200 || statusCode >= 300) {
+                res.resume();
+                reject(new Error(`Failed to fetch CDP targets: HTTP ${statusCode}`));
+                return;
+            }
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+                }
+                catch (error) {
+                    reject(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+        });
+        request.on('error', reject);
+        request.setTimeout(10_000, () => request.destroy(new Error('Timed out fetching CDP targets')));
+        request.end();
+    });
+}

package/vendor/opencli/dist/browser/cdp.test.d.ts

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

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

@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { MockWebSocket } = vi.hoisted(() => {
+    class MockWebSocket {
+        static OPEN = 1;
+        readyState = 1;
+        handlers = new Map();
+        constructor(_url) {
+            queueMicrotask(() => this.emit('open'));
+        }
+        on(event, handler) {
+            const handlers = this.handlers.get(event) ?? [];
+            handlers.push(handler);
+            this.handlers.set(event, handlers);
+        }
+        send(_message) { }
+        close() {
+            this.readyState = 3;
+        }
+        emit(event, ...args) {
+            for (const handler of this.handlers.get(event) ?? []) {
+                handler(...args);
+            }
+        }
+    }
+    return { MockWebSocket };
+});
+vi.mock('ws', () => ({
+    WebSocket: MockWebSocket,
+}));
+import { CDPBridge } from './cdp.js';
+describe('CDPBridge cookies', () => {
+    beforeEach(() => {
+        vi.unstubAllEnvs();
+    });
+    it('filters cookies by actual domain match instead of substring match', async () => {
+        vi.stubEnv('OPENCLI_CDP_ENDPOINT', 'ws://127.0.0.1:9222/devtools/page/1');
+        const bridge = new CDPBridge();
+        vi.spyOn(bridge, 'send').mockResolvedValue({
+            cookies: [
+                { name: 'good', value: '1', domain: '.example.com' },
+                { name: 'exact', value: '2', domain: 'example.com' },
+                { name: 'bad', value: '3', domain: 'notexample.com' },
+            ],
+        });
+        const page = await bridge.connect();
+        const cookies = await page.getCookies({ domain: 'example.com' });
+        expect(cookies).toEqual([
+            { name: 'good', value: '1', domain: '.example.com' },
+            { name: 'exact', value: '2', domain: 'example.com' },
+        ]);
+    });
+});

package/vendor/opencli/dist/browser/daemon-client.d.ts

@@ -0,0 +1,74 @@
+/**
+ * HTTP client for communicating with the opencli daemon.
+ *
+ * Provides a typed send() function that posts a Command and returns a Result.
+ */
+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';
+    tabId?: number;
+    code?: string;
+    workspace?: string;
+    url?: string;
+    op?: string;
+    index?: number;
+    domain?: string;
+    matchDomain?: string;
+    matchPathPrefix?: string;
+    format?: 'png' | 'jpeg';
+    quality?: number;
+    fullPage?: boolean;
+    /** Local file paths for set-file-input action */
+    files?: string[];
+    /** CSS selector for file input element (set-file-input action) */
+    selector?: string;
+    /** Raw text payload for insert-text action */
+    text?: string;
+    /** URL substring filter pattern for network capture */
+    pattern?: string;
+    cdpMethod?: string;
+    cdpParams?: Record<string, unknown>;
+}
+export interface DaemonResult {
+    id: string;
+    ok: boolean;
+    data?: unknown;
+    error?: string;
+}
+export interface DaemonStatus {
+    ok: boolean;
+    pid: number;
+    uptime: number;
+    extensionConnected: boolean;
+    extensionVersion?: string;
+    pending: number;
+    lastCliRequestTime: number;
+    memoryMB: number;
+    port: number;
+}
+export declare function fetchDaemonStatus(opts?: {
+    timeout?: number;
+}): Promise<DaemonStatus | null>;
+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,
+ * transient extension errors retry at 1500ms.
+ */
+export declare function sendCommand(action: DaemonCommand['action'], params?: Omit<DaemonCommand, 'id' | 'action'>): Promise<unknown>;
+export declare function listSessions(): Promise<BrowserSessionInfo[]>;
+export declare function bindCurrentTab(workspace: string, opts?: {
+    matchDomain?: string;
+    matchPathPrefix?: string;
+}): Promise<unknown>;

package/vendor/opencli/dist/browser/daemon-client.js

@@ -0,0 +1,113 @@
+/**
+ * HTTP client for communicating with the opencli daemon.
+ *
+ * Provides a typed send() function that posts a Command and returns a Result.
+ */
+import { DEFAULT_DAEMON_PORT } from '../constants.js';
+import { sleep } from '../utils.js';
+import { isTransientBrowserError } 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' };
+let _idCounter = 0;
+function generateId() {
+    return `cmd_${Date.now()}_${++_idCounter}`;
+}
+async function requestDaemon(pathname, init) {
+    const { timeout = 2000, headers, ...rest } = init ?? {};
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+        return await fetch(`${DAEMON_URL}${pathname}`, {
+            ...rest,
+            headers: { ...OPENCLI_HEADERS, ...headers },
+            signal: controller.signal,
+        });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function fetchDaemonStatus(opts) {
+    try {
+        const res = await requestDaemon('/status', { timeout: opts?.timeout ?? 2000 });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+export async function requestDaemonShutdown(opts) {
+    try {
+        const res = await requestDaemon('/shutdown', { method: 'POST', timeout: opts?.timeout ?? 5000 });
+        return res.ok;
+    }
+    catch {
+        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,
+ * transient extension errors retry at 1500ms.
+ */
+export async function sendCommand(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 };
+        try {
+            const res = await requestDaemon('/command', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(command),
+                timeout: 30000,
+            });
+            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);
+                    continue;
+                }
+                throw new Error(result.error ?? 'Daemon command failed');
+            }
+            return result.data;
+        }
+        catch (err) {
+            const isRetryable = err instanceof TypeError // fetch network error
+                || (err instanceof Error && err.name === 'AbortError');
+            if (isRetryable && attempt < maxRetries) {
+                await sleep(500);
+                continue;
+            }
+            throw err;
+        }
+    }
+    // Unreachable — the loop always returns or throws
+    throw new Error('sendCommand: max retries exhausted');
+}
+export async function listSessions() {
+    const result = await sendCommand('sessions');
+    return Array.isArray(result) ? result : [];
+}
+export async function bindCurrentTab(workspace, opts = {}) {
+    return sendCommand('bind-current', { workspace, ...opts });
+}

package/vendor/opencli/dist/browser/daemon-client.test.d.ts

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

package/vendor/opencli/dist/browser/daemon-client.test.js

@@ -0,0 +1,77 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { fetchDaemonStatus, isDaemonRunning, isExtensionConnected, requestDaemonShutdown, } from './daemon-client.js';
+describe('daemon-client', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('fetchDaemonStatus sends the shared status request and returns parsed data', async () => {
+        const status = {
+            ok: true,
+            pid: 123,
+            uptime: 10,
+            extensionConnected: true,
+            extensionVersion: '1.2.3',
+            pending: 0,
+            lastCliRequestTime: Date.now(),
+            memoryMB: 32,
+            port: 19825,
+        };
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(status),
+        });
+        await expect(fetchDaemonStatus()).resolves.toEqual(status);
+        expect(fetchMock).toHaveBeenCalledWith(expect.stringMatching(/\/status$/), expect.objectContaining({
+            headers: expect.objectContaining({ 'X-OpenCLI': '1' }),
+        }));
+    });
+    it('fetchDaemonStatus returns null on network failure', async () => {
+        vi.mocked(fetch).mockRejectedValue(new Error('ECONNREFUSED'));
+        await expect(fetchDaemonStatus()).resolves.toBeNull();
+    });
+    it('requestDaemonShutdown POSTs to the shared shutdown endpoint', async () => {
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({ ok: true });
+        await expect(requestDaemonShutdown()).resolves.toBe(true);
+        expect(fetchMock).toHaveBeenCalledWith(expect.stringMatching(/\/shutdown$/), expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({ 'X-OpenCLI': '1' }),
+        }));
+    });
+    it('isDaemonRunning reflects shared status availability', async () => {
+        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,
+            }),
+        });
+        await expect(isDaemonRunning()).resolves.toBe(true);
+    });
+    it('isExtensionConnected reflects shared status payload', async () => {
+        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,
+            }),
+        });
+        await expect(isExtensionConnected()).resolves.toBe(false);
+    });
+});

package/vendor/opencli/dist/browser/discover.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Daemon discovery — checks if the daemon is running.
+ */
+import { isDaemonRunning } from './daemon-client.js';
+export { isDaemonRunning };
+/**
+ * Check daemon status and return connection info.
+ */
+export declare function checkDaemonStatus(opts?: {
+    timeout?: number;
+}): Promise<{
+    running: boolean;
+    extensionConnected: boolean;
+    extensionVersion?: string;
+}>;

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

@@ -0,0 +1,19 @@
+/**
+ * Daemon discovery — checks if the daemon is running.
+ */
+import { fetchDaemonStatus, isDaemonRunning } from './daemon-client.js';
+export { isDaemonRunning };
+/**
+ * Check daemon status and return connection info.
+ */
+export async function checkDaemonStatus(opts) {
+    const status = await fetchDaemonStatus({ timeout: opts?.timeout ?? 2000 });
+    if (!status) {
+        return { running: false, extensionConnected: false };
+    }
+    return {
+        running: true,
+        extensionConnected: status.extensionConnected,
+        extensionVersion: status.extensionVersion,
+    };
+}