@kill-switch/cli 0.1.1 → 0.3.0

package/dist/commands/watch.js

@@ -0,0 +1,68 @@
+import { outputJson, handleError, spinner, success, warn, fail, colors as c } from "../output.js";
+export function registerWatchCommand(program, createClient) {
+    program
+        .command("watch")
+        .description("Continuously monitor all accounts (polls on interval)")
+        .option("--interval <seconds>", "Check interval in seconds", "60")
+        .action(async (opts) => {
+        const json = program.opts().json;
+        const intervalSec = Math.max(10, parseInt(opts.interval) || 60);
+        const client = createClient();
+        if (!json) {
+            console.log(c.bold(`\nKill Switch Watch Mode`) + c.dim(` (every ${intervalSec}s, Ctrl+C to stop)\n`));
+        }
+        const runCheck = async () => {
+            const s = json ? null : spinner("Checking...").start();
+            try {
+                const data = await client.monitoring.checkAll();
+                s?.stop();
+                const results = data.results || [];
+                const now = new Date().toLocaleTimeString();
+                if (json) {
+                    outputJson({ checkedAt: now, ...data });
+                    return;
+                }
+                const totalViolations = results.reduce((sum, r) => sum + (r.violations?.length || 0), 0);
+                if (totalViolations === 0) {
+                    success(`${c.dim(now)} All ${results.length} account(s) clear`);
+                }
+                else {
+                    warn(`${c.dim(now)} ${c.bold(String(totalViolations))} violation(s) across ${results.length} account(s)`);
+                    for (const r of results) {
+                        if (r.violations?.length) {
+                            console.log(`  ${c.bold((r.provider || "?") + ":")} ${r.name || r.cloudAccountId}`);
+                            for (const v of r.violations) {
+                                console.log(`    ${c.red("!")} ${v.metricName}: ${v.currentValue} ${v.unit} (threshold: ${v.threshold})`);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                s?.stop();
+                if (json) {
+                    handleError(err, json);
+                }
+                else {
+                    const now = new Date().toLocaleTimeString();
+                    fail(`${c.dim(now)} Check failed: ${err.message}`);
+                }
+            }
+        };
+        // Run immediately
+        await runCheck();
+        // Then loop
+        const timer = setInterval(runCheck, intervalSec * 1000);
+        // Graceful shutdown
+        const cleanup = () => {
+            clearInterval(timer);
+            if (!json)
+                console.log(c.dim("\nWatch stopped."));
+            process.exit(0);
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        // Keep alive
+        await new Promise(() => { });
+    });
+}

package/dist/device-flow.d.ts

@@ -0,0 +1,33 @@
+/**
+ * CLI device-flow login helper.
+ *
+ * Runs the start → openBrowser → poll → return-key sequence against the
+ * Kill Switch API. Side effects (fetch, browser opening, spinner output,
+ * sleep, hostname) are injected via `deps` so the loop logic can be unit
+ * tested without touching the network, terminal, or system clock.
+ */
+export interface DeviceFlowStart {
+    code: string;
+    verification_url: string;
+    expires_in: number;
+    polling_interval: number;
+}
+export interface DeviceFlowDeps {
+    fetch: typeof fetch;
+    sleep: (ms: number) => Promise<void>;
+    openBrowser: (url: string) => void;
+    hostname: () => string;
+    /** Called with status lines for the user — wired to console.log in prod, no-op in tests. */
+    log: (line: string) => void;
+    /** Spinner start/stop wrappers — wire to ora in prod, no-op in tests. */
+    spinnerStart: (label: string) => void;
+    spinnerStop: () => void;
+    /** Source of "now" in ms — overridable in tests for deadline math. */
+    now: () => number;
+}
+export declare function defaultDeviceFlowDeps(extras?: Partial<DeviceFlowDeps>): DeviceFlowDeps;
+/**
+ * Run the device-flow login. Returns the freshly-minted API key on success;
+ * throws on user denial, expiry, /start failure, or 10-minute timeout.
+ */
+export declare function runDeviceFlow(apiUrl: string, cliVersion: string, json: boolean, deps?: DeviceFlowDeps): Promise<string>;

package/dist/device-flow.js

@@ -0,0 +1,91 @@
+/**
+ * CLI device-flow login helper.
+ *
+ * Runs the start → openBrowser → poll → return-key sequence against the
+ * Kill Switch API. Side effects (fetch, browser opening, spinner output,
+ * sleep, hostname) are injected via `deps` so the loop logic can be unit
+ * tested without touching the network, terminal, or system clock.
+ */
+import { execFile } from "node:child_process";
+import { hostname as osHostname } from "node:os";
+const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const defaultOpenBrowser = (url) => {
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    execFile(cmd, [url], () => { });
+};
+export function defaultDeviceFlowDeps(extras) {
+    return {
+        fetch,
+        sleep: defaultSleep,
+        openBrowser: defaultOpenBrowser,
+        hostname: osHostname,
+        log: (line) => console.log(line),
+        spinnerStart: () => { },
+        spinnerStop: () => { },
+        now: () => Date.now(),
+        ...extras,
+    };
+}
+/**
+ * Run the device-flow login. Returns the freshly-minted API key on success;
+ * throws on user denial, expiry, /start failure, or 10-minute timeout.
+ */
+export async function runDeviceFlow(apiUrl, cliVersion, json, deps = defaultDeviceFlowDeps()) {
+    // 1. Start session — anonymous, server mints the short-lived code.
+    const startResp = await deps.fetch(`${apiUrl}/auth/cli/start`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ hostname: deps.hostname(), cliVersion }),
+    });
+    if (!startResp.ok) {
+        const text = await startResp.text().catch(() => "");
+        throw new Error(`Failed to start CLI auth (${startResp.status}): ${text.slice(0, 200)}`);
+    }
+    const start = (await startResp.json());
+    if (!json) {
+        deps.log("\n⚡ Kill Switch CLI Login\n");
+        deps.log("Open this URL in your browser to authorize:");
+        deps.log(`  ${start.verification_url}\n`);
+        deps.log("Confirm this code matches what you see on the page:");
+        deps.log(`  ${start.code}\n`);
+    }
+    deps.openBrowser(start.verification_url);
+    // 2. Poll until approved / denied / expired / timeout.
+    // `expires_in` is server-controlled (currently 600s / 10 min).
+    // `polling_interval` is also server-controlled — we floor it at 1s
+    // so a server bug can't crash us into a busy loop.
+    const deadline = deps.now() + start.expires_in * 1000;
+    const intervalMs = Math.max(1, start.polling_interval) * 1000;
+    if (!json)
+        deps.spinnerStart("Waiting for browser authorization...");
+    try {
+        while (deps.now() < deadline) {
+            await deps.sleep(intervalMs);
+            const pollResp = await deps.fetch(`${apiUrl}/auth/cli/poll`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ code: start.code }),
+            });
+            const body = (await pollResp.json().catch(() => ({})));
+            if (pollResp.status === 200 && body.api_key) {
+                deps.spinnerStop();
+                return body.api_key;
+            }
+            if (pollResp.status === 410) {
+                deps.spinnerStop();
+                throw new Error(`CLI login ${body.status || "ended"} — please run \`ks auth login\` again.`);
+            }
+            if (pollResp.status === 404) {
+                deps.spinnerStop();
+                throw new Error("CLI login code expired before any response was recorded.");
+            }
+            // 202 pending → loop. Any other code → also loop and let the deadline catch us.
+        }
+        deps.spinnerStop();
+        throw new Error("CLI login timed out after 10 minutes. Run `ks auth login` to try again.");
+    }
+    catch (e) {
+        deps.spinnerStop();
+        throw e;
+    }
+}

