@agentgazer/cli 0.2.1 → 0.3.0

package/dist/cli.js

@@ -1,47 +1,24 @@
 #!/usr/bin/env node
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __importStar(require("node:fs"));
-const path = __importStar(require("node:path"));
-const readline = __importStar(require("node:readline"));
-const config_js_1 = require("./config.js");
-const secret_store_js_1 = require("./secret-store.js");
-const server_1 = require("@agentgazer/server");
-const proxy_1 = require("@agentgazer/proxy");
-const shared_1 = require("@agentgazer/shared");
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import { ensureConfig, readConfig, resetToken, getDbPath, getConfigDir, setProvider, } from "./config.js";
+import { detectSecretStore, migrateFromPlaintextConfig, loadProviderKeys, PROVIDER_SERVICE, } from "./secret-store.js";
+import { startServer } from "@agentgazer/server";
+import { startProxy } from "@agentgazer/proxy";
+import { KNOWN_PROVIDER_NAMES } from "@agentgazer/shared";
+// New command imports
+import { cmdAgents } from "./commands/agents.js";
+import { cmdAgent } from "./commands/agent.js";
+import { cmdProviders } from "./commands/providers.js";
+import { cmdProvider } from "./commands/provider.js";
+import { cmdEvents } from "./commands/events.js";
+// cmdOverview is imported dynamically to avoid ESM top-level await issues
 // ---------------------------------------------------------------------------
 // Arg parsing
 // ---------------------------------------------------------------------------
