@agentrhq/webcmd 0.1.1 → 0.2.0

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

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

package/dist/src/commands/daemon.js

@@ -0,0 +1,91 @@
+/**
+ * CLI commands for daemon lifecycle:
+ *   webcmd daemon status — show daemon state
+ *   webcmd daemon stop   — graceful shutdown
+ *   webcmd daemon restart — graceful shutdown, then start a fresh daemon
+ */
+import { fetchDaemonStatus, requestDaemonShutdown } from '../browser/daemon-transport.js';
+import { restartDaemon } from '../browser/daemon-lifecycle.js';
+import { formatDuration } from '../download/progress.js';
+import { log } from '../logger.js';
+import { PKG_VERSION } from '../version.js';
+import { formatDaemonVersion, isDaemonStale } from '../browser/daemon-version.js';
+export async function daemonStatus() {
+    const status = await fetchDaemonStatus();
+    if (!status) {
+        console.log('Daemon: not running');
+        return;
+    }
+    // GH #1575: ``Runtime: disconnected`` used to be printed for THREE
+    // structurally different states — zero profiles (accurate), 2+
+    // profiles connected with no default (misleading), and a requested
+    // profile that vanished (misleading). The status JSON already
+    // distinguishes them; surface that distinction so the user's next
+    // step is visible inline instead of "reinstall everything".
+    const runtimeLabel = status.runtimeConnected
+        ? status.runtimeVersion
+            ? `${status.runtimeName} connected (v${status.runtimeVersion})`
+            : `${status.runtimeName} connected`
+        : status.profileRequired
+            ? `${status.profiles?.length ?? 0} ${status.profiles?.length === 1 ? 'profile' : 'profiles'} available, none selected — run \`webcmd profile use <name>\``
+            : status.profileDisconnected
+                ? 'requested profile not connected — run `webcmd profile use <name>`'
+                : 'disconnected';
+    const daemonVersion = formatDaemonVersion(status);
+    const stale = isDaemonStale(status, PKG_VERSION);
+    console.log(`Daemon: ${stale ? 'stale' : 'running'} (PID ${status.pid})`);
+    console.log(`Version: ${daemonVersion}${stale ? ` (CLI v${PKG_VERSION}; run: webcmd daemon restart)` : ''}`);
+    console.log(`Uptime: ${formatDuration(Math.round(status.uptime * 1000))}`);
+    console.log(`Runtime: ${runtimeLabel}`);
+    if (status.profiles && status.profiles.length > 0) {
+        console.log(`Profiles: ${status.profiles.map((profile) => {
+            const version = profile.runtimeVersion ? ` v${profile.runtimeVersion}` : '';
+            return `${profile.contextId}${version}`;
+        }).join(', ')}`);
+    }
+    console.log(`Memory: ${status.memoryMB} MB`);
+    console.log(`Port: ${status.port}`);
+}
+export async function daemonStop() {
+    const status = await fetchDaemonStatus();
+    if (!status) {
+        log.info('Daemon is not running.');
+        return;
+    }
+    const ok = await requestDaemonShutdown();
+    if (ok) {
+        log.success('Daemon stopped.');
+    }
+    else {
+        log.error('Failed to stop daemon.');
+        process.exitCode = 1;
+    }
+}
+export async function daemonRestart() {
+    const before = await fetchDaemonStatus();
+    if (before?.profiles && before.profiles.length > 0) {
+        log.warn(`Restarting daemon will disconnect ${before.profiles.length} browser ${before.profiles.length === 1 ? 'profile' : 'profiles'}; Cloak should reconnect automatically.`);
+    }
+    const result = await restartDaemon();
+    if (!result.stopped) {
+        log.error('Failed to stop daemon before restart.');
+        process.exitCode = 1;
+        return;
+    }
+    if (!result.status) {
+        log.error('Daemon restart timed out before the new daemon reported status.');
+        process.exitCode = 1;
+        return;
+    }
+    const action = result.previousStatus ? 'restarted' : 'started';
+    const version = formatDaemonVersion(result.status);
+    log.success(`Daemon ${action} on port ${result.status.port} (${version}).`);
+    if (result.status.runtimeConnected) {
+        const profiles = result.status.profiles?.length ?? 0;
+        const profileText = profiles > 0 ? `; ${profiles} ${profiles === 1 ? 'profile' : 'profiles'} connected` : '';
+        log.status(`Runtime connected${profileText}.`);
+    }
+    else {
+        log.warn('Daemon is running, but the Cloak runtime has not connected yet.');
+    }
+}

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

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

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

