@cortexlabs/forge 0.1.0-alpha.1

package/README.md

@@ -0,0 +1,33 @@
+# Forge CLI
+
+Forge is a local engineering terminal backed by the Forge platform.
+
+## Install
+
+The package is not public until the release checklist passes. For a packed local build:
+
+```bash
+npm install
+npm test
+npm pack
+npm install -g ./cortexlabs-forge-0.1.0-alpha.1.tgz
+forge doctor
+```
+
+After publication:
+
+```bash
+npm install -g @cortexlabs/forge
+```
+
+## Start
+
+```bash
+forge login
+forge status
+forge
+```
+
+`forge` opens the interactive terminal. Use `/help` inside it. Use `--json` with a command for machine-readable newline-delimited events.
+
+Forge never enables paid over-limit usage, changes spending limits, publishes, deploys, or performs destructive work without an explicit approval flow.

package/SECURITY.md

@@ -0,0 +1,5 @@
+# Security
+
+Do not report vulnerabilities in public issues. Contact the Cortex Labs security address configured in the Forge account portal. Include the CLI version, operating system, reproduction steps, and whether a workspace had been trusted.
+
+Forge CLI never requires provider credentials. Use a scoped Forge API key. Revoke affected keys from Forge Settings if a local machine or transcript may be compromised.

package/dist/api-client.d.ts

@@ -0,0 +1,17 @@
+import type { CliEvent, TaskMode } from "./types.js";
+import type { UsageEventData } from "./usage.js";
+export declare function getBootstrap(apiBaseUrl: string): Promise<Record<string, unknown>>;
+export declare function getBillingStatus(apiBaseUrl: string): Promise<Record<string, unknown>>;
+export declare function runRemote(params: {
+    apiBaseUrl: string;
+    prompt: string;
+    model: string;
+    mode: TaskMode;
+    sessionId: string;
+    project: Record<string, unknown>;
+    signal: AbortSignal;
+    emit(event: Omit<CliEvent, "at">): void;
+}): Promise<{
+    text: string;
+    usage: UsageEventData | null;
+}>;

package/dist/api-client.js

@@ -0,0 +1,71 @@
+import { getApiKey } from "./credentials.js";
+async function headers() {
+    const apiKey = await getApiKey();
+    if (!apiKey)
+        throw new Error("Not authenticated. Run `forge login` or set FORGE_API_KEY.");
+    return { authorization: `Bearer ${apiKey}`, "content-type": "application/json" };
+}
+async function apiError(response) {
+    const body = await response.json().catch(() => ({}));
+    const diagnostic = `HTTP ${response.status}`;
+    if (response.status === 401)
+        return new Error(`Forge authentication failed (${diagnostic}). Check or revoke the API key.`);
+    if (response.status === 402)
+        return new Error(`You have reached your included Forge usage (${diagnostic}). Balance: ${body.balance ?? "unknown"}. Run forge credits.`);
+    if (response.status === 429)
+        return new Error(`Forge is temporarily rate limited (${diagnostic}). Retry after ${body.retryAfter ?? response.headers.get("retry-after") ?? "the reset"}.`);
+    if (response.status >= 500)
+        return new Error(`Forge is temporarily unavailable (${diagnostic}). Your local session remains safe.`);
+    return new Error(`${body.error ?? "Forge request failed"} (${diagnostic}).`);
+}
+export async function getBootstrap(apiBaseUrl) {
+    const response = await fetch(`${apiBaseUrl}/api/forge/cli/bootstrap`, { headers: await headers(), signal: AbortSignal.timeout(15_000) });
+    if (!response.ok)
+        throw await apiError(response);
+    return response.json();
+}
+export async function getBillingStatus(apiBaseUrl) {
+    const response = await fetch(`${apiBaseUrl}/api/forge/cli/billing`, { headers: await headers(), signal: AbortSignal.timeout(15_000) });
+    if (!response.ok)
+        throw await apiError(response);
+    return response.json();
+}
+export async function runRemote(params) {
+    const response = await fetch(`${params.apiBaseUrl}/api/forge/cli/run`, {
+        method: "POST", headers: await headers(), signal: params.signal,
+        body: JSON.stringify({ prompt: params.prompt, model: params.model, mode: params.mode, sessionId: params.sessionId, requestId: crypto.randomUUID(), project: params.project }),
+    });
+    if (!response.ok)
+        throw await apiError(response);
+    if (!response.body)
+        throw new Error("Forge API returned an empty stream.");
+    const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+    let pending = "";
+    let text = "";
+    let usage = null;
+    let streamError = null;
+    while (true) {
+        const { done, value } = await reader.read();
+        pending += value ?? "";
+        const lines = pending.split("\n");
+        pending = lines.pop() ?? "";
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            const event = JSON.parse(line);
+            if (event.type === "text-delta")
+                text += event.message ?? "";
+            if (event.type === "usage")
+                usage = (event.data ?? {});
+            if (event.type === "error")
+                streamError = event.message ?? "Forge run failed.";
+            params.emit(event);
+        }
+        if (done)
+            break;
+    }
+    if (streamError)
+        throw new Error(streamError);
+    return { text, usage };
+}
+//# sourceMappingURL=api-client.js.map

