@jackwener/opencli 1.6.10 → 1.7.1

package/dist/src/commanderAdapter.test.js

@@ -5,9 +5,13 @@ const { mockExecuteCommand, mockRenderOutput } = vi.hoisted(() => ({
     mockExecuteCommand: vi.fn(),
     mockRenderOutput: vi.fn(),
 }));
-vi.mock('./execution.js', () => ({
-    executeCommand: mockExecuteCommand,
-}));
+vi.mock('./execution.js', async () => {
+    const actual = await vi.importActual('./execution.js');
+    return {
+        ...actual,
+        executeCommand: mockExecuteCommand,
+    };
+});
 vi.mock('./output.js', () => ({
     render: mockRenderOutput,
 }));
@@ -164,7 +168,33 @@ describe('commanderAdapter command aliases', () => {
         const siteCmd = program.command('notebooklm');
         registerCommandToProgram(siteCmd, cmd);
         await program.parseAsync(['node', 'opencli', 'notebooklm', 'metadata']);
-        expect(mockExecuteCommand).toHaveBeenCalledWith(cmd, {}, false);
+        expect(mockExecuteCommand).toHaveBeenCalledWith(cmd, {}, false, { prepared: true });
+    });
+});
+describe('commanderAdapter validation preparation', () => {
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockExecuteCommand.mockResolvedValue([]);
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('prepares args once before dispatching to executeCommand', async () => {
+        const validateArgs = vi.fn();
+        const program = new Command();
+        const siteCmd = program.command('test');
+        registerCommandToProgram(siteCmd, {
+            site: 'test',
+            name: 'run',
+            description: 'Run test command',
+            browser: false,
+            args: [{ name: 'count', default: '1', help: 'Count' }],
+            validateArgs,
+            func: vi.fn(),
+        });
+        await program.parseAsync(['node', 'opencli', 'test', 'run']);
+        expect(validateArgs).toHaveBeenCalledTimes(1);
+        expect(mockExecuteCommand).toHaveBeenCalledWith(expect.objectContaining({ site: 'test', name: 'run' }), { count: '1' }, false, { prepared: true });
     });
 });
 describe('commanderAdapter default formats', () => {
@@ -200,7 +230,7 @@ describe('commanderAdapter default formats', () => {
         expect(mockRenderOutput).toHaveBeenCalledWith([{ response: 'hello' }], expect.objectContaining({ fmt: 'json' }));
     });
 });
