@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/external.js

@@ -0,0 +1,209 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { spawnSync, execFileSync } from 'node:child_process';
+import yaml from 'js-yaml';
+import chalk from 'chalk';
+import { log } from './logger.js';
+import { EXIT_CODES, getErrorMessage } from './errors.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function getUserRegistryPath() {
+    const home = os.homedir();
+    return path.join(home, '.opencli', 'external-clis.yaml');
+}
+let _cachedExternalClis = null;
+export function loadExternalClis() {
+    if (_cachedExternalClis)
+        return _cachedExternalClis;
+    const configs = new Map();
+    // 1. Load built-in
+    const builtinPath = path.resolve(__dirname, 'external-clis.yaml');
+    try {
+        if (fs.existsSync(builtinPath)) {
+            const raw = fs.readFileSync(builtinPath, 'utf8');
+            const parsed = (yaml.load(raw) || []);
+            for (const item of parsed)
+                configs.set(item.name, item);
+        }
+    }
+    catch (err) {
+        log.warn(`Failed to parse built-in external-clis.yaml: ${getErrorMessage(err)}`);
+    }
+    // 2. Load user custom
+    const userPath = getUserRegistryPath();
+    try {
+        if (fs.existsSync(userPath)) {
+            const raw = fs.readFileSync(userPath, 'utf8');
+            const parsed = (yaml.load(raw) || []);
+            for (const item of parsed) {
+                configs.set(item.name, item); // Overwrite built-in if duplicated
+            }
+        }
+    }
+    catch (err) {
+        log.warn(`Failed to parse user external-clis.yaml: ${getErrorMessage(err)}`);
+    }
+    _cachedExternalClis = Array.from(configs.values()).sort((a, b) => a.name.localeCompare(b.name));
+    return _cachedExternalClis;
+}
+export function isBinaryInstalled(binary) {
+    try {
+        const isWindows = os.platform() === 'win32';
+        execFileSync(isWindows ? 'where' : 'which', [binary], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getInstallCmd(installConfig) {
+    if (!installConfig)
+        return null;
+    const platform = os.platform();
+    if (platform === 'darwin' && installConfig.mac)
+        return installConfig.mac;
+    if (platform === 'linux' && installConfig.linux)
+        return installConfig.linux;
+    if (platform === 'win32' && installConfig.windows)
+        return installConfig.windows;
+    if (installConfig.default)
+        return installConfig.default;
+    return null;
+}
+/**
+ * Safely parses a command string into a binary and argument list.
+ * Rejects commands containing shell operators (&&, ||, |, ;, >, <, `) that
+ * cannot be safely expressed as execFileSync arguments.
+ *
+ * Args:
+ *   cmd: Raw command string from YAML config (e.g. "brew install gh")
+ *
+ * Returns:
+ *   Object with `binary` and `args` fields, or throws on unsafe input.
+ */
+export function parseCommand(cmd) {
+    const shellOperators = /&&|\|\|?|;|[><`$#\n\r]|\$\(/;
+    if (shellOperators.test(cmd)) {
+        throw new Error(`Install command contains unsafe shell operators and cannot be executed securely: "${cmd}". ` +
+            `Please install the tool manually.`);
+    }
+    // Tokenise respecting single- and double-quoted segments (no variable expansion).
+    const tokens = [];
+    const re = /(?:"([^"]*)")|(?:'([^']*)')|(\S+)/g;
+    let match;
+    while ((match = re.exec(cmd)) !== null) {
+        tokens.push(match[1] ?? match[2] ?? match[3]);
+    }
+    if (tokens.length === 0) {
+        throw new Error(`Install command is empty.`);
+    }
+    const [binary, ...args] = tokens;
+    return { binary, args };
+}
+function shouldRetryWithCmdShim(binary, err) {
+    const code = err instanceof Error ? err.code : undefined;
+    return os.platform() === 'win32' && !path.extname(binary) && code === 'ENOENT';
+}
+function runInstallCommand(cmd) {
+    const { binary, args } = parseCommand(cmd);
+    try {
+        execFileSync(binary, args, { stdio: 'inherit' });
+    }
+    catch (err) {
+        if (shouldRetryWithCmdShim(binary, err)) {
+            execFileSync(`${binary}.cmd`, args, { stdio: 'inherit' });
+            return;
+        }
+        throw err;
+    }
+}
+export function installExternalCli(cli) {
+    if (!cli.install) {
+        console.error(chalk.red(`No auto-install command configured for '${cli.name}'.`));
+        console.error(`Please install '${cli.binary}' manually.`);
+        return false;
+    }
+    const cmd = getInstallCmd(cli.install);
+    if (!cmd) {
+        console.error(chalk.red(`No install command for your platform (${os.platform()}) for '${cli.name}'.`));
+        if (cli.homepage)
+            console.error(`See: ${cli.homepage}`);
+        return false;
+    }
+    console.log(chalk.cyan(`🔹 '${cli.name}' is not installed. Auto-installing...`));
+    console.log(chalk.dim(`$ ${cmd}`));
+    try {
+        runInstallCommand(cmd);
+        console.log(chalk.green(`✅ Installed '${cli.name}' successfully.\n`));
+        return true;
+    }
+    catch (err) {
+        console.error(chalk.red(`❌ Failed to install '${cli.name}': ${getErrorMessage(err)}`));
+        return false;
+    }
+}
+export function executeExternalCli(name, args, preloaded) {
+    const configs = preloaded ?? loadExternalClis();
+    const cli = configs.find((c) => c.name === name);
+    if (!cli) {
+        throw new Error(`External CLI '${name}' not found in registry.`);
+    }
+    // 1. Check if installed
+    if (!isBinaryInstalled(cli.binary)) {
+        // 2. Try to auto install
+        const success = installExternalCli(cli);
+        if (!success) {
+            process.exitCode = EXIT_CODES.SERVICE_UNAVAIL;
+            return;
+        }
+    }
+    // 3. Passthrough execution with stdio inherited
+    const result = spawnSync(cli.binary, args, { stdio: 'inherit' });
+    if (result.error) {
+        console.error(chalk.red(`Failed to execute '${cli.binary}': ${result.error.message}`));
+        process.exitCode = EXIT_CODES.GENERIC_ERROR;
+        return;
+    }
+    if (result.status !== null) {
+        process.exitCode = result.status;
+    }
+}
+export function registerExternalCli(name, opts) {
+    const userPath = getUserRegistryPath();
+    const configDir = path.dirname(userPath);
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    let items = [];
+    if (fs.existsSync(userPath)) {
+        try {
+            const raw = fs.readFileSync(userPath, 'utf8');
+            items = (yaml.load(raw) || []);
+        }
+        catch {
+            // Ignore
+        }
+    }
+    const existingIndex = items.findIndex((c) => c.name === name);
+    const newItem = {
+        name,
+        binary: opts?.binary || name,
+    };
+    if (opts?.description)
+        newItem.description = opts.description;
+    if (opts?.install)
+        newItem.install = { default: opts.install };
+    if (existingIndex >= 0) {
+        items[existingIndex] = { ...items[existingIndex], ...newItem };
+        console.log(chalk.green(`Updated '${name}' in user registry.`));
+    }
+    else {
+        items.push(newItem);
+        console.log(chalk.green(`Registered '${name}' in user registry.`));
+    }
+    const dump = yaml.dump(items, { indent: 2, sortKeys: true });
+    fs.writeFileSync(userPath, dump, 'utf8');
+    _cachedExternalClis = null; // Invalidate cache so next load reflects the change
+    console.log(chalk.dim(userPath));
+}

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

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

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

@@ -0,0 +1,68 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockExecFileSync, mockPlatform } = vi.hoisted(() => ({
+    mockExecFileSync: vi.fn(),
+    mockPlatform: vi.fn(() => 'darwin'),
+}));
+vi.mock('node:child_process', () => ({
+    spawnSync: vi.fn(),
+    execFileSync: mockExecFileSync,
+}));
+vi.mock('node:os', async () => {
+    const actual = await vi.importActual('node:os');
+    return {
+        ...actual,
+        platform: mockPlatform,
+    };
+});
+import { installExternalCli, parseCommand } from './external.js';
+describe('parseCommand', () => {
+    it('splits binaries and quoted arguments without invoking a shell', () => {
+        expect(parseCommand('npm install -g "@scope/tool name"')).toEqual({
+            binary: 'npm',
+            args: ['install', '-g', '@scope/tool name'],
+        });
+    });
+    it('rejects shell operators', () => {
+        expect(() => parseCommand('brew install gh && rm -rf /')).toThrow('Install command contains unsafe shell operators');
+    });
+    it('rejects command substitution and multiline input', () => {
+        expect(() => parseCommand('brew install $(whoami)')).toThrow('Install command contains unsafe shell operators');
+        expect(() => parseCommand('brew install gh\nrm -rf /')).toThrow('Install command contains unsafe shell operators');
+    });
+});
+describe('installExternalCli', () => {
+    const cli = {
+        name: 'readwise',
+        binary: 'readwise',
+        install: {
+            default: 'npm install -g @readwiseio/readwise-cli',
+        },
+    };
+    beforeEach(() => {
+        mockExecFileSync.mockReset();
+        mockPlatform.mockReturnValue('darwin');
+    });
+    it('retries with .cmd on Windows when the bare binary is unavailable', () => {
+        mockPlatform.mockReturnValue('win32');
+        mockExecFileSync
+            .mockImplementationOnce(() => {
+            const err = new Error('not found');
+            err.code = 'ENOENT';
+            throw err;
+        })
+            .mockReturnValueOnce(Buffer.from(''));
+        expect(installExternalCli(cli)).toBe(true);
+        expect(mockExecFileSync).toHaveBeenNthCalledWith(1, 'npm', ['install', '-g', '@readwiseio/readwise-cli'], { stdio: 'inherit' });
+        expect(mockExecFileSync).toHaveBeenNthCalledWith(2, 'npm.cmd', ['install', '-g', '@readwiseio/readwise-cli'], { stdio: 'inherit' });
+    });
+    it('does not mask non-ENOENT failures', () => {
+        mockPlatform.mockReturnValue('win32');
+        mockExecFileSync.mockImplementationOnce(() => {
+            const err = new Error('permission denied');
+            err.code = 'EACCES';
+            throw err;
+        });
+        expect(installExternalCli(cli)).toBe(false);
+        expect(mockExecFileSync).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -0,0 +1,41 @@
+/**
+ * Generate: one-shot CLI creation from URL.
+ *
+ * Orchestrates the full pipeline:
+ *   explore (Deep Explore) → synthesize (YAML generation) → register → verify
+ *
+ * Includes Strategy Cascade: if the initial strategy fails,
+ * automatically downgrades and retries.
+ */
+import type { IBrowserFactory } from './runtime.js';
+import { type SynthesizeCandidateSummary } from './synthesize.js';
+export interface GenerateCliOptions {
+    url: string;
+    BrowserFactory: new () => IBrowserFactory;
+    goal?: string | null;
+    site?: string;
+    waitSeconds?: number;
+    top?: number;
+    workspace?: string;
+}
+export interface GenerateCliResult {
+    ok: boolean;
+    goal?: string | null;
+    normalized_goal?: string | null;
+    site: string;
+    selected_candidate: SynthesizeCandidateSummary | null;
+    selected_command: string;
+    explore: {
+        endpoint_count: number;
+        api_endpoint_count: number;
+        capability_count: number;
+        top_strategy: string;
+        framework: Record<string, boolean>;
+    };
+    synthesize: {
+        candidate_count: number;
+        candidates: Array<Pick<SynthesizeCandidateSummary, 'name' | 'strategy' | 'confidence'>>;
+    };
+}
+export declare function generateCliFromUrl(opts: GenerateCliOptions): Promise<GenerateCliResult>;
+export declare function renderGenerateSummary(r: GenerateCliResult): string;

package/vendor/opencli/dist/generate.js

@@ -0,0 +1,121 @@
+/**
+ * Generate: one-shot CLI creation from URL.
+ *
+ * Orchestrates the full pipeline:
+ *   explore (Deep Explore) → synthesize (YAML generation) → register → verify
+ *
+ * Includes Strategy Cascade: if the initial strategy fails,
+ * automatically downgrades and retries.
+ */
+import { exploreUrl } from './explore.js';
+import { synthesizeFromExplore } from './synthesize.js';
+const CAPABILITY_ALIASES = {
+    search: ['search', '搜索', '查找', 'query', 'keyword'],
+    hot: ['hot', '热门', '热榜', '热搜', 'popular', 'top', 'ranking'],
+    trending: ['trending', '趋势', '流行', 'discover'],
+    feed: ['feed', '动态', '关注', '时间线', 'timeline', 'following'],
+    me: ['profile', 'me', '个人信息', 'myinfo', '账号'],
+    detail: ['detail', '详情', 'video', 'article', 'view'],
+    comments: ['comments', '评论', '回复', 'reply'],
+    history: ['history', '历史', '记录'],
+    favorite: ['favorite', '收藏', 'bookmark', 'collect'],
+};
+/**
+ * Normalize a goal string to a standard capability name.
+ */
+function normalizeGoal(goal) {
+    if (!goal)
+        return null;
+    const lower = goal.trim().toLowerCase();
+    for (const [cap, aliases] of Object.entries(CAPABILITY_ALIASES)) {
+        if (lower === cap || aliases.some(a => lower.includes(a.toLowerCase())))
+            return cap;
+    }
+    return null;
+}
+/**
+ * Select the best candidate matching the user's goal.
+ */
+function selectCandidate(candidates, goal) {
+    if (!candidates.length)
+        return null;
+    if (!goal)
+        return candidates[0]; // highest confidence first
+    const normalized = normalizeGoal(goal);
+    if (normalized) {
+        const exact = candidates.find(c => c.name === normalized);
+        if (exact)
+            return exact;
+    }
+    const lower = (goal ?? '').trim().toLowerCase();
+    const partial = candidates.find(c => {
+        const cName = c.name?.toLowerCase() ?? '';
+        return cName.includes(lower) || lower.includes(cName);
+    });
+    return partial ?? candidates[0];
+}
+export async function generateCliFromUrl(opts) {
+    // Step 1: Deep Explore
+    const exploreResult = await exploreUrl(opts.url, {
+        BrowserFactory: opts.BrowserFactory,
+        site: opts.site,
+        goal: normalizeGoal(opts.goal) ?? opts.goal ?? undefined,
+        waitSeconds: opts.waitSeconds ?? 3,
+        workspace: opts.workspace,
+    });
+    // Step 2: Synthesize candidates
+    const synthesizeResult = synthesizeFromExplore(exploreResult.out_dir, {
+        top: opts.top ?? 5,
+    });
+    // Step 3: Select best candidate for goal
+    const selected = selectCandidate(synthesizeResult.candidates ?? [], opts.goal);
+    const selectedSite = synthesizeResult.site ?? exploreResult.site;
+    const ok = exploreResult.endpoint_count > 0 && synthesizeResult.candidate_count > 0;
+    return {
+        ok,
+        goal: opts.goal,
+        normalized_goal: normalizeGoal(opts.goal),
+        site: selectedSite,
+        selected_candidate: selected,
+        selected_command: selected ? `${selectedSite}/${selected.name}` : '(none)',
+        explore: {
+            endpoint_count: exploreResult.endpoint_count,
+            api_endpoint_count: exploreResult.api_endpoint_count,
+            capability_count: exploreResult.capabilities?.length ?? 0,
+            top_strategy: exploreResult.top_strategy,
+            framework: exploreResult.framework,
+        },
+        synthesize: {
+            candidate_count: synthesizeResult.candidate_count,
+            candidates: (synthesizeResult.candidates ?? []).map((c) => ({
+                name: c.name,
+                strategy: c.strategy,
+                confidence: c.confidence,
+            })),
+        },
+    };
+}
+export function renderGenerateSummary(r) {
+    const lines = [
+        `opencli generate: ${r.ok ? 'OK' : 'FAIL'}`,
+        `Site: ${r.site}`,
+        `Goal: ${r.goal ?? '(auto)'}`,
+        `Selected: ${r.selected_command}`,
+        '',
+        `Explore:`,
+        `  Endpoints: ${r.explore?.endpoint_count ?? 0} total, ${r.explore?.api_endpoint_count ?? 0} API`,
+        `  Capabilities: ${r.explore?.capability_count ?? 0}`,
+        `  Strategy: ${r.explore?.top_strategy ?? 'unknown'}`,
+        '',
+        `Synthesize:`,
+        `  Candidates: ${r.synthesize?.candidate_count ?? 0}`,
+    ];
+    for (const c of r.synthesize?.candidates ?? []) {
+        lines.push(`    • ${c.name} (${c.strategy}, ${((c.confidence ?? 0) * 100).toFixed(0)}%)`);
+    }
+    const fw = r.explore?.framework ?? {};
+    const fwNames = Object.entries(fw).filter(([, v]) => v).map(([k]) => k);
+    if (fwNames.length)
+        lines.push(`Framework: ${fwNames.join(', ')}`);
+    return lines.join('\n');
+}

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

@@ -0,0 +1,46 @@
+/**
+ * Plugin lifecycle hooks: allows plugins to tap into opencli's execution lifecycle.
+ *
+ * Hooks use globalThis (like the command registry) to guarantee a single shared
+ * instance across all module copies — critical when TS plugins are loaded via
+ * npm link / peerDependency symlinks.
+ *
+ * Available hooks:
+ *   onStartup        — fired once after all commands & plugins are discovered
+ *   onBeforeExecute  — fired before every command execution
+ *   onAfterExecute   — fired after every command execution (receives result)
+ */
+export type HookName = 'onStartup' | 'onBeforeExecute' | 'onAfterExecute';
+export interface HookContext {
+    /** Command full name in "site/name" format, or "__startup__" for onStartup */
+    command: string;
+    /** Coerced and validated arguments */
+    args: Record<string, unknown>;
+    /** Epoch ms when execution started (set by executeCommand) */
+    startedAt?: number;
+    /** Epoch ms when execution finished (set by executeCommand) */
+    finishedAt?: number;
+    /** Error thrown by the command, if execution failed */
+    error?: unknown;
+    /** Plugins can attach arbitrary data here for cross-hook communication */
+    [key: string]: unknown;
+}
+export type HookFn = (ctx: HookContext, result?: unknown) => void | Promise<void>;
+declare global {
+    var __opencli_hooks__: Map<HookName, HookFn[]> | undefined;
+}
+/** Register a hook that fires once after all plugins are discovered. */
+export declare function onStartup(fn: HookFn): void;
+/** Register a hook that fires before every command execution. */
+export declare function onBeforeExecute(fn: HookFn): void;
+/** Register a hook that fires after every command execution with the result. */
+export declare function onAfterExecute(fn: HookFn): void;
+/**
+ * Trigger all registered handlers for a hook.
+ * Each handler is wrapped in try/catch — a failing hook never blocks command execution.
+ */
+export declare function emitHook(name: HookName, ctx: HookContext, result?: unknown): Promise<void>;
+/**
+ * Remove all registered hooks. Intended for testing only.
+ */
+export declare function clearAllHooks(): void;

package/vendor/opencli/dist/hooks.js

@@ -0,0 +1,58 @@
+/**
+ * Plugin lifecycle hooks: allows plugins to tap into opencli's execution lifecycle.
+ *
+ * Hooks use globalThis (like the command registry) to guarantee a single shared
+ * instance across all module copies — critical when TS plugins are loaded via
+ * npm link / peerDependency symlinks.
+ *
+ * Available hooks:
+ *   onStartup        — fired once after all commands & plugins are discovered
+ *   onBeforeExecute  — fired before every command execution
+ *   onAfterExecute   — fired after every command execution (receives result)
+ */
+import { log } from './logger.js';
+const _hooks = globalThis.__opencli_hooks__ ??= new Map();
+// ── Registration API (used by plugins) ─────────────────────────────────────
+function addHook(name, fn) {
+    const list = _hooks.get(name) ?? [];
+    if (list.includes(fn))
+        return;
+    list.push(fn);
+    _hooks.set(name, list);
+}
+/** Register a hook that fires once after all plugins are discovered. */
+export function onStartup(fn) {
+    addHook('onStartup', fn);
+}
+/** Register a hook that fires before every command execution. */
+export function onBeforeExecute(fn) {
+    addHook('onBeforeExecute', fn);
+}
+/** Register a hook that fires after every command execution with the result. */
+export function onAfterExecute(fn) {
+    addHook('onAfterExecute', fn);
+}
+// ── Emit API (used internally by opencli core) ─────────────────────────────
+/**
+ * Trigger all registered handlers for a hook.
+ * Each handler is wrapped in try/catch — a failing hook never blocks command execution.
+ */
+export async function emitHook(name, ctx, result) {
+    const handlers = _hooks.get(name);
+    if (!handlers || handlers.length === 0)
+        return;
+    for (const fn of handlers) {
+        try {
+            await fn(ctx, result);
+        }
+        catch (err) {
+            log.warn(`Hook ${name} handler failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+/**
+ * Remove all registered hooks. Intended for testing only.
+ */
+export function clearAllHooks() {
+    _hooks.clear();
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Tests for the plugin lifecycle hooks system.
+ */
+export {};

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

@@ -0,0 +1,92 @@
+/**
+ * Tests for the plugin lifecycle hooks system.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { onStartup, onBeforeExecute, onAfterExecute, emitHook, clearAllHooks, } from './hooks.js';
+beforeEach(() => {
+    clearAllHooks();
+});
+describe('hook registration and emission', () => {
+    it('onBeforeExecute hook is called with context', async () => {
+        const calls = [];
+        onBeforeExecute((ctx) => { calls.push({ ...ctx }); });
+        await emitHook('onBeforeExecute', { command: 'test/cmd', args: { limit: 5 }, startedAt: 100 });
+        expect(calls).toHaveLength(1);
+        expect(calls[0].command).toBe('test/cmd');
+        expect(calls[0].args).toEqual({ limit: 5 });
+        expect(calls[0].startedAt).toBe(100);
+    });
+    it('onAfterExecute hook receives result', async () => {
+        const results = [];
+        onAfterExecute((_ctx, result) => { results.push(result); });
+        const mockResult = [{ title: 'item1' }, { title: 'item2' }];
+        await emitHook('onAfterExecute', { command: 'test/cmd', args: {} }, mockResult);
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual(mockResult);
+    });
+    it('onStartup hook fires', async () => {
+        let fired = false;
+        onStartup(() => { fired = true; });
+        await emitHook('onStartup', { command: '__startup__', args: {} });
+        expect(fired).toBe(true);
+    });
+    it('multiple hooks on the same event fire in order', async () => {
+        const order = [];
+        onBeforeExecute(() => { order.push(1); });
+        onBeforeExecute(() => { order.push(2); });
+        onBeforeExecute(() => { order.push(3); });
+        await emitHook('onBeforeExecute', { command: 'test/cmd', args: {} });
+        expect(order).toEqual([1, 2, 3]);
+    });
+    it('async hooks are awaited', async () => {
+        const order = [];
+        onBeforeExecute(async () => {
+            await new Promise((r) => setTimeout(r, 10));
+            order.push('async-done');
+        });
+        onBeforeExecute(() => { order.push('sync'); });
+        await emitHook('onBeforeExecute', { command: 'test/cmd', args: {} });
+        expect(order).toEqual(['async-done', 'sync']);
+    });
+});
+describe('hook error isolation', () => {
+    it('failing hook does not prevent other hooks from running', async () => {
+        const calls = [];
+        onBeforeExecute(() => { calls.push('first'); });
+        onBeforeExecute(() => { throw new Error('boom'); });
+        onBeforeExecute(() => { calls.push('third'); });
+        await emitHook('onBeforeExecute', { command: 'test/cmd', args: {} });
+        // First and third should still run despite the second throwing
+        expect(calls).toEqual(['first', 'third']);
+    });
+    it('async hook rejection does not prevent other hooks', async () => {
+        const calls = [];
+        onAfterExecute(() => { calls.push('before-reject'); });
+        onAfterExecute(async () => { throw new Error('async boom'); });
+        onAfterExecute(() => { calls.push('after-reject'); });
+        await emitHook('onAfterExecute', { command: 'test/cmd', args: {} }, null);
+        expect(calls).toEqual(['before-reject', 'after-reject']);
+    });
+});
+describe('no-op when no hooks registered', () => {
+    it('emitHook with no registered hooks does nothing', async () => {
+        // Should not throw
+        await emitHook('onBeforeExecute', { command: 'test/cmd', args: {} });
+        await emitHook('onAfterExecute', { command: 'test/cmd', args: {} }, []);
+        await emitHook('onStartup', { command: '__startup__', args: {} });
+    });
+});
+describe('clearAllHooks', () => {
+    it('removes all hooks', async () => {
+        let called = false;
+        onStartup(() => { called = true; });
+        clearAllHooks();
+        await emitHook('onStartup', { command: '__startup__', args: {} });
+        expect(called).toBe(false);
+    });
+});
+describe('globalThis singleton', () => {
+    it('uses globalThis.__opencli_hooks__ for shared state', () => {
+        expect(globalThis.__opencli_hooks__).toBeInstanceOf(Map);
+    });
+});

package/vendor/opencli/dist/idle-manager.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Manages daemon idle timeout with dual-condition logic:
+ * exits only when BOTH CLI is idle AND Extension is disconnected.
+ */
+export declare class IdleManager {
+    private _timer;
+    private _lastCliRequestTime;
+    private _extensionConnected;
+    private _timeoutMs;
+    private _onExit;
+    constructor(timeoutMs: number, onExit: () => void);
+    get lastCliRequestTime(): number;
+    /** Call when an HTTP request arrives from CLI */
+    onCliRequest(): void;
+    /** Call when Extension WebSocket connects or disconnects */
+    setExtensionConnected(connected: boolean): void;
+    private _clearTimer;
+    private _resetTimer;
+}