package/dist/index.js

@@ -11,6 +11,8 @@
  *   kill-switch accounts list --json
  */
 import { Command } from "commander";
+import { KillSwitchClient } from "@kill-switch/sdk";
+import { resolveApiKey, resolveApiUrl } from "./config.js";
 import { registerAuthCommands } from "./commands/auth.js";
 import { registerAccountCommands } from "./commands/accounts.js";
 import { registerRuleCommands } from "./commands/rules.js";
@@ -21,22 +23,47 @@ import { registerKillCommands } from "./commands/kill.js";
 import { registerAnalyticsCommands } from "./commands/analytics.js";
 import { registerConfigCommands } from "./commands/config-cmd.js";
 import { registerOnboardCommands } from "./commands/onboard.js";
+import { registerOrgCommands } from "./commands/orgs.js";
+import { registerActivityCommands } from "./commands/activity.js";
+import { registerStatusCommand } from "./commands/status.js";
+import { registerWatchCommand } from "./commands/watch.js";
+import { registerProviderCommands } from "./commands/providers.js";
+import { registerAgentGuardCommands } from "./commands/agent-guard.js";
+import { CLI_VERSION } from "./version.js";
 const program = new Command();
 program
     .name("kill-switch")
     .description("Monitor cloud spending, kill runaway services, protect your infrastructure")
