@kill-switch/cli 0.1.0

package/dist/commands/onboard.js

@@ -0,0 +1,340 @@
+/**
+ * Onboard Command
+ *
+ * One-command setup for connecting cloud providers, applying protection rules,
+ * and configuring alerts. Designed for both human use and AI agent automation.
+ *
+ * Human use (interactive prompts):
+ *   kill-switch onboard
+ *
+ * AI agent use (non-interactive):
+ *   kill-switch onboard \
+ *     --provider cloudflare \
+ *     --account-id YOUR_CF_ACCOUNT_ID \
+ *     --token YOUR_CF_API_TOKEN \
+ *     --name "Production" \
+ *     --shields cost-runaway,ddos \
+ *     --alert-email you@example.com
+ *
+ * Multi-provider (run multiple times or comma-separate):
+ *   kill-switch onboard --provider cloudflare --token ... --account-id ...
+ *   kill-switch onboard --provider aws --access-key ... --secret-key ... --region us-east-1
+ */
+import { apiRequest } from "../api-client.js";
+import { outputJson, outputError } from "../output.js";
+import { createInterface } from "readline";
+const PROVIDER_HELP = {
+    cloudflare: {
+        name: "Cloudflare",
+        fields: "--account-id and --token",
+        howToGet: `How to get these values:
+
+  Account ID:
+    Found in your browser URL bar on any Cloudflare dashboard page:
+    https://dash.cloudflare.com/<ACCOUNT_ID>/example.com
+    Or run: curl -s -H "Authorization: Bearer TOKEN" https://api.cloudflare.com/client/v4/accounts | jq '.result[].id'
+
+  API Token (NOT Global API Key):
+    1. Go to https://dash.cloudflare.com/profile/api-tokens
+    2. Click "Create Token"
+    3. Use the "Edit Cloudflare Workers" template, or create custom with:
+       - Account > Account Analytics > Read
+       - Account > Workers Scripts > Edit
+       - Account > Workers R2 Storage > Read
+       - Account > D1 > Read
+       - Zone > Zone > Read
+    4. Copy the token (starts with a long alphanumeric string)
+
+  NOTE: The Global API Key will NOT work. You must create an API Token.`,
+    },
+    gcp: {
+        name: "Google Cloud",
+        fields: "--project-id and --service-account",
+        howToGet: `How to get these values:
+
+  Project ID:
+    Run: gcloud config get-value project
+    Or find it at: https://console.cloud.google.com/home/dashboard (project selector)
+
+  Service Account Key (JSON):
+    1. Go to https://console.cloud.google.com/iam-admin/serviceaccounts
+    2. Create a service account with "Viewer" + "Cloud Run Admin" roles
+    3. Create a JSON key: Actions > Manage Keys > Add Key > JSON
+    4. Pass the file contents: --service-account "$(cat key.json)"`,
+    },
+    aws: {
+        name: "Amazon Web Services",
+        fields: "--access-key, --secret-key, and --region",
+        howToGet: `How to get these values:
+
+  Access Key ID & Secret Access Key:
+    1. Go to https://console.aws.amazon.com/iam/home#/security_credentials
+    2. Create an access key (or use an existing IAM user with read permissions)
+    3. Copy both the Access Key ID and Secret Access Key
+    Run: aws configure get aws_access_key_id
+
+  Region:
+    Run: aws configure get region
+    Common values: us-east-1, us-west-2, eu-west-1`,
+    },
+};
+const AVAILABLE_SHIELDS = [
+    "cost-runaway", "ddos", "brute-force", "error-storm",
+    "exfiltration", "gpu-runaway", "lambda-loop", "aws-cost-runaway",
+];
+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());
+        });
+    });
+}
+export function registerOnboardCommands(program) {
+    program
+        .command("onboard")
+        .alias("setup")
+        .description("Quick setup: connect a cloud provider, apply protection, configure alerts")
+        .option("--provider <provider>", "Cloud provider: cloudflare, gcp, aws")
+        .option("--name <name>", "Account name (e.g., Production)")
+        .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, default: us-east-1)")
+        .option("--shields <presets>", "Comma-separated shield presets to apply (default: cost-runaway)")
+        .option("--alert-email <email>", "Email address for alerts")
+        .option("--alert-discord <url>", "Discord webhook URL for alerts")
+        .option("--alert-slack <url>", "Slack webhook URL for alerts")
+        .option("--skip-shields", "Skip applying protection rules")
+        .option("--skip-alerts", "Skip setting up alerts")
+        .option("--help-provider <provider>", "Show how to get credentials for a provider")
+        .addHelpText("after", `
+Examples:
+
+  # Interactive onboarding
+  kill-switch onboard
+
+  # AI agent / non-interactive: connect Cloudflare
+  kill-switch onboard \\
+    --provider cloudflare \\
+    --account-id 14a6fa23390363382f378b5bd4a0f849 \\
+    --token cf-api-token-here \\
+    --name "Production" \\
+    --shields cost-runaway,ddos \\
+    --alert-email you@example.com
+
+  # Show how to get Cloudflare credentials
+  kill-switch onboard --help-provider cloudflare
+
+  # Connect AWS with shields
+  kill-switch onboard \\
+    --provider aws \\
+    --access-key AKIA... \\
+    --secret-key wJalr... \\
+    --region us-east-1 \\
+    --shields aws-cost-runaway,gpu-runaway
+
+Available shields: ${AVAILABLE_SHIELDS.join(", ")}
+    `)
+        .action(async (opts) => {
+        const json = program.opts().json;
+        // Help for a specific provider
+        if (opts.helpProvider) {
+            const help = PROVIDER_HELP[opts.helpProvider];
+            if (!help) {
+                outputError(`Unknown provider: ${opts.helpProvider}. Use: cloudflare, gcp, aws`, json);
+                process.exit(1);
+            }
+            if (json) {
+                outputJson({ provider: opts.helpProvider, ...help });
+            }
+            else {
+                console.log(`\n${help.name} — required flags: ${help.fields}\n`);
+                console.log(help.howToGet);
+                console.log();
+            }
+            return;
+        }
+        try {
+            let provider = opts.provider;
+            let name = opts.name;
+            // Interactive mode if no provider specified
+            if (!provider) {
+                if (json) {
+                    outputError("--provider is required in JSON mode. Use: cloudflare, gcp, aws", json);
+                    process.exit(1);
+                }
+                console.log("\n\u26a1 Kill Switch Onboarding\n");
+                console.log("Let's connect your cloud provider and set up cost protection.\n");
+                console.log("Available providers:");
+                console.log("  1. cloudflare  — Workers, R2, D1, Queues, Stream");
+                console.log("  2. gcp         — Cloud Run, Compute, GKE, BigQuery");
+                console.log("  3. aws         — EC2, Lambda, RDS, ECS, S3");
+                console.log();
+                const choice = await ask("Choose a provider (1/2/3 or name): ");
+                provider = { "1": "cloudflare", "2": "gcp", "3": "aws" }[choice] || choice;
+            }
+            if (!PROVIDER_HELP[provider]) {
+                outputError(`Unknown provider: ${provider}. Use: cloudflare, gcp, aws`, json);
+                process.exit(1);
+            }
+            if (!name && !json) {
+                name = await ask("Account name (e.g., Production): ");
+            }
+            name = name || `${PROVIDER_HELP[provider].name} account`;
+            // Build credential
+            const credential = { provider };
+            if (provider === "cloudflare") {
+                let accountId = opts.accountId;
+                let token = opts.token;
+                if (!accountId && !json) {
+                    console.log("\n  Tip: Your Account ID is in the URL: dash.cloudflare.com/<ACCOUNT_ID>/...");
+                    accountId = await ask("  Cloudflare Account ID: ");
+                }
+                if (!token && !json) {
+                    console.log("\n  Tip: Create an API Token (not Global Key) at:");
+                    console.log("  https://dash.cloudflare.com/profile/api-tokens");
+                    console.log("  Use the 'Edit Cloudflare Workers' template.\n");
+                    token = await ask("  API Token: ");
+                }
+                if (!accountId || !token) {
+                    outputError(`Cloudflare requires ${PROVIDER_HELP.cloudflare.fields}`, json);
+                    process.exit(1);
+                }
+                credential.accountId = accountId;
+                credential.apiToken = token;
+            }
+            else if (provider === "gcp") {
+                let projectId = opts.projectId;
+                let serviceAccount = opts.serviceAccount;
+                if (!projectId && !json) {
+                    console.log("\n  Tip: Run `gcloud config get-value project` to find your project ID.");
+                    projectId = await ask("  GCP Project ID: ");
+                }
+                if (!serviceAccount && !json) {
+                    console.log("\n  Tip: Create at IAM > Service Accounts > Manage Keys > Add Key > JSON");
+                    serviceAccount = await ask("  Service Account Key JSON: ");
+                }
+                if (!projectId || !serviceAccount) {
+                    outputError(`GCP requires ${PROVIDER_HELP.gcp.fields}`, json);
+                    process.exit(1);
+                }
+                credential.projectId = projectId;
+                credential.serviceAccountJson = serviceAccount;
+            }
+            else if (provider === "aws") {
+                let accessKey = opts.accessKey;
+                let secretKey = opts.secretKey;
+                let region = opts.region;
+                if (!accessKey && !json) {
+                    console.log("\n  Tip: Find at IAM > Security Credentials, or `aws configure get aws_access_key_id`");
+                    accessKey = await ask("  AWS Access Key ID: ");
+                }
+                if (!secretKey && !json) {
+                    secretKey = await ask("  AWS Secret Access Key: ");
+                }
+                if (!region && !json) {
+                    region = await ask("  AWS Region (default: us-east-1): ");
+                }
+                if (!accessKey || !secretKey) {
+                    outputError(`AWS requires ${PROVIDER_HELP.aws.fields}`, json);
+                    process.exit(1);
+                }
+                credential.awsAccessKeyId = accessKey;
+                credential.awsSecretAccessKey = secretKey;
+                credential.awsRegion = region || "us-east-1";
+            }
+            // 1. Connect cloud account
+            if (!json)
+                console.log(`\nConnecting ${PROVIDER_HELP[provider].name}...`);
+            const account = await apiRequest("/cloud-accounts", {
+                method: "POST",
+                body: { provider, name, credential },
+            });
+            if (!json)
+                console.log(`\u2713 Connected: ${account.name || account._id}`);
+            // 2. Apply shields
+            if (!opts.skipShields) {
+                const shieldList = opts.shields
+                    ? opts.shields.split(",").map((s) => s.trim())
+                    : ["cost-runaway"];
+                if (!json)
+                    console.log(`\nApplying ${shieldList.length} shield(s)...`);
+                for (const shield of shieldList) {
+                    try {
+                        await apiRequest(`/rules/presets/${shield}`, { method: "POST", body: {} });
+                        if (!json)
+                            console.log(`  \u2713 ${shield}`);
+                    }
+                    catch (err) {
+                        if (!json)
+                            console.log(`  \u2717 ${shield}: ${err.message}`);
+                    }
+                }
+            }
+            // 3. Set up alerts
+            if (!opts.skipAlerts) {
+                const channels = [];
+                if (opts.alertEmail) {
+                    channels.push({ type: "email", name: "Email", config: { email: opts.alertEmail }, enabled: true });
+                }
+                if (opts.alertDiscord) {
+                    channels.push({ type: "discord", name: "Discord", config: { webhookUrl: opts.alertDiscord }, enabled: true });
+                }
+                if (opts.alertSlack) {
+                    channels.push({ type: "slack", name: "Slack", config: { webhookUrl: opts.alertSlack }, enabled: true });
+                }
+                if (channels.length === 0 && !json) {
+                    const email = await ask("\nAlert email (or Enter to skip): ");
+                    if (email) {
+                        channels.push({ type: "email", name: "Email", config: { email }, enabled: true });
+                    }
+                }
+                if (channels.length > 0) {
+                    if (!json)
+                        console.log("Setting up alerts...");
+                    try {
+                        await apiRequest("/alerts/channels", { method: "PUT", body: { channels } });
+                        if (!json)
+                            console.log(`  \u2713 ${channels.length} alert channel(s) configured`);
+                    }
+                    catch (err) {
+                        if (!json)
+                            console.log(`  \u2717 Alerts: ${err.message}`);
+                    }
+                }
+            }
+            // 4. Complete onboarding
+            try {
+                await apiRequest("/accounts/me", { method: "PATCH", body: { onboardingCompleted: true } });
+            }
+            catch {
+                // Non-critical
+            }
+            if (json) {
+                outputJson({
+                    success: true,
+                    provider,
+                    accountId: account._id || account.id,
+                    accountName: account.name,
+                });
+            }
+            else {
+                console.log(`\n\u2705 Setup complete! Kill Switch is monitoring your ${PROVIDER_HELP[provider].name} account.`);
+                console.log("\nNext steps:");
+                console.log("  kill-switch accounts list      — view connected accounts");
+                console.log("  kill-switch check               — run a monitoring check");
+                console.log("  kill-switch shield --list       — see all available shields");
+                console.log("  kill-switch onboard --provider  — add another provider\n");
+            }
+        }
+        catch (err) {
+            outputError(err.message, json);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/rules.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerRuleCommands(program: Command): void;

package/dist/commands/rules.js

@@ -0,0 +1,121 @@
+import { apiRequest } from "../api-client.js";
+import { outputJson, formatTable, outputError } from "../output.js";
+export function registerRuleCommands(program) {
+    const rules = program.command("rules").description("Manage kill switch rules");
+    rules
+        .command("list")
+        .alias("ls")
+        .description("List active rules")
+        .action(async () => {
+        const json = program.opts().json;
+        try {
+            const data = await apiRequest("/rules");
+            const list = data.rules || data;
+            if (json) {
+                outputJson(list);
+            }
+            else {
+                formatTable(Array.isArray(list) ? list : [], [
+                    { key: "id", header: "ID" },
+                    { key: "name", header: "Name" },
+                    { key: "trigger", header: "Trigger" },
+                    { key: "enabled", header: "Enabled" },
+                ]);
+            }
+        }
+        catch (err) {
+            outputError(err.message, json);
+            process.exit(1);
+        }
+    });
+    rules
+        .command("presets")
+        .description("List available preset templates")
+        .action(async () => {
+        const json = program.opts().json;
+        try {
+            const data = await apiRequest("/rules/presets", { public: true });
+            const presets = data.presets || data;
+            if (json) {
+                outputJson(presets);
+            }
+            else {
+                formatTable(presets, [
+                    { key: "id", header: "ID", width: 20 },
+                    { key: "name", header: "Name", width: 30 },
+                    { key: "description", header: "Description", width: 50 },
+                ]);
+            }
+        }
+        catch (err) {
+            outputError(err.message, json);
+            process.exit(1);
+        }
+    });
+    rules
+        .command("create <name>")
+        .description("Create a custom rule")
+        .requiredOption("--trigger <type>", "Trigger type (cost, security, api)")
+        .option("--condition <json>", "Condition JSON")
+        .option("--action <json>", "Action JSON")
+        .action(async (name, opts) => {
+        const json = program.opts().json;
+        try {
+            const body = { name, trigger: opts.trigger };
+            if (opts.condition)
+                body.conditions = JSON.parse(opts.condition);
+            if (opts.action)
+                body.actions = JSON.parse(opts.action);
+            const data = await apiRequest("/rules", { method: "POST", body });
+            if (json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Rule created: ${data.id || data._id}`);
+            }
+        }
+        catch (err) {
+            outputError(err.message, json);
+            process.exit(1);
+        }
+    });
+    rules
+        .command("delete <id>")
+        .alias("rm")
+        .description("Delete a rule")
+        .action(async (id) => {
+        const json = program.opts().json;
+        try {
+            await apiRequest(`/rules/${id}`, { method: "DELETE" });
+            if (json) {
+                outputJson({ deleted: true, id });
+            }
+            else {
+                console.log(`Rule ${id} deleted.`);
+            }
+        }
+        catch (err) {
+            outputError(err.message, json);
+            process.exit(1);
+        }
+    });
+    rules
+        .command("toggle <id>")
+        .description("Enable/disable a rule")
+        .action(async (id) => {
+        const json = program.opts().json;
+        try {
+            const data = await apiRequest(`/rules/${id}/toggle`, { method: "POST" });
+            if (json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Rule ${id} is now ${data.enabled ? "enabled" : "disabled"}.`);
+            }
+        }
+        catch (err) {
+            outputError(err.message, json);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/shield.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerShieldCommands(program: Command): void;

package/dist/commands/shield.js

@@ -0,0 +1,57 @@
+import { apiRequest } from "../api-client.js";
+import { outputJson, formatTable, outputError } 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
+        .command("shield [preset]")
+        .description("Quick-apply a protection preset (e.g., kill-switch shield cost-runaway)")
+        .option("--list", "List available shields")
+        .action(async (preset, opts) => {
+        const json = program.opts().json;
+        if (opts.list || !preset) {
+            try {
+                const data = await apiRequest("/rules/presets", { public: true });
+                const presets = data.presets || data;
+                if (json) {
+                    outputJson(presets);
+                }
+                else {
+                    console.log("Available shields:\n");
+                    formatTable(presets, [
+                        { key: "id", header: "Shield", width: 20 },
+                        { key: "name", header: "Name", width: 30 },
+                        { key: "description", header: "Description", width: 50 },
+                    ]);
+                    console.log("\nUsage: kill-switch shield <preset-id>");
+                }
+            }
+            catch (err) {
+                outputError(err.message, json);
+                process.exit(1);
+            }
+            return;
+        }
+        if (!PRESETS.includes(preset)) {
+            outputError(`Unknown preset "${preset}". Run: kill-switch shield --list`, json);
+            process.exit(1);
+        }
+        try {
+            const data = await apiRequest(`/rules/presets/${preset}`, { method: "POST" });
+            if (json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Shield activated: ${data.name || preset}`);
+                if (data.id)
+                    console.log(`Rule ID: ${data.id}`);
+            }
+        }
+        catch (err) {
+            outputError(err.message, json);
+            process.exit(1);
+        }
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Config file management — ~/.kill-switch/config.json
+ */
+export interface KillSwitchConfig {
+    apiKey?: string;
+    apiUrl?: string;
+}
+declare const CONFIG_DIR: string;
+declare const CONFIG_FILE: string;
+declare const DEFAULT_API_URL = "https://api.kill-switch.net";
+export declare function loadConfig(): KillSwitchConfig;
+export declare function saveConfig(config: KillSwitchConfig): void;
+export declare function deleteConfig(): void;
+/**
+ * Resolve the API key from (in priority order):
+ * 1. KILL_SWITCH_API_KEY env var
+ * 2. --api-key flag (passed at call site)
+ * 3. Config file
+ */
+export declare function resolveApiKey(flagKey?: string): string | undefined;
+/**
+ * Resolve the API URL.
+ */
+export declare function resolveApiUrl(flagUrl?: string): string;
+export { CONFIG_DIR, CONFIG_FILE, DEFAULT_API_URL };

package/dist/config.js

@@ -0,0 +1,49 @@
+/**
+ * Config file management — ~/.kill-switch/config.json
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const CONFIG_DIR = join(homedir(), ".kill-switch");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+const DEFAULT_API_URL = "https://api.kill-switch.net";
+export function loadConfig() {
+    try {
+        const raw = readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(config) {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+    chmodSync(CONFIG_FILE, 0o600); // owner read/write only
+}
+export function deleteConfig() {
+    try {
+        writeFileSync(CONFIG_FILE, "{}\n");
+    }
+    catch {
+        // ignore
+    }
+}
+/**
+ * Resolve the API key from (in priority order):
+ * 1. KILL_SWITCH_API_KEY env var
+ * 2. --api-key flag (passed at call site)
+ * 3. Config file
+ */
+export function resolveApiKey(flagKey) {
+    return process.env.KILL_SWITCH_API_KEY || flagKey || loadConfig().apiKey;
+}
+/**
+ * Resolve the API URL.
+ */
+export function resolveApiUrl(flagUrl) {
+    return process.env.KILL_SWITCH_API_URL || flagUrl || loadConfig().apiUrl || DEFAULT_API_URL;
+}
+export { CONFIG_DIR, CONFIG_FILE, DEFAULT_API_URL };

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Kill Switch CLI
+ *
+ * Monitor cloud spending, kill runaway services from the terminal.
+ *
+ * Usage:
+ *   kill-switch auth login --api-key ks_live_abc123
+ *   kill-switch shield cost-runaway
+ *   kill-switch check
+ *   kill-switch accounts list --json
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+/**
+ * Kill Switch CLI
+ *
+ * Monitor cloud spending, kill runaway services from the terminal.
+ *
+ * Usage:
+ *   kill-switch auth login --api-key ks_live_abc123
+ *   kill-switch shield cost-runaway
+ *   kill-switch check
+ *   kill-switch accounts list --json
+ */
+import { Command } from "commander";
+import { registerAuthCommands } from "./commands/auth.js";
+import { registerAccountCommands } from "./commands/accounts.js";
+import { registerRuleCommands } from "./commands/rules.js";
+import { registerShieldCommands } from "./commands/shield.js";
+import { registerCheckCommands } from "./commands/check.js";
+import { registerAlertCommands } from "./commands/alerts.js";
+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";
+const program = new Command();
+program
+    .name("kill-switch")
+    .description("Monitor cloud spending, kill runaway services, protect your infrastructure")
+    .version("0.1.0")
+    .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);
+registerConfigCommands(program);
+registerOnboardCommands(program);
+program.parse();

package/dist/output.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Output formatting — tables for humans, JSON for machines
+ */
+export interface Column {
+    key: string;
+    header: string;
+    width?: number;
+}
+export declare function formatTable(rows: any[], columns: Column[]): void;
+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.
+ */
+export declare function withOutput(fn: (opts: any) => Promise<any>, opts: {
+    json: boolean;
+}): Promise<any>;