@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/commanderAdapter.js

@@ -0,0 +1,301 @@
+/**
+ * Commander adapter: bridges Registry commands to Commander subcommands.
+ *
+ * This is a THIN adapter — it only handles:
+ * 1. Commander arg/option registration
+ * 2. Collecting kwargs from Commander's action args
+ * 3. Calling executeCommand (which handles browser sessions, validation, etc.)
+ * 4. Rendering output and errors
+ *
+ * All execution logic lives in execution.ts.
+ */
+import chalk from 'chalk';
+import { fullName, getRegistry } from './registry.js';
+import { formatRegistryHelpText } from './serialization.js';
+import { render as renderOutput } from './output.js';
+import { executeCommand } from './execution.js';
+import { CliError, EXIT_CODES, ERROR_ICONS, getErrorMessage, BrowserConnectError, AuthRequiredError, TimeoutError, SelectorError, EmptyResultError, ArgumentError, AdapterLoadError, CommandExecutionError, } from './errors.js';
+import { checkDaemonStatus } from './browser/discover.js';
+export function normalizeArgValue(argType, value, name) {
+    if (argType !== 'bool' && argType !== 'boolean')
+        return value;
+    if (typeof value === 'boolean')
+        return value;
+    if (value == null || value === '')
+        return false;
+    const normalized = String(value).trim().toLowerCase();
+    if (normalized === 'true')
+        return true;
+    if (normalized === 'false')
+        return false;
+    throw new ArgumentError(`"${name}" must be either "true" or "false".`);
+}
+/**
+ * Register a single CliCommand as a Commander subcommand.
+ */
+export function registerCommandToProgram(siteCmd, cmd) {
+    if (siteCmd.commands.some((c) => c.name() === cmd.name))
+        return;
+    const deprecatedSuffix = cmd.deprecated ? ' [deprecated]' : '';
+    const subCmd = siteCmd.command(cmd.name).description(`${cmd.description}${deprecatedSuffix}`);
+    if (cmd.aliases?.length)
+        subCmd.aliases(cmd.aliases);
+    // Register positional args first, then named options
+    const positionalArgs = [];
+    for (const arg of cmd.args) {
+        if (arg.positional) {
+            const bracket = arg.required ? `<${arg.name}>` : `[${arg.name}]`;
+            subCmd.argument(bracket, arg.help ?? '');
+            positionalArgs.push(arg);
+        }
+        else {
+            const expectsValue = arg.required || arg.valueRequired;
+            const flag = expectsValue ? `--${arg.name} <value>` : `--${arg.name} [value]`;
+            if (arg.required)
+                subCmd.requiredOption(flag, arg.help ?? '');
+            else if (arg.default != null)
+                subCmd.option(flag, arg.help ?? '', String(arg.default));
+            else
+                subCmd.option(flag, arg.help ?? '');
+        }
+    }
+    subCmd
+        .option('-f, --format <fmt>', 'Output format: table, plain, json, yaml, md, csv', 'table')
+        .option('-v, --verbose', 'Debug output', false);
+    subCmd.addHelpText('after', formatRegistryHelpText(cmd));
+    subCmd.action(async (...actionArgs) => {
+        const actionOpts = actionArgs[positionalArgs.length] ?? {};
+        const optionsRecord = typeof actionOpts === 'object' && actionOpts !== null ? actionOpts : {};
+        const startTime = Date.now();
+        // ── Execute + render ────────────────────────────────────────────────
+        try {
+            // ── Collect kwargs ────────────────────────────────────────────────
+            const kwargs = {};
+            for (let i = 0; i < positionalArgs.length; i++) {
+                const v = actionArgs[i];
+                if (v !== undefined)
+                    kwargs[positionalArgs[i].name] = v;
+            }
+            for (const arg of cmd.args) {
+                if (arg.positional)
+                    continue;
+                const camelName = arg.name.replace(/-([a-z])/g, (_m, ch) => ch.toUpperCase());
+                const v = optionsRecord[arg.name] ?? optionsRecord[camelName];
+                if (v !== undefined)
+                    kwargs[arg.name] = normalizeArgValue(arg.type, v, arg.name);
+            }
+            cmd.validateArgs?.(kwargs);
+            const verbose = optionsRecord.verbose === true;
+            let format = typeof optionsRecord.format === 'string' ? optionsRecord.format : 'table';
+            const formatExplicit = subCmd.getOptionValueSource('format') === 'cli';
+            if (verbose)
+                process.env.OPENCLI_VERBOSE = '1';
+            if (cmd.deprecated) {
+                const message = typeof cmd.deprecated === 'string' ? cmd.deprecated : `${fullName(cmd)} is deprecated.`;
+                const replacement = cmd.replacedBy ? ` Use ${cmd.replacedBy} instead.` : '';
+                console.error(chalk.yellow(`Deprecated: ${message}${replacement}`));
+            }
+            const result = await executeCommand(cmd, kwargs, verbose);
+            if (result === null || result === undefined) {
+                return;
+            }
+            const resolved = getRegistry().get(fullName(cmd)) ?? cmd;
+            if (!formatExplicit && format === 'table' && resolved.defaultFormat) {
+                format = resolved.defaultFormat;
+            }
+            if (verbose && (!result || (Array.isArray(result) && result.length === 0))) {
+                console.error(chalk.yellow('[Verbose] Warning: Command returned an empty result.'));
+            }
+            renderOutput(result, {
+                fmt: format,
+                fmtExplicit: formatExplicit,
+                columns: resolved.columns,
+                title: `${resolved.site}/${resolved.name}`,
+                elapsed: (Date.now() - startTime) / 1000,
+                source: fullName(resolved),
+                footerExtra: resolved.footerExtra?.(kwargs),
+            });
+        }
+        catch (err) {
+            await renderError(err, fullName(cmd), optionsRecord.verbose === true);
+            process.exitCode = resolveExitCode(err);
+        }
+    });
+}
+// ── Exit code resolution ─────────────────────────────────────────────────────
+/**
+ * Map any thrown value to a Unix process exit code.
+ *
+ * - CliError subclasses carry their own exitCode (set in errors.ts).
+ * - Generic Error objects are classified by message pattern so that
+ *   un-typed auth / not-found errors from adapters still produce
+ *   meaningful exit codes for shell scripts.
+ */
+function resolveExitCode(err) {
+    if (err instanceof CliError)
+        return err.exitCode;
+    // Pattern-based fallback for untyped errors thrown by third-party adapters.
+    const msg = getErrorMessage(err);
+    const kind = classifyGenericError(msg);
+    if (kind === 'auth')
+        return EXIT_CODES.NOPERM;
+    if (kind === 'not-found')
+        return EXIT_CODES.EMPTY_RESULT;
+    if (kind === 'http')
+        return EXIT_CODES.GENERIC_ERROR; // HTTP 4xx/5xx → generic; renderer shows details
+    return EXIT_CODES.GENERIC_ERROR;
+}
+// ── Error rendering ──────────────────────────────────────────────────────────
+const ISSUES_URL = 'https://github.com/jackwener/opencli/issues';
+/** Pattern-based classifier for untyped errors thrown by adapters. */
+function classifyGenericError(msg) {
+    const m = msg.toLowerCase();
+    if (/not logged in|login required|please log in|未登录|请先登录|authentication required|cookie expired/.test(m))
+        return 'auth';
+    // Match "HTTP 404", "status: 500", "status 403", bare "404 Not Found", etc.
+    if (/\b(status[: ]+)?[45]\d{2}\b|http[/ ][45]\d{2}/.test(m))
+        return 'http';
+    if (/not found|未找到|could not find|no .+ found/.test(m))
+        return 'not-found';
+    return 'other';
+}
+/** Render a status line for BrowserConnectError based on real-time or kind-derived state. */
+function renderBridgeStatus(running, extensionConnected) {
+    const ok = chalk.green('✓');
+    const fail = chalk.red('✗');
+    console.error(`  Daemon    ${running ? ok : fail} ${running ? 'running' : 'not running'}`);
+    console.error(`  Extension ${extensionConnected ? ok : fail} ${extensionConnected ? 'connected' : 'not connected'}`);
+    console.error();
+    if (!running) {
+        console.error(chalk.yellow('  Run the command again — daemon should auto-start.'));
+        console.error(chalk.dim('  Still failing? Run: opencli doctor'));
+    }
+    else if (!extensionConnected) {
+        console.error(chalk.yellow('  Install the Browser Bridge extension to continue:'));
+        console.error(chalk.dim('    1. Download from github.com/jackwener/opencli/releases'));
+        console.error(chalk.dim('    2. chrome://extensions → Enable Developer Mode → Load unpacked'));
+    }
+    else {
+        console.error(chalk.yellow('  Connection failed despite extension being active.'));
+        console.error(chalk.dim('  Try reloading the extension, or run: opencli doctor'));
+    }
+}
+async function renderError(err, cmdName, verbose) {
+    // ── BrowserConnectError: real-time diagnosis, kind as fallback ────────
+    if (err instanceof BrowserConnectError) {
+        console.error(chalk.red('🔌 Browser Bridge not connected'));
+        console.error();
+        try {
+            // 300ms matches execution.ts — localhost responds in <50ms when running.
+            const status = await checkDaemonStatus({ timeout: 300 });
+            renderBridgeStatus(status.running, status.extensionConnected);
+        }
+        catch (_statusErr) {
+            // checkDaemonStatus itself failed — derive best-guess state from kind.
+            const running = err.kind !== 'daemon-not-running';
+            const extensionConnected = err.kind === 'command-failed';
+            renderBridgeStatus(running, extensionConnected);
+        }
+        return;
+    }
+    // ── AuthRequiredError ─────────────────────────────────────────────────
+    if (err instanceof AuthRequiredError) {
+        console.error(chalk.red(`🔒 Not logged in to ${err.domain}`));
+        // Respect custom hints set by the adapter; fall back to generic guidance.
+        console.error(chalk.yellow(`→ ${err.hint ?? `Open Chrome or Chromium and log in to https://${err.domain}, then retry.`}`));
+        return;
+    }
+    // ── TimeoutError ──────────────────────────────────────────────────────
+    if (err instanceof TimeoutError) {
+        console.error(chalk.red(`⏱  ${err.message}`));
+        console.error(chalk.yellow('→ Try again, or raise the limit:'));
+        console.error(chalk.dim(`    OPENCLI_BROWSER_COMMAND_TIMEOUT=60 ${cmdName}`));
+        return;
+    }
+    // ── SelectorError / EmptyResultError: likely outdated adapter ─────────
+    if (err instanceof SelectorError || err instanceof EmptyResultError) {
+        const icon = ERROR_ICONS[err.code] ?? '⚠️';
+        console.error(chalk.red(`${icon} ${err.message}`));
+        console.error(chalk.yellow(`→ ${err.hint ?? 'The page structure may have changed — this adapter may be outdated.'}`));
+        console.error(chalk.dim(`  Debug:  ${cmdName} --verbose`));
+        console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
+        return;
+    }
+    // ── ArgumentError ─────────────────────────────────────────────────────
+    if (err instanceof ArgumentError) {
+        console.error(chalk.red(`❌ ${err.message}`));
+        if (err.hint)
+            console.error(chalk.yellow(`→ ${err.hint}`));
+        return;
+    }
+    // ── AdapterLoadError ──────────────────────────────────────────────────
+    if (err instanceof AdapterLoadError) {
+        console.error(chalk.red(`📦 ${err.message}`));
+        if (err.hint)
+            console.error(chalk.yellow(`→ ${err.hint}`));
+        return;
+    }
+    // ── CommandExecutionError ─────────────────────────────────────────────
+    if (err instanceof CommandExecutionError) {
+        console.error(chalk.red(`💥 ${err.message}`));
+        if (err.hint) {
+            console.error(chalk.yellow(`→ ${err.hint}`));
+        }
+        else {
+            console.error(chalk.dim(`  Add --verbose for details, or report: ${ISSUES_URL}`));
+        }
+        return;
+    }
+    // ── Other typed CliError (fallback for future codes) ──────────────────
+    if (err instanceof CliError) {
+        const icon = ERROR_ICONS[err.code] ?? '⚠️';
+        console.error(chalk.red(`${icon} ${err.message}`));
+        if (err.hint)
+            console.error(chalk.yellow(`→ ${err.hint}`));
+        return;
+    }
+    // ── Generic Error from adapters: classify by message pattern ──────────
+    const msg = getErrorMessage(err);
+    const kind = classifyGenericError(msg);
+    if (kind === 'auth') {
+        console.error(chalk.red(`🔒 ${msg}`));
+        console.error(chalk.yellow('→ Open Chrome or Chromium, log in to the target site, then retry.'));
+        return;
+    }
+    if (kind === 'http') {
+        console.error(chalk.red(`🌐 ${msg}`));
+        console.error(chalk.yellow('→ Check your login status, or the site may be temporarily unavailable.'));
+        return;
+    }
+    if (kind === 'not-found') {
+        console.error(chalk.red(`📭 ${msg}`));
+        console.error(chalk.yellow('→ The resource was not found. The adapter or page structure may have changed.'));
+        console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
+        return;
+    }
+    // ── Unknown error: show stack in verbose mode ─────────────────────────
+    if (verbose && err instanceof Error && err.stack) {
+        console.error(chalk.red(err.stack));
+    }
+    else {
+        console.error(chalk.red(`💥 Unexpected error: ${msg}`));
+        console.error(chalk.dim(`  Run with --verbose for details, or report: ${ISSUES_URL}`));
+    }
+}
+/**
+ * Register all commands from the registry onto a Commander program.
+ */
+export function registerAllCommands(program, siteGroups) {
+    const seen = new Set();
+    for (const [, cmd] of getRegistry()) {
+        if (seen.has(cmd))
+            continue;
+        seen.add(cmd);
+        let siteCmd = siteGroups.get(cmd.site);
+        if (!siteCmd) {
+            siteCmd = program.command(cmd.site).description(`${cmd.site} commands`);
+            siteGroups.set(cmd.site, siteCmd);
+        }
+        registerCommandToProgram(siteCmd, cmd);
+    }
+}

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

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

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

@@ -0,0 +1,244 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Command } from 'commander';
+import { EmptyResultError, SelectorError } from './errors.js';
+const { mockExecuteCommand, mockRenderOutput } = vi.hoisted(() => ({
+    mockExecuteCommand: vi.fn(),
+    mockRenderOutput: vi.fn(),
+}));
+vi.mock('./execution.js', () => ({
+    executeCommand: mockExecuteCommand,
+}));
+vi.mock('./output.js', () => ({
+    render: mockRenderOutput,
+}));
+import { registerCommandToProgram } from './commanderAdapter.js';
+describe('commanderAdapter arg passing', () => {
+    const cmd = {
+        site: 'paperreview',
+        name: 'submit',
+        description: 'Submit a PDF',
+        browser: false,
+        args: [
+            { name: 'pdf', positional: true, required: true, help: 'Path to the paper PDF' },
+            { name: 'dry-run', type: 'bool', default: false, help: 'Validate only' },
+            { name: 'prepare-only', type: 'bool', default: false, help: 'Prepare only' },
+        ],
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockExecuteCommand.mockResolvedValue([]);
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('passes bool flag values through to executeCommand for coercion', async () => {
+        const program = new Command();
+        const siteCmd = program.command('paperreview');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'false']);
+        expect(mockExecuteCommand).toHaveBeenCalled();
+        const kwargs = mockExecuteCommand.mock.calls[0][1];
+        expect(kwargs.pdf).toBe('./paper.pdf');
+        expect(kwargs).toHaveProperty('dry-run');
+    });
+    it('passes valueless bool flags as true to executeCommand', async () => {
+        const program = new Command();
+        const siteCmd = program.command('paperreview');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--prepare-only']);
+        expect(mockExecuteCommand).toHaveBeenCalled();
+        const kwargs = mockExecuteCommand.mock.calls[0][1];
+        expect(kwargs.pdf).toBe('./paper.pdf');
+        expect(kwargs['prepare-only']).toBe(true);
+    });
+    it('rejects invalid bool values before calling executeCommand', async () => {
+        const program = new Command();
+        const siteCmd = program.command('paperreview');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'maybe']);
+        // normalizeArgValue validates bools eagerly; executeCommand should not be reached
+        expect(mockExecuteCommand).not.toHaveBeenCalled();
+    });
+});
+describe('commanderAdapter boolean alias support', () => {
+    const cmd = {
+        site: 'reddit',
+        name: 'save',
+        description: 'Save a post',
+        browser: false,
+        args: [
+            { name: 'post-id', positional: true, required: true, help: 'Post ID' },
+            { name: 'undo', type: 'boolean', default: false, help: 'Unsave instead of save' },
+        ],
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockExecuteCommand.mockResolvedValue([]);
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('coerces default false for boolean args to a real boolean', async () => {
+        const program = new Command();
+        const siteCmd = program.command('reddit');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'reddit', 'save', 't3_abc123']);
+        expect(mockExecuteCommand).toHaveBeenCalled();
+        const kwargs = mockExecuteCommand.mock.calls[0][1];
+        expect(kwargs['post-id']).toBe('t3_abc123');
+        expect(kwargs.undo).toBe(false);
+    });
+    it('coerces explicit false for boolean args to a real boolean', async () => {
+        const program = new Command();
+        const siteCmd = program.command('reddit');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'reddit', 'save', 't3_abc123', '--undo', 'false']);
+        expect(mockExecuteCommand).toHaveBeenCalled();
+        const kwargs = mockExecuteCommand.mock.calls[0][1];
+        expect(kwargs.undo).toBe(false);
+    });
+});
+describe('commanderAdapter value-required optional options', () => {
+    const cmd = {
+        site: 'instagram',
+        name: 'post',
+        description: 'Post to Instagram',
+        browser: true,
+        args: [
+            { name: 'image', valueRequired: true, help: 'Single image path' },
+            { name: 'images', valueRequired: true, help: 'Comma-separated image paths' },
+            { name: 'content', positional: true, required: false, help: 'Caption text' },
+        ],
+        validateArgs: (kwargs) => {
+            if (!kwargs.image && !kwargs.images) {
+                throw new Error('media required');
+            }
+        },
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockExecuteCommand.mockResolvedValue([]);
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('requires a value when --image is present', async () => {
+        const program = new Command();
+        program.exitOverride();
+        const siteCmd = program.command('instagram');
+        registerCommandToProgram(siteCmd, cmd);
+        await expect(program.parseAsync(['node', 'opencli', 'instagram', 'post', '--image'])).rejects.toMatchObject({ code: 'commander.optionMissingArgument' });
+        expect(mockExecuteCommand).not.toHaveBeenCalled();
+    });
+    it('runs validateArgs before executeCommand so missing media does not dispatch the browser command', async () => {
+        const program = new Command();
+        const siteCmd = program.command('instagram');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'instagram', 'post', 'caption only']);
+        expect(mockExecuteCommand).not.toHaveBeenCalled();
+        expect(process.exitCode).toBeDefined();
+    });
+});
+describe('commanderAdapter command aliases', () => {
+    const cmd = {
+        site: 'notebooklm',
+        name: 'get',
+        aliases: ['metadata'],
+        description: 'Get notebook metadata',
+        browser: false,
+        args: [],
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockExecuteCommand.mockResolvedValue([]);
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('registers aliases with Commander so compatibility names execute the same command', async () => {
+        const program = new Command();
+        const siteCmd = program.command('notebooklm');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'notebooklm', 'metadata']);
+        expect(mockExecuteCommand).toHaveBeenCalledWith(cmd, {}, false);
+    });
+});
+describe('commanderAdapter default formats', () => {
+    const cmd = {
+        site: 'gemini',
+        name: 'ask',
+        description: 'Ask Gemini',
+        browser: false,
+        args: [],
+        columns: ['response'],
+        defaultFormat: 'plain',
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockExecuteCommand.mockResolvedValue([{ response: 'hello' }]);
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('uses the command defaultFormat when the user keeps the default table format', async () => {
+        const program = new Command();
+        const siteCmd = program.command('gemini');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'gemini', 'ask']);
+        expect(mockRenderOutput).toHaveBeenCalledWith([{ response: 'hello' }], expect.objectContaining({ fmt: 'plain' }));
+    });
+    it('respects an explicit user format over the command defaultFormat', async () => {
+        const program = new Command();
+        const siteCmd = program.command('gemini');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'gemini', 'ask', '--format', 'json']);
+        expect(mockRenderOutput).toHaveBeenCalledWith([{ response: 'hello' }], expect.objectContaining({ fmt: 'json' }));
+    });
+});
+describe('commanderAdapter empty result hints', () => {
+    const cmd = {
+        site: 'xiaohongshu',
+        name: 'note',
+        description: 'Read one note',
+        browser: false,
+        args: [
+            { name: 'note-id', positional: true, required: true, help: 'Note ID' },
+        ],
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('prints the adapter hint instead of the generic outdated-adapter message', async () => {
+        const program = new Command();
+        const siteCmd = program.command('xiaohongshu');
+        registerCommandToProgram(siteCmd, cmd);
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        mockExecuteCommand.mockRejectedValueOnce(new EmptyResultError('xiaohongshu/note', 'Pass the full search_result URL with xsec_token instead of a bare note ID.'));
+        await program.parseAsync(['node', 'opencli', 'xiaohongshu', 'note', '69ca3927000000001a020fd5']);
+        const output = errorSpy.mock.calls.flat().join('\n');
+        expect(output).toContain('xsec_token');
+        expect(output).not.toContain('this adapter may be outdated');
+        errorSpy.mockRestore();
+    });
+    it('prints selector-specific hints too', async () => {
+        const program = new Command();
+        const siteCmd = program.command('xiaohongshu');
+        registerCommandToProgram(siteCmd, cmd);
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        mockExecuteCommand.mockRejectedValueOnce(new SelectorError('.note-title', 'The note title selector no longer matches the current page.'));
+        await program.parseAsync(['node', 'opencli', 'xiaohongshu', 'note', '69ca3927000000001a020fd5']);
+        const output = errorSpy.mock.calls.flat().join('\n');
+        expect(output).toContain('selector no longer matches');
+        expect(output).not.toContain('this adapter may be outdated');
+        errorSpy.mockRestore();
+    });
+});

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

@@ -0,0 +1,9 @@
+/**
+ * CLI commands for daemon lifecycle management:
+ *   opencli daemon status  — show daemon state
+ *   opencli daemon stop    — graceful shutdown
+ *   opencli daemon restart — stop + respawn
+ */
+export declare function daemonStatus(): Promise<void>;
+export declare function daemonStop(): Promise<void>;
+export declare function daemonRestart(): Promise<void>;

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

@@ -0,0 +1,85 @@
+/**
+ * CLI commands for daemon lifecycle management:
+ *   opencli daemon status  — show daemon state
+ *   opencli daemon stop    — graceful shutdown
+ *   opencli daemon restart — stop + respawn
+ */
+import chalk from 'chalk';
+import { fetchDaemonStatus, requestDaemonShutdown } from '../browser/daemon-client.js';
+function formatUptime(seconds) {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    if (h > 0)
+        return `${h}h ${m}m`;
+    if (m > 0)
+        return `${m}m`;
+    return `${Math.floor(seconds)}s`;
+}
+function formatTimeSince(timestampMs) {
+    const seconds = (Date.now() - timestampMs) / 1000;
+    if (seconds < 60)
+        return `${Math.floor(seconds)}s ago`;
+    const m = Math.floor(seconds / 60);
+    if (m < 60)
+        return `${m} min ago`;
+    const h = Math.floor(m / 60);
+    return `${h}h ${m % 60}m ago`;
+}
+export async function daemonStatus() {
+    const status = await fetchDaemonStatus();
+    if (!status) {
+        console.log(`Daemon: ${chalk.dim('not running')}`);
+        return;
+    }
+    console.log(`Daemon: ${chalk.green('running')} (PID ${status.pid})`);
+    console.log(`Uptime: ${formatUptime(status.uptime)}`);
+    console.log(`Extension: ${status.extensionConnected ? chalk.green('connected') : chalk.yellow('disconnected')}`);
+    console.log(`Last CLI request: ${formatTimeSince(status.lastCliRequestTime)}`);
+    console.log(`Memory: ${status.memoryMB} MB`);
+    console.log(`Port: ${status.port}`);
+}
+export async function daemonStop() {
+    const status = await fetchDaemonStatus();
+    if (!status) {
+        console.log(chalk.dim('Daemon is not running.'));
+        return;
+    }
+    const ok = await requestDaemonShutdown();
+    if (ok) {
+        console.log(chalk.green('Daemon stopped.'));
+    }
+    else {
+        console.error(chalk.red('Failed to stop daemon.'));
+        process.exitCode = 1;
+    }
+}
+export async function daemonRestart() {
+    const status = await fetchDaemonStatus();
+    if (status) {
+        const ok = await requestDaemonShutdown();
+        if (!ok) {
+            console.error(chalk.red('Failed to stop daemon.'));
+            process.exitCode = 1;
+            return;
+        }
+        // Wait for daemon to actually exit (poll until unreachable)
+        const deadline = Date.now() + 5000;
+        while (Date.now() < deadline) {
+            await new Promise(r => setTimeout(r, 200));
+            if (!(await fetchDaemonStatus()))
+                break;
+        }
+    }
+    // Import BrowserBridge to spawn a new daemon
+    const { BrowserBridge } = await import('../browser/bridge.js');
+    const bridge = new BrowserBridge();
+    try {
+        console.log('Starting daemon...');
+        await bridge.connect({ timeout: 10 });
+        console.log(chalk.green('Daemon restarted.'));
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed to restart daemon: ${err instanceof Error ? err.message : err}`));
+        process.exitCode = 1;
+    }
+}

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

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