@burdenoff/vibe-agent 1.0.0

package/dist/cli.js

@@ -0,0 +1,1043 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { Command } from 'commander';
+import { AgentService } from './services/agent.service.js';
+import { ServiceManager } from './services/service-manager.js';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Read package.json for version
+let packageVersion = '1.0.0';
+try {
+    const packageJsonPath = join(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    packageVersion = packageJson.version;
+}
+catch {
+    // fallback
+}
+const DEFAULT_AGENT_URL = 'http://localhost:3005';
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+async function agentFetch(agentUrl, path, options = {}) {
+    const apiKey = process.env.AGENT_API_KEY;
+    const headers = {
+        ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+        ...(apiKey ? { 'x-agent-api-key': apiKey } : {}),
+        ...(options.headers ?? {}),
+    };
+    const res = await fetch(`${agentUrl}${path}`, { ...options, headers });
+    const data = await res.json().catch(() => ({}));
+    return { ok: res.ok, status: res.status, data };
+}
+function fail(msg) {
+    console.error(`\x1b[31mError:\x1b[0m ${msg}`);
+    process.exit(1);
+}
+function formatTable(rows) {
+    if (rows.length === 0) {
+        console.log('  (none)');
+        return;
+    }
+    console.table(rows);
+}
+function timeAgo(dateStr) {
+    const diff = Date.now() - new Date(dateStr).getTime();
+    const s = Math.floor(diff / 1000);
+    if (s < 60)
+        return `${s}s ago`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    return `${Math.floor(h / 24)}d ago`;
+}
+// ─── Program ──────────────────────────────────────────────────────────────────
+const program = new Command();
+const agentService = new AgentService();
+const serviceManager = new ServiceManager();
+program
+    .name('vibe')
+    .description('VibeControls Agent CLI — Remote development environment management')
+    .version(packageVersion, '-v, --version');
+// ═══════════════════════════════════════════════════════════════════════════════
+// Core Commands
+// ═══════════════════════════════════════════════════════════════════════════════
+program
+    .command('start')
+    .description('Start the agent server')
+    .option('-p, --port <port>', 'Port to run on', '3005')
+    .option('-n, --name <name>', 'Instance name', 'default')
+    .option('-d, --daemon', 'Run as background daemon', false)
+    .option('--db-path <path>', 'SQLite database path', './vibecontrols-agent.db')
+    .action(async (options) => {
+    try {
+        const config = {
+            port: parseInt(options.port),
+            name: options.name,
+            daemon: options.daemon,
+            dbPath: options.dbPath,
+        };
+        if (options.daemon) {
+            await serviceManager.startDaemon(config);
+        }
+        else {
+            await agentService.start(config);
+        }
+    }
+    catch (error) {
+        fail(`Failed to start agent: ${error instanceof Error ? error.message : error}`);
+    }
+});
+program
+    .command('stop')
+    .description('Stop a running agent instance')
+    .option('-n, --name <name>', 'Instance name', 'default')
+    .option('--all', 'Stop all instances', false)
+    .action(async (options) => {
+    try {
+        if (options.all) {
+            await serviceManager.stopAll();
+        }
+        else {
+            await serviceManager.stop(options.name);
+        }
+    }
+    catch (error) {
+        fail(`Failed to stop: ${error instanceof Error ? error.message : error}`);
+    }
+});
+program
+    .command('restart')
+    .description('Restart an agent instance')
+    .option('-n, --name <name>', 'Instance name', 'default')
+    .option('-p, --port <port>', 'Port', '3005')
+    .option('--db-path <path>', 'Database path', './vibecontrols-agent.db')
+    .action(async (options) => {
+    try {
+        await serviceManager.restart(options.name, {
+            port: parseInt(options.port),
+            name: options.name,
+            daemon: true,
+            dbPath: options.dbPath,
+        });
+    }
+    catch (error) {
+        fail(`Failed to restart: ${error instanceof Error ? error.message : error}`);
+    }
+});
+program
+    .command('status')
+    .description('Show status of agent instances')
+    .option('-n, --name <name>', 'Specific instance name')
+    .action(async (options) => {
+    try {
+        if (options.name) {
+            const status = await serviceManager.getStatus(options.name);
+            if (!status) {
+                console.log(`No agent instance named '${options.name}' found.`);
+            }
+            else {
+                console.log(`\n  Agent: ${status.name}`);
+                console.log(`  Status: ${status.status === 'running' ? '\x1b[32m● running\x1b[0m' : '\x1b[31m○ stopped\x1b[0m'}`);
+                console.log(`  PID: ${status.pid}`);
+                console.log(`  Port: ${status.port}`);
+                console.log(`  Started: ${status.startTime}\n`);
+            }
+        }
+        else {
+            const all = await serviceManager.getStatusAll();
+            if (all.length === 0) {
+                console.log('No agent instances registered.');
+            }
+            else {
+                formatTable(all.map(s => ({
+                    Name: s.name,
+                    Status: s.status,
+                    PID: s.pid,
+                    Port: s.port,
+                    Started: s.startTime,
+                })));
+            }
+        }
+    }
+    catch (error) {
+        fail(`Failed to get status: ${error instanceof Error ? error.message : error}`);
+    }
+});
+program
+    .command('list')
+    .description('List all agent instances')
+    .action(async () => {
+    try {
+        const instances = await serviceManager.listInstances();
+        if (instances.length === 0) {
+            console.log('No agent instances found.');
+        }
+        else {
+            formatTable(instances.map(i => ({
+                Name: i.name,
+                Status: i.status,
+                PID: i.pid,
+                Port: i.port,
+                Started: i.startTime,
+            })));
+        }
+    }
+    catch (error) {
+        fail(`Failed to list: ${error instanceof Error ? error.message : error}`);
+    }
+});
+program
+    .command('kill')
+    .description('Force kill an agent instance')
+    .option('-n, --name <name>', 'Instance name', 'default')
+    .option('--all', 'Kill all instances', false)
+    .action(async (options) => {
+    try {
+        if (options.all) {
+            await serviceManager.killAll();
+        }
+        else {
+            await serviceManager.kill(options.name);
+        }
+    }
+    catch (error) {
+        fail(`Failed to kill: ${error instanceof Error ? error.message : error}`);
+    }
+});
+program
+    .command('logs')
+    .description('Show logs for an agent instance')
+    .option('-n, --name <name>', 'Instance name', 'default')
+    .option('-f, --follow', 'Follow log output', false)
+    .option('--tail <lines>', 'Number of lines', '100')
+    .action(async (options) => {
+    try {
+        await serviceManager.showLogs(options.name, {
+            follow: options.follow,
+            tail: parseInt(options.tail),
+        });
+    }
+    catch (error) {
+        fail(`Failed to show logs: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// ─── Key ──────────────────────────────────────────────────────────────────────
+program
+    .command('key')
+    .description('Display the current agent API key')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const res = await fetch(`${options.agentUrl}/api/agent-api-key`);
+        if (!res.ok)
+            fail(`Agent returned ${res.status}`);
+        const data = await res.json();
+        console.log(`\n  \x1b[1mAPI Key:\x1b[0m  ${data.apiKey}`);
+        console.log(`  Generated: ${data.generatedAt}`);
+        console.log(`  Note: ${data.note}\n`);
+    }
+    catch (error) {
+        fail(`Cannot reach agent at ${options.agentUrl}: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// ─── Health ───────────────────────────────────────────────────────────────────
+program
+    .command('health')
+    .description('Check health of the agent')
+    .option('-n, --name <name>', 'Instance name (uses local registry)')
+    .option('--agent-url <url>', 'Agent URL (direct)', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        if (options.name) {
+            const h = await serviceManager.checkHealth(options.name);
+            console.log(JSON.stringify(h, null, 2));
+        }
+        else {
+            const res = await fetch(`${options.agentUrl}/health`);
+            if (!res.ok)
+                fail(`Health check failed: ${res.status}`);
+            const data = await res.json();
+            console.log(`\n  Status:  \x1b[32m${data.status}\x1b[0m`);
+            console.log(`  Version: ${data.version}`);
+            console.log(`  Uptime:  ${Math.floor(data.uptime / 60)}m ${Math.floor(data.uptime % 60)}s`);
+            if (data.tunnelUrl)
+                console.log(`  Tunnel:  ${data.tunnelUrl}`);
+            console.log();
+        }
+    }
+    catch (error) {
+        fail(`Health check failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// ─── Version (detailed) ──────────────────────────────────────────────────────
+program
+    .command('info')
+    .description('Show detailed version and system information')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    console.log(`\n  \x1b[1mVibeControls Agent\x1b[0m v${packageVersion}`);
+    console.log(`  Node.js:     ${process.version}`);
+    console.log(`  Platform:    ${process.platform}`);
+    console.log(`  Architecture: ${process.arch}`);
+    try {
+        const res = await fetch(`${options.agentUrl}/api/version`);
+        if (res.ok) {
+            const data = await res.json();
+            console.log(`  Agent Port:  ${data.port || 'N/A'}`);
+            console.log(`  Uptime:      ${data.uptime ? `${Math.floor(data.uptime / 60)}m` : 'N/A'}`);
+        }
+    }
+    catch {
+        console.log(`  Agent:       not reachable at ${options.agentUrl}`);
+    }
+    console.log();
+});
+// ─── Setup ────────────────────────────────────────────────────────────────────
+program
+    .command('setup')
+    .description('Install or verify system dependencies (tmux, ttyd, cloudflared)')
+    .option('--check', 'Only check without installing', false)
+    .action(async (options) => {
+    try {
+        const { bootstrap, checkDependencies } = await import('./services/bootstrap.js');
+        if (options.check) {
+            console.log('\n  Checking dependencies...\n');
+            const deps = checkDependencies();
+            for (const [name, info] of Object.entries(deps)) {
+                const icon = info.available ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m';
+                console.log(`  ${icon} ${name.padEnd(14)} ${info.available ? info.version : 'not installed'}`);
+            }
+            const missing = Object.entries(deps).filter(([, v]) => !v.available);
+            if (missing.length > 0) {
+                console.log(`\n  Missing: ${missing.map(([k]) => k).join(', ')}`);
+                console.log('  Run `vibe setup` to install them.\n');
+                process.exit(1);
+            }
+            else {
+                console.log('\n  All dependencies are installed.\n');
+            }
+        }
+        else {
+            console.log('\n  Installing system dependencies...\n');
+            const results = await bootstrap({ verbose: true });
+            const failed = results.filter(r => r.status === 'failed');
+            if (failed.length > 0) {
+                console.log(`\n  ${failed.length} tool(s) failed: ${failed.map(f => f.tool).join(', ')}`);
+                console.log('  You may need to install manually or use sudo.\n');
+                process.exit(1);
+            }
+            else {
+                console.log('\n  All dependencies installed successfully.\n');
+            }
+        }
+    }
+    catch (error) {
+        fail(`Setup failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// ─── Config ───────────────────────────────────────────────────────────────────
+program
+    .command('config')
+    .description('Manage agent configuration')
+    .option('--set <key=value>', 'Set a configuration value')
+    .option('--get <key>', 'Get a configuration value')
+    .option('--list', 'List all configuration')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        if (options.set) {
+            const eq = options.set.indexOf('=');
+            if (eq === -1)
+                fail('Use --set key=value format');
+            const key = options.set.substring(0, eq);
+            const value = options.set.substring(eq + 1);
+            const { ok } = await agentFetch(options.agentUrl, `/api/config/${key}`, {
+                method: 'PUT',
+                body: JSON.stringify({ value }),
+            });
+            if (ok)
+                console.log(`  Set: ${key} = ${value}`);
+            else
+                fail(`Failed to set config key '${key}'`);
+        }
+        else if (options.get) {
+            const { ok, data } = await agentFetch(options.agentUrl, `/api/config/${options.get}`);
+            if (ok && data.value !== undefined) {
+                console.log(`  ${options.get} = ${data.value}`);
+            }
+            else {
+                console.log(`  Key '${options.get}' not found`);
+            }
+        }
+        else if (options.list) {
+            const { ok, data } = await agentFetch(options.agentUrl, '/api/config/');
+            if (ok) {
+                const entries = Object.entries(data);
+                if (entries.length === 0) {
+                    console.log('  No configuration set.');
+                }
+                else {
+                    for (const [k, v] of entries) {
+                        console.log(`  ${k} = ${v}`);
+                    }
+                }
+            }
+            else {
+                fail('Failed to list config');
+            }
+        }
+        else {
+            console.log('Use --set key=value, --get <key>, or --list');
+        }
+    }
+    catch (error) {
+        fail(`Config failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// ═══════════════════════════════════════════════════════════════════════════════
+// Tunnel Commands
+// ═══════════════════════════════════════════════════════════════════════════════
+const tunnelCmd = program
+    .command('tunnel')
+    .description('Manage cloudflared tunnels');
+tunnelCmd
+    .command('list')
+    .description('List all tunnels')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, '/api/tunnel');
+        if (!ok)
+            fail('Failed to list tunnels');
+        if (data.tunnels.length === 0) {
+            console.log('  No tunnels found.');
+        }
+        else {
+            formatTable(data.tunnels.map(t => ({
+                ID: t.id.substring(0, 12) + '...',
+                Port: t.localPort,
+                'Public URL': t.publicUrl || '(none)',
+                Status: t.status,
+                PID: t.pid || 'N/A',
+            })));
+        }
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+tunnelCmd
+    .command('start')
+    .description('Start a tunnel for a local port')
+    .requiredOption('-p, --port <port>', 'Local port to expose')
+    .option('-s, --subdomain <subdomain>', 'Preferred subdomain')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        console.log(`  Starting tunnel for port ${options.port}...`);
+        const { ok, data } = await agentFetch(options.agentUrl, '/api/tunnel/start', {
+            method: 'POST',
+            body: JSON.stringify({
+                localPort: parseInt(options.port),
+                subdomain: options.subdomain,
+            }),
+        });
+        if (!ok)
+            fail(data.error || `Agent returned error`);
+        console.log(`\n  \x1b[32mTunnel started:\x1b[0m`);
+        console.log(`  ID:         ${data.id}`);
+        console.log(`  Local Port: ${data.localPort}`);
+        console.log(`  Public URL: ${data.publicUrl || '(pending...)'}`);
+        console.log(`  PID:        ${data.pid || 'N/A'}`);
+        console.log(`  Status:     ${data.status}\n`);
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+tunnelCmd
+    .command('stop')
+    .description('Stop a running tunnel')
+    .requiredOption('-i, --id <id>', 'Tunnel ID')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, `/api/tunnel/${options.id}/stop`, {
+            method: 'POST',
+        });
+        if (!ok)
+            fail(data.error || 'Failed to stop tunnel');
+        console.log('  Tunnel stopped.');
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+tunnelCmd
+    .command('delete')
+    .description('Delete a tunnel')
+    .requiredOption('-i, --id <id>', 'Tunnel ID')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, `/api/tunnel/${options.id}`, {
+            method: 'DELETE',
+        });
+        if (!ok)
+            fail(data.error || 'Failed to delete tunnel');
+        console.log('  Tunnel deleted.');
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+tunnelCmd
+    .command('status')
+    .description('Get tunnel overview')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, '/api/tunnel/status');
+        if (!ok)
+            fail('Failed to get tunnel status');
+        console.log(`\n  Total:    ${data.total}`);
+        console.log(`  Active:   \x1b[32m${data.active}\x1b[0m`);
+        console.log(`  Inactive: ${data.inactive}`);
+        console.log(`  Errored:  \x1b[31m${data.errored}\x1b[0m\n`);
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// Agent tunnel (the main agent tunnel, not per-port tunnels)
+tunnelCmd
+    .command('agent')
+    .description('Show/manage the main agent cloudflared tunnel')
+    .option('--start', 'Start the agent tunnel')
+    .option('--stop', 'Stop the agent tunnel')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        if (options.start) {
+            const { ok, data } = await agentFetch(options.agentUrl, '/api/agent-tunnel/start', { method: 'POST' });
+            if (!ok)
+                fail('Failed to start agent tunnel');
+            console.log(`  Agent tunnel started: ${data.tunnelUrl}`);
+        }
+        else if (options.stop) {
+            await agentFetch(options.agentUrl, '/api/agent-tunnel/stop', { method: 'POST' });
+            console.log('  Agent tunnel stopped.');
+        }
+        else {
+            const { ok, data } = await agentFetch(options.agentUrl, '/api/agent-tunnel');
+            if (!ok)
+                fail('Failed to get agent tunnel');
+            console.log(`\n  Tunnel URL: ${data.tunnelUrl || '(not running)'}`);
+            console.log(`  Status:     ${data.status || 'unknown'}\n`);
+        }
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// ═══════════════════════════════════════════════════════════════════════════════
+// Session Commands (tmux)
+// ═══════════════════════════════════════════════════════════════════════════════
+const sessionCmd = program
+    .command('session')
+    .description('Manage tmux terminal sessions');
+sessionCmd
+    .command('list')
+    .description('List all tmux sessions')
+    .option('--system', 'Include system (unmanaged) sessions')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const path = options.system ? '/api/tmux/system' : '/api/tmux/';
+        const { ok, data } = await agentFetch(options.agentUrl, path);
+        if (!ok)
+            fail('Failed to list sessions');
+        const sessions = Array.isArray(data) ? data : (data.sessions ?? []);
+        if (sessions.length === 0) {
+            console.log('  No sessions found.');
+        }
+        else {
+            formatTable(sessions.map(s => ({
+                ID: (s.id || s.sessionId || '').substring(0, 12),
+                Name: s.sessionName || s.name || 'N/A',
+                Status: s.status || 'unknown',
+                Port: s.ttydPort || 'N/A',
+                Project: s.projectId || 'N/A',
+            })));
+        }
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+sessionCmd
+    .command('create')
+    .description('Create a new tmux session')
+    .requiredOption('--name <name>', 'Session name')
+    .option('--project <id>', 'Project ID', 'default')
+    .option('--command <cmd>', 'Initial command')
+    .option('--cwd <dir>', 'Working directory')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, '/api/tmux/create', {
+            method: 'POST',
+            body: JSON.stringify({
+                sessionId: `cli-${Date.now()}`,
+                sessionName: options.name,
+                projectId: options.project,
+                command: options.command,
+                startDirectory: options.cwd,
+            }),
+        });
+        if (!ok)
+            fail(data.error || 'Failed to create session');
+        console.log(`  Session created: ${data.sessionName || options.name}`);
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+sessionCmd
+    .command('kill')
+    .description('Kill a tmux session')
+    .requiredOption('-i, --id <id>', 'Session ID')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, `/api/tmux/${options.id}`, {
+            method: 'DELETE',
+        });
+        if (!ok)
+            fail(data.error || 'Failed to kill session');
+        console.log('  Session killed.');
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+sessionCmd
+    .command('exec')
+    .description('Execute a command in a tmux session')
+    .requiredOption('-i, --id <id>', 'Session ID')
+    .requiredOption('-c, --command <cmd>', 'Command to execute')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, `/api/tmux/${options.id}/command`, {
+            method: 'POST',
+            body: JSON.stringify({ command: options.command }),
+        });
+        if (!ok)
+            fail(data.error || 'Failed to execute command');
+        console.log('  Command sent.');
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+sessionCmd
+    .command('capture')
+    .description('Capture output from a tmux session')
+    .requiredOption('-i, --id <id>', 'Session ID')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, `/api/tmux/${options.id}/capture`);
+        if (!ok)
+            fail('Failed to capture output');
+        console.log(data.output || '(empty)');
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// ═══════════════════════════════════════════════════════════════════════════════
+// SSH Commands
+// ═══════════════════════════════════════════════════════════════════════════════
+const sshCmd = program
+    .command('ssh')
+    .description('Manage SSH connections');
+sshCmd
+    .command('list')
+    .description('List saved SSH connections')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, '/api/ssh/connections');
+        if (!ok)
+            fail('Failed to list SSH connections');
+        const conns = Array.isArray(data) ? data : (data.connections ?? []);
+        if (conns.length === 0) {
+            console.log('  No SSH connections saved.');
+        }
+        else {
+            formatTable(conns.map(c => ({
+                ID: (c.id || '').substring(0, 12),
+                Name: c.serverName,
+                Host: c.host,
+                Port: c.port,
+                User: c.username,
+            })));
+        }
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+sshCmd
+    .command('add')
+    .description('Add an SSH connection')
+    .requiredOption('--name <name>', 'Server name')
+    .requiredOption('--host <host>', 'Hostname or IP')
+    .requiredOption('--user <user>', 'Username')
+    .option('--port <port>', 'Port', '22')
+    .option('--key <path>', 'Private key path')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, '/api/ssh/connections', {
+            method: 'POST',
+            body: JSON.stringify({
+                serverName: options.name,
+                host: options.host,
+                port: parseInt(options.port),
+                username: options.user,
+                privateKeyPath: options.key,
+            }),
+        });
+        if (!ok)
+            fail(data.error || 'Failed to add connection');
+        console.log(`  SSH connection '${options.name}' added.`);
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+sshCmd
+    .command('remove')
+    .description('Remove an SSH connection')
+    .requiredOption('-i, --id <id>', 'Connection ID')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok } = await agentFetch(options.agentUrl, `/api/ssh/connections/${options.id}`, {
+            method: 'DELETE',
+        });
+        if (!ok)
+            fail('Failed to remove connection');
+        console.log('  SSH connection removed.');
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+sshCmd
+    .command('test')
+    .description('Test an SSH connection')
+    .requiredOption('-i, --id <id>', 'Connection ID')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, `/api/ssh/test/${options.id}`, { method: 'POST' });
+        if (!ok)
+            fail(data.error || 'Connection test failed');
+        console.log('  \x1b[32mConnection successful.\x1b[0m');
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+sshCmd
+    .command('exec')
+    .description('Execute a command on a remote server')
+    .requiredOption('-i, --id <id>', 'Connection ID')
+    .requiredOption('-c, --command <cmd>', 'Command to execute')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, '/api/ssh/execute', {
+            method: 'POST',
+            body: JSON.stringify({
+                connectionId: options.id,
+                command: options.command,
+            }),
+        });
+        if (!ok)
+            fail(data.error || 'Execution failed');
+        if (data.output)
+            console.log(data.output);
+        if (data.error)
+            console.error(data.error);
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// ═══════════════════════════════════════════════════════════════════════════════
+// Port Forward Commands
+// ═══════════════════════════════════════════════════════════════════════════════
+const forwardCmd = program
+    .command('forward')
+    .description('Manage SSH port forwards');
+forwardCmd
+    .command('list')
+    .description('List all port forwards')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, '/api/port-forward/');
+        if (!ok)
+            fail('Failed to list forwards');
+        const fwds = Array.isArray(data) ? data : (data.forwards ?? []);
+        if (fwds.length === 0) {
+            console.log('  No port forwards found.');
+        }
+        else {
+            formatTable(fwds.map(f => ({
+                ID: (f.id || '').substring(0, 12),
+                Local: f.localPort,
+                Remote: `${f.remoteHost}:${f.remotePort}`,
+                Server: f.serverName,
+                Status: f.status,
+            })));
+        }
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+forwardCmd
+    .command('create')
+    .description('Create a port forward rule')
+    .requiredOption('--local <port>', 'Local port')
+    .requiredOption('--remote-host <host>', 'Remote host')
+    .requiredOption('--remote-port <port>', 'Remote port')
+    .requiredOption('--server <name>', 'SSH server name')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, '/api/port-forward/', {
+            method: 'POST',
+            body: JSON.stringify({
+                localPort: parseInt(options.local),
+                remoteHost: options.remoteHost,
+                remotePort: parseInt(options.remotePort),
+                serverName: options.server,
+            }),
+        });
+        if (!ok)
+            fail(data.error || 'Failed to create forward');
+        console.log('  Port forward created.');
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+forwardCmd
+    .command('start')
+    .description('Start a port forward')
+    .requiredOption('-i, --id <id>', 'Forward ID')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, `/api/port-forward/${options.id}/start`, {
+            method: 'POST',
+        });
+        if (!ok)
+            fail(data.error || 'Failed to start forward');
+        console.log('  Port forward started.');
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+forwardCmd
+    .command('stop')
+    .description('Stop a port forward')
+    .requiredOption('-i, --id <id>', 'Forward ID')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, `/api/port-forward/${options.id}/stop`, {
+            method: 'POST',
+        });
+        if (!ok)
+            fail(data.error || 'Failed to stop forward');
+        console.log('  Port forward stopped.');
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+forwardCmd
+    .command('delete')
+    .description('Delete a port forward')
+    .requiredOption('-i, --id <id>', 'Forward ID')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok } = await agentFetch(options.agentUrl, `/api/port-forward/${options.id}`, {
+            method: 'DELETE',
+        });
+        if (!ok)
+            fail('Failed to delete forward');
+        console.log('  Port forward deleted.');
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// ═══════════════════════════════════════════════════════════════════════════════
+// Task Commands
+// ═══════════════════════════════════════════════════════════════════════════════
+const taskCmd = program
+    .command('task')
+    .description('Manage background tasks');
+taskCmd
+    .command('list')
+    .description('List tasks')
+    .option('--status <status>', 'Filter by status (pending, running, completed, failed)')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const query = options.status ? `?status=${options.status}` : '';
+        const { ok, data } = await agentFetch(options.agentUrl, `/api/tasks/${query}`);
+        if (!ok)
+            fail('Failed to list tasks');
+        const tasks = Array.isArray(data) ? data : [];
+        if (tasks.length === 0) {
+            console.log('  No tasks found.');
+        }
+        else {
+            formatTable(tasks.map(t => ({
+                ID: (t.id || '').substring(0, 12),
+                Type: t.type,
+                Status: t.status,
+                Created: t.createdAt ? timeAgo(t.createdAt) : 'N/A',
+            })));
+        }
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+taskCmd
+    .command('run')
+    .description('Run a command as a background task')
+    .requiredOption('-c, --command <cmd>', 'Command to execute')
+    .option('--cwd <dir>', 'Working directory')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, '/api/tasks/', {
+            method: 'POST',
+            body: JSON.stringify({
+                type: 'command',
+                payload: JSON.stringify({
+                    command: options.command,
+                    cwd: options.cwd,
+                }),
+            }),
+        });
+        if (!ok)
+            fail(data.error || 'Failed to create task');
+        console.log(`  Task created: ${data.id}`);
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// ═══════════════════════════════════════════════════════════════════════════════
+// Notification Commands
+// ═══════════════════════════════════════════════════════════════════════════════
+const notifyCmd = program
+    .command('notify')
+    .description('Manage notifications');
+notifyCmd
+    .command('list')
+    .description('List notifications')
+    .option('--unread', 'Show only unread')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const path = options.unread ? '/api/notifications/unread' : '/api/notifications/';
+        const { ok, data } = await agentFetch(options.agentUrl, path);
+        if (!ok)
+            fail('Failed to list notifications');
+        const notifications = Array.isArray(data) ? data : (data.notifications ?? []);
+        if (notifications.length === 0) {
+            console.log('  No notifications.');
+        }
+        else {
+            for (const n of notifications) {
+                const icon = n.type === 'error' ? '\x1b[31m●\x1b[0m' :
+                    n.type === 'warning' ? '\x1b[33m●\x1b[0m' :
+                        n.type === 'success' ? '\x1b[32m●\x1b[0m' : '\x1b[34m●\x1b[0m';
+                const unread = n.status === 'unread' ? ' [NEW]' : '';
+                console.log(`  ${icon} ${n.title}${unread}`);
+                console.log(`    ${n.message}`);
+                if (n.createdAt)
+                    console.log(`    ${timeAgo(n.createdAt)}`);
+                console.log();
+            }
+        }
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+notifyCmd
+    .command('read-all')
+    .description('Mark all notifications as read')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok } = await agentFetch(options.agentUrl, '/api/notifications/read-all', {
+            method: 'PUT',
+        });
+        if (!ok)
+            fail('Failed to mark as read');
+        console.log('  All notifications marked as read.');
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// ═══════════════════════════════════════════════════════════════════════════════
+// System Info
+// ═══════════════════════════════════════════════════════════════════════════════
+program
+    .command('system')
+    .description('Show system information from the agent')
+    .option('--agent-url <url>', 'Agent URL', DEFAULT_AGENT_URL)
+    .action(async (options) => {
+    try {
+        const { ok, data } = await agentFetch(options.agentUrl, '/api/config/system/info');
+        if (!ok)
+            fail('Failed to get system info');
+        console.log(`\n  Hostname:     ${data.hostname}`);
+        console.log(`  Platform:     ${data.platform}`);
+        console.log(`  Architecture: ${data.arch}`);
+        console.log(`  CPUs:         ${data.cpuCount}`);
+        console.log(`  Memory:       ${data.totalMemory}`);
+        console.log(`  Uptime:       ${data.uptime}`);
+        console.log(`  Environment:  ${data.environment}\n`);
+    }
+    catch (error) {
+        fail(`Failed: ${error instanceof Error ? error.message : error}`);
+    }
+});
+// ═══════════════════════════════════════════════════════════════════════════════
+program.parse();
+//# sourceMappingURL=cli.js.map