@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/commands/daemon.test.js

@@ -0,0 +1,160 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+const { fetchDaemonStatusMock, requestDaemonShutdownMock, } = vi.hoisted(() => ({
+    fetchDaemonStatusMock: vi.fn(),
+    requestDaemonShutdownMock: vi.fn(),
+}));
+vi.mock('chalk', () => ({
+    default: {
+        green: (s) => s,
+        yellow: (s) => s,
+        red: (s) => s,
+        dim: (s) => s,
+    },
+}));
+const mockConnect = vi.fn();
+vi.mock('../browser/bridge.js', () => ({
+    BrowserBridge: class {
+        connect = mockConnect;
+    },
+}));
+vi.mock('../browser/daemon-client.js', () => ({
+    fetchDaemonStatus: fetchDaemonStatusMock,
+    requestDaemonShutdown: requestDaemonShutdownMock,
+}));
+import { daemonStatus, daemonStop, daemonRestart } from './daemon.js';
+describe('daemon commands', () => {
+    let logSpy;
+    let errorSpy;
+    beforeEach(() => {
+        logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        fetchDaemonStatusMock.mockReset();
+        requestDaemonShutdownMock.mockReset();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        mockConnect.mockReset();
+    });
+    describe('daemonStatus', () => {
+        it('shows "not running" when daemon is unreachable', async () => {
+            fetchDaemonStatusMock.mockResolvedValue(null);
+            await daemonStatus();
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
+        });
+        it('shows "not running" when daemon returns non-ok response', async () => {
+            fetchDaemonStatusMock.mockResolvedValue(null);
+            await daemonStatus();
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
+        });
+        it('shows daemon info when running', async () => {
+            const status = {
+                ok: true,
+                pid: 12345,
+                uptime: 3661,
+                extensionConnected: true,
+                pending: 0,
+                lastCliRequestTime: Date.now() - 30_000,
+                memoryMB: 64,
+                port: 19825,
+            };
+            fetchDaemonStatusMock.mockResolvedValue(status);
+            await daemonStatus();
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('running'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('PID 12345'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('1h 1m'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('connected'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('64 MB'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('19825'));
+        });
+        it('shows disconnected when extension is not connected', async () => {
+            const status = {
+                ok: true,
+                pid: 99,
+                uptime: 120,
+                extensionConnected: false,
+                pending: 0,
+                lastCliRequestTime: Date.now() - 5000,
+                memoryMB: 32,
+                port: 19825,
+            };
+            fetchDaemonStatusMock.mockResolvedValue(status);
+            await daemonStatus();
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('disconnected'));
+        });
+    });
+    describe('daemonStop', () => {
+        it('reports "not running" when daemon is unreachable', async () => {
+            fetchDaemonStatusMock.mockResolvedValue(null);
+            await daemonStop();
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
+        });
+        it('sends shutdown and reports success', async () => {
+            fetchDaemonStatusMock.mockResolvedValue({
+                ok: true,
+                pid: 12345,
+                uptime: 100,
+                extensionConnected: true,
+                pending: 0,
+                lastCliRequestTime: Date.now(),
+                memoryMB: 50,
+                port: 19825,
+            });
+            requestDaemonShutdownMock.mockResolvedValue(true);
+            await daemonStop();
+            expect(requestDaemonShutdownMock).toHaveBeenCalledTimes(1);
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Daemon stopped'));
+        });
+        it('reports failure when shutdown request fails', async () => {
+            fetchDaemonStatusMock.mockResolvedValue({
+                ok: true,
+                pid: 12345,
+                uptime: 100,
+                extensionConnected: true,
+                pending: 0,
+                lastCliRequestTime: Date.now(),
+                memoryMB: 50,
+                port: 19825,
+            });
+            requestDaemonShutdownMock.mockResolvedValue(false);
+            await daemonStop();
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon'));
+        });
+    });
+    describe('daemonRestart', () => {
+        const statusData = {
+            ok: true,
+            pid: 12345,
+            uptime: 100,
+            extensionConnected: true,
+            pending: 0,
+            lastCliRequestTime: Date.now(),
+            memoryMB: 50,
+            port: 19825,
+        };
+        it('starts daemon directly when not running', async () => {
+            fetchDaemonStatusMock.mockResolvedValue(null);
+            mockConnect.mockResolvedValue(undefined);
+            await daemonRestart();
+            expect(mockConnect).toHaveBeenCalledWith({ timeout: 10 });
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Daemon restarted'));
+        });
+        it('stops then starts when daemon is running', async () => {
+            fetchDaemonStatusMock
+                .mockResolvedValueOnce(statusData)
+                .mockResolvedValueOnce(null);
+            requestDaemonShutdownMock.mockResolvedValue(true);
+            mockConnect.mockResolvedValue(undefined);
+            await daemonRestart();
+            expect(requestDaemonShutdownMock).toHaveBeenCalledTimes(1);
+            expect(mockConnect).toHaveBeenCalledWith({ timeout: 10 });
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Daemon restarted'));
+        });
+        it('aborts when shutdown fails', async () => {
+            fetchDaemonStatusMock.mockResolvedValue(statusData);
+            requestDaemonShutdownMock.mockResolvedValue(false);
+            await daemonRestart();
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon'));
+            expect(mockConnect).not.toHaveBeenCalled();
+        });
+    });
+});

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

@@ -0,0 +1,21 @@
+/**
+ * Shell tab-completion support for opencli.
+ *
+ * Provides:
+ *  - Shell script generators for bash, zsh, and fish
+ *  - Dynamic completion logic that returns candidates for the current cursor position
+ */
+/**
+ * Return completion candidates given the current command-line words and cursor index.
+ *
+ * @param words  - The argv after 'opencli' (words[0] is the first arg, e.g. site name)
+ * @param cursor - 1-based position of the word being completed (1 = first arg)
+ */
+export declare function getCompletions(words: string[], cursor: number): string[];
+export declare function bashCompletionScript(): string;
+export declare function zshCompletionScript(): string;
+export declare function fishCompletionScript(): string;
+/**
+ * Print the completion script for the requested shell.
+ */
+export declare function printCompletionScript(shell: string): void;

package/vendor/opencli/dist/completion.js

@@ -0,0 +1,120 @@
+/**
+ * Shell tab-completion support for opencli.
+ *
+ * Provides:
+ *  - Shell script generators for bash, zsh, and fish
+ *  - Dynamic completion logic that returns candidates for the current cursor position
+ */
+import { getRegistry } from './registry.js';
+import { CliError } from './errors.js';
+// ── Dynamic completion logic ───────────────────────────────────────────────
+/**
+ * Built-in (non-dynamic) top-level commands.
+ */
+const BUILTIN_COMMANDS = [
+    'list',
+    'validate',
+    'verify',
+    'explore',
+    'probe', // alias for explore
+    'synthesize',
+    'generate',
+    'cascade',
+    'doctor',
+    'plugin',
+    'install',
+    'register',
+    'completion',
+];
+/**
+ * Return completion candidates given the current command-line words and cursor index.
+ *
+ * @param words  - The argv after 'opencli' (words[0] is the first arg, e.g. site name)
+ * @param cursor - 1-based position of the word being completed (1 = first arg)
+ */
+export function getCompletions(words, cursor) {
+    // cursor === 1 → completing the first argument (site name or built-in command)
+    if (cursor <= 1) {
+        const sites = new Set();
+        for (const [, cmd] of getRegistry()) {
+            sites.add(cmd.site);
+        }
+        return [...BUILTIN_COMMANDS, ...sites].sort();
+    }
+    const site = words[0];
+    // If the first word is a built-in command, no further completion
+    if (BUILTIN_COMMANDS.includes(site)) {
+        return [];
+    }
+    // cursor === 2 → completing the sub-command name under a site
+    if (cursor === 2) {
+        const subcommands = [];
+        for (const [, cmd] of getRegistry()) {
+            if (cmd.site === site) {
+                subcommands.push(cmd.name);
+                if (cmd.aliases?.length)
+                    subcommands.push(...cmd.aliases);
+            }
+        }
+        return [...new Set(subcommands)].sort();
+    }
+    // cursor >= 3 → no further completion
+    return [];
+}
+// ── Shell script generators ────────────────────────────────────────────────
+export function bashCompletionScript() {
+    return `# Bash completion for opencli
+# Add to ~/.bashrc:  eval "$(opencli completion bash)"
+_opencli_completions() {
+  local cur words cword
+  _get_comp_words_by_ref -n : cur words cword
+
+  local completions
+  completions=$(opencli --get-completions --cursor "$cword" "\${words[@]:1}" 2>/dev/null)
+
+  COMPREPLY=( $(compgen -W "$completions" -- "$cur") )
+  __ltrim_colon_completions "$cur"
+}
+complete -F _opencli_completions opencli
+`;
+}
+export function zshCompletionScript() {
+    return `# Zsh completion for opencli
+# Add to ~/.zshrc:  eval "$(opencli completion zsh)"
+_opencli() {
+  local -a completions
+  local cword=$((CURRENT - 1))
+  completions=(\${(f)"$(opencli --get-completions --cursor "$cword" "\${words[@]:1}" 2>/dev/null)"})
+  compadd -a completions
+}
+compdef _opencli opencli
+`;
+}
+export function fishCompletionScript() {
+    return `# Fish completion for opencli
+# Add to ~/.config/fish/config.fish:  opencli completion fish | source
+complete -c opencli -f -a '(
+  set -l tokens (commandline -cop)
+  set -l cursor (count (commandline -cop))
+  opencli --get-completions --cursor $cursor $tokens[2..] 2>/dev/null
+)'
+`;
+}
+/**
+ * Print the completion script for the requested shell.
+ */
+export function printCompletionScript(shell) {
+    switch (shell) {
+        case 'bash':
+            process.stdout.write(bashCompletionScript());
+            break;
+        case 'zsh':
+            process.stdout.write(zshCompletionScript());
+            break;
+        case 'fish':
+            process.stdout.write(fishCompletionScript());
+            break;
+        default:
+            throw new CliError('UNSUPPORTED_SHELL', `Unsupported shell: ${shell}. Supported: bash, zsh, fish`);
+    }
+}

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

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

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

@@ -0,0 +1,23 @@
+import { describe, expect, it, vi } from 'vitest';
+const { mockGetRegistry } = vi.hoisted(() => ({
+    mockGetRegistry: vi.fn(() => new Map([
+        ['github/issues', { site: 'github', name: 'issues' }],
+    ])),
+}));
+vi.mock('./registry.js', () => ({
+    getRegistry: mockGetRegistry,
+}));
+import { getCompletions } from './completion.js';
+describe('getCompletions', () => {
+    it('includes top-level built-ins that are registered outside the site registry', () => {
+        const completions = getCompletions([], 1);
+        expect(completions).toContain('plugin');
+        expect(completions).toContain('install');
+        expect(completions).toContain('register');
+        expect(completions).not.toContain('setup');
+    });
+    it('still includes discovered site names', () => {
+        const completions = getCompletions([], 1);
+        expect(completions).toContain('github');
+    });
+});

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

@@ -0,0 +1,17 @@
+/**
+ * Shared constants used across explore, synthesize, and pipeline modules.
+ */
+/** Default daemon port for HTTP/WebSocket communication with browser extension */
+export declare const DEFAULT_DAEMON_PORT = 19825;
+/** Default idle timeout before daemon auto-exits (ms). Override via OPENCLI_DAEMON_TIMEOUT env var. */
+export declare const DEFAULT_DAEMON_IDLE_TIMEOUT: number;
+/** URL query params that are volatile/ephemeral and should be stripped from patterns */
+export declare const VOLATILE_PARAMS: Set<string>;
+/** Search-related query parameter names */
+export declare const SEARCH_PARAMS: Set<string>;
+/** Pagination-related query parameter names */
+export declare const PAGINATION_PARAMS: Set<string>;
+/** Limit/page-size query parameter names */
+export declare const LIMIT_PARAMS: Set<string>;
+/** Field role → common API field names mapping */
+export declare const FIELD_ROLES: Record<string, string[]>;

package/vendor/opencli/dist/constants.js

@@ -0,0 +1,34 @@
+/**
+ * Shared constants used across explore, synthesize, and pipeline modules.
+ */
+/** Default daemon port for HTTP/WebSocket communication with browser extension */
+export const DEFAULT_DAEMON_PORT = 19825;
+/** Default idle timeout before daemon auto-exits (ms). Override via OPENCLI_DAEMON_TIMEOUT env var. */
+export const DEFAULT_DAEMON_IDLE_TIMEOUT = 4 * 60 * 60 * 1000; // 4 hours
+/** URL query params that are volatile/ephemeral and should be stripped from patterns */
+export const VOLATILE_PARAMS = new Set([
+    'w_rid', 'wts', '_', 'callback', 'timestamp', 't', 'nonce', 'sign',
+]);
+/** Search-related query parameter names */
+export const SEARCH_PARAMS = new Set([
+    'q', 'query', 'keyword', 'search', 'wd', 'kw', 'search_query', 'w',
+]);
+/** Pagination-related query parameter names */
+export const PAGINATION_PARAMS = new Set([
+    'page', 'pn', 'offset', 'cursor', 'next', 'page_num',
+]);
+/** Limit/page-size query parameter names */
+export const LIMIT_PARAMS = new Set([
+    'limit', 'count', 'size', 'per_page', 'page_size', 'ps', 'num',
+]);
+/** Field role → common API field names mapping */
+export const FIELD_ROLES = {
+    title: ['title', 'name', 'text', 'content', 'desc', 'description', 'headline', 'subject'],
+    url: ['url', 'uri', 'link', 'href', 'permalink', 'jump_url', 'web_url', 'share_url'],
+    author: ['author', 'username', 'user_name', 'nickname', 'nick', 'owner', 'creator', 'up_name', 'uname'],
+    score: ['score', 'hot', 'heat', 'likes', 'like_count', 'view_count', 'views', 'play', 'favorite_count', 'reply_count'],
+    time: ['time', 'created_at', 'publish_time', 'pub_time', 'date', 'ctime', 'mtime', 'pubdate', 'created'],
+    id: ['id', 'aid', 'bvid', 'mid', 'uid', 'oid', 'note_id', 'item_id'],
+    cover: ['cover', 'pic', 'image', 'thumbnail', 'poster', 'avatar'],
+    category: ['category', 'tag', 'type', 'tname', 'channel', 'section'],
+};

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

@@ -0,0 +1,21 @@
+/**
+ * opencli micro-daemon — HTTP + WebSocket bridge between CLI and Chrome Extension.
+ *
+ * Architecture:
+ *   CLI → HTTP POST /command → daemon → WebSocket → Extension
+ *   Extension → WebSocket result → daemon → HTTP response → CLI
+ *
+ * Security (defense-in-depth against browser-based CSRF):
+ *   1. Origin check — reject HTTP/WS from non chrome-extension:// origins
+ *   2. Custom header — require X-OpenCLI header (browsers can't send it
+ *      without CORS preflight, which we deny)
+ *   3. No CORS headers — responses never include Access-Control-Allow-Origin
+ *   4. Body size limit — 1 MB max to prevent OOM
+ *   5. WebSocket verifyClient — reject upgrade before connection is established
+ *
+ * Lifecycle:
+ *   - Auto-spawned by opencli on first browser command
+ *   - Auto-exits after idle timeout (default 4h, configurable via OPENCLI_DAEMON_TIMEOUT)
+ *   - Listens on localhost:19825
+ */
+export {};