@indigoai-us/hq-cloud 6.15.4 → 6.15.6

package/dist/outposts/command.js

@@ -0,0 +1,661 @@
+/**
+ * `hq outposts` — the full command tree for managing personal HQ Outposts from a
+ * terminal instead of the web console.
+ *
+ * Targets the hq-pro `/outpost/*` control plane — the same routes the console's
+ * outpost panel calls — through an injected transport, so the host CLI keeps
+ * ownership of auth, telemetry, and error decoration while the command surface
+ * itself lives here and is shared by every consumer.
+ *
+ * Outposts are PERSONAL / caller-scoped: hq-pro keys every `/outpost/*` route on
+ * the caller's Cognito sub, so there is no `--company`. `--id <outpostId>` selects
+ * a specific box; when omitted hq-pro targets the caller's primary slot.
+ *
+ * Subcommands:
+ *   outposts provision              — provision a box (paid; requires --yes)
+ *   outposts list                   — every Outpost you own (row summaries)
+ *   outposts status [--id]          — live detail for one box
+ *   outposts exec <command...>      — run a command on the box (sync/async/detach)
+ *   outposts exec-stage             — presign an input upload for an async command
+ *   outposts exec-submit <cmd...>   — fire-and-forget async submit
+ *   outposts exec-result            — poll an async command
+ *   outposts codex-enable [--id]    — enable / retry Codex on the box
+ *   outposts login [--id]           — request a fresh login URL
+ *   outposts login-code <code>      — hand the box its Claude sign-in code
+ *   outposts destroy [--id] --yes   — tear the box down (destructive; flag-guarded)
+ *   outposts heartbeat              — hidden; box-side systemd loop
+ *   outposts self-deploy            — hidden; make THIS host an unmanaged outpost
+ *   outposts replica-sync           — hidden; box-side full-replica timer target
+ *
+ * NOTE: hq-pro exposes no rename or settings-mutation route for Outposts (the web
+ * console can't rename them either), so this wraps only the lifecycle and status
+ * routes that exist. Renaming an Outpost is not a backend capability.
+ */
+import chalk from "chalk";
+import * as fs from "node:fs";
+import { OUTPOST_PRICE_CENTS } from "./billing.js";
+import { confirmChargeOrExit, surfaceBillingBlocked, } from "./cli-billing.js";
+import { EXEC_MAX_TIMEOUT_SECONDS, OutpostsClient, } from "./client.js";
+import { OutpostHttpError } from "./errors.js";
+import { registerHeartbeatCommand } from "./heartbeat-command.js";
+import { defaultReplicaSyncDependencies, } from "./host-deps.js";
+import { joinCommandParts, withRemoteHqDir } from "./remote-command.js";
+import { replicaSyncOutpost } from "./replica-sync.js";
+import { selfDeployOutpost } from "./self-deploy.js";
+import { execViaSsh } from "./ssh.js";
+/**
+ * Explain a `409` per-person cap.
+ *
+ * hq-pro checks the cap BEFORE activation billing, so nothing was charged — worth
+ * saying, since the caller just confirmed a recurring charge to get here.
+ */
+function surfaceOutpostCapped(capped) {
+    const owned = capped.outposts.length;
+    console.error(chalk.yellow(`You're already at your Outpost limit (${owned} of ${capped.limit}). ` +
+        `No new box was provisioned and you have not been charged.`));
+    for (const o of capped.outposts) {
+        const detail = [o.state, o.instanceName, o.region].filter(Boolean).join("  ");
+        console.error(`  ${o.outpostId}  ${detail}`);
+    }
+    console.error(chalk.dim("Inspect it: hq outposts status"));
+    console.error(chalk.dim("Or tear it down first: hq outposts destroy --id <id> --yes"));
+}
+function fail(err) {
+    if (err instanceof OutpostHttpError) {
+        console.error(chalk.red(err.message));
+    }
+    else {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+    }
+    process.exit(1);
+}
+/** Print a top-level object as `key: value`, JSON-ifying nested values. */
+function printKeyValues(obj) {
+    for (const [k, v] of Object.entries(obj)) {
+        const rendered = v && typeof v === "object" ? JSON.stringify(v) : String(v);
+        console.log(`${chalk.bold(k)}: ${rendered}`);
+    }
+}
+/** Reject a `--timeout-seconds` outside the AWS-RunShellScript range. */
+function assertExecTimeoutInRange(timeoutSeconds, hint) {
+    if (!Number.isInteger(timeoutSeconds) ||
+        timeoutSeconds < 1 ||
+        timeoutSeconds > EXEC_MAX_TIMEOUT_SECONDS) {
+        console.error(chalk.red(hint));
+        process.exit(1);
+    }
+}
+/**
+ * The local process exit code for a remote exec result.
+ *
+ * SSM does not always report a numeric `exitCode` even when it terminates a
+ * command with a non-success status (`Failed`, `Cancelled`). Falling back to `0`
+ * there tells automation the command SUCCEEDED — so `hq outposts exec` in a
+ * script silently swallows a remote failure. Fall back to `1` whenever the SSM
+ * status is not `Success`, and to `0` only for a genuine success with no code.
+ */
+function execExitCode(result) {
+    if (typeof result.exitCode === "number")
+        return result.exitCode;
+    return result.status === "Success" ? 0 : 1;
+}
+function parseIntegerOption(flag) {
+    return (v) => {
+        const n = Number(v);
+        if (!Number.isInteger(n)) {
+            throw new Error(`${flag} must be an integer`);
+        }
+        return n;
+    };
+}
+export function registerOutpostsCommand(program, deps) {
+    const host = {
+        ...defaultReplicaSyncDependencies,
+        ...deps.host,
+    };
+    const client = new OutpostsClient({
+        transport: deps.transport,
+        token: deps.getToken,
+        ...(deps.baseUrl ? { baseUrl: deps.baseUrl } : {}),
+    });
+    const billingContext = {
+        transport: deps.transport,
+        token: deps.getToken,
+        ...(deps.baseUrl ? { baseUrl: deps.baseUrl } : {}),
+    };
+    const outposts = program
+        .command("outposts")
+        .description("Manage your personal HQ Outposts (EC2 boxes)");
+    // On-box session heartbeat (systemd). Hidden — operators never run it.
+    registerHeartbeatCommand(outposts, {
+        getJwt: async () => {
+            if (deps.getTokenNonInteractive)
+                return deps.getTokenNonInteractive();
+            return typeof deps.getToken === "function"
+                ? deps.getToken()
+                : deps.getToken;
+        },
+        resolveCallerPersonUid: deps.resolveCallerPersonUid,
+        defaultApiBaseUrl: deps.defaultApiBaseUrl,
+    });
+    outposts
+        .command("self-deploy", { hidden: true })
+        .description("Configure this EC2 host as a locally self-hosted HQ outpost")
+        .option("--yes", "Skip the self-hosting confirmation")
+        .option("--hq-root <path>", "HQ root to sync", host.defaultHqRoot())
+        .action(async (opts) => {
+        try {
+            await selfDeployOutpost(opts, host);
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("replica-sync", { hidden: true })
+        .description("Replicate your full HQ onto this box (personal pull + core rescue + repos). Runs on a timer.")
+        .option("--hq-root <path>", "HQ root to replicate into", host.defaultHqRoot())
+        .action(async (opts) => {
+        // Best-effort background job: never hard-fail the systemd unit on a
+        // transient step. Swallow, log, and exit 0.
+        try {
+            await replicaSyncOutpost(opts, host);
+        }
+        catch (err) {
+            console.warn(`replica-sync: unexpected error — ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    outposts
+        .command("provision")
+        .alias("create")
+        .description("Provision a new Outpost ($80/month — requires --yes)")
+        .option("--runtime <runtime>", "Agent runtime: claude | codex (default claude)")
+        .option("--disk <gb>", "Root disk size in GB (EC2 only)")
+        .option("--client-ip <ip>", "Your public IP for the box's SSH ingress (optional; server derives it otherwise)")
+        .option("--yes", "Confirm the $80/month charge (required to provision)")
+        .action(async function (opts) {
+        try {
+            // Reject an unrecognized runtime rather than resolving it to claude:
+            // `--runtime codx` would otherwise hand back a silently Claude box.
+            if (opts.runtime !== undefined &&
+                opts.runtime !== "claude" &&
+                opts.runtime !== "codex") {
+                console.error(chalk.red(`Invalid --runtime '${opts.runtime}': must be 'claude' or 'codex'.`));
+                process.exit(1);
+            }
+            const agentRuntime = opts.runtime === "codex"
+                ? "codex"
+                : opts.runtime === "claude"
+                    ? "claude"
+                    : undefined;
+            let diskSizeGb;
+            if (opts.disk !== undefined) {
+                diskSizeGb = Number(opts.disk);
+                if (!Number.isFinite(diskSizeGb) || diskSizeGb <= 0) {
+                    console.error(chalk.red(`Invalid --disk '${opts.disk}': must be a positive number of GB.`));
+                    process.exit(1);
+                }
+            }
+            // Paid gate: print the monthly cost and require --yes before any call.
+            confirmChargeOrExit({
+                resource: "Outpost",
+                unitCents: OUTPOST_PRICE_CENTS,
+                yes: opts.yes,
+            });
+            // The box authenticates AS the caller using the cached refresh token —
+            // the same body the console sends. Never printed.
+            const refreshToken = deps.loadCachedTokens()?.refreshToken;
+            if (!refreshToken) {
+                console.error(chalk.red("No cached session found — run `hq login` first, then re-run."));
+                process.exit(1);
+            }
+            try {
+                await client.provision({
+                    refreshToken,
+                    ...(opts.clientIp ? { clientIp: opts.clientIp } : {}),
+                    ...(diskSizeGb ? { diskSizeGb } : {}),
+                    ...(agentRuntime ? { agentRuntime } : {}),
+                });
+                console.log(chalk.green("Provisioning started for your Outpost."));
+                console.log(chalk.dim("Track it: hq outposts status"));
+            }
+            catch (err) {
+                // No card on file → surface the shareable payment link, not an opaque 402.
+                if (err instanceof OutpostHttpError &&
+                    err.status === 402 &&
+                    err.billing) {
+                    await surfaceBillingBlocked(billingContext, err.billing, err.message);
+                    process.exit(1);
+                }
+                // Already at the per-person cap → say so and name the box they own, not
+                // a bare "Conflict".
+                if (err instanceof OutpostHttpError &&
+                    err.status === 409 &&
+                    err.capped) {
+                    surfaceOutpostCapped(err.capped);
+                    process.exit(1);
+                }
+                throw err;
+            }
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("list")
+        .description("List every Outpost you own")
+        .option("--json", "Emit raw JSON")
+        .action(async function (opts) {
+        try {
+            const rows = await client.list();
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(rows, null, 2) + "\n");
+                return;
+            }
+            if (rows.length === 0) {
+                console.log(chalk.gray("You don't own any Outposts yet."));
+                return;
+            }
+            const idW = Math.max(2, ...rows.map((r) => (r.outpostId ?? "").length));
+            const stateW = Math.max(5, ...rows.map((r) => (r.state ?? "").length));
+            const nameW = Math.max(4, ...rows.map((r) => (r.instanceName ?? "").length));
+            const regionW = Math.max(6, ...rows.map((r) => (r.region ?? "").length));
+            const rtW = Math.max(7, ...rows.map((r) => (r.agentRuntime ?? "").length));
+            console.log(chalk.bold([
+                "ID".padEnd(idW),
+                "STATE".padEnd(stateW),
+                "INSTANCE".padEnd(nameW),
+                "REGION".padEnd(regionW),
+                "RUNTIME".padEnd(rtW),
+                "PLATFORM",
+            ].join("  ")));
+            for (const r of rows) {
+                console.log([
+                    (r.outpostId ?? "").padEnd(idW),
+                    (r.state ?? "").padEnd(stateW),
+                    (r.instanceName ?? "").padEnd(nameW),
+                    (r.region ?? "").padEnd(regionW),
+                    (r.agentRuntime ?? "").padEnd(rtW),
+                    r.platform ?? "",
+                ].join("  "));
+            }
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("status")
+        .description("Show live detail for one Outpost")
+        .option("--id <outpostId>", "Outpost id (defaults to your primary box)")
+        .option("--json", "Emit raw JSON")
+        .action(async function (opts) {
+        try {
+            const status = await client.status(opts.id);
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(status, null, 2) + "\n");
+                return;
+            }
+            printKeyValues(status);
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("exec <command...>")
+        .description("Run a shell command on an Outpost and print its output (use -- before flags meant for the remote command). " +
+        "Default is synchronous (API Gateway ~20s cap). Use --async for long jobs, or --detach to print the commandId and return immediately.")
+        .option("--id <outpostId>", "Outpost id (defaults to your primary box)")
+        .option("--async", "Submit via the async transport and wait for completion (bypasses the ~20s sync cap; shell budget defaults to 48h)")
+        .option("--detach", "Submit via the async transport, print commandId, and return immediately (pair with `hq outposts exec-result --wait`)")
+        .option("--timeout-seconds <n>", "Async shell budget in seconds (AWS-RunShellScript executionTimeout; 1..172800). Implies --async unless --detach is set.", parseIntegerOption("--timeout-seconds"))
+        .option("--json", "Emit raw JSON")
+        .action(async function (commandParts, opts) {
+        try {
+            const command = joinCommandParts(commandParts);
+            if (!command.trim()) {
+                console.error(chalk.red("No command given. Usage: hq outposts exec -- <command>"));
+                process.exit(1);
+            }
+            if (opts.async && opts.detach) {
+                console.error(chalk.red("Use either --async (submit + wait) or --detach (submit only), not both."));
+                process.exit(1);
+            }
+            // --timeout-seconds only applies to the async path; bare use implies --async.
+            const useAsync = Boolean(opts.async) ||
+                Boolean(opts.detach) ||
+                opts.timeoutSeconds !== undefined;
+            if (opts.timeoutSeconds !== undefined) {
+                assertExecTimeoutInRange(opts.timeoutSeconds, "--timeout-seconds must be an integer between 1 and 172800 (48h, the AWS-RunShellScript max)");
+            }
+            // Run from the box's HQ folder by default (works over both SSM and SSH).
+            const remoteCommand = withRemoteHqDir(command);
+            if (useAsync) {
+                try {
+                    const submitted = await client.submitExec(remoteCommand, opts.id, opts.timeoutSeconds);
+                    if (opts.detach) {
+                        const output = {
+                            commandId: submitted.commandId,
+                            ...(submitted.executionTimeoutSeconds !== undefined
+                                ? {
+                                    executionTimeoutSeconds: submitted.executionTimeoutSeconds,
+                                }
+                                : opts.timeoutSeconds !== undefined
+                                    ? { executionTimeoutSeconds: opts.timeoutSeconds }
+                                    : {}),
+                        };
+                        if (opts.json) {
+                            process.stdout.write(JSON.stringify(output) + "\n");
+                        }
+                        else {
+                            printKeyValues(output);
+                            console.error(chalk.dim("Submitted. Poll with: hq outposts exec-result --command-id " +
+                                submitted.commandId +
+                                (opts.id ? ` --id ${opts.id}` : "") +
+                                " --wait"));
+                        }
+                        return;
+                    }
+                    // --async (or --timeout-seconds without --detach): wait for terminal.
+                    if (!opts.json) {
+                        console.error(chalk.dim(`Submitted ${submitted.commandId}; waiting for completion…`));
+                    }
+                    const result = await client.waitForExecResult(submitted.commandId, opts.id);
+                    if (opts.json) {
+                        process.stdout.write(JSON.stringify({
+                            commandId: submitted.commandId,
+                            done: result.done,
+                            status: result.status,
+                            exitCode: result.exitCode ?? null,
+                            stdout: result.stdout ?? "",
+                            stderr: result.stderr ?? "",
+                            truncated: result.truncated ?? false,
+                        }, null, 2) + "\n");
+                    }
+                    else {
+                        if (result.stdout)
+                            process.stdout.write(result.stdout);
+                        if (result.stderr)
+                            process.stderr.write(result.stderr);
+                        if (result.truncated) {
+                            console.error(chalk.yellow("(output truncated — redirect to a file on the box for full output)"));
+                        }
+                        if (result.status !== "Success" && result.exitCode === null) {
+                            console.error(chalk.yellow(`(command ended with SSM status: ${result.status})`));
+                        }
+                    }
+                    process.exitCode = execExitCode(result);
+                    return;
+                }
+                catch (err) {
+                    // Async requires EC2/SSM. Lightsail has no async channel — refuse
+                    // rather than silently falling back to a live SSH hold, which is the
+                    // exact timeout failure mode --async is meant to escape.
+                    if (err instanceof OutpostHttpError &&
+                        err.step === "platform-unsupported") {
+                        console.error(chalk.red("Async exec requires an EC2 Outpost (SSM). This box is Lightsail — " +
+                            "re-provision on EC2, or run a short sync command / SSH session instead."));
+                        process.exit(1);
+                    }
+                    throw err;
+                }
+            }
+            try {
+                const result = await client.exec(remoteCommand, opts.id);
+                if (opts.json) {
+                    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+                }
+                else {
+                    // Stream the remote streams to ours so the command feels local.
+                    if (result.stdout)
+                        process.stdout.write(result.stdout);
+                    if (result.stderr)
+                        process.stderr.write(result.stderr);
+                    if (result.truncated) {
+                        console.error(chalk.yellow("(output truncated by SSM's inline limit — redirect to a file on the box for full output)"));
+                    }
+                    if (result.status !== "Success" && result.exitCode === null) {
+                        console.error(chalk.yellow(`(command ended with SSM status: ${result.status})`));
+                    }
+                }
+                // Propagate the remote exit code so `hq outposts exec -- false` exits 1.
+                process.exitCode = execExitCode(result);
+            }
+            catch (err) {
+                // Lightsail boxes have no SSM agent — transparently fall back to SSH.
+                if (err instanceof OutpostHttpError &&
+                    err.step === "platform-unsupported") {
+                    const access = await client.sshAccess(opts.id);
+                    const ssh = execViaSsh(access, remoteCommand);
+                    if (ssh.error) {
+                        console.error(chalk.red(`Could not run the command over SSH: ${ssh.error}`));
+                        process.exit(1);
+                    }
+                    if (opts.json) {
+                        process.stdout.write(JSON.stringify({
+                            via: "ssh",
+                            platform: access.platform,
+                            host: access.host,
+                            exitCode: ssh.exitCode,
+                            stdout: ssh.stdout,
+                            stderr: ssh.stderr,
+                        }, null, 2) + "\n");
+                    }
+                    else {
+                        if (ssh.stdout)
+                            process.stdout.write(ssh.stdout);
+                        if (ssh.stderr)
+                            process.stderr.write(ssh.stderr);
+                    }
+                    process.exitCode =
+                        typeof ssh.exitCode === "number" ? ssh.exitCode : 1;
+                    return;
+                }
+                throw err;
+            }
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("exec-stage")
+        .description("Stage a file for an asynchronous Outpost command")
+        .requiredOption("--file <path>", "File to upload")
+        .option("--id <outpostId>", "Outpost id (defaults to your primary box)")
+        .option("--json", "Emit raw JSON")
+        .action(async function (opts) {
+        try {
+            const bytes = fs.readFileSync(opts.file);
+            const staged = await client.stageExecInput(opts.id);
+            const upload = await fetch(staged.putUrl, {
+                method: "PUT",
+                headers: { "Content-Length": String(bytes.byteLength) },
+                body: bytes,
+            });
+            if (!upload.ok) {
+                throw new Error(`Could not upload exec input: HTTP ${upload.status} ${upload.statusText}`);
+            }
+            const output = { key: staged.key, getUrl: staged.getUrl };
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(output) + "\n");
+            }
+            else {
+                printKeyValues(output);
+            }
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("exec-submit <command...>")
+        .description("Submit an asynchronous shell command to an Outpost (returns immediately with commandId; shell budget defaults to 48h)")
+        .option("--id <outpostId>", "Outpost id (defaults to your primary box)")
+        .option("--timeout-seconds <n>", "Shell budget in seconds (AWS-RunShellScript executionTimeout; 1..172800)", parseIntegerOption("--timeout-seconds"))
+        .option("--json", "Emit raw JSON")
+        .action(async function (commandParts, opts) {
+        try {
+            const command = joinCommandParts(commandParts);
+            if (!command.trim()) {
+                console.error(chalk.red("No command given. Usage: hq outposts exec-submit -- <command>"));
+                process.exit(1);
+            }
+            if (opts.timeoutSeconds !== undefined) {
+                assertExecTimeoutInRange(opts.timeoutSeconds, "--timeout-seconds must be an integer between 1 and 172800 (48h)");
+            }
+            // exec-submit is the raw fire-and-forget path — do NOT wrap with
+            // withRemoteHqDir here (callers that want the HQ cwd use `exec --async` or
+            // prefix their own cd). Matches the existing contract.
+            const submitted = await client.submitExec(command, opts.id, opts.timeoutSeconds);
+            const output = {
+                commandId: submitted.commandId,
+                ...(submitted.executionTimeoutSeconds !== undefined
+                    ? { executionTimeoutSeconds: submitted.executionTimeoutSeconds }
+                    : opts.timeoutSeconds !== undefined
+                        ? { executionTimeoutSeconds: opts.timeoutSeconds }
+                        : {}),
+            };
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(output) + "\n");
+            }
+            else {
+                printKeyValues(output);
+            }
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("exec-result")
+        .description("Fetch the result of an asynchronous Outpost command")
+        .requiredOption("--command-id <commandId>", "Command id returned by exec-submit")
+        .option("--id <outpostId>", "Outpost id (defaults to your primary box)")
+        .option("--wait", "Poll until the command reaches a terminal state")
+        .option("--json", "Emit raw JSON")
+        .action(async function (opts) {
+        try {
+            const result = opts.wait
+                ? await client.waitForExecResult(opts.commandId, opts.id)
+                : await client.fetchExecResult(opts.commandId, opts.id);
+            const output = {
+                done: result.done,
+                status: result.status,
+                exitCode: result.exitCode ?? null,
+                stdout: result.stdout ?? "",
+                stderr: result.stderr ?? "",
+            };
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(output) + "\n");
+            }
+            else {
+                printKeyValues(output);
+            }
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("codex-enable")
+        .description("Enable (or retry) Codex on an Outpost")
+        .option("--id <outpostId>", "Outpost id (defaults to your primary box)")
+        .option("--json", "Emit raw JSON")
+        .action(async function (opts) {
+        try {
+            const result = await client.enableCodex(opts.id);
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+                return;
+            }
+            console.log(chalk.green("Codex enablement requested for the Outpost."));
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("login")
+        .description("Request a fresh login URL for an Outpost")
+        .option("--id <outpostId>", "Outpost id (defaults to your primary box)")
+        .option("--json", "Emit raw JSON")
+        .action(async function (opts) {
+        try {
+            const result = await client.regenerateLoginUrl(opts.id);
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+                return;
+            }
+            console.log(chalk.green("Login-URL regeneration requested. The box mints a fresh URL shortly."));
+            console.log(chalk.dim("Next: `hq outposts status" +
+                (opts.id ? ` --id ${opts.id}` : "") +
+                "` to read the login URL, open it and sign in, then paste the code back with " +
+                "`hq outposts login-code <code>" +
+                (opts.id ? ` --id ${opts.id}` : "") +
+                "`."));
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("login-code <code>")
+        .description("Submit the Claude sign-in code for an Outpost that is awaiting login")
+        .option("--id <outpostId>", "Outpost id (defaults to your primary box)")
+        .option("--json", "Emit raw JSON")
+        .action(async function (code, opts) {
+        try {
+            const trimmed = code.trim();
+            if (!trimmed) {
+                console.error(chalk.red("Provide the sign-in code: hq outposts login-code <code>"));
+                process.exit(1);
+            }
+            const result = await client.submitLoginCode(trimmed, opts.id);
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+                return;
+            }
+            console.log(chalk.green("Code submitted — the box will finish signing in shortly."));
+            console.log(chalk.dim("Track it: `hq outposts status" +
+                (opts.id ? ` --id ${opts.id}` : "") +
+                "` (it flips to `ready` once Claude auth completes)."));
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("destroy")
+        .description("Tear down (permanently destroy) an Outpost")
+        .option("--id <outpostId>", "Outpost id (defaults to your primary box)")
+        .option("--yes", "Confirm the irreversible teardown (required)")
+        .action(async function (opts) {
+        const target = opts.id ?? "your primary Outpost";
+        if (!opts.yes) {
+            console.error(chalk.yellow(`This will permanently destroy ${target} and delete its cloud resources. ` +
+                `This cannot be undone.\n` +
+                `Re-run with --yes to confirm: hq outposts destroy${opts.id ? ` --id ${opts.id}` : ""} --yes`));
+            process.exit(1);
+        }
+        try {
+            await client.destroy(opts.id);
+            console.log(chalk.green(`Destroyed ${target}.`));
+        }
+        catch (err) {
+            // A 409 teardown-incomplete is not a failure — the gateway's 30s cap fired
+            // while the Lambda keeps working. The row is preserved and the operation is
+            // idempotent, so tell the caller to retry.
+            if (err instanceof OutpostHttpError &&
+                (err.status === 409 || err.step === "teardown-incomplete")) {
+                console.log(chalk.yellow(`Teardown still in progress for ${target} — this is expected for large boxes. ` +
+                    `Re-run the same destroy command to finish (it's idempotent).`));
+                return;
+            }
+            fail(err);
+        }
+    });
+}
+//# sourceMappingURL=command.js.map