@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/synthesize.js

@@ -0,0 +1,216 @@
+/**
+ * Synthesize candidate CLIs from explore artifacts.
+ * Generates evaluate-based YAML pipelines (matching hand-written adapter patterns).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import yaml from 'js-yaml';
+import { VOLATILE_PARAMS, SEARCH_PARAMS, LIMIT_PARAMS, PAGINATION_PARAMS } from './constants.js';
+/** Renamed aliases for backward compatibility with local references */
+const SEARCH_PARAM_NAMES = SEARCH_PARAMS;
+const LIMIT_PARAM_NAMES = LIMIT_PARAMS;
+const PAGE_PARAM_NAMES = PAGINATION_PARAMS;
+export function synthesizeFromExplore(target, opts = {}) {
+    const exploreDir = resolveExploreDir(target);
+    const bundle = loadExploreBundle(exploreDir);
+    const targetDir = opts.outDir ?? path.join(exploreDir, 'candidates');
+    fs.mkdirSync(targetDir, { recursive: true });
+    const site = bundle.manifest.site;
+    const capabilities = (bundle.capabilities ?? [])
+        .sort((a, b) => (b.confidence ?? 0) - (a.confidence ?? 0))
+        .slice(0, opts.top ?? 3);
+    const candidates = [];
+    for (const cap of capabilities) {
+        const endpoint = chooseEndpoint(cap, bundle.endpoints);
+        if (!endpoint)
+            continue;
+        const candidate = buildCandidateYaml(site, bundle.manifest, cap, endpoint);
+        const filePath = path.join(targetDir, `${candidate.name}.yaml`);
+        fs.writeFileSync(filePath, yaml.dump(candidate.yaml, { sortKeys: false, lineWidth: 120 }));
+        candidates.push({ name: candidate.name, path: filePath, strategy: cap.strategy, confidence: cap.confidence });
+    }
+    const index = { site, target_url: bundle.manifest.target_url, generated_from: exploreDir, candidate_count: candidates.length, candidates };
+    fs.writeFileSync(path.join(targetDir, 'candidates.json'), JSON.stringify(index, null, 2));
+    return { site, explore_dir: exploreDir, out_dir: targetDir, candidate_count: candidates.length, candidates };
+}
+export function renderSynthesizeSummary(result) {
+    const lines = ['opencli synthesize: OK', `Site: ${result.site}`, `Source: ${result.explore_dir}`, `Candidates: ${result.candidate_count}`];
+    for (const c of result.candidates ?? [])
+        lines.push(`  • ${c.name} (${c.strategy}, ${((c.confidence ?? 0) * 100).toFixed(0)}% confidence) → ${c.path}`);
+    return lines.join('\n');
+}
+export function resolveExploreDir(target) {
+    if (fs.existsSync(target))
+        return target;
+    const candidate = path.join('.opencli', 'explore', target);
+    if (fs.existsSync(candidate))
+        return candidate;
+    throw new Error(`Explore directory not found: ${target}`);
+}
+export function loadExploreBundle(exploreDir) {
+    return {
+        manifest: JSON.parse(fs.readFileSync(path.join(exploreDir, 'manifest.json'), 'utf-8')),
+        endpoints: JSON.parse(fs.readFileSync(path.join(exploreDir, 'endpoints.json'), 'utf-8')),
+        capabilities: JSON.parse(fs.readFileSync(path.join(exploreDir, 'capabilities.json'), 'utf-8')),
+        auth: JSON.parse(fs.readFileSync(path.join(exploreDir, 'auth.json'), 'utf-8')),
+    };
+}
+function chooseEndpoint(cap, endpoints) {
+    if (!endpoints.length)
+        return null;
+    // Match by endpoint pattern from capability
+    if (cap.endpoint) {
+        const endpointPattern = cap.endpoint;
+        const match = endpoints.find((endpoint) => endpoint.pattern === endpointPattern || endpoint.url?.includes(endpointPattern));
+        if (match)
+            return match;
+    }
+    return [...endpoints].sort((a, b) => (b.score ?? 0) - (a.score ?? 0))[0];
+}
+// ── URL templating ─────────────────────────────────────────────────────────
+function buildTemplatedUrl(rawUrl, cap, _endpoint) {
+    try {
+        const u = new URL(rawUrl);
+        const base = `${u.protocol}//${u.host}${u.pathname}`;
+        const params = [];
+        const hasKeyword = cap.recommendedArgs?.some((arg) => arg.name === 'keyword');
+        u.searchParams.forEach((v, k) => {
+            if (VOLATILE_PARAMS.has(k))
+                return;
+            if (hasKeyword && SEARCH_PARAM_NAMES.has(k))
+                params.push([k, '${{ args.keyword }}']);
+            else if (LIMIT_PARAM_NAMES.has(k))
+                params.push([k, '${{ args.limit | default(20) }}']);
+            else if (PAGE_PARAM_NAMES.has(k))
+                params.push([k, '${{ args.page | default(1) }}']);
+            else
+                params.push([k, v]);
+        });
+        return params.length ? base + '?' + params.map(([k, v]) => `${k}=${v}`).join('&') : base;
+    }
+    catch {
+        return rawUrl;
+    }
+}
+/**
+ * Build inline evaluate script for browser-based fetch+parse.
+ * Follows patterns from bilibili/hot.yaml and twitter/trending.yaml.
+ */
+function buildEvaluateScript(url, itemPath, endpoint) {
+    const pathChain = itemPath.split('.').map((p) => `?.${p}`).join('');
+    const detectedFields = endpoint?.detectedFields ?? {};
+    const hasFields = Object.keys(detectedFields).length > 0;
+    let mapCode = '';
+    if (hasFields) {
+        const mappings = Object.entries(detectedFields)
+            .map(([role, field]) => `      ${role}: item${String(field).split('.').map(p => `?.${p}`).join('')}`)
+            .join(',\n');
+        mapCode = `.map((item) => ({\n${mappings}\n    }))`;
+    }
+    return [
+        '(async () => {',
+        `  const res = await fetch(${JSON.stringify(url)}, {`,
+        `    credentials: 'include'`,
+        '  });',
+        '  const data = await res.json();',
+        `  return (data${pathChain} || [])${mapCode};`,
+        '})()\n',
+    ].join('\n');
+}
+// ── YAML pipeline generation ───────────────────────────────────────────────
+function buildCandidateYaml(site, manifest, cap, endpoint) {
+    const needsBrowser = cap.strategy !== 'public';
+    const pipeline = [];
+    const templatedUrl = buildTemplatedUrl(endpoint?.url ?? manifest.target_url, cap, endpoint);
+    let domain = '';
+    try {
+        domain = new URL(manifest.target_url).hostname;
+    }
+    catch { }
+    if (cap.strategy === 'store-action' && cap.storeHint) {
+        // Store Action: navigate + wait + tap (declarative, clean)
+        pipeline.push({ navigate: manifest.target_url });
+        pipeline.push({ wait: 3 });
+        const tapStep = {
+            store: cap.storeHint.store,
+            action: cap.storeHint.action,
+            timeout: 8,
+        };
+        // Infer capture pattern from endpoint URL
+        if (endpoint?.url) {
+            try {
+                const epUrl = new URL(endpoint.url);
+                const pathParts = epUrl.pathname.split('/').filter((p) => p);
+                // Use last meaningful path segment as capture pattern
+                const capturePart = pathParts.filter((p) => !p.match(/^v\d+$/)).pop();
+                if (capturePart)
+                    tapStep.capture = capturePart;
+            }
+            catch { }
+        }
+        if (cap.itemPath)
+            tapStep.select = cap.itemPath;
+        pipeline.push({ tap: tapStep });
+    }
+    else if (needsBrowser) {
+        // Browser-based: navigate + evaluate (like bilibili/hot.yaml, twitter/trending.yaml)
+        pipeline.push({ navigate: manifest.target_url });
+        const itemPath = cap.itemPath ?? 'data.data.list';
+        pipeline.push({ evaluate: buildEvaluateScript(templatedUrl, itemPath, endpoint) });
+    }
+    else {
+        // Public API: direct fetch (like hackernews/top.yaml)
+        pipeline.push({ fetch: { url: templatedUrl } });
+        if (cap.itemPath)
+            pipeline.push({ select: cap.itemPath });
+    }
+    // Map fields
+    const mapStep = {};
+    const columns = cap.recommendedColumns ?? ['title', 'url'];
+    if (!cap.recommendedArgs?.some((arg) => arg.name === 'keyword'))
+        mapStep['rank'] = '${{ index + 1 }}';
+    const detectedFields = endpoint?.detectedFields ?? {};
+    for (const col of columns) {
+        const fieldPath = detectedFields[col];
+        mapStep[col] = fieldPath ? `\${{ item.${fieldPath} }}` : `\${{ item.${col} }}`;
+    }
+    pipeline.push({ map: mapStep });
+    pipeline.push({ limit: '${{ args.limit | default(20) }}' });
+    // Args
+    const argsDef = {};
+    for (const arg of cap.recommendedArgs ?? []) {
+        const def = { type: arg.type ?? 'str' };
+        if (arg.required)
+            def.required = true;
+        if (arg.default != null)
+            def.default = arg.default;
+        if (arg.name === 'keyword')
+            def.description = 'Search keyword';
+        else if (arg.name === 'limit')
+            def.description = 'Number of items to return';
+        else if (arg.name === 'page')
+            def.description = 'Page number';
+        argsDef[arg.name] = def;
+    }
+    if (!argsDef['limit'])
+        argsDef['limit'] = { type: 'int', default: 20, description: 'Number of items to return' };
+    return {
+        name: cap.name,
+        yaml: {
+            site, name: cap.name, description: `${cap.description || site + ' ' + cap.name} (auto-generated)`,
+            domain, strategy: cap.strategy, browser: needsBrowser,
+            args: argsDef, pipeline, columns: Object.keys(mapStep),
+        },
+    };
+}
+/** Backward-compatible export for scaffold.ts */
+export function buildCandidate(site, targetUrl, cap, endpoint) {
+    // Map old-style field names to new ones
+    const normalizedCap = {
+        ...cap,
+        recommendedArgs: cap.recommendedArgs ?? cap.recommended_args,
+        recommendedColumns: cap.recommendedColumns ?? cap.recommended_columns,
+    };
+    const manifest = { target_url: targetUrl, final_url: targetUrl };
+    return buildCandidateYaml(site, manifest, normalizedCap, endpoint);
+}

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