package/dist/api-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-client.js","sourceRoot":"","sources":["../src/api-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAI7C,KAAK,UAAU,OAAO;IACpB,MAAM,MAAM,GAAG,MAAM,SAAS,EAAE,CAAC;IACjC,IAAI,CAAC,MAAM;QAAE,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;IAC3F,OAAO,EAAE,aAAa,EAAE,UAAU,MAAM,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;AACnF,CAAC;AAED,KAAK,UAAU,QAAQ,CAAC,QAAkB;IACxC,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAA8D,CAAC;IAClH,MAAM,UAAU,GAAG,QAAQ,QAAQ,CAAC,MAAM,EAAE,CAAC;IAC7C,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG;QAAE,OAAO,IAAI,KAAK,CAAC,gCAAgC,UAAU,iCAAiC,CAAC,CAAC;IAC3H,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG;QAAE,OAAO,IAAI,KAAK,CAAC,+CAA+C,UAAU,eAAe,IAAI,CAAC,OAAO,IAAI,SAAS,sBAAsB,CAAC,CAAC;IACvK,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG;QAAE,OAAO,IAAI,KAAK,CAAC,sCAAsC,UAAU,kBAAkB,IAAI,CAAC,UAAU,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,WAAW,GAAG,CAAC,CAAC;IAC1L,IAAI,QAAQ,CAAC,MAAM,IAAI,GAAG;QAAE,OAAO,IAAI,KAAK,CAAC,qCAAqC,UAAU,qCAAqC,CAAC,CAAC;IACnI,OAAO,IAAI,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,IAAI,sBAAsB,KAAK,UAAU,IAAI,CAAC,CAAC;AAC/E,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,UAAkB;IACnD,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,UAAU,0BAA0B,EAAE,EAAE,OAAO,EAAE,MAAM,OAAO,EAAE,EAAE,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACzI,IAAI,CAAC,QAAQ,CAAC,EAAE;QAAE,MAAM,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACjD,OAAO,QAAQ,CAAC,IAAI,EAAsC,CAAC;AAC7D,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,UAAkB;IACvD,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,UAAU,wBAAwB,EAAE,EAAE,OAAO,EAAE,MAAM,OAAO,EAAE,EAAE,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACvI,IAAI,CAAC,QAAQ,CAAC,EAAE;QAAE,MAAM,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACjD,OAAO,QAAQ,CAAC,IAAI,EAAsC,CAAC;AAC7D,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,MAG/B;IACC,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,MAAM,CAAC,UAAU,oBAAoB,EAAE;QACrE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM;QAC/D,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC;KAC9K,CAAC,CAAC;IACH,IAAI,CAAC,QAAQ,CAAC,EAAE;QAAE,MAAM,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACjD,IAAI,CAAC,QAAQ,CAAC,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IAC3E,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,iBAAiB,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC;IAC9E,IAAI,OAAO,GAAG,EAAE,CAAC;IACjB,IAAI,IAAI,GAAG,EAAE,CAAC;IACd,IAAI,KAAK,GAA0B,IAAI,CAAC;IACxC,IAAI,WAAW,GAAkB,IAAI,CAAC;IACtC,OAAO,IAAI,EAAE,CAAC;QACZ,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;QAC5C,OAAO,IAAI,KAAK,IAAI,EAAE,CAAC;QACvB,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAClC,OAAO,GAAG,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC;QAC5B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;gBAAE,SAAS;YAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAyB,CAAC;YACvD,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY;gBAAE,IAAI,IAAI,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC;YAC7D,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;gBAAE,KAAK,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,CAAmB,CAAC;YACzE,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;gBAAE,WAAW,GAAG,KAAK,CAAC,OAAO,IAAI,mBAAmB,CAAC;YAC/E,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC;QACD,IAAI,IAAI;YAAE,MAAM;IAClB,CAAC;IACD,IAAI,WAAW;QAAE,MAAM,IAAI,KAAK,CAAC,WAAW,CAAC,CAAC;IAC9C,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;AACzB,CAAC"}

