@agentgazer/cli 0.2.0

package/dist/cli.js

@@ -0,0 +1,819 @@
+#!/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");
+// ---------------------------------------------------------------------------
+// Arg parsing
+// ---------------------------------------------------------------------------
+function parseFlags(argv) {
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith("--")) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                flags[key] = "";
+            }
+        }
+    }
+    return flags;
+}
+function parsePositional(argv) {
+    const positional = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith("--")) {
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith("--")) {
+                i++; // skip flag value
+            }
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    return positional;
+}
+// ---------------------------------------------------------------------------
+// Help
+// ---------------------------------------------------------------------------
+function printUsage() {
+    console.log(`
+AgentGazer — AI Agent Observability
+
+Usage: agentgazer <command> [options]
+
+Commands:
+  onboard                     First-time setup — generate token and configure providers
+  start                       Start the server, proxy, and dashboard
+  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
+  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)
+  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
+
+Options (for doctor, stats, agents):
+  --port <number>            Server port to check (default: 8080)
+  --proxy-port <number>      Proxy port to check (default: 4000)
+
+Options (for stats):
+  --range <period>           Time range (default: 24h)
+
+Options (for uninstall):
+  --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
+`);
+}
+// ---------------------------------------------------------------------------
+// Subcommands
+// ---------------------------------------------------------------------------
+const KNOWN_PROVIDERS = shared_1.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)();
+    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
+
+  ───────────────────────────────────────
+`);
+    // Initialize secret store
+    const { store, backendName } = await (0, secret_store_js_1.detectSecretStore)((0, config_js_1.getConfigDir)());
+    console.log(`  Secret backend: ${backendName}\n`);
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    let providerCount = 0;
+    try {
+        console.log("  Configure provider API keys (the proxy will inject these for you).");
+        console.log(`  Available providers: ${KNOWN_PROVIDERS.join(", ")}\n`);
+        for (const provider of KNOWN_PROVIDERS) {
+            const key = await ask(rl, `  API key for ${provider} (press Enter to skip): `);
+            if (!key)
+                continue;
+            // Store API key in secret store
+            await store.set(secret_store_js_1.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);
+            providerCount++;
+            console.log(`  ✓ ${provider} configured.\n`);
+        }
+    }
+    finally {
+        rl.close();
+    }
+    console.log(`
+  ───────────────────────────────────────
+  Setup complete. ${providerCount} provider(s) configured.
+  ───────────────────────────────────────
+
+  Add this to your project to start tracking:
+
+  ┌──────────────────────────────────────────────────────────┐
+  │                                                          │
+  │  import { AgentGazer } from "@agentgazer/sdk";           │
+  │                                                          │
+  │  const at = AgentGazer.init({                            │
+  │    apiKey: "${saved.token.slice(0, 20)}...",│
+  │    agentId: "my-agent",                                  │
+  │  });                                                     │
+  │                                                          │
+  │  at.track({                                              │
+  │    provider: "openai",                                   │
+  │    model: "gpt-4o",                                      │
+  │    tokens: { input: 150, output: 50 },                   │
+  │    latency_ms: 1200,                                     │
+  │    status: 200,                                          │
+  │  });                                                     │
+  │                                                          │
+  └──────────────────────────────────────────────────────────┘
+
+  Or point your LLM client at the proxy (with auto API key injection):
+
+    export OPENAI_BASE_URL=http://localhost:4000/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)();
+    if (!config) {
+        console.log("No configuration found. Run \"agentgazer onboard\" first.");
+        process.exit(1);
+    }
+    console.log(`
+  AgentGazer — Status
+  ───────────────────────────────────────
+
+  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)
+`);
+}
+function cmdResetToken() {
+    const config = (0, config_js_1.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 proxyPort = flags["proxy-port"]
+        ? parseInt(flags["proxy-port"], 10)
+        : 4000;
+    if (isNaN(serverPort) || serverPort < 1 || serverPort > 65535) {
+        console.error("Error: --port must be a valid port number (1-65535)");
+        process.exit(1);
+    }
+    if (isNaN(proxyPort) || proxyPort < 1 || proxyPort > 65535) {
+        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 (proxyPort < 1024) {
+        console.warn("Warning: proxy port %d may require elevated privileges on Unix systems.", proxyPort);
+    }
+    const retentionDays = flags["retention-days"]
+        ? parseInt(flags["retention-days"], 10)
+        : 30;
+    if (isNaN(retentionDays) || retentionDays < 1) {
+        console.error("Error: --retention-days must be a positive integer");
+        process.exit(1);
+    }
+    // Resolve dashboard directory
+    let dashboardDir;
+    const possibleDashboardPaths = [
+        path.resolve(__dirname, "dashboard"),
+        path.resolve(__dirname, "../../dashboard-local/dist"),
+        path.resolve(__dirname, "../../../apps/dashboard-local/dist"),
+    ];
+    for (const p of possibleDashboardPaths) {
+        try {
+            const fs = await import("node:fs");
+            if (fs.existsSync(path.join(p, "index.html"))) {
+                dashboardDir = p;
+                break;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    // Start the local server
+    const { db, shutdown: shutdownServer } = await (0, server_1.startServer)({
+        port: serverPort,
+        token: config.token,
+        dbPath: (0, config_js_1.getDbPath)(),
+        dashboardDir,
+        retentionDays,
+    });
+    // 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);
+    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);
+    // Start the LLM proxy (with db for policy enforcement and rate limits)
+    const { shutdown: shutdownProxy } = (0, proxy_1.startProxy)({
+        apiKey: config.token,
+        agentId: "proxy",
+        port: proxyPort,
+        endpoint: `http://localhost:${serverPort}/api/events`,
+        providerKeys,
+        db, // Rate limits are loaded from db
+    });
+    console.log(`
+  ╔════════════════════════════════════════════════════╗
+  ║              AgentGazer running                    ║
+  ╠════════════════════════════════════════════════════╣
+  ║                                                    ║
+  ║  Dashboard:  http://localhost:${String(serverPort).padEnd(5)}                ║
+  ║  Proxy:      http://localhost:${String(proxyPort).padEnd(5)}                ║
+  ║                                                    ║
+  ║  Token:      ${config.token.padEnd(32)}    ║
+  ║                                                    ║
+  ╚════════════════════════════════════════════════════╝
+
+  Proxy routes:  http://localhost:${proxyPort}/{provider}/...
+  Providers:     ${shared_1.KNOWN_PROVIDER_NAMES.join(", ")}
+`);
+    // Auto-open browser unless --no-open
+    if (!("no-open" in flags)) {
+        try {
+            const open = await import("open");
+            await open.default(`http://localhost:${serverPort}`);
+        }
+        catch {
+            // Silently fail if browser can't be opened
+        }
+    }
+    // Graceful shutdown
+    let shuttingDown = false;
+    function handleShutdown() {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        console.log("\nShutting down...");
+        Promise.all([shutdownProxy(), shutdownServer()])
+            .then(() => {
+            console.log("Shutdown complete.");
+            process.exit(0);
+        })
+            .catch((err) => {
+            console.error("Error during shutdown:", err);
+            process.exit(1);
+        });
+    }
+    process.on("SIGINT", handleShutdown);
+    process.on("SIGTERM", handleShutdown);
+    // Clean up listeners once shutdown completes to prevent leaks on restart
+    process.once("exit", () => {
+        process.removeListener("SIGINT", handleShutdown);
+        process.removeListener("SIGTERM", handleShutdown);
+    });
+}
+// ---------------------------------------------------------------------------
+// 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
+// ---------------------------------------------------------------------------
+function cmdVersion() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const pkg = require(path.resolve(__dirname, "../package.json"));
+    console.log(`agentgazer ${pkg.version}`);
+}
+async function cmdDoctor(flags) {
+    const port = flags["port"] ? parseInt(flags["port"], 10) : 8080;
+    const proxyPort = flags["proxy-port"]
+        ? parseInt(flags["proxy-port"], 10)
+        : 4000;
+    if (isNaN(port) || port < 1 || port > 65535) {
+        console.error("Error: --port must be a valid port number (1-65535)");
+        process.exit(1);
+    }
+    if (isNaN(proxyPort) || proxyPort < 1 || proxyPort > 65535) {
+        console.error("Error: --proxy-port must be a valid port number (1-65535)");
+        process.exit(1);
+    }
+    console.log(`
+  AgentGazer — Doctor
+  ───────────────────────────────────────
+`);
+    let passed = 0;
+    const total = 6;
+    // 1. Config file exists
+    const config = (0, config_js_1.readConfig)();
+    if (config) {
+        console.log("  ✓ Config file exists");
+        passed++;
+    }
+    else {
+        console.log("  ✗ Config file missing");
+    }
+    // 2. Auth token set
+    if (config?.token) {
+        console.log("  ✓ Auth token set");
+        passed++;
+    }
+    else {
+        console.log("  ✗ Auth token not set");
+    }
+    // 3. Database file exists
+    if (fs.existsSync((0, config_js_1.getDbPath)())) {
+        console.log("  ✓ Database file exists");
+        passed++;
+    }
+    else {
+        console.log("  ✗ Database file missing");
+    }
+    // 4. Secret store accessible
+    try {
+        const { store } = await (0, secret_store_js_1.detectSecretStore)((0, config_js_1.getConfigDir)());
+        if (await store.isAvailable()) {
+            console.log("  ✓ Secret store accessible");
+            passed++;
+        }
+        else {
+            console.log("  ✗ Secret store not accessible");
+        }
+    }
+    catch {
+        console.log("  ✗ Secret store not accessible");
+    }
+    // 5. Server responding
+    try {
+        const res = await fetch(`http://localhost:${port}/api/health`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (res.ok) {
+            console.log(`  ✓ Server responding (http://localhost:${port})`);
+            passed++;
+        }
+        else {
+            console.log(`  ✗ Server not responding (http://localhost:${port})`);
+        }
+    }
+    catch {
+        console.log(`  ✗ Server not responding (http://localhost:${port})`);
+    }
+    // 6. Proxy responding
+    try {
+        await fetch(`http://localhost:${proxyPort}/`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        // Any response (even 4xx) means it's up
+        console.log(`  ✓ Proxy responding (http://localhost:${proxyPort})`);
+        passed++;
+    }
+    catch {
+        console.log(`  ✗ Proxy not responding (http://localhost:${proxyPort})`);
+    }
+    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.");
+        return;
+    }
+    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}`);
+    }
+}
+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;
+        }
+        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);
+        }
+    }
+    let data;
+    try {
+        data = (await apiGet(`/api/stats/${encodeURIComponent(agentId)}?range=${encodeURIComponent(range)}`, port));
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "message" in err) {
+            console.error(`Error fetching stats for "${agentId}": ${err.message}`);
+        }
+        else {
+            console.error(`Error fetching stats for "${agentId}".`);
+        }
+        process.exit(1);
+    }
+    const errorPct = data.total_requests > 0
+        ? ((data.total_errors / data.total_requests) * 100).toFixed(2)
+        : "0.00";
+    console.log(`
+  AgentGazer — Stats for "${agentId}" (last ${range})
+  ───────────────────────────────────────
+
+  Requests:   ${formatNumber(data.total_requests)}
+  Errors:     ${formatNumber(data.total_errors)} (${errorPct}%)
+  Cost:       $${data.total_cost.toFixed(2)}
+  Tokens:     ${formatNumber(data.total_tokens)}
+
+  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();
+}
+// ---------------------------------------------------------------------------
+// Uninstall
+// ---------------------------------------------------------------------------
+async function cmdUninstall(flags) {
+    const home = process.env.AGENTTRACE_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.AGENTTRACE_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('');
+        return;
+    }
+    const skipPrompt = "yes" in flags;
+    console.log(`
+  AgentGazer — Uninstall
+  ───────────────────────────────────────
+`);
+    // 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})`);
+        }
+        catch {
+            console.log(`  ! Could not remove ${wrapperPath} — try: sudo rm ${wrapperPath}`);
+        }
+    }
+    // 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);
+        }
+        if (removeData) {
+            fs.rmSync(home, { recursive: true, force: true });
+            console.log(`  ✓ Removed all data (${home})`);
+        }
+        else {
+            console.log(`  → User data preserved at ${home}`);
+        }
+    }
+    console.log("\n  ✓ AgentGazer uninstalled.\n");
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+    const subcommand = process.argv[2];
+    const flags = parseFlags(process.argv.slice(3));
+    switch (subcommand) {
+        case "onboard":
+            await cmdOnboard();
+            break;
+        case "start":
+            await cmdStart(flags);
+            break;
+        case "status":
+            cmdStatus();
+            break;
+        case "reset-token":
+            cmdResetToken();
+            break;
+        case "providers":
+            await cmdProviders(process.argv.slice(3));
+            break;
+        case "version":
+            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;
+        case "--help":
+        case "-h":
+        case "help":
+        case undefined:
+            printUsage();
+            break;
+        default:
+            console.error(`Unknown command: ${subcommand}`);
+            printUsage();
+            process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map