@@ -0,0 +1,29 @@
+export interface CheckboxItem {
+    label: string;
+    value: string;
+    checked: boolean;
+    /** Optional status to display after the label */
+    status?: string;
+    statusColor?: 'green' | 'yellow' | 'red' | 'dim';
+}
+/**
+ * Interactive multi-select checkbox prompt.
+ *
+ * Controls:
+ *   ↑/↓ or j/k  — navigate
+ *   Space        — toggle selection
+ *   a            — toggle all
+ *   Enter        — confirm
+ *   q/Esc        — cancel (returns empty)
+ */
+export declare function checkboxPrompt(items: CheckboxItem[], opts?: {
+    title?: string;
+    hint?: string;
+}): Promise<string[]>;
+/**
+ * Simple yes/no confirmation prompt.
+ *
+ * In non-TTY environments, returns `defaultYes` (defaults to true) without blocking.
+ * In TTY, waits for a single keypress: y/Enter → true, n/Esc/q → false.
+ */
+export declare function confirmPrompt(message: string, defaultYes?: boolean): Promise<boolean>;

package/vendor/opencli/dist/tui.js

@@ -0,0 +1,192 @@
+/**
+ * tui.ts — Zero-dependency interactive TUI components
+ *
+ * Uses raw stdin mode + ANSI escape codes for interactive prompts.
+ */
+import chalk from 'chalk';
+import { EXIT_CODES } from './errors.js';
+/**
+ * Interactive multi-select checkbox prompt.
+ *
+ * Controls:
+ *   ↑/↓ or j/k  — navigate
+ *   Space        — toggle selection
+ *   a            — toggle all
+ *   Enter        — confirm
+ *   q/Esc        — cancel (returns empty)
+ */
+export async function checkboxPrompt(items, opts = {}) {
+    if (items.length === 0)
+        return [];
+    const { stdin, stdout } = process;
+    if (!stdin.isTTY) {
+        // Non-interactive: return all checked items
+        return items.filter(i => i.checked).map(i => i.value);
+    }
+    let cursor = 0;
+    const state = items.map(i => ({ ...i }));
+    function colorStatus(status, color) {
+        if (!status)
+            return '';
+        switch (color) {
+            case 'green': return chalk.green(status);
+            case 'yellow': return chalk.yellow(status);
+            case 'red': return chalk.red(status);
+            case 'dim': return chalk.dim(status);
+            default: return chalk.dim(status);
+        }
+    }
+    function render() {
+        // Move cursor to start and clear
+        let out = '';
+        if (opts.title) {
+            out += `\n${chalk.bold(opts.title)}\n\n`;
+        }
+        for (let i = 0; i < state.length; i++) {
+            const item = state[i];
+            const pointer = i === cursor ? chalk.cyan('❯') : ' ';
+            const checkbox = item.checked ? chalk.green('◉') : chalk.dim('○');
+            const label = i === cursor ? chalk.bold(item.label) : item.label;
+            const status = colorStatus(item.status, item.statusColor);
+            out += `  ${pointer} ${checkbox} ${label}${status ? `  ${status}` : ''}\n`;
+        }
+        out += `\n  ${chalk.dim('↑↓ navigate  ·  Space toggle  ·  a all  ·  Enter confirm  ·  q cancel')}\n`;
+        return out;
+    }
+    return new Promise((resolve) => {
+        const wasRaw = stdin.isRaw;
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdout.write('\x1b[?25l'); // Hide cursor
+        let firstDraw = true;
+        function draw() {
+            // Clear previous render (skip on first draw)
+            if (!firstDraw) {
+                const lines = render().split('\n').length;
+                stdout.write(`\x1b[${lines}A\x1b[J`);
+            }
+            firstDraw = false;
+            stdout.write(render());
+        }
+        function cleanup() {
+            stdin.setRawMode(wasRaw ?? false);
+            stdin.pause();
+            stdin.removeListener('data', onData);
+            // Clear the TUI and restore cursor
+            const lines = render().split('\n').length;
+            stdout.write(`\x1b[${lines}A\x1b[J`);
+            stdout.write('\x1b[?25h'); // Show cursor
+        }
+        function onData(data) {
+            const key = data.toString();
+            // Arrow up / k
+            if (key === '\x1b[A' || key === 'k') {
+                cursor = (cursor - 1 + state.length) % state.length;
+                draw();
+                return;
+            }
+            // Arrow down / j
+            if (key === '\x1b[B' || key === 'j') {
+                cursor = (cursor + 1) % state.length;
+                draw();
+                return;
+            }
+            // Space — toggle
+            if (key === ' ') {
+                state[cursor].checked = !state[cursor].checked;
+                draw();
+                return;
+            }
+            // Tab — toggle and move down
+            if (key === '\t') {
+                state[cursor].checked = !state[cursor].checked;
+                cursor = (cursor + 1) % state.length;
+                draw();
+                return;
+            }
+            // 'a' — toggle all
+            if (key === 'a') {
+                const allChecked = state.every(i => i.checked);
+                for (const item of state)
+                    item.checked = !allChecked;
+                draw();
+                return;
+            }
+            // Enter — confirm
+            if (key === '\r' || key === '\n') {
+                cleanup();
+                const selected = state.filter(i => i.checked).map(i => i.value);
+                // Show summary
+                stdout.write(`  ${chalk.green('✓')} ${chalk.bold(`${selected.length} file(s) selected`)}\n\n`);
+                resolve(selected);
+                return;
+            }
+            // q / Esc — cancel
+            if (key === 'q' || key === '\x1b') {
+                cleanup();
+                stdout.write(`  ${chalk.yellow('✗')} ${chalk.dim('Cancelled')}\n\n`);
+                resolve([]);
+                return;
+            }
+            // Ctrl+C — exit process
+            if (key === '\x03') {
+                cleanup();
+                process.exit(EXIT_CODES.INTERRUPTED);
+            }
+        }
+        stdin.on('data', onData);
+        draw();
+    });
+}
+/**
+ * Simple yes/no confirmation prompt.
+ *
+ * In non-TTY environments, returns `defaultYes` (defaults to true) without blocking.
+ * In TTY, waits for a single keypress: y/Enter → true, n/Esc/q → false.
+ */
+export async function confirmPrompt(message, defaultYes = true) {
+    const { stdin, stdout } = process;
+    if (!stdin.isTTY)
+        return defaultYes;
+    const hint = defaultYes ? '[Y/n]' : '[y/N]';
+    stdout.write(`  ${message} ${chalk.dim(hint)} `);
+    return new Promise((resolve) => {
+        const wasRaw = stdin.isRaw;
+        stdin.setRawMode(true);
+        stdin.resume();
+        function cleanup() {
+            stdin.setRawMode(wasRaw ?? false);
+            stdin.pause();
+            stdin.removeListener('data', onData);
+            stdout.write('\n');
+        }
+        function onData(data) {
+            const key = data.toString();
+            // Ctrl+C
+            if (key === '\x03') {
+                cleanup();
+                process.exit(EXIT_CODES.INTERRUPTED);
+            }
+            // Enter — use default
+            if (key === '\r' || key === '\n') {
+                cleanup();
+                resolve(defaultYes);
+                return;
+            }
+            // y/Y — yes
+            if (key === 'y' || key === 'Y') {
+                cleanup();
+                resolve(true);
+                return;
+            }
+            // n/N/q/Esc — no
+            if (key === 'n' || key === 'N' || key === 'q' || key === '\x1b') {
+                cleanup();
+                resolve(false);
+                return;
+            }
+            // Ignore other keys
+        }
+        stdin.on('data', onData);
+    });
+}

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

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

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