-    .version("0.1.0")
+    .version(CLI_VERSION)
     .option("--json", "Output as JSON (for automation/scripting)")
     .option("--api-key <key>", "API key (overrides config and env)")
-    .option("--api-url <url>", "API URL (overrides config and env)");
-registerAuthCommands(program);
-registerAccountCommands(program);
-registerRuleCommands(program);
-registerShieldCommands(program);
-registerCheckCommands(program);
-registerAlertCommands(program);
-registerKillCommands(program);
-registerAnalyticsCommands(program);
+    .option("--api-url <url>", "API URL (overrides config and env)")
+    .option("-y, --yes", "Skip confirmation prompts");
+/**
+ * Create an SDK client with the resolved apiKey/apiUrl.
+ * Called lazily when a command runs (after options are parsed).
+ */
+const createClient = () => {
+    const opts = program.opts();
+    return new KillSwitchClient({
+        apiKey: resolveApiKey(opts.apiKey),
+        baseUrl: resolveApiUrl(opts.apiUrl),
+    });
+};
+registerAuthCommands(program, createClient);
+registerAccountCommands(program, createClient);
+registerRuleCommands(program, createClient);
+registerShieldCommands(program, createClient);
+registerCheckCommands(program, createClient);
+registerAlertCommands(program, createClient);
+registerKillCommands(program, createClient);
+registerAnalyticsCommands(program, createClient);
 registerConfigCommands(program);
-registerOnboardCommands(program);
+registerOnboardCommands(program, createClient);
+registerOrgCommands(program, createClient);
+registerActivityCommands(program, createClient);
+registerStatusCommand(program, createClient);
+registerWatchCommand(program, createClient);
+registerProviderCommands(program, createClient);
+registerAgentGuardCommands(program);
 program.parse();

package/dist/output.d.ts

@@ -1,6 +1,19 @@
 /**
  * Output formatting — tables for humans, JSON for machines
+ *
+ * Colors via chalk, spinners via ora.
+ * Respects NO_COLOR env var and --json flag.
  */