@@ -52,7 +29,19 @@ function parseFlags(argv) {
         if (arg.startsWith("--")) {
             const key = arg.slice(2);
             const next = argv[i + 1];
-            if (next !== undefined && !next.startsWith("--")) {
+            if (next !== undefined && !next.startsWith("-")) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                flags[key] = "";
+            }
+        }
+        else if (arg.startsWith("-") && arg.length === 2) {
+            // Short flags like -v, -d, or short flags with values like -o json
+            const key = arg.slice(1);
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith("-")) {
                 flags[key] = next;
                 i++;
             }
@@ -80,6 +69,50 @@ function parsePositional(argv) {
     return positional;
 }
 // ---------------------------------------------------------------------------
+// Port utilities
+// ---------------------------------------------------------------------------
+function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once("error", () => resolve(false));
+        server.once("listening", () => {
+            server.close(() => resolve(true));
+        });
+        server.listen(port, "0.0.0.0");
+    });
+}
+async function findAvailablePort(startPort, maxAttempts = 10) {
+    for (let i = 0; i < maxAttempts; i++) {
+        const port = startPort + i;
+        if (await isPortAvailable(port)) {
+            return port;
+        }
+    }
+    throw new Error(`No available port found in range ${startPort}-${startPort + maxAttempts - 1}`);
+}
+/**
+ * Find PIDs of processes listening on the given ports.
+ * Uses lsof on macOS/Linux. Returns empty array on error.
+ */
+function findPidsOnPorts(ports) {
+    const pids = new Set();
+    for (const port of ports) {
+        try {
+            const result = execSync(`lsof -ti:${port} 2>/dev/null`, { encoding: "utf-8" });
+            for (const line of result.trim().split("\n")) {
+                const pid = parseInt(line.trim(), 10);
+                if (!isNaN(pid) && pid > 0) {
+                    pids.add(pid);
+                }
+            }
+        }
+        catch {
+            // No process on this port or lsof not available
+        }
+    }
+    return Array.from(pids);
+}
+// ---------------------------------------------------------------------------
 // Help
 // ---------------------------------------------------------------------------
 function printUsage() {
@@ -91,70 +124,133 @@ Usage: agentgazer <command> [options]
 Commands:
   onboard                     First-time setup — generate token and configure providers
   start                       Start the server, proxy, and dashboard
+  stop                        Stop the daemon process
+  logs                        Show daemon logs (use -f to follow)
   status                      Show current configuration
   reset-token                 Generate a new auth token
-  providers list              List configured providers
-  providers set-key           Interactive provider key setup
-  providers set <name> <key>  Set provider key (non-interactive)
-  providers remove <name>     Remove a provider
+  overview                    Launch real-time TUI dashboard
+  events                      Query and display agent events
+
+  agents                      List all registered agents
+  agent <name> active         Activate an agent
+  agent <name> deactive       Deactivate an agent
+  agent <name> killswitch on|off  Toggle kill switch
+  agent <name> delete         Delete agent and all data
+  agent <name> stat           Show agent statistics
+  agent <name> model          List model overrides
+  agent <name> model-override <model>  Set model override
+  agent <name> alerts         List alert rules for agent
+  agent <name> alert add <type>  Add alert rule (agent_down, error_rate, budget)
+  agent <name> alert delete <id>  Delete alert rule
+  agent <name> alert reset <id>   Reset alert state to normal
+
+  providers                   List all configured providers
+  provider add [name] [key]   Add provider (interactive if args omitted)
+  provider <name> active      Activate a provider
+  provider <name> deactive    Deactivate a provider
+  provider <name> test-connection  Test API key validity
+  provider <name> delete      Delete provider and key
+  provider <name> models      List available models
+  provider <name> stat        Show provider statistics
+
   version                     Show version
   doctor                      Check system health
-  agents                      List registered agents
-  stats [agentId]             Show agent statistics (auto-selects if only one agent)
-  uninstall                   Remove AgentGazer (curl-installed only)
+  uninstall                   Remove AgentGazer data (interactive menu)
   help                        Show this help message
 
 Options (for start):
-  --port <number>            Server/dashboard port (default: 8080)
-  --proxy-port <number>      LLM proxy port (default: 4000)
-  --retention-days <number>  Data retention period in days (default: 30)
-  --no-open                  Don't auto-open browser
+  --port <number>            Server/dashboard port (default: 18800, or config.server.port)
+  --proxy-port <number>      LLM proxy port (default: 18900, or config.server.proxyPort)
+  --retention-days <number>  Data retention in days (default: 30, or config.data.retentionDays)
+  --no-open                  Don't auto-open browser (or set config.server.autoOpen: false)
+  -v, --verbose              Print verbose logs to console
+  -d, --daemon               Print info and token, then run in background
+
+Config file: ~/.agentgazer/config.json (optional settings: port, proxyPort, autoOpen, retentionDays)
+
+Options (for agent/provider stat):
+  --range <period>           Time range: 1h, 24h, 7d, 30d (default: 24h)
+
+Options (for delete commands):
+  --yes                      Skip confirmation prompts
+
+Options (for alert add):
+  --threshold <percent>      Error rate threshold (error_rate only, default: 10)
+  --timeout <seconds>        Timeout in seconds (agent_down only, default: 300)
+  --limit <amount>           Budget limit in USD (budget only, required)
+  --period <period>          Budget period: daily, weekly, monthly (budget only)
+  --repeat                   Enable repeat notifications (default: enabled)
+  --no-repeat                Disable repeat notifications (one-time only)
+  --interval <minutes>       Repeat interval in minutes (default: 15)
+  --recovery-notify          Send notification when alert recovers
+  --webhook <url>            Webhook URL for notifications
+  --telegram <chat_id>       Telegram chat ID for notifications
 
-Options (for doctor, stats, agents):
-  --port <number>            Server port to check (default: 8080)
-  --proxy-port <number>      Proxy port to check (default: 4000)
+Options (for logs):
+  -f, --follow               Follow log output (like tail -f)
+  -n, --lines <number>       Number of lines to show (default: 50)
 
-Options (for stats):
-  --range <period>           Time range (default: 24h)
+Options (for events):
+  -a, --agent <name>         Filter by agent ID
+  -t, --type <type>          Filter by event type
+  -p, --provider <name>      Filter by provider
+  -s, --since <duration>     Time range: 1h, 24h, 7d, 30d (default: 24h)
+  -n, --limit <number>       Max events (default: 50, max: 1000)
+  -o, --output <format>      Output: table, json, csv (default: table)
+      --search <term>        Search in model/provider/error
+  -f, --follow               Poll for new events every 3s
 
 Options (for uninstall):
+  --all                      Remove everything (keys, config, data)
+  --config                   Remove config only
+  --keys                     Remove provider keys only
+  --data                     Remove agent data only
   --yes                      Skip confirmation prompts
 
 Examples:
-  agentgazer onboard                           First-time setup
-  agentgazer start                             Start with defaults
-  agentgazer start --port 9090                 Use custom server port
-  agentgazer providers set-key                 Interactive provider setup
-  agentgazer providers list                    List configured providers
-  agentgazer stats                             Show stats (auto-selects agent)
-  agentgazer stats my-agent --range 7d         Show stats for specific agent
+  agentgazer onboard                    First-time setup
+  agentgazer start                      Start with defaults
+  agentgazer start -d                   Start as daemon (background)
+  agentgazer stop                       Stop the daemon
+  agentgazer logs -f                    Follow daemon logs
+  agentgazer overview                   Launch TUI dashboard
+  agentgazer provider add openai        Add OpenAI (prompts for key)
+  agentgazer agent my-bot stat          Show stats for my-bot
+  agentgazer agent my-bot killswitch on Enable kill switch
+  agentgazer events                     Show recent events
+  agentgazer events -a my-bot -t error  Filter by agent and type
+  agentgazer events -f                  Follow new events live
+  agentgazer agent my-bot alerts        List alerts for my-bot
+  agentgazer agent my-bot alert add error_rate --threshold 20
+  agentgazer agent my-bot alert add budget --limit 50 --period daily
+  agentgazer agent my-bot alert reset abc  Reset alert state
 `);
 }
 // ---------------------------------------------------------------------------
 // Subcommands
 // ---------------------------------------------------------------------------
-const KNOWN_PROVIDERS = shared_1.KNOWN_PROVIDER_NAMES;
+const KNOWN_PROVIDERS = KNOWN_PROVIDER_NAMES;
 function ask(rl, question) {
     return new Promise((resolve) => {
         rl.question(question, (answer) => resolve(answer.trim()));
     });
 }
 async function cmdOnboard() {
-    const saved = (0, config_js_1.ensureConfig)();
+    const saved = ensureConfig();
     console.log(`
   AgentGazer — Setup
   ───────────────────────────────────────
 
   Token:    ${saved.token}
-  Config:   ${(0, config_js_1.getConfigDir)()}/config.json
-  Database: ${(0, config_js_1.getDbPath)()}
-  Server:   http://localhost:8080
-  Proxy:    http://localhost:4000
+  Config:   ${getConfigDir()}/config.json
+  Database: ${getDbPath()}
+  Server:   http://localhost:18800
+  Proxy:    http://localhost:18900
 
   ───────────────────────────────────────
 `);
     // Initialize secret store
-    const { store, backendName } = await (0, secret_store_js_1.detectSecretStore)((0, config_js_1.getConfigDir)());
+    const { store, backendName } = await detectSecretStore(getConfigDir());
     console.log(`  Secret backend: ${backendName}\n`);
     const rl = readline.createInterface({
         input: process.stdin,
@@ -169,10 +265,10 @@ async function cmdOnboard() {
             if (!key)
                 continue;
             // Store API key in secret store
-            await store.set(secret_store_js_1.PROVIDER_SERVICE, provider, key);
+            await store.set(PROVIDER_SERVICE, provider, key);
             // Store provider entry in config.json (apiKey is empty — actual key is in secret store)
             const providerConfig = { apiKey: "" };
-            (0, config_js_1.setProvider)(provider, providerConfig);
+            setProvider(provider, providerConfig);
             providerCount++;
             console.log(`  ✓ ${provider} configured.\n`);
         }
@@ -208,121 +304,13 @@ async function cmdOnboard() {
 
   Or point your LLM client at the proxy (with auto API key injection):
 
-    export OPENAI_BASE_URL=http://localhost:4000/openai/v1
+    export OPENAI_BASE_URL=http://localhost:18900/openai/v1
 
   Next: run "agentgazer start" to launch.
 `);
 }