@@ -0,0 +1,19 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { confirmPrompt } from './tui.js';
+describe('confirmPrompt', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('returns defaultYes when stdin is not TTY', async () => {
+        const result = await confirmPrompt('Restart?', true);
+        expect(result).toBe(true);
+    });
+    it('returns false when defaultYes is false and non-TTY', async () => {
+        const result = await confirmPrompt('Restart?', false);
+        expect(result).toBe(false);
+    });
+    it('defaults to true when defaultYes is omitted and non-TTY', async () => {
+        const result = await confirmPrompt('Restart?');
+        expect(result).toBe(true);
+    });
+});

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

@@ -0,0 +1,98 @@
+/**
+ * Page interface: type-safe abstraction over browser page.
+ *
+ * All pipeline steps and CLI adapters should use this interface
+ * instead of `any` for browser interactions.
+ */
+export interface BrowserCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    expirationDate?: number;
+}
+export interface SnapshotOptions {
+    interactive?: boolean;
+    compact?: boolean;
+    maxDepth?: number;
+    raw?: boolean;
+    viewportExpand?: number;
+    maxTextLength?: number;
+}
+export interface WaitOptions {
+    text?: string;
+    selector?: string;
+    time?: number;
+    timeout?: number;
+}
+export interface ScreenshotOptions {
+    format?: 'png' | 'jpeg';
+    quality?: number;
+    fullPage?: boolean;
+    path?: string;
+}
+export interface BrowserSessionInfo {
+    workspace?: string;
+    connected?: boolean;
+    [key: string]: unknown;
+}
+export interface IPage {
+    goto(url: string, options?: {
+        waitUntil?: 'load' | 'none';
+        settleMs?: number;
+    }): Promise<void>;
+    evaluate(js: string): Promise<any>;
+    getCookies(opts?: {
+        domain?: string;
+        url?: string;
+    }): Promise<BrowserCookie[]>;
+    snapshot(opts?: SnapshotOptions): Promise<any>;
+    click(ref: string): Promise<void>;
+    typeText(ref: string, text: string): Promise<void>;
+    pressKey(key: string): Promise<void>;
+    scrollTo(ref: string): Promise<any>;
+    getFormState(): Promise<any>;
+    wait(options: number | WaitOptions): Promise<void>;
+    tabs(): Promise<any>;
+    closeTab?(index?: number): Promise<void>;
+    newTab?(): Promise<void>;
+    selectTab(index: number): Promise<void>;
+    networkRequests(includeStatic?: boolean): Promise<any>;
+    consoleMessages(level?: string): Promise<any>;
+    scroll(direction?: string, amount?: number): Promise<void>;
+    autoScroll(options?: {
+        times?: number;
+        delayMs?: number;
+    }): Promise<void>;
+    installInterceptor(pattern: string): Promise<void>;
+    getInterceptedRequests(): Promise<any[]>;
+    waitForCapture(timeout?: number): Promise<void>;
+    screenshot(options?: ScreenshotOptions): Promise<string>;
+    startNetworkCapture?(pattern?: string): Promise<void>;
+    readNetworkCapture?(): Promise<unknown[]>;
+    /**
+     * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
+     * Chrome reads the files directly — no base64 encoding or payload size limits.
+     */
+    setFileInput?(files: string[], selector?: string): Promise<void>;
+    /**
+     * Insert text via native CDP Input.insertText into the currently focused element.
+     * Useful for rich editors that ignore synthetic DOM value/text mutations.
+     */
+    insertText?(text: string): Promise<void>;
+    closeWindow?(): Promise<void>;
+    /** Returns the current page URL, or null if unavailable. */
+    getCurrentUrl?(): Promise<string | null>;
+    /** Returns the active tab ID, or undefined if not yet resolved. */
+    getActiveTabId?(): number | undefined;
+    /** Send a raw CDP command via chrome.debugger passthrough. */
+    cdp?(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    /** Click at native coordinates via CDP Input.dispatchMouseEvent. */
+    nativeClick?(x: number, y: number): Promise<void>;
+    /** Type text via CDP Input.insertText. */
+    nativeType?(text: string): Promise<void>;
+    /** Press a key via CDP Input.dispatchKeyEvent. */
+    nativeKeyPress?(key: string, modifiers?: string[]): Promise<void>;
+}

package/vendor/opencli/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * Page interface: type-safe abstraction over browser page.
+ *
+ * All pipeline steps and CLI adapters should use this interface
+ * instead of `any` for browser interactions.
+ */
+export {};

package/vendor/opencli/dist/update-check.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Non-blocking update checker.
+ *
+ * Pattern: register exit-hook + kick-off-background-fetch
+ * - On startup: kick off background fetch (non-blocking)
+ * - On process exit: read cache, print notice if newer version exists
+ * - Check interval: 24 hours
+ * - Notice appears AFTER command output, not before (same as npm/gh/yarn)
+ * - Never delays or blocks the CLI command
+ */
+/**
+ * Register a process exit hook that prints an update notice if a newer
+ * version was found on the last background check.
+ * Notice appears after command output — same pattern as npm/gh/yarn.
+ * Skipped during --get-completions to avoid polluting shell completion output.
+ */
+export declare function registerUpdateNoticeOnExit(): void;
+/**
+ * Kick off a background fetch to npm registry. Writes to cache for next run.
+ * Fully non-blocking — never awaited.
+ */
+export declare function checkForUpdateBackground(): void;