@jackwener/opencli 1.6.9 → 1.7.0

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

@@ -6,23 +6,16 @@ const { fetchDaemonStatusMock, requestDaemonShutdownMock, } = vi.hoisted(() => (
 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', () => {
+import { daemonStop } from './daemon.js';
+describe('daemonStop', () => {
     let logSpy;
     let errorSpy;
     beforeEach(() => {
@@ -33,128 +26,39 @@ describe('daemon commands', () => {
     });
     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(logSpy).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(logSpy).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(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon'));
     });
 });

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

@@ -0,0 +1,25 @@
+/**
+ * Lightweight manifest-based completion for the fast path.
+ *
+ * This module MUST NOT import registry, discovery, or any heavy module.
+ * It only reads pre-compiled cli-manifest.json files synchronously.
+ */
+/**
+ * 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),
+ * the fast path must not be used — otherwise those adapters would silently
+ * disappear from completion results.
+ */
+export declare function hasAllManifests(manifestPaths: string[]): boolean;
+/**
+ * Lightweight completion that reads directly from manifest JSON files,
+ * 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.
+ */
+export declare function printCompletionScriptFast(shell: string): boolean;

package/dist/src/completion-fast.js

@@ -0,0 +1,140 @@
+/**
+ * Lightweight manifest-based completion for the fast path.
+ *
+ * This module MUST NOT import registry, discovery, or any heavy module.
+ * 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',
+];
+/**
+ * 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),
+ * the fast path must not be used — otherwise those adapters would silently
+ * disappear from completion results.
+ */
+export function hasAllManifests(manifestPaths) {
+    for (const p of manifestPaths) {
+        try {
+            fs.accessSync(p);
+        }
+        catch {
+            return false;
+        }
+    }
+    return manifestPaths.length > 0;
+}
+/**
+ * Lightweight completion that reads directly from manifest JSON files,
+ * bypassing full CLI discovery and adapter loading.
+ */
+export function getCompletionsFromManifest(words, cursor, manifestPaths) {
+    const entries = loadManifestEntries(manifestPaths);
+    if (entries === null) {
+        return [];
+    }
+    if (cursor <= 1) {
+        const sites = new Set();
+        for (const entry of entries) {
+            sites.add(entry.site);
+        }
+        return [...BUILTIN_COMMANDS, ...sites].sort();
+    }
+    const site = words[0];
+    if (BUILTIN_COMMANDS.includes(site)) {
+        return [];
+    }
+    if (cursor === 2) {
+        const subcommands = [];
+        for (const entry of entries) {
+            if (entry.site === site) {
+                subcommands.push(entry.name);
+                if (entry.aliases?.length)
+                    subcommands.push(...entry.aliases);
+            }
+        }
+        return [...new Set(subcommands)].sort();
+    }
+    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
+)'
+`;
+}
+const SHELL_SCRIPTS = {
+    bash: bashCompletionScript,
+    zsh: zshCompletionScript,
+    fish: fishCompletionScript,
+};
+/**
+ * Print completion script for the given shell. Returns true if handled, false if unknown shell.
+ */
+export function printCompletionScriptFast(shell) {
+    const gen = SHELL_SCRIPTS[shell];
+    if (!gen)
+        return false;
+    process.stdout.write(gen());
+    return true;
+}
+function loadManifestEntries(manifestPaths) {
+    const entries = [];
+    let found = false;
+    for (const manifestPath of manifestPaths) {
+        try {
+            const raw = fs.readFileSync(manifestPath, 'utf-8');
+            const manifest = JSON.parse(raw);
+            entries.push(...manifest);
+            found = true;
+        }
+        catch { /* skip missing/unreadable */ }
+    }
+    return found ? entries : null;
+}

package/dist/src/completion.d.ts

@@ -7,6 +7,7 @@
  */
 /**
  * Return completion candidates given the current command-line words and cursor index.
+ * Requires full CLI discovery to have been run (uses getRegistry()).
  *
  * @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)

package/dist/src/completion.js

@@ -28,6 +28,7 @@ const BUILTIN_COMMANDS = [
 ];
 /**
  * Return completion candidates given the current command-line words and cursor index.
+ * Requires full CLI discovery to have been run (uses getRegistry()).
  *
  * @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)

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 {};

package/dist/src/daemon.js

@@ -15,16 +15,14 @@
  *
  * 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
  */
 import { createServer } from 'node:http';
 import { WebSocketServer, WebSocket } from 'ws';
-import { DEFAULT_DAEMON_PORT, DEFAULT_DAEMON_IDLE_TIMEOUT } from './constants.js';
+import { DEFAULT_DAEMON_PORT } from './constants.js';
 import { EXIT_CODES } from './errors.js';
-import { IdleManager } from './idle-manager.js';
 const PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
-const IDLE_TIMEOUT = Number(process.env.OPENCLI_DAEMON_TIMEOUT ?? DEFAULT_DAEMON_IDLE_TIMEOUT);
 // ─── State ───────────────────────────────────────────────────────────
 let extensionWs = null;
 let extensionVersion = null;
@@ -36,11 +34,6 @@ function pushLog(entry) {
     if (logBuffer.length > LOG_BUFFER_SIZE)
         logBuffer.shift();
 }
-// ─── Idle auto-exit ──────────────────────────────────────────────────
-const idleManager = new IdleManager(IDLE_TIMEOUT, () => {
-    console.error('[daemon] Idle timeout (no CLI requests + no Extension), shutting down');
-    process.exit(EXIT_CODES.SUCCESS);
-});
 // ─── HTTP Server ─────────────────────────────────────────────────────
 const MAX_BODY = 1024 * 1024; // 1 MB — commands are tiny; this prevents OOM
 function readBody(req) {
@@ -118,7 +111,6 @@ async function handleRequest(req, res) {
             extensionConnected: extensionWs?.readyState === WebSocket.OPEN,
             extensionVersion,
             pending: pending.size,
-            lastCliRequestTime: idleManager.lastCliRequestTime,
             memoryMB: Math.round(mem.rss / 1024 / 1024 * 10) / 10,
             port: PORT,
         });
@@ -144,7 +136,6 @@ async function handleRequest(req, res) {
         return;
     }
     if (req.method === 'POST' && url === '/command') {
-        idleManager.onCliRequest();
         try {
             const body = JSON.parse(await readBody(req));
             if (!body.id) {
@@ -196,7 +187,6 @@ wss.on('connection', (ws) => {
     console.error('[daemon] Extension connected');
     extensionWs = ws;
     extensionVersion = null; // cleared until hello message arrives
-    idleManager.setExtensionConnected(true);
     // ── Heartbeat: ping every 15s, close if 2 pongs missed ──
     let missedPongs = 0;
     const heartbeatInterval = setInterval(() => {
@@ -249,7 +239,6 @@ wss.on('connection', (ws) => {
         if (extensionWs === ws) {
             extensionWs = null;
             extensionVersion = null;
-            idleManager.setExtensionConnected(false);
             // Reject all pending requests since the extension is gone
             for (const [id, p] of pending) {
                 clearTimeout(p.timer);
@@ -263,7 +252,6 @@ wss.on('connection', (ws) => {
         if (extensionWs === ws) {
             extensionWs = null;
             extensionVersion = null;
-            idleManager.setExtensionConnected(false);
             // Reject pending requests in case 'close' does not follow this 'error'
             for (const [, p] of pending) {
                 clearTimeout(p.timer);
@@ -276,7 +264,6 @@ wss.on('connection', (ws) => {
 // ─── Start ───────────────────────────────────────────────────────────
 httpServer.listen(PORT, '127.0.0.1', () => {
     console.error(`[daemon] Listening on http://127.0.0.1:${PORT}`);
-    idleManager.onCliRequest();
 });
 httpServer.on('error', (err) => {
     if (err.code === 'EADDRINUSE') {

package/dist/src/diagnostic.test.js

@@ -83,8 +83,8 @@ describe('redactText', () => {
 });
 describe('resolveAdapterSourcePath', () => {
     it('returns source when it is a real file path (not manifest:)', () => {
-        const cmd = makeCmd({ source: '/home/user/.opencli/clis/arxiv/search.yaml' });
-        expect(resolveAdapterSourcePath(cmd)).toBe('/home/user/.opencli/clis/arxiv/search.yaml');
+        const cmd = makeCmd({ source: '/home/user/.opencli/clis/arxiv/search.ts' });
+        expect(resolveAdapterSourcePath(cmd)).toBe('/home/user/.opencli/clis/arxiv/search.ts');
     });
     it('skips manifest: pseudo-paths and falls back to _modulePath', () => {
         const cmd = makeCmd({ source: 'manifest:arxiv/search', _modulePath: '/pkg/dist/clis/arxiv/search.js' });

package/dist/src/discovery.d.ts

@@ -1,10 +1,10 @@
 /**
- * CLI discovery: finds YAML/TS CLI definitions and registers them.
+ * CLI discovery: finds TS CLI definitions and registers them.
  *
  * Supports two modes:
  * 1. FAST PATH (manifest): If a pre-compiled cli-manifest.json exists,
- *    registers all YAML commands instantly without runtime YAML parsing.
- *    TS modules are loaded lazily only when their command is executed.
+ *    registers commands instantly. TS modules are loaded lazily only
+ *    when their command is executed.
  * 2. FALLBACK (filesystem scan): Traditional runtime discovery for development.
  */
 /** User runtime directory: ~/.opencli */