-describe('commanderAdapter empty result hints', () => {
+describe('commanderAdapter error envelope output', () => {
     const cmd = {
         site: 'xiaohongshu',
         name: 'note',
@@ -217,28 +247,30 @@ describe('commanderAdapter empty result hints', () => {
         delete process.env.OPENCLI_VERBOSE;
         process.exitCode = undefined;
     });
-    it('prints the adapter hint instead of the generic outdated-adapter message', async () => {
+    it('outputs YAML error envelope with adapter hint to stderr', async () => {
         const program = new Command();
         const siteCmd = program.command('xiaohongshu');
         registerCommandToProgram(siteCmd, cmd);
-        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
         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');
+        const output = stderrSpy.mock.calls.map(c => String(c[0])).join('');
+        expect(output).toContain('ok: false');
+        expect(output).toContain('code: EMPTY_RESULT');
         expect(output).toContain('xsec_token');
-        expect(output).not.toContain('this adapter may be outdated');
-        errorSpy.mockRestore();
+        stderrSpy.mockRestore();
     });
-    it('prints selector-specific hints too', async () => {
+    it('outputs YAML error envelope for selector errors', async () => {
         const program = new Command();
         const siteCmd = program.command('xiaohongshu');
         registerCommandToProgram(siteCmd, cmd);
-        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
         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');
+        const output = stderrSpy.mock.calls.map(c => String(c[0])).join('');
+        expect(output).toContain('ok: false');
+        expect(output).toContain('code: SELECTOR');
         expect(output).toContain('selector no longer matches');
-        expect(output).not.toContain('this adapter may be outdated');
-        errorSpy.mockRestore();
+        stderrSpy.mockRestore();
     });
 });

package/dist/src/commands/daemon.d.ts

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

package/dist/src/commands/daemon.js

@@ -1,77 +1,21 @@
 /**
- * CLI commands for daemon lifecycle management:
- *   opencli daemon status  — show daemon state
- *   opencli daemon stop    — graceful shutdown
- *   opencli daemon restart — stop + respawn
+ * CLI command for daemon lifecycle:
+ *   opencli daemon stop — graceful shutdown
  */
-import chalk from 'chalk';
 import { fetchDaemonStatus, requestDaemonShutdown } from '../browser/daemon-client.js';
-import { formatDuration } from '../download/progress.js';
-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: ${formatDuration(Math.round(status.uptime * 1000))}`);
-    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}`);
-}
+import { log } from '../logger.js';
 export async function daemonStop() {
     const status = await fetchDaemonStatus();
     if (!status) {
-        console.log(chalk.dim('Daemon is not running.'));
+        log.info('Daemon is not running.');
         return;
     }
     const ok = await requestDaemonShutdown();
     if (ok) {
-        console.log(chalk.green('Daemon stopped.'));
+        log.success('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}`));
+        log.error('Failed to stop daemon.');
         process.exitCode = 1;
     }
 }

package/dist/src/commands/daemon.test.js

@@ -3,158 +3,53 @@ 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;
+import { daemonStop } from './daemon.js';
+describe('daemonStop', () => {
+    let stderrSpy;
     beforeEach(() => {
-        logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
         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'));
-        });
+    it('reports "not running" when daemon is unreachable', async () => {
+        fetchDaemonStatusMock.mockResolvedValue(null);
+        await daemonStop();
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
     });
-    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'));
+    it('sends shutdown and reports success', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 12345,
+            uptime: 100,
+            extensionConnected: true,
+            pending: 0,
+            memoryMB: 50,
+            port: 19825,
         });
+        requestDaemonShutdownMock.mockResolvedValue(true);
+        await daemonStop();
+        expect(requestDaemonShutdownMock).toHaveBeenCalledTimes(1);
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Daemon stopped'));
     });
-    describe('daemonRestart', () => {
-        const statusData = {
+    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,
-        };
-        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();
         });
+        requestDaemonShutdownMock.mockResolvedValue(false);
+        await daemonStop();
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon'));
     });
 });

package/dist/src/completion-fast.d.ts

@@ -16,9 +16,6 @@ export declare function hasAllManifests(manifestPaths: string[]): boolean;
  * bypassing full CLI discovery and adapter loading.
  */
 export declare function getCompletionsFromManifest(words: string[], cursor: number, manifestPaths: string[]): string[];
-export declare function bashCompletionScript(): string;
-export declare function zshCompletionScript(): string;
-export declare function fishCompletionScript(): string;
 /**
  * Print completion script for the given shell. Returns true if handled, false if unknown shell.
  */

package/dist/src/completion-fast.js

@@ -5,21 +5,7 @@
  * It only reads pre-compiled cli-manifest.json files synchronously.
  */
 import * as fs from 'node:fs';
-const BUILTIN_COMMANDS = [
-    'list',
-    'validate',
-    'verify',
-    'explore',
-    'probe',
-    'synthesize',
-    'generate',
-    'cascade',
-    'doctor',
-    'plugin',
-    'install',
-    'register',
-    'completion',
-];
+import { BUILTIN_COMMANDS, bashCompletionScript, zshCompletionScript, fishCompletionScript, } from './completion-shared.js';
 /**
  * Returns true only if ALL manifest files exist and are readable.
  * If any source lacks a manifest (e.g. user adapters without a compiled manifest),
@@ -70,45 +56,7 @@ export function getCompletionsFromManifest(words, cursor, manifestPaths) {
     }
     return [];
 }
-// ── Shell script generators (pure strings, no registry dependency) ───────
-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
-)'
-`;
-}
+// ── Shell script generators (re-exported from shared, no registry dependency) ───────
 const SHELL_SCRIPTS = {
     bash: bashCompletionScript,
     zsh: zshCompletionScript,

package/dist/src/completion-shared.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared constants and shell script generators for tab-completion.
+ *
+ * This module MUST remain lightweight (no registry, no discovery imports).
+ * Both completion.ts (full path) and completion-fast.ts (manifest path) import from here.
+ */
+/**
+ * Built-in (non-dynamic) top-level commands.
+ */
+export declare const BUILTIN_COMMANDS: string[];
+export declare function bashCompletionScript(): string;
+export declare function zshCompletionScript(): string;
+export declare function fishCompletionScript(): string;

package/dist/src/completion-shared.js

@@ -0,0 +1,63 @@
+/**
+ * Shared constants and shell script generators for tab-completion.
+ *
+ * This module MUST remain lightweight (no registry, no discovery imports).
+ * Both completion.ts (full path) and completion-fast.ts (manifest path) import from here.
+ */
+/**
+ * Built-in (non-dynamic) top-level commands.
+ */
+export const BUILTIN_COMMANDS = [
+    'list',
+    'validate',
+    'verify',
+    'explore',
+    'probe', // alias for explore
+    'synthesize',
+    'generate',
+    'cascade',
+    'doctor',
+    'plugin',
+    'install',
+    'register',
+    'completion',
+];
+// ── 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
+)'
+`;
+}

package/dist/src/completion.d.ts

@@ -5,6 +5,8 @@
  *  - Shell script generators for bash, zsh, and fish
  *  - Dynamic completion logic that returns candidates for the current cursor position
  */
+import { bashCompletionScript, zshCompletionScript, fishCompletionScript } from './completion-shared.js';
+export { bashCompletionScript, zshCompletionScript, fishCompletionScript };
 /**
  * Return completion candidates given the current command-line words and cursor index.
  * Requires full CLI discovery to have been run (uses getRegistry()).
@@ -13,9 +15,6 @@
  * @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.
  */

package/dist/src/completion.js

@@ -7,25 +7,10 @@
  */
 import { getRegistry } from './registry.js';
 import { CliError } from './errors.js';
+import { BUILTIN_COMMANDS, bashCompletionScript, zshCompletionScript, fishCompletionScript, } from './completion-shared.js';
+// Re-export shell scripts so existing callers (cli.ts) don't break
+export { bashCompletionScript, zshCompletionScript, fishCompletionScript };
 // ── 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.
  * Requires full CLI discovery to have been run (uses getRegistry()).
@@ -63,44 +48,6 @@ export function getCompletions(words, cursor) {
     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.
  */

package/dist/src/constants.d.ts

@@ -3,8 +3,6 @@
  */
 /** 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 */

package/dist/src/constants.js

@@ -3,8 +3,6 @@
  */
 /** 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',

package/dist/src/daemon.d.ts

@@ -15,7 +15,7 @@
  *
  * Lifecycle:
  *   - Auto-spawned by opencli on first browser command
- *   - Auto-exits after idle timeout (default 4h, configurable via OPENCLI_DAEMON_TIMEOUT)
+ *   - Persistent — stays alive until explicit shutdown, SIGTERM, or uninstall
  *   - Listens on localhost:19825
  */
 export {};