@@ -0,0 +1,293 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+const { fetchDaemonStatusMock, requestDaemonShutdownMock, restartDaemonMock, } = vi.hoisted(() => ({
+    fetchDaemonStatusMock: vi.fn(),
+    requestDaemonShutdownMock: vi.fn(),
+    restartDaemonMock: vi.fn(),
+}));
+vi.mock('../browser/daemon-transport.js', () => ({
+    fetchDaemonStatus: fetchDaemonStatusMock,
+    requestDaemonShutdown: requestDaemonShutdownMock,
+}));
+vi.mock('../browser/daemon-lifecycle.js', () => ({
+    restartDaemon: restartDaemonMock,
+}));
+import { daemonRestart, daemonStatus, daemonStop } from './daemon.js';
+import { PKG_VERSION } from '../version.js';
+describe('daemonStatus', () => {
+    let stdoutSpy;
+    beforeEach(() => {
+        stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        fetchDaemonStatusMock.mockReset();
+        requestDaemonShutdownMock.mockReset();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('reports "not running" when daemon is unreachable', async () => {
+        fetchDaemonStatusMock.mockResolvedValue(null);
+        await daemonStatus();
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
+    });
+    it('shows daemon info when running', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 12345,
+            uptime: 3661,
+            daemonVersion: PKG_VERSION,
+            runtimeConnected: true,
+            runtimeName: 'fake',
+            runtimeVersion: '1.6.8',
+            pending: 0,
+            memoryMB: 64,
+            port: 19825,
+        });
+        await daemonStatus();
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('running'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('PID 12345'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining(`v${PKG_VERSION}`));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('1h 1m'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('connected'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('v1.6.8'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('64 MB'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('19825'));
+    });
+    it('shows disconnected when runtime is not connected', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 99,
+            uptime: 120,
+            daemonVersion: PKG_VERSION,
+            runtimeConnected: false,
+            runtimeName: 'fake',
+            pending: 0,
+            memoryMB: 32,
+            port: 19825,
+        });
+        await daemonStatus();
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('disconnected'));
+    });
+    it('shows runtime name when the connected runtime does not report a version', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 99,
+            uptime: 120,
+            daemonVersion: PKG_VERSION,
+            runtimeConnected: true,
+            runtimeName: 'fake',
+            runtimeVersion: undefined,
+            pending: 0,
+            memoryMB: 32,
+            port: 19825,
+        });
+        await daemonStatus();
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('fake connected'));
+    });
+});
+// ────────────────────────────────────────────────────────────────────
+// GH #1575: differentiate the three "no route" states. The pre-fix
+// behaviour collapsed multi-profile-no-default + profile-disconnected
+// + zero-profile all to "Runtime: disconnected", sending users on
+// reinstall-everything debug paths when the actual fix was
+// `webcmd profile use <name>`.
+// ────────────────────────────────────────────────────────────────────
+describe('daemonStatus runtime label states (#1575)', () => {
+    let stdoutSpy;
+    beforeEach(() => {
+        stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        fetchDaemonStatusMock.mockReset();
+    });
+    afterEach(() => vi.restoreAllMocks());
+    async function runtimeLineFor(extra) {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 99,
+            uptime: 60,
+            daemonVersion: PKG_VERSION,
+            pending: 0,
+            memoryMB: 32,
+            port: 19825,
+            runtimeName: 'fake',
+            ...extra,
+        });
+        await daemonStatus();
+        return stdoutSpy.mock.calls
+            .map((c) => c[0])
+            .find((line) => typeof line === 'string' && line.startsWith('Runtime:'));
+    }
+    it('prints a route hint for 2+ profiles with no default (not bare "disconnected")', async () => {
+        const line = await runtimeLineFor({
+            runtimeConnected: false,
+            profileRequired: true,
+            profiles: [
+                { contextId: 'work', runtimeConnected: true, pending: 0 },
+                { contextId: 'personal', runtimeConnected: true, pending: 0 },
+            ],
+        });
+        expect(line).not.toBe('Runtime: disconnected');
+        expect(line).toContain('2 profiles available');
+        expect(line).toContain('webcmd profile use');
+    });
+    it('uses the required profile-available label for a one-profile profile-required payload', async () => {
+        const line = await runtimeLineFor({
+            runtimeConnected: false,
+            profileRequired: true,
+            profiles: [{ contextId: 'work', runtimeConnected: true, pending: 0 }],
+        });
+        expect(line).toContain('1 profile available');
+    });
+    it('prints a route hint when the requested profile is disconnected', async () => {
+        const line = await runtimeLineFor({
+            runtimeConnected: false,
+            profileDisconnected: true,
+        });
+        expect(line).not.toBe('Runtime: disconnected');
+        expect(line).toContain('webcmd profile use');
+    });
+    it('keeps the plain "disconnected" label when zero profiles are connected', async () => {
+        const line = await runtimeLineFor({ runtimeConnected: false });
+        expect(line).toBe('Runtime: disconnected');
+    });
+});
+describe('daemonStop', () => {
+    let stderrSpy;
+    beforeEach(() => {
+        stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        fetchDaemonStatusMock.mockReset();
+        requestDaemonShutdownMock.mockReset();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('reports "not running" when daemon is unreachable', async () => {
+        fetchDaemonStatusMock.mockResolvedValue(null);
+        await daemonStop();
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
+    });
+    it('sends shutdown and reports success', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 12345,
+            uptime: 100,
+            daemonVersion: PKG_VERSION,
+            runtimeConnected: true,
+            runtimeName: 'fake',
+            pending: 0,
+            memoryMB: 50,
+            port: 19825,
+        });
+        requestDaemonShutdownMock.mockResolvedValue(true);
+        await daemonStop();
+        expect(requestDaemonShutdownMock).toHaveBeenCalledTimes(1);
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Daemon stopped'));
+    });
+    it('reports failure when shutdown request fails', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 12345,
+            uptime: 100,
+            daemonVersion: PKG_VERSION,
+            runtimeConnected: true,
+            runtimeName: 'fake',
+            pending: 0,
+            memoryMB: 50,
+            port: 19825,
+        });
+        requestDaemonShutdownMock.mockResolvedValue(false);
+        await daemonStop();
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon'));
+    });
+});
+describe('daemonRestart', () => {
+    let stderrSpy;
+    beforeEach(() => {
+        stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        fetchDaemonStatusMock.mockReset();
+        requestDaemonShutdownMock.mockReset();
+        restartDaemonMock.mockReset();
+        process.exitCode = undefined;
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        process.exitCode = undefined;
+    });
+    it('restarts a running daemon and reports the new version', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 12345,
+            uptime: 100,
+            daemonVersion: '1.7.6',
+            runtimeConnected: true,
+            runtimeName: 'fake',
+            profiles: [{ contextId: 'work', runtimeConnected: true, pending: 0 }],
+            pending: 0,
+            memoryMB: 50,
+            port: 19825,
+        });
+        restartDaemonMock.mockResolvedValue({
+            previousStatus: { daemonVersion: '1.7.6' },
+            stopped: true,
+            spawned: true,
+            status: {
+                ok: true,
+                pid: 12346,
+                uptime: 1,
+                daemonVersion: PKG_VERSION,
+                runtimeConnected: true,
+                runtimeName: 'fake',
+                profiles: [{ contextId: 'work', runtimeConnected: true, pending: 0 }],
+                pending: 0,
+                memoryMB: 51,
+                port: 19825,
+            },
+        });
+        await daemonRestart();
+        expect(restartDaemonMock).toHaveBeenCalledTimes(1);
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('will disconnect 1 browser profile'));
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining(`Daemon restarted on port 19825 (v${PKG_VERSION})`));
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Runtime connected; 1 profile connected'));
+    });
+    it('starts a new daemon when none was running', async () => {
+        fetchDaemonStatusMock.mockResolvedValue(null);
+        restartDaemonMock.mockResolvedValue({
+            previousStatus: null,
+            stopped: true,
+            spawned: true,
+            status: {
+                ok: true,
+                pid: 12346,
+                uptime: 1,
+                daemonVersion: PKG_VERSION,
+                runtimeConnected: false,
+                runtimeName: 'fake',
+                pending: 0,
+                memoryMB: 51,
+                port: 19825,
+            },
+        });
+        await daemonRestart();
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining(`Daemon started on port 19825 (v${PKG_VERSION})`));
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Cloak runtime has not connected yet'));
+    });
+    it('reports failure when the daemon cannot stop', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 12345,
+            uptime: 100,
+            daemonVersion: '1.7.6',
+            runtimeConnected: true,
+            runtimeName: 'fake',
+            pending: 0,
+            memoryMB: 50,
+            port: 19825,
+        });
+        restartDaemonMock.mockResolvedValue({
+            previousStatus: { daemonVersion: '1.7.6' },
+            status: { daemonVersion: '1.7.6' },
+            stopped: false,
+            spawned: false,
+        });
+        await daemonRestart();
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon before restart'));
+        expect(process.exitCode).toBe(1);
+    });
+});

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