+import { type Ora } from "ora";
+declare const c: {
+    bold: ((s: string) => string) | import("chalk").ChalkInstance;
+    dim: import("chalk").ChalkInstance | ((s: string) => string);
+    green: import("chalk").ChalkInstance | ((s: string) => string);
+    red: import("chalk").ChalkInstance | ((s: string) => string);
+    yellow: import("chalk").ChalkInstance | ((s: string) => string);
+    cyan: import("chalk").ChalkInstance | ((s: string) => string);
+};
+export { c as colors };
 export interface Column {
     key: string;
     header: string;
@@ -11,8 +24,17 @@ export declare function formatObject(obj: any, fields?: string[]): void;
 export declare function outputJson(data: any): void;
 export declare function outputError(message: string, json: boolean): void;
 /**
- * Wrap a command handler with JSON/error handling.
+ * Map SDK errors to contextual CLI messages.
  */
-export declare function withOutput(fn: (opts: any) => Promise<any>, opts: {
-    json: boolean;
-}): Promise<any>;
+export declare function formatSdkError(err: unknown): {
+    message: string;
+    exitCode: number;
+};
+/**
+ * Wrap a command handler with error handling, spinner, and JSON support.
+ */
+export declare function handleError(err: unknown, json: boolean): never;
+export declare function spinner(text: string): Ora;
+export declare function success(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function fail(msg: string): void;

package/dist/output.js

@@ -1,9 +1,26 @@
 /**
  * Output formatting — tables for humans, JSON for machines
+ *
+ * Colors via chalk, spinners via ora.
+ * Respects NO_COLOR env var and --json flag.
  */
+import chalk from "chalk";
+import ora from "ora";
+import { ApiError, AuthenticationError, ForbiddenError, NotFoundError, RateLimitError, NetworkError, TimeoutError } from "@kill-switch/sdk";
+const noColor = !!process.env.NO_COLOR;
+// Color helpers — no-op when NO_COLOR is set
+const c = {
+    bold: noColor ? (s) => s : chalk.bold,
+    dim: noColor ? (s) => s : chalk.dim,
+    green: noColor ? (s) => s : chalk.green,
+    red: noColor ? (s) => s : chalk.red,
+    yellow: noColor ? (s) => s : chalk.yellow,
+    cyan: noColor ? (s) => s : chalk.cyan,
+};
+export { c as colors };
 export function formatTable(rows, columns) {
     if (rows.length === 0) {
-        console.log("No results.");
+        console.log(c.dim("No results."));
         return;
     }
     // Calculate column widths
@@ -17,14 +34,33 @@ export function formatTable(rows, columns) {
     });
     // Header
     const headerLine = columns
-        .map((col, i) => col.header.padEnd(widths[i]))
+        .map((col, i) => c.bold(col.header.padEnd(widths[i])))
         .join("  ");
     console.log(headerLine);
-    console.log(widths.map((w) => "-".repeat(w)).join("  "));
+    console.log(c.dim(widths.map((w) => "─".repeat(w)).join("  ")));
     // Rows
     for (const row of rows) {
         const line = columns
-            .map((col, i) => String(row[col.key] ?? "").padEnd(widths[i]).slice(0, widths[i]))
+            .map((col, i) => {
+            const val = String(row[col.key] ?? "");
+            const display = val.padEnd(widths[i]).slice(0, widths[i]);
+            // Color status-like values
+            if (col.key === "status" || col.key === "enabled") {
+                if (val === "active" || val === "true")
+                    return c.green(display);
+                if (val === "paused" || val === "false" || val === "disabled")
+                    return c.yellow(display);
+                if (val === "disconnected" || val === "error")
+                    return c.red(display);
+            }
+            if (col.key === "severity") {
+                if (val === "critical")
+                    return c.red(display);
+                if (val === "warning")
+                    return c.yellow(display);
+            }
+            return display;
+        })
             .join("  ");
         console.log(line);
     }
@@ -35,7 +71,7 @@ export function formatObject(obj, fields) {
     for (const key of keys) {
         const val = obj[key];
         const display = typeof val === "object" ? JSON.stringify(val) : String(val ?? "");
-        console.log(`${key.padEnd(maxKeyLen + 2)}${display}`);
+        console.log(`${c.bold(key.padEnd(maxKeyLen + 2))}${display}`);
     }
 }
 export function outputJson(data) {
@@ -46,15 +82,68 @@ export function outputError(message, json) {
         console.error(JSON.stringify({ error: message }));
     }
     else {
-        console.error(`Error: ${message}`);
+        console.error(`${c.red("Error:")} ${message}`);
     }
 }
 /**
- * Wrap a command handler with JSON/error handling.
+ * Map SDK errors to contextual CLI messages.
  */
-export function withOutput(fn, opts) {
-    return fn(opts).catch((err) => {
-        outputError(err.message || String(err), opts.json);
-        process.exit(err.status === 401 || err.status === 403 ? 2 : 1);
-    });
+export function formatSdkError(err) {
+    if (err instanceof AuthenticationError) {
+        return {
+            message: "Authentication failed. Run `ks auth login` or set KILL_SWITCH_API_KEY.",
+            exitCode: 2,
+        };
+    }
+    if (err instanceof ForbiddenError) {
+        const tier = err.tierInfo;
+        if (tier) {
+            return {
+                message: `Requires ${tier.currentTier ? `upgrade from ${tier.currentTier}` : "a higher"} plan.${tier.upgradeUrl ? ` Upgrade: https://app.kill-switch.net${tier.upgradeUrl}` : ""}`,
+                exitCode: 1,
+            };
+        }
+        return { message: err.message, exitCode: 2 };
+    }
+    if (err instanceof NotFoundError) {
+        return { message: `${err.message} Run \`ks accounts list\` or \`ks rules list\` to see available resources.`, exitCode: 1 };
+    }
+    if (err instanceof RateLimitError) {
+        return { message: `Rate limited. Try again in ${err.retryAfter}s.`, exitCode: 1 };
+    }
+    if (err instanceof NetworkError) {
+        return { message: err.message, exitCode: 1 };
+    }
+    if (err instanceof TimeoutError) {
+        return { message: err.message, exitCode: 1 };
+    }
+    if (err instanceof ApiError) {
+        return { message: err.message, exitCode: 1 };
+    }
+    if (err instanceof Error) {
+        return { message: err.message, exitCode: 1 };
+    }
+    return { message: String(err), exitCode: 1 };
+}
+/**
+ * Wrap a command handler with error handling, spinner, and JSON support.
+ */
+export function handleError(err, json) {
+    const { message, exitCode } = formatSdkError(err);
+    outputError(message, json);
+    process.exit(exitCode);
+}
+// ─── Spinner helpers ─────────────────────────────────────────────────────────
+export function spinner(text) {
+    return ora({ text, isSilent: !!process.env.NO_COLOR });
+}
+// ─── Status indicators ──────────────────────────────────────────────────────
+export function success(msg) {
+    console.log(`${c.green("✓")} ${msg}`);
+}
+export function warn(msg) {
+    console.log(`${c.yellow("⚠")} ${msg}`);
+}
+export function fail(msg) {
+    console.log(`${c.red("✗")} ${msg}`);
 }

package/dist/prompts.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Interactive prompts — shared across commands
+ */
+export declare function ask(question: string): Promise<string>;
+/**
+ * Ask for yes/no confirmation.
+ * Returns true if user confirms. Skips prompt and returns true if
+ * `--yes` flag is set or `--json` mode is active.
+ */
+export declare function confirm(message: string, opts?: {
+    yes?: boolean;
+    json?: boolean;
+}): Promise<boolean>;

package/dist/prompts.js

@@ -0,0 +1,24 @@
+/**
+ * Interactive prompts — shared across commands
+ */
+import { createInterface } from "readline";
+export function ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/**
+ * Ask for yes/no confirmation.
+ * Returns true if user confirms. Skips prompt and returns true if
+ * `--yes` flag is set or `--json` mode is active.
+ */
+export async function confirm(message, opts = {}) {
+    if (opts.yes || opts.json)
+        return true;
+    const answer = await ask(`${message} (y/N): `);
+    return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import type { KillSwitchClient } from "@kill-switch/sdk";
+export type ClientFactory = () => KillSwitchClient;

package/dist/types.js

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

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const CLI_VERSION: string;

package/dist/version.js

@@ -0,0 +1,4 @@
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+export const CLI_VERSION = pkg.version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kill-switch/cli",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Kill Switch CLI — monitor cloud spending, kill runaway services from the terminal",
   "type": "module",
   "bin": {
@@ -13,21 +13,43 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "commander": "^12.1.0"
+    "@kill-switch/agent-guard": "^0.1.0",
+    "@kill-switch/sdk": "^0.1.0",
+    "chalk": "^5.6.2",
+    "commander": "^12.1.0",
+    "ora": "^8.2.0"
   },
   "devDependencies": {
-    "typescript": "^5.4.0",
+    "@types/node": "^22.0.0",
     "tsx": "^4.7.0",
-    "@types/node": "^22.0.0"
+    "typescript": "^5.4.0",
+    "vite": "^6.4.1",
+    "vitest": "^3.2.4"
   },
   "engines": {
     "node": ">=18"
   },
-  "files": ["dist", "README.md"],
-  "keywords": ["cloud", "kill-switch", "cost-monitoring", "cloudflare", "aws", "gcp", "finops", "billing", "cli", "devops"],
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "cloud",
+    "kill-switch",
+    "cost-monitoring",
+    "cloudflare",
+    "aws",
+    "gcp",
+    "runpod",
+    "gpu",
+    "finops",
+    "billing",
+    "cli",
+    "devops"
+  ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/AiExpanse/kill-switch",
+    "url": "https://github.com/divinci-ai/kill-switch",
     "directory": "packages/cli"
   },
   "homepage": "https://kill-switch.net",