@kill-switch/cli 0.2.0 → 0.3.1

package/dist/commands/orgs.js

@@ -0,0 +1,192 @@
+import { outputJson, formatTable, formatObject, handleError, success } from "../output.js";
+import { confirm } from "../prompts.js";
+export function registerOrgCommands(program, createClient) {
+    const orgs = program.command("orgs").description("Manage organizations");
+    orgs
+        .command("list")
+        .alias("ls")
+        .description("List organizations you belong to")
+        .action(async () => {
+        const json = program.opts().json;
+        try {
+            const client = createClient();
+            const data = await client.orgs.list();
+            if (json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Active org: ${data.activeOrgId || "none"}\n`);
+                formatTable(data.orgs, [
+                    { key: "id", header: "ID" },
+                    { key: "name", header: "Name" },
+                    { key: "type", header: "Type" },
+                    { key: "tier", header: "Tier" },
+                    { key: "role", header: "Role" },
+                    { key: "slug", header: "Slug" },
+                ]);
+            }
+        }
+        catch (err) {
+            handleError(err, json);
+        }
+    });
+    orgs
+        .command("create <name>")
+        .description("Create a new organization (requires team/enterprise tier)")
+        .action(async (name) => {
+        const json = program.opts().json;
+        try {
+            const client = createClient();
+            const data = await client.orgs.create({ name });
+            if (json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Organization created:`);
+                console.log(`  ID:   ${data.id}`);
+                console.log(`  Name: ${data.name}`);
+                console.log(`  Slug: ${data.slug}`);
+                console.log(`  Type: ${data.type}`);
+                console.log(`\nSwitch to it with: ks orgs switch ${data.id}`);
+            }
+        }
+        catch (err) {
+            handleError(err, json);
+        }
+    });
+    orgs
+        .command("switch <orgId>")
+        .description("Switch active organization")
+        .action(async (orgId) => {
+        const json = program.opts().json;
+        try {
+            const client = createClient();
+            await client.orgs.switch(orgId);
+            if (json) {
+                outputJson({ switched: true, activeOrgId: orgId });
+            }
+            else {
+                console.log(`Switched to org: ${orgId}`);
+            }
+        }
+        catch (err) {
+            handleError(err, json);
+        }
+    });
+    orgs
+        .command("info [orgId]")
+        .description("Get organization details")
+        .action(async (orgId) => {
+        const json = program.opts().json;
+        try {
+            const client = createClient();
+            if (orgId) {
+                const data = await client.orgs.get(orgId);
+                if (json) {
+                    outputJson(data);
+                }
+                else {
+                    formatObject(data);
+                }
+            }
+            else {
+                // Show current org info via /accounts/me
+                const data = await client.account.me();
+                if (json) {
+                    outputJson(data);
+                }
+                else {
+                    formatObject({
+                        name: data.name,
+                        tier: data.tier,
+                        type: data.type || "personal",
+                        slug: data.slug,
+                        role: data.teamRole,
+                        activeOrgId: data.activeOrgId,
+                        orgCount: data.orgs?.length || 1,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            handleError(err, json);
+        }
+    });
+    orgs
+        .command("members")
+        .description("List team members in current organization")
+        .action(async () => {
+        const json = program.opts().json;
+        try {
+            const client = createClient();
+            const data = await client.teams.members();
+            if (json) {
+                outputJson(data);
+            }
+            else {
+                console.log("Team Members:");
+                formatTable(data.members || [], [
+                    { key: "email", header: "Email" },
+                    { key: "role", header: "Role" },
+                    { key: "isOwner", header: "Owner" },
+                ]);
+                if (data.invitations?.length) {
+                    console.log("\nPending Invitations:");
+                    formatTable(data.invitations, [
+                        { key: "email", header: "Email" },
+                        { key: "role", header: "Role" },
+                        { key: "status", header: "Status" },
+                    ]);
+                }
+            }
+        }
+        catch (err) {
+            handleError(err, json);
+        }
+    });
+    orgs
+        .command("invite <email>")
+        .description("Invite a member to the current organization")
+        .option("--role <role>", "Role: admin, member, or viewer", "member")
+        .action(async (email, opts) => {
+        const json = program.opts().json;
+        try {
+            const client = createClient();
+            const data = await client.teams.invite({ email, role: opts.role });
+            if (json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Invitation sent to ${email} (role: ${opts.role})`);
+                console.log(`Accept URL: ${data.acceptUrl}`);
+            }
+        }
+        catch (err) {
+            handleError(err, json);
+        }
+    });
+    orgs
+        .command("delete <orgId>")
+        .description("Delete an organization (owner only, cannot delete personal workspace)")
+        .action(async (orgId) => {
+        const { json, yes } = program.opts();
+        try {
+            const ok = await confirm(`Delete organization ${orgId}? This cannot be undone.`, { yes, json });
+            if (!ok) {
+                console.log("Aborted.");
+                return;
+            }
+            const client = createClient();
+            await client.orgs.delete(orgId);
+            if (json) {
+                outputJson({ deleted: true, orgId });
+            }
+            else {
+                success(`Organization ${orgId} deleted.`);
+            }
+        }
+        catch (err) {
+            handleError(err, json);
+        }
+    });
+}

package/dist/commands/providers.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { ClientFactory } from "../types.js";
+export declare function registerProviderCommands(program: Command, createClient: ClientFactory): void;

package/dist/commands/providers.js

@@ -0,0 +1,82 @@
+import { outputJson, formatTable, handleError, spinner, success, fail, colors as c } from "../output.js";
+export function registerProviderCommands(program, createClient) {
+    const providers = program.command("providers").description("Cloud provider information and credential validation");
+    providers
+        .command("list")
+        .alias("ls")
+        .description("List supported cloud providers")
+        .action(async () => {
+        const json = program.opts().json;
+        try {
+            const client = createClient();
+            const list = await client.providers.list();
+            if (json) {
+                outputJson(list);
+            }
+            else {
+                formatTable(list, [
+                    { key: "id", header: "ID", width: 14 },
+                    { key: "name", header: "Name", width: 25 },
+                ]);
+            }
+        }
+        catch (err) {
+            handleError(err, json);
+        }
+    });
+    providers
+        .command("validate <provider>")
+        .description("Validate cloud provider credentials without connecting")
+        .option("--token <token>", "API token (Cloudflare)")
+        .option("--account-id <id>", "Account ID (Cloudflare)")
+        .option("--project-id <id>", "Project ID (GCP)")
+        .option("--service-account <json>", "Service Account JSON (GCP)")
+        .option("--access-key <key>", "Access Key ID (AWS)")
+        .option("--secret-key <key>", "Secret Access Key (AWS)")
+        .option("--region <region>", "Region (AWS)")
+        .option("--runpod-api-key <key>", "API Key (RunPod)")
+        .action(async (provider, opts) => {
+        const json = program.opts().json;
+        const credential = {};
+        // Build credential based on provider
+        if (opts.token)
+            credential.apiToken = opts.token;
+        if (opts.accountId)
+            credential.accountId = opts.accountId;
+        if (opts.projectId)
+            credential.projectId = opts.projectId;
+        if (opts.serviceAccount)
+            credential.serviceAccountJson = opts.serviceAccount;
+        if (opts.accessKey)
+            credential.awsAccessKeyId = opts.accessKey;
+        if (opts.secretKey)
+            credential.awsSecretAccessKey = opts.secretKey;
+        if (opts.region)
+            credential.awsRegion = opts.region;
+        if (opts.runpodApiKey)
+            credential.runpodApiKey = opts.runpodApiKey;
+        const s = json ? null : spinner(`Validating ${provider} credentials...`).start();
+        try {
+            const client = createClient();
+            const result = await client.providers.validate(provider, credential);
+            s?.stop();
+            if (json) {
+                outputJson(result);
+            }
+            else if (result.valid) {
+                success("Credentials are valid!");
+                if (result.accountId)
+                    console.log(`  ${c.bold("Account ID:")}   ${result.accountId}`);
+                if (result.accountName)
+                    console.log(`  ${c.bold("Account Name:")} ${result.accountName}`);
+            }
+            else {
+                fail(`Validation failed: ${result.error || "Unknown error"}`);
+            }
+        }
+        catch (err) {
+            s?.stop();
+            handleError(err, json);
+        }
+    });
+}

package/dist/commands/rules.d.ts

@@ -1,2 +1,3 @@
 import { Command } from "commander";
-export declare function registerRuleCommands(program: Command): void;
+import type { ClientFactory } from "../types.js";
+export declare function registerRuleCommands(program: Command, createClient: ClientFactory): void;

package/dist/commands/rules.js

@@ -1,21 +1,30 @@
-import { apiRequest } from "../api-client.js";
-import { outputJson, formatTable, outputError } from "../output.js";
-export function registerRuleCommands(program) {
+import { outputJson, formatTable, handleError, success, colors as c } from "../output.js";
+import { confirm } from "../prompts.js";
+export function registerRuleCommands(program, createClient) {
     const rules = program.command("rules").description("Manage kill switch rules");
     rules
         .command("list")
         .alias("ls")
         .description("List active rules")
-        .action(async () => {
+        .option("--trigger <type>", "Filter by trigger type (cost, security, custom, api, agent)")
+        .option("--enabled", "Show only enabled rules")
+        .option("--disabled", "Show only disabled rules")
+        .action(async (opts) => {
         const json = program.opts().json;
         try {
-            const data = await apiRequest("/rules");
-            const list = data.rules || data;
+            const client = createClient();
+            let list = await client.rules.list();
+            if (opts.trigger)
+                list = list.filter((r) => r.trigger === opts.trigger);
+            if (opts.enabled)
+                list = list.filter((r) => r.enabled);
+            if (opts.disabled)
+                list = list.filter((r) => !r.enabled);
             if (json) {
                 outputJson(list);
             }
             else {
-                formatTable(Array.isArray(list) ? list : [], [
+                formatTable(list, [
                     { key: "id", header: "ID" },
                     { key: "name", header: "Name" },
                     { key: "trigger", header: "Trigger" },
@@ -24,8 +33,7 @@ export function registerRuleCommands(program) {
             }
         }
         catch (err) {
-            outputError(err.message, json);
-            process.exit(1);
+            handleError(err, json);
         }
     });
     rules
@@ -34,8 +42,8 @@ export function registerRuleCommands(program) {
         .action(async () => {
         const json = program.opts().json;
         try {
-            const data = await apiRequest("/rules/presets", { public: true });
-            const presets = data.presets || data;
+            const client = createClient();
+            const presets = await client.rules.presets();
             if (json) {
                 outputJson(presets);
             }
@@ -48,8 +56,7 @@ export function registerRuleCommands(program) {
             }
         }
         catch (err) {
-            outputError(err.message, json);
-            process.exit(1);
+            handleError(err, json);
         }
     });
     rules
@@ -58,6 +65,7 @@ export function registerRuleCommands(program) {
         .requiredOption("--trigger <type>", "Trigger type (cost, security, api)")
         .option("--condition <json>", "Condition JSON")
         .option("--action <json>", "Action JSON")
+        .option("--dry-run", "Preview rule without creating it")
         .action(async (name, opts) => {
         const json = program.opts().json;
         try {
@@ -66,17 +74,27 @@ export function registerRuleCommands(program) {
                 body.conditions = JSON.parse(opts.condition);
             if (opts.action)
                 body.actions = JSON.parse(opts.action);
-            const data = await apiRequest("/rules", { method: "POST", body });
+            if (opts.dryRun) {
+                if (json) {
+                    outputJson({ dryRun: true, rule: body });
+                }
+                else {
+                    console.log(c.yellow("Dry run — rule would be created:"));
+                    console.log(JSON.stringify(body, null, 2));
+                }
+                return;
+            }
+            const client = createClient();
+            const rule = await client.rules.create(body);
             if (json) {
-                outputJson(data);
+                outputJson(rule);
             }
             else {
-                console.log(`Rule created: ${data.id || data._id}`);
+                success(`Rule created: ${rule.id}`);
             }
         }
         catch (err) {
-            outputError(err.message, json);
-            process.exit(1);
+            handleError(err, json);
         }
     });
     rules
@@ -84,19 +102,24 @@ export function registerRuleCommands(program) {
         .alias("rm")
         .description("Delete a rule")
         .action(async (id) => {
-        const json = program.opts().json;
+        const { json, yes } = program.opts();
         try {
-            await apiRequest(`/rules/${id}`, { method: "DELETE" });
+            const ok = await confirm(`Delete rule ${id}?`, { yes, json });
+            if (!ok) {
+                console.log("Aborted.");
+                return;
+            }
+            const client = createClient();
+            await client.rules.delete(id);
             if (json) {
                 outputJson({ deleted: true, id });
             }
             else {
-                console.log(`Rule ${id} deleted.`);
+                success(`Rule ${id} deleted.`);
             }
         }
         catch (err) {
-            outputError(err.message, json);
-            process.exit(1);
+            handleError(err, json);
         }
     });
     rules
@@ -105,17 +128,17 @@ export function registerRuleCommands(program) {
         .action(async (id) => {
         const json = program.opts().json;
         try {
-            const data = await apiRequest(`/rules/${id}/toggle`, { method: "POST" });
+            const client = createClient();
+            const rule = await client.rules.toggle(id);
             if (json) {
-                outputJson(data);
+                outputJson(rule);
             }
             else {
-                console.log(`Rule ${id} is now ${data.enabled ? "enabled" : "disabled"}.`);
+                success(`Rule ${id} is now ${rule.enabled ? c.green("enabled") : c.yellow("disabled")}.`);
             }
         }
         catch (err) {
-            outputError(err.message, json);
-            process.exit(1);
+            handleError(err, json);
         }
     });
 }

package/dist/commands/shield.d.ts

@@ -1,2 +1,3 @@
 import { Command } from "commander";
-export declare function registerShieldCommands(program: Command): void;
+import type { ClientFactory } from "../types.js";
+export declare function registerShieldCommands(program: Command, createClient: ClientFactory): void;

package/dist/commands/shield.js

@@ -1,20 +1,20 @@
-import { apiRequest } from "../api-client.js";
-import { outputJson, formatTable, outputError } from "../output.js";
+import { outputJson, formatTable, handleError, spinner, success, colors as c } from "../output.js";
 const PRESETS = [
     "ddos", "brute-force", "cost-runaway", "error-storm",
     "exfiltration", "gpu-runaway", "lambda-loop", "aws-cost-runaway",
 ];
-export function registerShieldCommands(program) {
-    const shield = program
+export function registerShieldCommands(program, createClient) {
+    program
         .command("shield [preset]")
         .description("Quick-apply a protection preset (e.g., kill-switch shield cost-runaway)")
         .option("--list", "List available shields")
+        .option("--dry-run", "Preview what the shield would do without applying")
         .action(async (preset, opts) => {
         const json = program.opts().json;
+        const client = createClient();
         if (opts.list || !preset) {
             try {
-                const data = await apiRequest("/rules/presets", { public: true });
-                const presets = data.presets || data;
+                const presets = await client.rules.presets();
                 if (json) {
                     outputJson(presets);
                 }
@@ -29,29 +29,48 @@ export function registerShieldCommands(program) {
                 }
             }
             catch (err) {
-                outputError(err.message, json);
-                process.exit(1);
+                handleError(err, json);
             }
             return;
         }
         if (!PRESETS.includes(preset)) {
-            outputError(`Unknown preset "${preset}". Run: kill-switch shield --list`, json);
-            process.exit(1);
+            handleError(new Error(`Unknown preset "${preset}". Run: kill-switch shield --list`), json);
         }
+        if (opts.dryRun) {
+            try {
+                const presets = await client.rules.presets();
+                const match = presets.find((p) => p.id === preset);
+                if (json) {
+                    outputJson({ dryRun: true, preset, details: match });
+                }
+                else {
+                    console.log(c.yellow("Dry run — shield would be applied:"));
+                    console.log(`  ${c.bold("Shield:")}  ${match?.name || preset}`);
+                    console.log(`  ${c.bold("Description:")} ${match?.description || "N/A"}`);
+                    console.log(`  ${c.bold("Category:")} ${match?.category || "N/A"}`);
+                }
+            }
+            catch (err) {
+                handleError(err, json);
+            }
+            return;
+        }
+        const s = json ? null : spinner(`Applying ${preset} shield...`).start();
         try {
-            const data = await apiRequest(`/rules/presets/${preset}`, { method: "POST" });
+            const rule = await client.rules.applyPreset(preset);
+            s?.stop();
             if (json) {
-                outputJson(data);
+                outputJson(rule);
             }
             else {
-                console.log(`Shield activated: ${data.name || preset}`);
-                if (data.id)
-                    console.log(`Rule ID: ${data.id}`);
+                success(`Shield activated: ${rule.name || preset}`);
+                if (rule.id)
+                    console.log(`  Rule ID: ${c.dim(rule.id)}`);
             }
         }
         catch (err) {
-            outputError(err.message, json);
-            process.exit(1);
+            s?.stop();
+            handleError(err, json);
         }
     });
 }

package/dist/commands/status.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { ClientFactory } from "../types.js";
+export declare function registerStatusCommand(program: Command, createClient: ClientFactory): void;

package/dist/commands/status.js

@@ -0,0 +1,100 @@
+import { outputJson, formatTable, handleError, spinner, warn, colors as c } from "../output.js";
+export function registerStatusCommand(program, createClient) {
+    program
+        .command("status")
+        .description("Show a quick overview of your Kill Switch setup")
+        .action(async () => {
+        const json = program.opts().json;
+        const s = json ? null : spinner("Loading status...").start();
+        try {
+            const client = createClient();
+            // Fire all requests in parallel
+            const [accountInfo, accounts, rules, sequences, channels, analytics] = await Promise.all([
+                client.billing.status().catch(() => null),
+                client.accounts.list().catch(() => []),
+                client.rules.list().catch(() => []),
+                client.database.list().catch(() => []),
+                client.alerts.channels().catch(() => []),
+                client.analytics.overview().catch(() => null),
+            ]);
+            s?.stop();
+            if (json) {
+                outputJson({
+                    tier: accountInfo?.tier || "unknown",
+                    limits: accountInfo?.limits,
+                    accounts: accounts.length,
+                    rules: rules.length,
+                    activeKillSequences: sequences.length,
+                    alertChannels: channels.length,
+                    totalSpendPeriod: analytics?.totalSpendPeriod ?? 0,
+                    savingsEstimate: analytics?.savingsEstimate ?? 0,
+                    killSwitchActions: analytics?.killSwitchActions ?? 0,
+                });
+                return;
+            }
+            // Header
+            console.log(c.bold("\nKill Switch Status\n"));
+            // Tier
+            const tier = accountInfo?.tier || "unknown";
+            const tierColor = tier === "free" ? c.dim : tier === "pro" ? c.cyan : c.green;
+            console.log(`  ${c.bold("Plan:")}       ${tierColor(tier)}`);
+            // Accounts
+            const activeAccounts = accounts.filter((a) => a.status === "active").length;
+            const limit = accountInfo?.limits?.cloudAccounts;
+            console.log(`  ${c.bold("Accounts:")}   ${activeAccounts} active${limit ? c.dim(` / ${limit} max`) : ""}`);
+            // Rules (programmatic kill rules — account-level thresholds are set per account)
+            const enabledRules = rules.filter((r) => r.enabled).length;
+            console.log(`  ${c.bold("Kill rules:")} ${enabledRules} enabled${rules.length > enabledRules ? c.dim(` (${rules.length} total)`) : ""}${enabledRules === 0 ? c.dim("  · thresholds set per account") : ""}`);
+            // Kill sequences
+            if (sequences.length > 0) {
+                warn(`  ${c.bold("Kill sequences:")} ${sequences.length} active`);
+            }
+            else {
+                console.log(`  ${c.bold("Kill seqs:")}  ${c.dim("none")}`);
+            }
+            // Alert channels
+            if (channels.length > 0) {
+                const enabledChannels = channels.filter((ch) => ch.enabled !== false).length;
+                console.log(`  ${c.bold("Alerts:")}     ${enabledChannels} channel(s) — ${channels.map((ch) => ch.type).join(", ")}`);
+            }
+            else {
+                console.log(`  ${c.bold("Alerts:")}     ${c.yellow("none")} — run: ks alerts add --type pagerduty --routing-key KEY`);
+            }
+            // 30-day spend summary
+            if (analytics) {
+                const totalSpend = analytics.totalSpendPeriod ?? 0;
+                const savings = analytics.savingsEstimate ?? 0;
+                const actions = analytics.killSwitchActions ?? 0;
+                console.log(`  ${c.bold("Spend (30d):")} $${totalSpend.toFixed(2)}${savings > 0 ? c.green(` · $${savings.toFixed(2)} saved`) : ""}${actions > 0 ? c.yellow(` · ${actions} action(s) taken`) : ""}`);
+            }
+            // Connected accounts table
+            if (accounts.length > 0) {
+                console.log(c.bold("\nConnected Accounts:\n"));
+                formatTable(accounts, [
+                    { key: "provider", header: "Provider", width: 12 },
+                    { key: "name", header: "Name", width: 25 },
+                    { key: "status", header: "Status", width: 12 },
+                    { key: "lastCheckStatus", header: "Last Check", width: 12 },
+                ]);
+            }
+            else {
+                console.log(`\n  ${c.dim("No accounts connected. Run:")} ks onboard`);
+            }
+            // Alert channels detail
+            if (channels.length > 0) {
+                console.log(c.bold("\nAlert Channels:\n"));
+                formatTable(channels, [
+                    { key: "type", header: "Type", width: 14 },
+                    { key: "name", header: "Name", width: 20 },
+                    { key: "enabled", header: "Enabled", width: 8 },
+                    { key: "configPreview", header: "Config", width: 30 },
+                ]);
+            }
+            console.log();
+        }
+        catch (err) {
+            s?.stop();
+            handleError(err, json);
+        }
+    });
+}

package/dist/commands/watch.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { ClientFactory } from "../types.js";
+export declare function registerWatchCommand(program: Command, createClient: ClientFactory): void;