@@ -0,0 +1,22 @@
+/**
+ * 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[];
+/**
+ * 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,88 @@
+/**
+ * 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';
+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),
+ * 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 (re-exported from shared, no registry dependency) ───────
+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-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,61 @@
+/**
+ * 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.
+ */
+import { CLI_COMMAND } from './brand.js';
+/**
+ * Built-in (non-dynamic) top-level commands.
+ */
+export const BUILTIN_COMMANDS = [
+    'list',
+    'validate',
+    'verify',
+    'auth',
+    'browser',
+    'tab',
+    'doctor',
+    'plugin',
+    'external',
+    'completion',
+];
+// ── Shell script generators ────────────────────────────────────────────────
+export function bashCompletionScript() {
+    return `# Bash completion for ${CLI_COMMAND}
+# Add to ~/.bashrc:  eval "$(${CLI_COMMAND} completion bash)"
+_${CLI_COMMAND}_completions() {
+  local cur words cword
+  _get_comp_words_by_ref -n : cur words cword
+
+  local completions
+  completions=$(${CLI_COMMAND} --get-completions --cursor "$cword" "\${words[@]:1}" 2>/dev/null)
+
+  COMPREPLY=( $(compgen -W "$completions" -- "$cur") )
+  __ltrim_colon_completions "$cur"
+}
+complete -F _${CLI_COMMAND}_completions ${CLI_COMMAND}
+`;
+}
+export function zshCompletionScript() {
+    return `# Zsh completion for ${CLI_COMMAND}
+# Add to ~/.zshrc:  eval "$(${CLI_COMMAND} completion zsh)"
+_${CLI_COMMAND}() {
+  local -a completions
+  local cword=$((CURRENT - 1))
+  completions=(\${(f)"$(${CLI_COMMAND} --get-completions --cursor "$cword" "\${words[@]:1}" 2>/dev/null)"})
+  compadd -a completions
+}
+compdef _${CLI_COMMAND} ${CLI_COMMAND}
+`;
+}
+export function fishCompletionScript() {
+    return `# Fish completion for ${CLI_COMMAND}
+# Add to ~/.config/fish/config.fish:  ${CLI_COMMAND} completion fish | source
+complete -c ${CLI_COMMAND} -f -a '(
+  set -l tokens (commandline -cop)
+  set -l cursor (count (commandline -cop))
+  ${CLI_COMMAND} --get-completions --cursor $cursor $tokens[2..] 2>/dev/null
+)'
+`;
+}