package/dist/audit.d.ts

@@ -0,0 +1 @@
+export declare function audit(action: string, data?: Record<string, unknown>): Promise<void>;

package/dist/audit.js

@@ -0,0 +1,19 @@
+import { appendPrivateJsonLine } from "./storage.js";
+import { forgePaths } from "./paths.js";
+const secretPattern = /forge_[a-f0-9]{16,}/gi;
+function redact(value) {
+    if (typeof value === "string")
+        return value.replace(secretPattern, "forge_[REDACTED]");
+    if (Array.isArray(value))
+        return value.map(redact);
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, /token|secret|key/i.test(key) ? "[REDACTED]" : redact(item)]));
+    }
+    return value;
+}
+export async function audit(action, data = {}) {
+    await appendPrivateJsonLine(forgePaths().audit, {
+        at: new Date().toISOString(), action, data: redact(data),
+    });
+}
+//# sourceMappingURL=audit.js.map

package/dist/audit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.js","sourceRoot":"","sources":["../src/audit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,aAAa,GAAG,uBAAuB,CAAC;AAE9C,SAAS,MAAM,CAAC,KAAc;IAC5B,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC,OAAO,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC;IACvF,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACnD,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QACvC,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5I,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,KAAK,CAAC,MAAc,EAAE,OAAgC,EAAE;IAC5E,MAAM,qBAAqB,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE;QAC9C,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;KACzD,CAAC,CAAC;AACL,CAAC"}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { createEmitter } from "./output.js";
+import { interactiveLoop, requestApproval, runCommandLine } from "./interactive.js";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+const args = process.argv.slice(2);
+const outputMode = args.includes("--json") ? "json" : "human";
+const filtered = args.filter((arg) => arg !== "--json");
+const emit = createEmitter(outputMode);
+const controller = new AbortController();
+let interrupted = false;
+process.on("SIGINT", () => {
+    if (interrupted)
+        process.exit(130);
+    interrupted = true;
+    controller.abort(new Error("Cancelled by user."));
+    emit({ type: "warning", message: "Cancelled. Press Ctrl-C again to exit immediately." });
+});
+async function main() {
+    const cwd = resolve(process.cwd());
+    if (filtered.includes("--help") || filtered.includes("-h"))
+        return runCommandLine("help", { cwd, outputMode, signal: controller.signal, emit, requestApproval });
+    if (filtered.includes("--version") || filtered.includes("-v")) {
+        const packageJson = JSON.parse(await readFile(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8"));
+        process.stdout.write(`${packageJson.version}\n`);
+        return 0;
+    }
+    if (!filtered.length)
+        return interactiveLoop({ cwd, outputMode, signal: controller.signal, emit });
+    const input = filtered.map((arg) => JSON.stringify(arg)).join(" ");
+    return runCommandLine(input, { cwd, outputMode, signal: controller.signal, emit, requestApproval });
+}
+main().then((code) => { process.exitCode = code === 99 ? 0 : code; }).catch((error) => {
+    emit({ type: "error", message: error instanceof Error ? error.message : String(error) });
+    process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEpF,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACnC,MAAM,UAAU,GAAe,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;AAC1E,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,QAAQ,CAAC,CAAC;AACxD,MAAM,IAAI,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;AACvC,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;AACzC,IAAI,WAAW,GAAG,KAAK,CAAC;AAExB,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;IACxB,IAAI,WAAW;QAAE,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnC,WAAW,GAAG,IAAI,CAAC;IACnB,UAAU,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC;IAClD,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,oDAAoD,EAAE,CAAC,CAAC;AAC3F,CAAC,CAAC,CAAC;AAEH,KAAK,UAAU,IAAI;IACjB,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IACnC,IAAI,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO,cAAc,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC;IACjK,IAAI,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QAC9D,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,QAAQ,CAAC,aAAa,CAAC,IAAI,GAAG,CAAC,iBAAiB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAwB,CAAC;QAC1I,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,WAAW,CAAC,OAAO,IAAI,CAAC,CAAC;QAAC,OAAO,CAAC,CAAC;IAC7D,CAAC;IACD,IAAI,CAAC,QAAQ,CAAC,MAAM;QAAE,OAAO,eAAe,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IACnG,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnE,OAAO,cAAc,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC;AACtG,CAAC;AAED,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;IACpF,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACzF,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;AACvB,CAAC,CAAC,CAAC"}

package/dist/commands.d.ts

@@ -0,0 +1,3 @@
+import type { CommandDefinition } from "./types.js";
+export declare function resolveCommand(name: string): CommandDefinition | null;
+export declare function allCommands(): CommandDefinition[];

package/dist/commands.js

@@ -0,0 +1,391 @@
+import { audit } from "./audit.js";
+import { getBillingStatus, getBootstrap, runRemote } from "./api-client.js";
+import { clearApiKey, credentialSource, getApiKey, readMaskedApiKey, saveApiKey } from "./credentials.js";
+import { loadConfig, loadConfigWithSources, saveConfig } from "./config.js";
+import { permissionDecision } from "./permissions.js";
+import { collectProjectManifest } from "./project.js";
+import { clearSession, compactSession, createSession, deleteSession, forkSession, getCurrentSession, listSessions, loadSession, saveSession, sessionsOlderThan, setCurrentSession } from "./sessions.js";
+import { findTrustRecord, trustWorkspace, trustWorkspaceOnce } from "./trust.js";
+import { inspectExtensions } from "./extensions.js";
+import { writePrivateJson } from "./storage.js";
+import { join, relative } from "node:path";
+import { contextSummary, contextWarning, mergeUsage } from "./usage.js";
+const registry = new Map();
+function define(command) {
+    registry.set(command.name, command);
+    for (const alias of command.aliases ?? [])
+        registry.set(alias, command);
+}
+function text(context, message) { context.emit({ type: "info", message }); }
+define({ name: "help", aliases: ["?"], summary: "Show commands", usage: "forge help", interactive: true, async run(ctx) {
+        const query = ctx.args.join(" ").toLowerCase();
+        const commands = [...new Set(registry.values())].filter((command) => !query || `${command.name} ${command.summary}`.toLowerCase().includes(query)).sort((a, b) => a.name.localeCompare(b.name));
+        if (!commands.length) {
+            ctx.emit({ type: "warning", message: `No commands match "${query}".` });
+            return 1;
+        }
+        for (const command of commands)
+            text(ctx, `${command.name.padEnd(14)} ${command.summary}`);
+        return 0;
+    } });
+define({ name: "login", summary: "Save a Forge API key", usage: "forge login", interactive: true, async run(ctx) {
+        const key = await readMaskedApiKey();
+        await saveApiKey(key);
+        await audit("auth.login", { source: "private-file" });
+        ctx.emit({ type: "success", message: "Forge API key saved in a mode-0600 local file." });
+        ctx.emit({ type: "warning", message: "This preview does not use the OS keychain yet. Prefer FORGE_API_KEY on shared machines." });
+        return 0;
+    } });
+define({ name: "logout", summary: "Remove the saved API key", usage: "forge logout", interactive: true, async run(ctx) {
+        await clearApiKey();
+        await audit("auth.logout");
+        ctx.emit({ type: "success", message: "Saved Forge credentials removed." });
+        return 0;
+    } });
+define({ name: "status", summary: "Show workspace and account status", usage: "forge status", interactive: true, async run(ctx) {
+        const config = await loadConfig();
+        const trust = await findTrustRecord(ctx.cwd);
+        const session = await getCurrentSession();
+        const project = await collectProjectManifest(ctx.cwd);
+        let account = null;
+        if (await getApiKey())
+            account = await getBootstrap(config.apiBaseUrl).catch(() => null);
+        text(ctx, `workspace: ${trust.current.repositoryRoot ?? trust.current.path}`);
+        text(ctx, `trust: ${trust.record ? "trusted" : "not trusted"}`);
+        text(ctx, `mode: ${config.taskMode} / permissions: ${config.permissionMode} / model: ${config.model}`);
+        text(ctx, `project: ${project.rootName}${project.branch ? ` @ ${project.branch}` : ""}`);
+        text(ctx, `session: ${session?.id ?? "none"} / state: ${session?.state ?? "idle"}`);
+        text(ctx, contextSummary(session?.usage));
+        const warning = contextWarning(session?.usage);
+        if (warning)
+            ctx.emit({ type: "warning", message: warning });
+        const accountPlan = account?.plan;
+        const accountCredits = account?.credits;
+        text(ctx, `plan: ${accountPlan?.name ?? "unknown"} / credits: ${accountCredits?.unlimited ? "unlimited" : accountCredits?.balance?.toLocaleString() ?? "unknown"} / session cost: ${session?.usage?.credits ?? 0}`);
+        text(ctx, `agents: 0 / provider: ${account ? "connected" : "disconnected"}`);
+        text(ctx, `credentials: ${(await getApiKey()) ? credentialSource() : "missing"}`);
+        return 0;
+    } });
+define({ name: "doctor", summary: "Check local and API readiness", usage: "forge doctor", interactive: true, async run(ctx) {
+        const config = await loadConfig();
+        const checks = [
+            ["Node.js 20+", Number(process.versions.node.split(".")[0]) >= 20, process.versions.node],
+            ["API key", Boolean(await getApiKey()), (await getApiKey()) ? credentialSource() : "missing"],
+            ["API URL", /^https?:\/\//.test(config.apiBaseUrl), config.apiBaseUrl],
+        ];
+        for (const [name, ok, detail] of checks)
+            ctx.emit({ type: ok ? "success" : "warning", message: `${name}: ${detail}` });
+        if (await getApiKey()) {
+            try {
+                await getBootstrap(config.apiBaseUrl);
+                ctx.emit({ type: "success", message: "Forge API connection is healthy." });
+            }
+            catch (error) {
+                ctx.emit({ type: "error", message: error instanceof Error ? error.message : String(error) });
+                return 1;
+            }
+        }
+        return checks.every(([, ok]) => ok) ? 0 : 1;
+    } });
+define({ name: "trust", summary: "Inspect or trust this workspace", usage: "forge trust [--always]", interactive: true, async run(ctx) {
+        const result = await findTrustRecord(ctx.cwd);
+        text(ctx, `path: ${result.current.path}`);
+        text(ctx, `instructions: ${result.current.instructionFiles.join(", ") || "none"}`);
+        text(ctx, `executable config: ${result.current.executableConfigFiles.join(", ") || "none"}`);
+        if (result.record) {
+            ctx.emit({ type: "success", message: "Workspace fingerprint is trusted." });
+            return 0;
+        }
+        if (ctx.flags.has("read-only")) {
+            const config = await loadConfig();
+            await saveConfig({ ...config, permissionMode: "read-only", taskMode: "read-only" });
+            ctx.emit({ type: "success", message: "Opened in read-only mode without trusting project configuration." });
+            return 0;
+        }
+        const approved = ctx.flags.has("always") || ctx.flags.has("once") || await ctx.requestApproval?.("Trust once? Use --always to persist, or --read-only to avoid trust.", false);
+        if (!approved) {
+            ctx.emit({ type: "warning", message: "Workspace remains untrusted." });
+            return 1;
+        }
+        const permanent = ctx.flags.has("always");
+        if (permanent)
+            await trustWorkspace(ctx.cwd);
+        else
+            await trustWorkspaceOnce(ctx.cwd);
+        await audit("workspace.trust", { path: result.current.path, scope: permanent ? "always" : "once" });
+        ctx.emit({ type: "success", message: `Workspace trusted ${permanent ? "permanently" : "for this process"}. Configuration metadata changes invalidate trust.` });
+        return 0;
+    } });
+define({ name: "permissions", summary: "View or set permission mode", usage: "forge permissions [mode]", interactive: true, async run(ctx) {
+        const config = await loadConfig();
+        const requested = ctx.args[0];
+        const modes = ["read-only", "ask", "workspace-write", "trusted-session", "custom", "autonomous"];
+        if (!requested) {
+            text(ctx, `current: ${config.permissionMode}`);
+            for (const action of ["read", "write", "command", "network", "destructive", "billing", "publish"])
+                text(ctx, `${action}: ${permissionDecision(config.permissionMode, action)}`);
+            return 0;
+        }
+        if (!modes.includes(requested))
+            throw new Error(`Unknown permission mode: ${requested}`);
+        await saveConfig({ ...config, permissionMode: requested });
+        ctx.emit({ type: "success", message: `Permission mode set to ${requested}.` });
+        return 0;
+    } });
+define({ name: "model", summary: "View or select the product model", usage: "forge model [forge-spark|forge-anvil|forge-foundry]", interactive: true, async run(ctx) {
+        const config = await loadConfig();
+        const model = ctx.args[0];
+        const bootstrap = await getBootstrap(config.apiBaseUrl);
+        const models = Array.isArray(bootstrap.models) ? bootstrap.models : [];
+        if (!model) {
+            for (const item of models)
+                text(ctx, `${item.id === config.model ? "*" : " "} ${item.id}  ${item.name ?? ""}  context ${item.contextWindow?.toLocaleString() ?? "unknown"}`);
+            return 0;
+        }
+        if (!models.some((item) => item.id === model))
+            throw new Error(`Model is unavailable: ${model}`);
+        await saveConfig({ ...config, model });
+        ctx.emit({ type: "success", message: `Model set to ${model}.` });
+        return 0;
+    } });
+for (const name of ["usage", "credits", "plan"])
+    define({ name, summary: `Show account ${name}`, usage: `forge ${name}`, interactive: true, async run(ctx) {
+            const config = await loadConfig();
+            const data = await getBootstrap(config.apiBaseUrl);
+            ctx.emit({ type: "info", message: JSON.stringify(name === "credits" ? data.credits : name === "plan" ? data.plan : data, null, 2) });
+            return 0;
+        } });
+define({ name: "config", summary: "Show effective configuration", usage: "forge config", interactive: true, async run(ctx) { text(ctx, JSON.stringify(await loadConfigWithSources(ctx.cwd), null, 2)); return 0; } });
+define({ name: "sessions", summary: "List saved sessions", usage: "forge sessions", interactive: true, async run(ctx) {
+        const sessions = await listSessions();
+        if (!sessions.length)
+            text(ctx, "No saved sessions.");
+        for (const item of sessions)
+            text(ctx, `${item.id}  ${item.updatedAt}  ${item.title}`);
+        return 0;
+    } });
+define({ name: "new", summary: "Create a session", usage: "forge new [title]", interactive: true, async run(ctx) {
+        const session = await createSession(ctx.cwd, await loadConfig(), ctx.args.join(" ") || undefined);
+        ctx.emit({ type: "success", message: `Created session ${session.id}.` });
+        return 0;
+    } });
+define({ name: "resume", summary: "Resume a saved session", usage: "forge resume <id>", interactive: true, async run(ctx) {
+        const id = ctx.args[0];
+        if (!id)
+            throw new Error("Session id is required.");
+        const session = await loadSession(id);
+        if (!session)
+            throw new Error("Session not found.");
+        await setCurrentSession(id);
+        ctx.emit({ type: "success", message: `Resumed ${session.title}.` });
+        return 0;
+    } });
+define({ name: "fork", summary: "Fork the current session", usage: "forge fork", interactive: true, async run(ctx) {
+        const session = await getCurrentSession();
+        if (!session)
+            throw new Error("No current session.");
+        const copy = await forkSession(session);
+        ctx.emit({ type: "success", message: `Forked to ${copy.id}.` });
+        return 0;
+    } });
+define({ name: "rename", summary: "Rename the current session", usage: "forge rename <title>", interactive: true, async run(ctx) {
+        const session = await getCurrentSession();
+        if (!session)
+            throw new Error("No current session.");
+        const title = ctx.args.join(" ").trim();
+        if (!title)
+            throw new Error("Title is required.");
+        await saveSession({ ...session, title });
+        ctx.emit({ type: "success", message: `Renamed to ${title}.` });
+        return 0;
+    } });
+define({ name: "clear", summary: "Clear current session messages", usage: "forge clear", interactive: true, async run(ctx) {
+        const session = await getCurrentSession();
+        if (!session)
+            throw new Error("No current session.");
+        await clearSession(session);
+        ctx.emit({ type: "success", message: "Session cleared." });
+        return 0;
+    } });
+define({ name: "compact", summary: "Compact the current session", usage: "forge compact", interactive: true, async run(ctx) {
+        const session = await getCurrentSession();
+        if (!session)
+            throw new Error("No current session.");
+        const before = session.messages.length;
+        const next = await compactSession(session);
+        ctx.emit({ type: "success", message: before === next.messages.length ? "Session is already compact." : `Compacted ${before} messages to ${next.messages.length}; full transcript archived locally.` });
+        return 0;
+    } });
+define({ name: "prune", summary: "Delete old sessions after confirmation", usage: "forge prune [--days 30]", interactive: true, async run(ctx) {
+        const days = Number(ctx.flags.get("days") ?? 30);
+        if (!Number.isInteger(days) || days < 1)
+            throw new Error("--days must be a positive integer.");
+        const current = await getCurrentSession();
+        const candidates = (await sessionsOlderThan(days)).filter((item) => item.id !== current?.id);
+        if (!candidates.length) {
+            text(ctx, `No inactive sessions older than ${days} days.`);
+            return 0;
+        }
+        const approved = await ctx.requestApproval?.(`Delete ${candidates.length} inactive session files older than ${days} days? This is irreversible.`, false);
+        if (!approved) {
+            ctx.emit({ type: "warning", message: "Prune cancelled." });
+            return 1;
+        }
+        for (const item of candidates)
+            await deleteSession(item.id);
+        await audit("sessions.prune", { count: candidates.length, days });
+        ctx.emit({ type: "success", message: `Deleted ${candidates.length} sessions.` });
+        return 0;
+    } });
+define({ name: "init", summary: "Create a local .forge project marker", usage: "forge init", interactive: true, async run(ctx) {
+        const trust = await findTrustRecord(ctx.cwd);
+        if (!trust.record)
+            throw new Error("Trust the workspace before initializing Forge.");
+        const root = trust.current.repositoryRoot ?? trust.current.path;
+        const target = join(root, ".forge", "config.json");
+        if (relative(root, target).startsWith(".."))
+            throw new Error("Forge config path escapes the workspace.");
+        const approved = await ctx.requestApproval?.(`Create ${target}? This reversible write enables project-local Forge configuration.`, false);
+        if (!approved) {
+            ctx.emit({ type: "warning", message: "Initialization cancelled." });
+            return 1;
+        }
+        await writePrivateJson(target, { version: 1, taskMode: "plan", permissionMode: "ask" });
+        await audit("workspace.init", { target });
+        ctx.emit({ type: "success", message: `Created ${target}.` });
+        return 0;
+    } });
+define({ name: "diff", summary: "Show local changes made by Forge", usage: "forge diff", interactive: true, async run(ctx) {
+        ctx.emit({ type: "info", message: "No Forge-applied local patch exists in this session. Phase 2 remote runs cannot mutate files." });
+        return 0;
+    } });
+for (const kind of ["memory", "skills", "agents", "plugins", "mcp", "hooks"])
+    define({ name: kind, summary: `Inspect loaded ${kind}`, usage: `forge ${kind}`, interactive: true, async run(ctx) {
+            const singular = kind === "skills" ? "skill" : kind === "agents" ? "agent" : kind === "plugins" ? "plugin" : kind === "hooks" ? "hook" : kind;
+            const items = (await inspectExtensions(ctx.cwd)).filter((item) => item.kind === singular);
+            if (!items.length) {
+                text(ctx, `No trusted ${kind} detected.`);
+                return 0;
+            }
+            for (const item of items)
+                text(ctx, `${item.name}  source=${item.source}  ${item.path}`);
+            return 0;
+        } });
+define({ name: "over-limit", summary: "Inspect paid over-limit controls", usage: "forge over-limit", interactive: true, async run(ctx) {
+        const config = await loadConfig();
+        const billing = await getBillingStatus(config.apiBaseUrl);
+        text(ctx, JSON.stringify(billing, null, 2));
+        ctx.emit({ type: "warning", message: "Not configured. This CLI cannot enable paid usage, change limits, or purchase credits." });
+        return 0;
+    } });
+define({ name: "completion", summary: "Generate shell completion", usage: "forge completion [bash|zsh|fish]", interactive: true, async run(ctx) {
+        const shell = ctx.args[0] ?? "zsh";
+        const names = [...new Set(registry.values())].map((command) => command.name).sort().join(" ");
+        if (shell === "bash")
+            process.stdout.write(`complete -W "${names}" forge\n`);
+        else if (shell === "zsh")
+            process.stdout.write(`#compdef forge\n_arguments '1:command:(${names})'\n`);
+        else if (shell === "fish")
+            process.stdout.write(names.split(" ").map((name) => `complete -c forge -f -a '${name}'`).join("\n") + "\n");
+        else
+            throw new Error("Shell must be bash, zsh, or fish.");
+        return 0;
+    } });
+for (const modeName of ["plan", "execute", "review"])
+    define({ name: modeName === "review" ? "review" : modeName, summary: `${modeName} a task`, usage: `forge ${modeName} <task>`, interactive: true, async run(ctx) {
+            const config = await loadConfig();
+            let session = await getCurrentSession();
+            let prompt = ctx.args.join(" ").trim();
+            if (!prompt && modeName === "execute" && session?.plan?.status === "approved")
+                prompt = `Execute this approved plan:\n${session.plan.steps.map((step, index) => `${index + 1}. ${step}`).join("\n")}`;
+            if (!prompt)
+                throw new Error(modeName === "execute" ? "Task text or an approved plan is required." : "Task text is required.");
+            const trust = await findTrustRecord(ctx.cwd);
+            if (!trust.record && config.permissionMode !== "read-only")
+                throw new Error("Workspace is not trusted. Run `forge trust --once`, `forge trust --always`, or `forge trust --read-only`.");
+            if (!session)
+                session = await createSession(ctx.cwd, config, prompt.slice(0, 72));
+            const project = await collectProjectManifest(ctx.cwd);
+            await saveSession({ ...session, state: modeName === "plan" ? "planning" : "executing" });
+            let response;
+            try {
+                response = await runRemote({ apiBaseUrl: config.apiBaseUrl, prompt, model: config.model, mode: modeName, sessionId: session.id, project, signal: ctx.signal, emit: ctx.emit });
+            }
+            catch (error) {
+                await saveSession({ ...session, state: ctx.signal.aborted ? "cancelled" : "failed" });
+                throw error;
+            }
+            const messages = [...session.messages,
+                { role: "user", content: prompt, at: new Date().toISOString() },
+                { role: "assistant", content: response.text, at: new Date().toISOString() },
+            ];
+            const draftPlan = modeName === "plan" ? {
+                task: prompt,
+                steps: response.text.split("\n").map((line) => line.replace(/^\s*(?:\d+[.)]|[-*])\s*/, "").trim()).filter(Boolean),
+                status: "draft",
+                createdAt: new Date().toISOString(),
+            } : session.plan;
+            const baseNext = response.usage
+                ? { ...session, state: "completed", messages, usage: mergeUsage(session.usage, response.usage) }
+                : { ...session, state: "completed", messages };
+            const next = draftPlan ? { ...baseNext, plan: draftPlan } : baseNext;
+            await saveSession(next);
+            const warning = contextWarning(next.usage);
+            if (warning)
+                ctx.emit({ type: "warning", message: warning });
+            process.stdout.write(ctx.outputMode === "human" ? "\n" : "");
+            return 0;
+        } });
+define({ name: "run", aliases: ["ask"], summary: "Run a task using the configured mode", usage: "forge run <task>", interactive: true, async run(ctx) {
+        const config = await loadConfig();
+        const command = registry.get(config.taskMode === "read-only" ? "review" : config.taskMode);
+        if (!command)
+            throw new Error(`Unsupported task mode: ${config.taskMode}`);
+        return command.run(ctx);
+    } });
+define({ name: "view-plan", summary: "View the current task plan", usage: "forge view-plan", interactive: true, async run(ctx) {
+        const session = await getCurrentSession();
+        if (!session?.plan)
+            throw new Error("No plan in the current session.");
+        text(ctx, `${session.plan.task} [${session.plan.status}]`);
+        session.plan.steps.forEach((step, index) => text(ctx, `${index + 1}. ${step}`));
+        return 0;
+    } });
+define({ name: "approve-plan", summary: "Approve the current task plan", usage: "forge approve-plan", interactive: true, async run(ctx) {
+        const session = await getCurrentSession();
+        if (!session?.plan)
+            throw new Error("No plan in the current session.");
+        await saveSession({ ...session, state: "waiting-for-approval" });
+        const approved = await ctx.requestApproval?.("Approve this plan for execution?", false);
+        if (!approved) {
+            await saveSession({ ...session, state: "completed" });
+            ctx.emit({ type: "warning", message: "Plan was not approved." });
+            return 1;
+        }
+        await saveSession({ ...session, state: "completed", plan: { ...session.plan, status: "approved", approvedAt: new Date().toISOString() } });
+        await audit("plan.approve", { sessionId: session.id });
+        ctx.emit({ type: "success", message: "Plan approved. Run `forge execute`." });
+        return 0;
+    } });
+define({ name: "edit-plan", summary: "Replace the current plan steps", usage: "forge edit-plan <step; step>", interactive: true, async run(ctx) {
+        const session = await getCurrentSession();
+        if (!session?.plan)
+            throw new Error("No plan in the current session.");
+        const steps = ctx.args.join(" ").split(";").map((step) => step.trim()).filter(Boolean);
+        if (!steps.length)
+            throw new Error("Provide semicolon-separated plan steps.");
+        await saveSession({ ...session, plan: { ...session.plan, steps, status: "draft" } });
+        ctx.emit({ type: "success", message: "Plan updated and returned to draft." });
+        return 0;
+    } });
+for (const [name, summary] of [
+    ["cancel", "Cancel the active run"],
+])
+    define({ name, summary, usage: `forge ${name}`, interactive: true, async run(ctx) {
+            ctx.emit({ type: "warning", message: "No task is active at the prompt. Press Ctrl-C while a task is streaming to cancel it." });
+            return 2;
+        } });
+define({ name: "exit", aliases: ["quit"], summary: "Exit interactive mode", usage: "/exit", interactive: true, async run() { return 99; } });
+export function resolveCommand(name) { return registry.get(name) ?? null; }
+export function allCommands() { return [...new Set(registry.values())]; }
+//# sourceMappingURL=commands.js.map