-async function cmdProviders(args) {
-    const action = args[0];
-    switch (action) {
-        case "list": {
-            // List reads from config.json only — no secret store access needed.
-            const providers = (0, config_js_1.listProviders)();
-            const names = Object.keys(providers);
-            if (names.length === 0) {
-                console.log("No providers configured. Use \"agentgazer providers set-key\" to add one.");
-                return;
-            }
-            console.log("\n  Configured providers:");
-            console.log("  ───────────────────────────────────────");
-            for (const name of names) {
-                const p = providers[name];
-                const keyStatus = p.apiKey ? "(plaintext — run \"agentgazer start\" to migrate)" : "(secured)";
-                const rateInfo = p.rateLimit
-                    ? ` (rate limit: ${p.rateLimit.maxRequests} req / ${p.rateLimit.windowSeconds}s)`
-                    : "";
-                console.log(`  ${name}: ${keyStatus}${rateInfo}`);
-            }
-            console.log();
-            break;
-        }
-        case "set": {
-            const name = args[1];
-            const key = args[2];
-            if (!name || !key) {
-                console.error("Usage: agentgazer providers set <provider-name> <api-key>");
-                process.exit(1);
-            }
-            if (!KNOWN_PROVIDERS.includes(name)) {
-                console.warn(`Warning: "${name}" is not a known provider (${KNOWN_PROVIDERS.join(", ")}). Proceeding anyway.`);
-            }
-            const { store, backendName } = await (0, secret_store_js_1.detectSecretStore)((0, config_js_1.getConfigDir)());
-            // Store API key in secret store
-            await store.set(secret_store_js_1.PROVIDER_SERVICE, name, key);
-            // Ensure provider entry exists in config.json (for rate limits etc.)
-            const config = (0, config_js_1.ensureConfig)();
-            if (!config.providers)
-                config.providers = {};
-            if (!config.providers[name]) {
-                config.providers[name] = { apiKey: "" };
-            }
-            // Remove any plaintext apiKey that might be in config
-            config.providers[name].apiKey = "";
-            (0, config_js_1.saveConfig)(config);
-            console.log(`Provider "${name}" configured (secret stored in ${backendName}).`);
-            break;
-        }
-        case "set-key": {
-            // Interactive provider key setup
-            const rl = readline.createInterface({
-                input: process.stdin,
-                output: process.stdout,
-            });
-            console.log("\n  Available providers:");
-            console.log("  ───────────────────────────────────────");
-            KNOWN_PROVIDERS.forEach((p, i) => {
-                console.log(`  ${i + 1}. ${p}`);
-            });
-            console.log();
-            try {
-                const choice = await ask(rl, "  Select provider (number): ");
-                const idx = parseInt(choice, 10) - 1;
-                if (isNaN(idx) || idx < 0 || idx >= KNOWN_PROVIDERS.length) {
-                    console.error("  Invalid selection.");
-                    process.exit(1);
-                }
-                const provider = KNOWN_PROVIDERS[idx];
-                const apiKey = await ask(rl, `  API key for ${provider}: `);
-                if (!apiKey) {
-                    console.error("  API key is required.");
-                    process.exit(1);
-                }
-                // Store API key in secret store
-                const { store, backendName: backend } = await (0, secret_store_js_1.detectSecretStore)((0, config_js_1.getConfigDir)());
-                await store.set(secret_store_js_1.PROVIDER_SERVICE, provider, apiKey);
-                // Store provider entry in config.json (apiKey is empty — actual key is in secret store)
-                const providerConfig = { apiKey: "" };
-                (0, config_js_1.setProvider)(provider, providerConfig);
-                console.log(`\n  ✓ ${provider} configured (secret stored in ${backend}).`);
-                console.log(`  Rate limits can be configured in the Dashboard.`);
-            }
-            finally {
-                rl.close();
-            }
-            break;
-        }
-        case "remove": {
-            const name = args[1];
-            if (!name) {
-                console.error("Usage: agentgazer providers remove <provider-name>");
-                process.exit(1);
-            }
-            const { store } = await (0, secret_store_js_1.detectSecretStore)((0, config_js_1.getConfigDir)());
-            // Delete from secret store
-            await store.delete(secret_store_js_1.PROVIDER_SERVICE, name);
-            // Remove from config.json
-            (0, config_js_1.removeProvider)(name);
-            console.log(`Provider "${name}" removed.`);
-            break;
-        }
-        default:
-            console.error("Usage: agentgazer providers <list|set-key|set|remove>");
-            process.exit(1);
-    }
-}
 function cmdStatus() {
-    const config = (0, config_js_1.readConfig)();
+    const config = readConfig();
     if (!config) {
         console.log("No configuration found. Run \"agentgazer onboard\" first.");
         process.exit(1);
@@ -332,23 +320,90 @@ function cmdStatus() {
   ───────────────────────────────────────
 
   Token:    ${config.token}
-  Config:   ${(0, config_js_1.getConfigDir)()}/config.json
-  Database: ${(0, config_js_1.getDbPath)()}
-  Server:   http://localhost:8080 (default)
-  Proxy:    http://localhost:4000 (default)
+  Config:   ${getConfigDir()}/config.json
+  Database: ${getDbPath()}
+  Server:   http://localhost:18800 (default)
+  Proxy:    http://localhost:18900 (default)
 `);
 }
 function cmdResetToken() {
-    const config = (0, config_js_1.resetToken)();
+    const config = resetToken();
     console.log(`Token reset. New token: ${config.token}`);
 }
 async function cmdStart(flags) {
-    const config = (0, config_js_1.ensureConfig)();
-    const serverPort = flags["port"] ? parseInt(flags["port"], 10) : 8080;
+    const verbose = "v" in flags || "verbose" in flags;
+    const daemon = "d" in flags || "daemon" in flags;
+    // Set log level for verbose mode
+    if (verbose) {
+        process.env.LOG_LEVEL = "debug";
+    }
+    // Handle daemon mode: fork process and exit
+    if (daemon && !process.env.AGENTGAZER_DAEMON_CHILD) {
+        const { spawn } = await import("node:child_process");
+        const configDir = getConfigDir();
+        const pidFile = path.join(configDir, "agentgazer.pid");
+        const logFile = path.join(configDir, "agentgazer.log");
+        // Check if already running
+        if (fs.existsSync(pidFile)) {
+            const existingPid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+            try {
+                process.kill(existingPid, 0); // Check if process exists
+                console.error(`AgentGazer is already running (PID: ${existingPid})`);
+                console.error(`Use "agentgazer stop" to stop it first.`);
+                process.exit(1);
+            }
+            catch {
+                // Process doesn't exist, clean up stale PID file
+                fs.unlinkSync(pidFile);
+            }
+        }
+        // Open log file for output
+        const logFd = fs.openSync(logFile, "a");
+        const args = process.argv.slice(2).filter((a) => a !== "-d" && a !== "--daemon");
+        const child = spawn(process.execPath, [process.argv[1], ...args], {
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+            env: { ...process.env, AGENTGAZER_DAEMON_CHILD: "1" },
+        });
+        child.unref();
+        fs.closeSync(logFd);
+        // Write PID file
+        fs.writeFileSync(pidFile, String(child.pid));
+        const config = ensureConfig();
+        // Use config values as defaults for daemon mode display
+        const serverPort = flags["port"] ? parseInt(flags["port"], 10) : (config.server?.port ?? 18800);
+        const proxyPort = flags["proxy-port"] ? parseInt(flags["proxy-port"], 10) : (config.server?.proxyPort ?? 18900);
+        console.log(`
+  ╔════════════════════════════════════════════════════╗
+  ║          AgentGazer started (daemon)               ║
+  ╠════════════════════════════════════════════════════╣
+  ║                                                    ║
+  ║  Dashboard:  http://localhost:${String(serverPort).padEnd(5)}                ║
+  ║  Proxy:      http://localhost:${String(proxyPort).padEnd(5)}                ║
+  ║                                                    ║
+  ║  Token:      ${config.token.padEnd(32)}    ║
+  ║                                                    ║
+  ╚════════════════════════════════════════════════════╝
+
+  Process running in background (PID: ${child.pid})
+  Logs:    ${logFile}
+
+  To stop:  agentgazer stop
+  To logs:  agentgazer logs -f
+`);
+        process.exit(0);
+    }
+    const config = ensureConfig();
+    // Use config values as defaults, CLI flags override
+    const defaultPort = config.server?.port ?? 18800;
+    const defaultProxyPort = config.server?.proxyPort ?? 18900;
+    const defaultRetentionDays = config.data?.retentionDays ?? 30;
+    const defaultAutoOpen = config.server?.autoOpen ?? true;
+    const requestedServerPort = flags["port"] ? parseInt(flags["port"], 10) : defaultPort;
     const proxyPort = flags["proxy-port"]
         ? parseInt(flags["proxy-port"], 10)
-        : 4000;
-    if (isNaN(serverPort) || serverPort < 1 || serverPort > 65535) {
+        : defaultProxyPort;
+    if (isNaN(requestedServerPort) || requestedServerPort < 1 || requestedServerPort > 65535) {
         console.error("Error: --port must be a valid port number (1-65535)");
         process.exit(1);
     }
@@ -356,15 +411,35 @@ async function cmdStart(flags) {
         console.error("Error: --proxy-port must be a valid port number (1-65535)");
         process.exit(1);
     }
-    if (serverPort < 1024) {
-        console.warn("Warning: port %d may require elevated privileges on Unix systems.", serverPort);
+    if (requestedServerPort < 1024) {
+        console.warn("Warning: port %d may require elevated privileges on Unix systems.", requestedServerPort);
     }
     if (proxyPort < 1024) {
         console.warn("Warning: proxy port %d may require elevated privileges on Unix systems.", proxyPort);
     }
+    // Check if proxy port is available (no auto-switching for proxy)
+    if (!(await isPortAvailable(proxyPort))) {
+        console.error(`Error: Proxy port ${proxyPort} is already in use.`);
+        console.error("  The proxy port must be fixed for OpenClaw configuration to work.");
+        console.error("  Please stop the process using this port or specify a different port with --proxy-port <number>");
+        process.exit(1);
+    }
+    // Find available port for dashboard (auto-increment if in use)
+    let serverPort;
+    try {
+        serverPort = await findAvailablePort(requestedServerPort);
+        if (serverPort !== requestedServerPort) {
+            console.log(`  Dashboard port ${requestedServerPort} is in use, using ${serverPort} instead.`);
+        }
+    }
+    catch {
+        console.error(`Error: Could not find available port starting from ${requestedServerPort}`);
+        console.error("  Try specifying a different port with --port <number>");
+        process.exit(1);
+    }
     const retentionDays = flags["retention-days"]
         ? parseInt(flags["retention-days"], 10)
-        : 30;
+        : defaultRetentionDays;
     if (isNaN(retentionDays) || retentionDays < 1) {
         console.error("Error: --retention-days must be a positive integer");
         process.exit(1);
@@ -388,38 +463,42 @@ async function cmdStart(flags) {
             // ignore
         }
     }
+    // Initialize secret store first (needed for both server and proxy)
+    const configDir = getConfigDir();
+    const configPath = path.join(configDir, "config.json");
+    const { store, backendName } = await detectSecretStore(configDir);
     // Start the local server
-    const { db, shutdown: shutdownServer } = await (0, server_1.startServer)({
+    const { db, shutdown: shutdownServer } = await startServer({
         port: serverPort,
         token: config.token,
-        dbPath: (0, config_js_1.getDbPath)(),
+        dbPath: getDbPath(),
         dashboardDir,
         retentionDays,
+        secretStore: store,
+        configPath,
     });
-    // Initialize secret store
-    const configDir = (0, config_js_1.getConfigDir)();
-    const configPath = path.join(configDir, "config.json");
-    const { store, backendName } = await (0, secret_store_js_1.detectSecretStore)(configDir);
     console.log(`  Secret backend: ${backendName}`);
     // Auto-migrate plaintext keys from config.json to secret store
-    const migratedCount = await (0, secret_store_js_1.migrateFromPlaintextConfig)(configPath, store);
+    const migratedCount = await migrateFromPlaintextConfig(configPath, store);
     if (migratedCount > 0) {
         console.log(`  Migrated ${migratedCount} provider key(s) from config.json to secret store.`);
     }
     // Load provider keys from secret store
-    const providerKeys = await (0, secret_store_js_1.loadProviderKeys)(store);
+    const providerKeys = await loadProviderKeys(store);
     // Start the LLM proxy (with db for policy enforcement and rate limits)
-    const { shutdown: shutdownProxy } = (0, proxy_1.startProxy)({
+    const { shutdown: shutdownProxy } = startProxy({
         apiKey: config.token,
         agentId: "proxy",
         port: proxyPort,
         endpoint: `http://localhost:${serverPort}/api/events`,
         providerKeys,
         db, // Rate limits are loaded from db
+        secretStore: store, // For hot-reloading provider keys
     });
+    const modeLabel = verbose ? "running (verbose)" : "running";
     console.log(`
   ╔════════════════════════════════════════════════════╗
-  ║              AgentGazer running                    ║
+  ║              AgentGazer ${modeLabel.padEnd(21)}   ║
   ╠════════════════════════════════════════════════════╣
   ║                                                    ║
   ║  Dashboard:  http://localhost:${String(serverPort).padEnd(5)}                ║
@@ -430,10 +509,11 @@ async function cmdStart(flags) {
   ╚════════════════════════════════════════════════════╝
 
   Proxy routes:  http://localhost:${proxyPort}/{provider}/...
-  Providers:     ${shared_1.KNOWN_PROVIDER_NAMES.join(", ")}
+  Providers:     ${KNOWN_PROVIDER_NAMES.join(", ")}
 `);
-    // Auto-open browser unless --no-open
-    if (!("no-open" in flags)) {
+    // Auto-open browser unless --no-open flag or autoOpen=false in config
+    const shouldAutoOpen = !("no-open" in flags) && defaultAutoOpen;
+    if (shouldAutoOpen) {
         try {
             const open = await import("open");
             await open.default(`http://localhost:${serverPort}`);
@@ -444,17 +524,36 @@ async function cmdStart(flags) {
     }
     // Graceful shutdown
     let shuttingDown = false;
+    let forceExitTimeout = null;
+    const pidFile = path.join(configDir, "agentgazer.pid");
     function handleShutdown() {
-        if (shuttingDown)
-            return;
+        if (shuttingDown) {
+            // Second Ctrl+C: force exit immediately
+            console.log("\nForce exiting...");
+            process.exit(1);
+        }
         shuttingDown = true;
-        console.log("\nShutting down...");
+        console.log("\nShutting down... (press Ctrl+C again to force exit)");
+        // Force exit after 5 seconds if graceful shutdown hangs
+        forceExitTimeout = setTimeout(() => {
+            console.error("Shutdown timed out, forcing exit.");
+            process.exit(1);
+        }, 5000);
+        forceExitTimeout.unref();
         Promise.all([shutdownProxy(), shutdownServer()])
             .then(() => {
+            if (forceExitTimeout)
+                clearTimeout(forceExitTimeout);
+            // Clean up PID file if we're a daemon child
+            if (process.env.AGENTGAZER_DAEMON_CHILD && fs.existsSync(pidFile)) {
+                fs.unlinkSync(pidFile);
+            }
             console.log("Shutdown complete.");
             process.exit(0);
         })
             .catch((err) => {
+            if (forceExitTimeout)
+                clearTimeout(forceExitTimeout);
             console.error("Error during shutdown:", err);
             process.exit(1);
         });
@@ -468,69 +567,18 @@ async function cmdStart(flags) {
     });
 }
 // ---------------------------------------------------------------------------
-// Formatting helpers
-// ---------------------------------------------------------------------------
-function formatNumber(n) {
-    return n.toLocaleString("en-US");
-}
-function timeAgo(iso) {
-    if (!iso)
-        return "—";
-    const diff = Date.now() - new Date(iso).getTime();
-    if (diff < 0)
-        return "just now";
-    const seconds = Math.floor(diff / 1000);
-    if (seconds < 60)
-        return `${seconds} seconds ago`;
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-        return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24)
-        return `${hours} hour${hours === 1 ? "" : "s"} ago`;
-    const days = Math.floor(hours / 24);
-    return `${days} day${days === 1 ? "" : "s"} ago`;
-}
-// ---------------------------------------------------------------------------
-// API helper
-// ---------------------------------------------------------------------------
-async function apiGet(urlPath, port) {
-    const config = (0, config_js_1.readConfig)();
-    const token = config?.token ?? "";
-    try {
-        const res = await fetch(`http://localhost:${port}${urlPath}`, {
-            headers: { Authorization: `Bearer ${token}` },
-            signal: AbortSignal.timeout(5000),
-        });
-        if (!res.ok) {
-            console.error(`Server responded with ${res.status} ${res.statusText}`);
-            process.exit(1);
-        }
-        return await res.json();
-    }
-    catch (err) {
-        if (err instanceof TypeError &&
-            err.cause
-                ?.code === "ECONNREFUSED") {
-            console.error('Server not running. Run "agentgazer start" first.');
-            process.exit(1);
-        }
-        throw err;
-    }
-}
-// ---------------------------------------------------------------------------
-// New subcommands
+// Subcommands
 // ---------------------------------------------------------------------------
-function cmdVersion() {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const pkg = require(path.resolve(__dirname, "../package.json"));
+async function cmdVersion() {
+    const pkgPath = path.resolve(__dirname, "../package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
     console.log(`agentgazer ${pkg.version}`);
 }
 async function cmdDoctor(flags) {
-    const port = flags["port"] ? parseInt(flags["port"], 10) : 8080;
+    const port = flags["port"] ? parseInt(flags["port"], 10) : 18800;
     const proxyPort = flags["proxy-port"]
         ? parseInt(flags["proxy-port"], 10)
-        : 4000;
+        : 18900;
     if (isNaN(port) || port < 1 || port > 65535) {
         console.error("Error: --port must be a valid port number (1-65535)");
         process.exit(1);
@@ -546,7 +594,7 @@ async function cmdDoctor(flags) {
     let passed = 0;
     const total = 6;
     // 1. Config file exists
-    const config = (0, config_js_1.readConfig)();
+    const config = readConfig();
     if (config) {
         console.log("  ✓ Config file exists");
         passed++;
@@ -563,7 +611,7 @@ async function cmdDoctor(flags) {
         console.log("  ✗ Auth token not set");
     }
     // 3. Database file exists
-    if (fs.existsSync((0, config_js_1.getDbPath)())) {
+    if (fs.existsSync(getDbPath())) {
         console.log("  ✓ Database file exists");
         passed++;
     }
@@ -572,7 +620,7 @@ async function cmdDoctor(flags) {
     }
     // 4. Secret store accessible
     try {
-        const { store } = await (0, secret_store_js_1.detectSecretStore)((0, config_js_1.getConfigDir)());
+        const { store } = await detectSecretStore(getConfigDir());
         if (await store.isAvailable()) {
             console.log("  ✓ Secret store accessible");
             passed++;
@@ -614,161 +662,417 @@ async function cmdDoctor(flags) {
     }
     console.log(`\n  ${passed}/${total} checks passed.`);
 }
-async function cmdAgents(flags) {
-    const port = flags["port"] ? parseInt(flags["port"], 10) : 8080;
-    if (isNaN(port) || port < 1 || port > 65535) {
-        console.error("Error: --port must be a valid port number (1-65535)");
-        process.exit(1);
-    }
-    const resp = (await apiGet("/api/agents", port));
-    const agents = resp.agents;
-    if (!agents || agents.length === 0) {
-        console.log("No agents registered yet.");
+// ---------------------------------------------------------------------------
+// Uninstall
+// ---------------------------------------------------------------------------
+async function confirmPrompt(message) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await ask(rl, message);
+    rl.close();
+    return /^y(es)?$/i.test(answer);
+}
+async function stopDaemonIfRunning() {
+    const configDir = getConfigDir();
+    const pidFile = path.join(configDir, "agentgazer.pid");
+    if (!fs.existsSync(pidFile))
         return;
+    const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+    try {
+        process.kill(pid, 0); // Check if process exists
     }
-    const header = `  ${"Agent ID".padEnd(18)}${"Status".padEnd(11)}${"Events".padStart(8)}   Last Heartbeat`;
-    console.log(header);
-    console.log("  " + "─".repeat(header.trimStart().length));
-    for (const a of agents) {
-        const id = (a.agent_id ?? "").padEnd(18);
-        const status = (a.status ?? "unknown").padEnd(11);
-        const events = formatNumber(a.total_events ?? 0).padStart(8);
-        const heartbeat = timeAgo(a.last_heartbeat);
-        console.log(`  ${id}${status}${events}   ${heartbeat}`);
+    catch {
+        // Process doesn't exist, clean up stale PID file
+        fs.unlinkSync(pidFile);
+        return;
     }
-}
-async function cmdStats(flags) {
-    const port = flags["port"] ? parseInt(flags["port"], 10) : 8080;
-    const range = flags["range"] || "24h";
-    const positional = parsePositional(process.argv.slice(3));
-    let agentId = positional[0];
-    // Auto-select agent if not specified
-    if (!agentId) {
-        const resp = (await apiGet("/api/agents", port));
-        const agents = resp.agents;
-        if (!agents || agents.length === 0) {
-            console.log("No agents registered yet.");
-            return;
-        }
-        if (agents.length === 1) {
-            agentId = agents[0].agent_id;
+    console.log("  Stopping AgentGazer daemon...");
+    process.kill(pid, "SIGTERM");
+    // Wait for process to exit (poll for up to 3 seconds)
+    for (let i = 0; i < 30; i++) {
+        await new Promise((r) => setTimeout(r, 100));
+        try {
+            process.kill(pid, 0);
         }
-        else {
-            console.log("Multiple agents found. Please specify one:\n");
-            for (const a of agents) {
-                console.log(`  agentgazer stats ${a.agent_id}`);
-            }
-            console.log();
-            process.exit(1);
+        catch {
+            if (fs.existsSync(pidFile))
+                fs.unlinkSync(pidFile);
+            console.log("  ✓ Daemon stopped");
+            return;
         }
     }
-    let data;
+    // Force kill
     try {
-        data = (await apiGet(`/api/stats/${encodeURIComponent(agentId)}?range=${encodeURIComponent(range)}`, port));
+        process.kill(pid, "SIGKILL");
     }
-    catch (err) {
-        if (err && typeof err === "object" && "message" in err) {
-            console.error(`Error fetching stats for "${agentId}": ${err.message}`);
+    catch {
+        // Already dead
+    }
+    if (fs.existsSync(pidFile))
+        fs.unlinkSync(pidFile);
+    console.log("  ✓ Daemon stopped (forced)");
+}
+async function removeProviderKeys() {
+    const configDir = getConfigDir();
+    const { store } = await detectSecretStore(configDir);
+    const providers = await store.list(PROVIDER_SERVICE);
+    if (providers.length === 0) {
+        console.log("  No provider keys found.");
+        return;
+    }
+    console.log("  Removing provider keys...");
+    for (const provider of providers) {
+        try {
+            await store.delete(PROVIDER_SERVICE, provider);
+            console.log(`    ✓ ${provider}`);
         }
-        else {
-            console.error(`Error fetching stats for "${agentId}".`);
+        catch (err) {
+            console.log(`    ✗ ${provider}: ${err}`);
         }
-        process.exit(1);
     }
-    const errorPct = data.total_requests > 0
-        ? ((data.total_errors / data.total_requests) * 100).toFixed(2)
-        : "0.00";
+}
+function removeConfig() {
+    const configDir = getConfigDir();
+    const configPath = path.join(configDir, "config.json");
+    if (fs.existsSync(configPath)) {
+        fs.unlinkSync(configPath);
+        console.log(`  ✓ Removed config (${configPath})`);
+    }
+    else {
+        console.log("  Config file not found.");
+    }
+}
+function removeAgentData() {
+    const configDir = getConfigDir();
+    const dbPath = path.join(configDir, "data.db");
+    if (fs.existsSync(dbPath)) {
+        const stats = fs.statSync(dbPath);
+        const sizeMB = (stats.size / 1024 / 1024).toFixed(1);
+        fs.unlinkSync(dbPath);
+        console.log(`  ✓ Removed database (${sizeMB} MB)`);
+    }
+    else {
+        console.log("  Database file not found.");
+    }
+}
+function removeLogFiles() {
+    const configDir = getConfigDir();
+    const logFile = path.join(configDir, "agentgazer.log");
+    const pidFile = path.join(configDir, "agentgazer.pid");
+    let removed = 0;
+    if (fs.existsSync(logFile)) {
+        fs.unlinkSync(logFile);
+        removed++;
+    }
+    if (fs.existsSync(pidFile)) {
+        fs.unlinkSync(pidFile);
+        removed++;
+    }
+    if (removed > 0) {
+        console.log(`  ✓ Removed log files`);
+    }
+}
+function showBinaryRemovalCommands() {
     console.log(`
-  AgentGazer — Stats for "${agentId}" (last ${range})
-  ───────────────────────────────────────
+  To remove the agentgazer binary:
 
-  Requests:   ${formatNumber(data.total_requests)}
-  Errors:     ${formatNumber(data.total_errors)} (${errorPct}%)
-  Cost:       $${data.total_cost.toFixed(2)}
-  Tokens:     ${formatNumber(data.total_tokens)}
+    npm uninstall -g @agentgazer/cli
 
-  Latency:    p50 = ${data.p50_latency != null ? formatNumber(data.p50_latency) : "--"}ms   p99 = ${data.p99_latency != null ? formatNumber(data.p99_latency) : "--"}ms`);
-    if (data.cost_by_model && data.cost_by_model.length > 0) {
-        console.log("\n  Cost by model:");
-        for (const m of data.cost_by_model) {
-            const model = m.model.padEnd(16);
-            const cost = `$${m.cost.toFixed(2)}`;
-            console.log(`    ${model}${cost}  (${formatNumber(m.count)} calls)`);
-        }
-    }
-    console.log();
+  Or if installed via Homebrew:
+
+    brew uninstall agentgazer
+`);
 }
-// ---------------------------------------------------------------------------
-// Uninstall
-// ---------------------------------------------------------------------------
 async function cmdUninstall(flags) {
-    const home = process.env.AGENTGAZER_HOME || path.join(require("os").homedir(), ".agentgazer");
-    const libDir = path.join(home, "lib");
-    const nodeDir = path.join(home, "node");
-    const wrapperPath = path.join(process.env.AGENTGAZER_BIN || "/usr/local/bin", "agentgazer");
-    // Detect install method
-    if (!fs.existsSync(libDir)) {
-        console.log('AgentGazer was not installed via the install script.');
-        console.log('');
-        console.log('  If installed via npm:');
-        console.log('    npm uninstall -g agentgazer');
-        console.log('');
-        console.log('  If installed via Homebrew:');
-        console.log('    brew uninstall agentgazer');
-        console.log('');
+    const configDir = getConfigDir();
+    const skipPrompt = "yes" in flags;
+    // Handle flags for scripting
+    if ("all" in flags) {
+        if (!skipPrompt) {
+            const confirmed = await confirmPrompt("\n  This will remove ALL AgentGazer data. Continue? [y/N] ");
+            if (!confirmed) {
+                console.log("  Cancelled.");
+                return;
+            }
+        }
+        await stopDaemonIfRunning();
+        await removeProviderKeys();
+        removeConfig();
+        removeAgentData();
+        removeLogFiles();
+        showBinaryRemovalCommands();
         return;
     }
-    const skipPrompt = "yes" in flags;
+    if ("config" in flags) {
+        if (!skipPrompt) {
+            const confirmed = await confirmPrompt("\n  Remove config file? [y/N] ");
+            if (!confirmed) {
+                console.log("  Cancelled.");
+                return;
+            }
+        }
+        await stopDaemonIfRunning();
+        removeConfig();
+        return;
+    }
+    if ("keys" in flags) {
+        if (!skipPrompt) {
+            const { store } = await detectSecretStore(configDir);
+            const providers = await store.list(PROVIDER_SERVICE);
+            if (providers.length === 0) {
+                console.log("  No provider keys to remove.");
+                return;
+            }
+            console.log(`\n  Provider keys to remove: ${providers.join(", ")}`);
+            const confirmed = await confirmPrompt("  Continue? [y/N] ");
+            if (!confirmed) {
+                console.log("  Cancelled.");
+                return;
+            }
+        }
+        await removeProviderKeys();
+        return;
+    }
+    if ("data" in flags) {
+        if (!skipPrompt) {
+            const dbPath = path.join(configDir, "data.db");
+            if (!fs.existsSync(dbPath)) {
+                console.log("  No database to remove.");
+                return;
+            }
+            const confirmed = await confirmPrompt("\n  Remove agent data (database)? [y/N] ");
+            if (!confirmed) {
+                console.log("  Cancelled.");
+                return;
+            }
+        }
+        await stopDaemonIfRunning();
+        removeAgentData();
+        return;
+    }
+    // Interactive menu
     console.log(`
   AgentGazer — Uninstall
   ───────────────────────────────────────
+
+  What would you like to remove?
+
+    1. Complete uninstall (everything)
+    2. Binary only (show npm/brew command)
+    3. Config only (~/.agentgazer/config.json)
+    4. Provider keys only (from secret store)
+    5. Agent data only (~/.agentgazer/data.db)
+
 `);
-    // Remove embedded Node.js
-    if (fs.existsSync(nodeDir)) {
-        fs.rmSync(nodeDir, { recursive: true, force: true });
-        console.log(`  ✓ Removed embedded Node.js (${nodeDir})`);
-    }
-    // Remove lib
-    fs.rmSync(libDir, { recursive: true, force: true });
-    console.log(`  ✓ Removed installation (${libDir})`);
-    // Remove wrapper
-    if (fs.existsSync(wrapperPath)) {
-        try {
-            fs.unlinkSync(wrapperPath);
-            console.log(`  ✓ Removed wrapper (${wrapperPath})`);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const choice = await ask(rl, "  Select [1-5]: ");
+    rl.close();
+    console.log("");
+    switch (choice) {
+        case "1": {
+            // Complete uninstall
+            const confirmed = await confirmPrompt("  This will remove ALL AgentGazer data. Continue? [y/N] ");
+            if (!confirmed) {
+                console.log("  Cancelled.");
+                return;
+            }
+            await stopDaemonIfRunning();
+            await removeProviderKeys();
+            removeConfig();
+            removeAgentData();
+            removeLogFiles();
+            showBinaryRemovalCommands();
+            break;
         }
-        catch {
-            console.log(`  ! Could not remove ${wrapperPath} — try: sudo rm ${wrapperPath}`);
+        case "2":
+            // Binary only
+            showBinaryRemovalCommands();
+            break;
+        case "3": {
+            // Config only
+            const confirmed = await confirmPrompt("  Remove config file? [y/N] ");
+            if (!confirmed) {
+                console.log("  Cancelled.");
+                return;
+            }
+            await stopDaemonIfRunning();
+            removeConfig();
+            break;
         }
-    }
-    // Handle user data
-    const configPath = path.join(home, "config.json");
-    const dbPath = path.join(home, "data.db");
-    const hasData = fs.existsSync(configPath) || fs.existsSync(dbPath);
-    if (hasData) {
-        let removeData = skipPrompt;
-        if (!skipPrompt) {
-            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-            const answer = await ask(rl, "\n  Remove user data (config.json, data.db)? [y/N] ");
-            rl.close();
-            removeData = /^y(es)?$/i.test(answer);
+        case "4": {
+            // Provider keys only
+            const { store } = await detectSecretStore(configDir);
+            const providers = await store.list(PROVIDER_SERVICE);
+            if (providers.length === 0) {
+                console.log("  No provider keys to remove.");
+                return;
+            }
+            console.log(`  Provider keys to remove: ${providers.join(", ")}`);
+            const confirmed = await confirmPrompt("  Continue? [y/N] ");
+            if (!confirmed) {
+                console.log("  Cancelled.");
+                return;
+            }
+            await removeProviderKeys();
+            break;
         }
-        if (removeData) {
-            fs.rmSync(home, { recursive: true, force: true });
-            console.log(`  ✓ Removed all data (${home})`);
+        case "5": {
+            // Agent data only
+            const dbPath = path.join(configDir, "data.db");
+            if (!fs.existsSync(dbPath)) {
+                console.log("  No database to remove.");
+                return;
+            }
+            const confirmed = await confirmPrompt("  Remove agent data (database)? [y/N] ");
+            if (!confirmed) {
+                console.log("  Cancelled.");
+                return;
+            }
+            await stopDaemonIfRunning();
+            removeAgentData();
+            break;
         }
-        else {
-            console.log(`  → User data preserved at ${home}`);
+        default:
+            console.log("  Invalid option.");
+    }
+}
+// ---------------------------------------------------------------------------
+// Stop command
+// ---------------------------------------------------------------------------
+function cmdStop() {
+    const configDir = getConfigDir();
+    const pidFile = path.join(configDir, "agentgazer.pid");
+    const config = readConfig();
+    const port = config?.server?.port ?? 18800;
+    const proxyPort = config?.server?.proxyPort ?? 18900;
+    if (!fs.existsSync(pidFile)) {
+        // No PID file, but check if processes are running on ports
+        const pidsOnPorts = findPidsOnPorts([port, proxyPort]);
+        if (pidsOnPorts.length > 0) {
+            console.log("AgentGazer PID file not found, but processes detected on ports.");
+            console.log(`Killing processes: ${pidsOnPorts.join(", ")}...`);
+            for (const pid of pidsOnPorts) {
+                try {
+                    process.kill(pid, "SIGTERM");
+                }
+                catch {
+                    // Ignore errors
+                }
+            }
+            // Wait a bit and force kill if needed
+            setTimeout(() => {
+                for (const pid of pidsOnPorts) {
+                    try {
+                        process.kill(pid, 0);
+                        process.kill(pid, "SIGKILL");
+                    }
+                    catch {
+                        // Already dead
+                    }
+                }
+                console.log("AgentGazer stopped.");
+            }, 1000);
+            return;
         }
+        console.log("AgentGazer is not running.");
+        return;
+    }
+    const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+    try {
+        process.kill(pid, 0); // Check if process exists
+    }
+    catch {
+        // Process doesn't exist
+        fs.unlinkSync(pidFile);
+        console.log("AgentGazer is not running (stale PID file removed).");
+        return;
+    }
+    // Send SIGTERM
+    try {
+        process.kill(pid, "SIGTERM");
+        console.log(`Stopping AgentGazer (PID: ${pid})...`);
+        // Wait for process to exit (poll for up to 5 seconds)
+        let attempts = 0;
+        const maxAttempts = 50;
+        const checkInterval = 100;
+        const waitForExit = () => {
+            try {
+                process.kill(pid, 0);
+                attempts++;
+                if (attempts < maxAttempts) {
+                    setTimeout(waitForExit, checkInterval);
+                }
+                else {
+                    console.log("Process did not exit gracefully, sending SIGKILL...");
+                    try {
+                        process.kill(pid, "SIGKILL");
+                    }
+                    catch {
+                        // Already dead
+                    }
+                    if (fs.existsSync(pidFile))
+                        fs.unlinkSync(pidFile);
+                    console.log("AgentGazer stopped.");
+                }
+            }
+            catch {
+                // Process exited
+                if (fs.existsSync(pidFile))
+                    fs.unlinkSync(pidFile);
+                console.log("AgentGazer stopped.");
+            }
+        };
+        waitForExit();
+    }
+    catch (err) {
+        console.error(`Failed to stop AgentGazer: ${err}`);
+        process.exit(1);
+    }
+}
+// ---------------------------------------------------------------------------
+// Logs command
+// ---------------------------------------------------------------------------
+async function cmdLogs(flags) {
+    const configDir = getConfigDir();
+    const logFile = path.join(configDir, "agentgazer.log");
+    if (!fs.existsSync(logFile)) {
+        console.log("No log file found. Start AgentGazer with -d flag first.");
+        console.log(`  agentgazer start -d`);
+        return;
+    }
+    const follow = "f" in flags || "follow" in flags;
+    const lines = flags["n"] ? parseInt(flags["n"], 10) : (flags["lines"] ? parseInt(flags["lines"], 10) : 50);
+    if (follow) {
+        // Follow mode: tail -f equivalent
+        const { spawn } = await import("node:child_process");
+        const tail = spawn("tail", ["-f", "-n", String(lines), logFile], {
+            stdio: "inherit",
+        });
+        // Handle Ctrl+C gracefully
+        process.on("SIGINT", () => {
+            tail.kill();
+            process.exit(0);
+        });
+        await new Promise((resolve) => {
+            tail.on("close", () => resolve());
+        });
+    }
+    else {
+        // Just show last N lines
+        const content = fs.readFileSync(logFile, "utf-8");
+        const allLines = content.split("\n");
+        const lastLines = allLines.slice(-lines).join("\n");
+        console.log(lastLines);
     }
-    console.log("\n  ✓ AgentGazer uninstalled.\n");
 }
 // ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
 async function main() {
     const subcommand = process.argv[2];
-    const flags = parseFlags(process.argv.slice(3));
+    const allArgs = process.argv.slice(3);
+    const flags = parseFlags(allArgs);
+    const positional = parsePositional(allArgs);
+    const port = flags["port"] ? parseInt(flags["port"], 10) : 18800;
     switch (subcommand) {
         case "onboard":
             await cmdOnboard();
@@ -776,27 +1080,46 @@ async function main() {
         case "start":
             await cmdStart(flags);
             break;
+        case "stop":
+            cmdStop();
+            break;
+        case "logs":
+            await cmdLogs(flags);
+            break;
         case "status":
             cmdStatus();
             break;
         case "reset-token":
             cmdResetToken();
             break;
+        case "overview": {
+            const { cmdOverview } = await import("./commands/overview.js");
+            await cmdOverview(port);
+            break;
+        }
+        case "agents":
+            await cmdAgents(port);
+            break;
+        case "agent":
+            await cmdAgent(positional[0], positional[1], positional.slice(2), flags);
+            break;
         case "providers":
-            await cmdProviders(process.argv.slice(3));
+            await cmdProviders(port);
+            break;
+        case "provider":
+            await cmdProvider(positional[0], positional.slice(1), flags);
+            break;
+        case "events":
+            await cmdEvents(flags);
             break;
         case "version":
-            cmdVersion();
+        case "--version":
+        case "-V":
+            await cmdVersion();
             break;
         case "doctor":
             await cmdDoctor(flags);
             break;
-        case "agents":
-            await cmdAgents(flags);
-            break;
-        case "stats":
-            await cmdStats(flags);
-            break;
         case "uninstall":
             await cmdUninstall(flags);
             break;