package/dist/src/completion.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shell tab-completion support for webcmd.
+ *
+ * Provides:
+ *  - 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()).
+ *
+ * @param words  - The argv after 'webcmd' (words[0] is the first arg, e.g. site name)
+ * @param cursor - 1-based position of the word being completed (1 = first arg)
+ */
+export declare function getCompletions(words: string[], cursor: number): string[];
+/**
+ * Print the completion script for the requested shell.
+ */
+export declare function printCompletionScript(shell: string): void;

package/dist/src/completion.js

@@ -0,0 +1,68 @@
+/**
+ * Shell tab-completion support for webcmd.
+ *
+ * Provides:
+ *  - Shell script generators for bash, zsh, and fish
+ *  - Dynamic completion logic that returns candidates for the current cursor position
+ */
+import { getRegistry } from './registry.js';
+import { CliError } from './errors.js';
+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 ───────────────────────────────────────────────
+/**
+ * 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 'webcmd' (words[0] is the first arg, e.g. site name)
+ * @param cursor - 1-based position of the word being completed (1 = first arg)
+ */
+export function getCompletions(words, cursor) {
+    // cursor === 1 → completing the first argument (site name or built-in command)
+    if (cursor <= 1) {
+        const sites = new Set();
+        for (const [, cmd] of getRegistry()) {
+            sites.add(cmd.site);
+        }
+        return [...BUILTIN_COMMANDS, ...sites].sort();
+    }
+    const site = words[0];
+    // If the first word is a built-in command, no further completion
+    if (BUILTIN_COMMANDS.includes(site)) {
+        return [];
+    }
+    // cursor === 2 → completing the sub-command name under a site
+    if (cursor === 2) {
+        const subcommands = [];
+        for (const [, cmd] of getRegistry()) {
+            if (cmd.site === site) {
+                subcommands.push(cmd.name);
+                if (cmd.aliases?.length)
+                    subcommands.push(...cmd.aliases);
+            }
+        }
+        return [...new Set(subcommands)].sort();
+    }
+    // cursor >= 3 → no further completion
+    return [];
+}
+// ── Shell script generators ────────────────────────────────────────────────
+/**
+ * Print the completion script for the requested shell.
+ */
+export function printCompletionScript(shell) {
+    switch (shell) {
+        case 'bash':
+            process.stdout.write(bashCompletionScript());
+            break;
+        case 'zsh':
+            process.stdout.write(zshCompletionScript());
+            break;
+        case 'fish':
+            process.stdout.write(fishCompletionScript());
+            break;
+        default:
+            throw new CliError('UNSUPPORTED_SHELL', `Unsupported shell: ${shell}. Supported: bash, zsh, fish`);
+    }
+}

package/dist/src/completion.test.d.ts

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