@getforgeai/cli 0.1.0-beta.1

package/dist/commands/disconnect.d.ts

@@ -0,0 +1,5 @@
+export declare function disconnectAction(options: {
+    server?: string;
+    org?: string;
+}): Promise<void>;
+//# sourceMappingURL=disconnect.d.ts.map

package/dist/commands/disconnect.js

@@ -0,0 +1,126 @@
+import chalk from "chalk";
+import { getConfig, getServerUrl } from "../config/config-manager.js";
+import { loadToken } from "../config/token-manager.js";
+import { createRestClient } from "../lib/rest-client.js";
+import { isDaemonRunning } from "../lib/daemon.js";
+import { sendIpcCommand, DaemonNotRunningError } from "../lib/ipc-client.js";
+export async function disconnectAction(options) {
+    // Check if daemon is running — if so, delegate via IPC
+    const daemonPid = isDaemonRunning();
+    if (daemonPid) {
+        return disconnectViaDaemon(options);
+    }
+    // No daemon running — fallback to REST-only behavior
+    return disconnectViaRest(options);
+}
+/**
+ * Print disconnect response orgs or generic message.
+ */
+function printDisconnectResponse(response) {
+    if ("orgs" in response && response.orgs) {
+        for (const org of response.orgs) {
+            console.log(chalk.green(`Disconnected from "${org.slug}" (daemon stays alive)`));
+        }
+    }
+    else {
+        console.log(chalk.green("Disconnected (daemon stays alive)"));
+    }
+    console.log(chalk.cyan("Run `forge reconnect` to reconnect."));
+}
+/**
+ * Disconnect via IPC when daemon is running (AC #8).
+ */
+async function disconnectViaDaemon(options) {
+    try {
+        const response = await sendIpcCommand({
+            cmd: "disconnect",
+            org: options.org,
+        });
+        if (response.ok) {
+            printDisconnectResponse(response);
+        }
+        else {
+            console.error(chalk.red(response.error));
+        }
+    }
+    catch (error) {
+        if (error instanceof DaemonNotRunningError) {
+            // Race condition: daemon stopped between check and IPC call
+            console.log(chalk.yellow("Daemon stopped. No active connections to disconnect."));
+        }
+        else {
+            console.error(chalk.red(`Disconnect failed: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+}
+/**
+ * Resolve target organizations for disconnection.
+ */
+function resolveTargetOrgs(config, orgFlag) {
+    if (config.linkedOrgs && config.linkedOrgs.length > 0) {
+        if (orgFlag) {
+            // --org flag: disconnect from specific org only
+            const match = config.linkedOrgs.find((o) => o.orgSlug === orgFlag);
+            if (!match) {
+                console.error(chalk.red(`Organization "${orgFlag}" not found in linked orgs. Available: ${config.linkedOrgs.map((o) => o.orgSlug).join(", ")}`));
+                return null;
+            }
+            return [match];
+        }
+        // No flag: disconnect from ALL linked orgs
+        return config.linkedOrgs;
+    }
+    if (config.defaultOrgId) {
+        return [
+            {
+                orgId: config.defaultOrgId,
+                orgSlug: config.defaultOrg ?? "default",
+            },
+        ];
+    }
+    return null;
+}
+/**
+ * REST-only disconnect fallback when no daemon is running (AC #9).
+ * Preserves the original behavior from story 4-0c.
+ */
+async function disconnectViaRest(options) {
+    const token = loadToken();
+    if (!token) {
+        console.error(chalk.red("Not authenticated. Run `forge auth login` first."));
+        return;
+    }
+    const config = getConfig();
+    const serverUrl = options.server ?? getServerUrl();
+    if (!config.cliId) {
+        console.error(chalk.red("No CLI ID found. Run `forge connect` first to register this CLI."));
+        return;
+    }
+    // Determine which orgs to disconnect from
+    const targetOrgs = resolveTargetOrgs(config, options.org);
+    if (!targetOrgs) {
+        console.error(chalk.red("No organization configured. Run `forge auth login` to select one."));
+        return;
+    }
+    let successCount = 0;
+    let failCount = 0;
+    for (const org of targetOrgs) {
+        const restClient = createRestClient(serverUrl, token, org.orgId);
+        try {
+            await restClient.disconnectCli({ cliId: config.cliId });
+            console.log(chalk.green(`Disconnected from "${org.orgSlug}" (CLI remains registered)`));
+            successCount++;
+        }
+        catch (error) {
+            console.error(chalk.red(`Failed to disconnect from "${org.orgSlug}": ${error instanceof Error ? error.message : String(error)}`));
+            failCount++;
+        }
+    }
+    if (targetOrgs.length > 1) {
+        console.log(chalk.cyan(`\nDisconnect summary: ${successCount} succeeded, ${failCount} failed`));
+    }
+    if (successCount > 0) {
+        console.log(chalk.cyan("Run `forge connect` to reconnect."));
+    }
+}
+//# sourceMappingURL=disconnect.js.map

package/dist/commands/journal-clear.d.ts

@@ -0,0 +1,2 @@
+export declare function journalClearAction(projectId?: string): void;
+//# sourceMappingURL=journal-clear.d.ts.map

package/dist/commands/journal-clear.js

@@ -0,0 +1,16 @@
+import chalk from "chalk";
+import { EventJournal } from "../lib/event-journal.js";
+export function journalClearAction(projectId = "default") {
+    const id = projectId;
+    const journal = new EventJournal(id);
+    const cursor = journal.getCursor();
+    if (!cursor) {
+        console.log(chalk.gray(`No journal entries to clear for project "${id}"`));
+        return;
+    }
+    const count = journal.readAll().length;
+    console.log(chalk.yellow(`Warning: clearing ${count} journal entries (events not yet synced to Cloud will be lost)`));
+    journal.clear(cursor);
+    console.log(chalk.green(`Cleared ${count} journal entries for project "${id}"`));
+}
+//# sourceMappingURL=journal-clear.js.map

package/dist/commands/journal-list.d.ts

@@ -0,0 +1,2 @@
+export declare function journalListAction(projectId?: string): void;
+//# sourceMappingURL=journal-list.d.ts.map

package/dist/commands/journal-list.js

@@ -0,0 +1,20 @@
+import chalk from "chalk";
+import { EventJournal } from "../lib/event-journal.js";
+export function journalListAction(projectId = "default") {
+    // Default to orgId-scoped journal when no projectId specified (matches connect.ts)
+    const id = projectId;
+    const journal = new EventJournal(id);
+    const entries = journal.readAll();
+    if (entries.length === 0) {
+        console.log(chalk.gray(`No journal entries for project "${id}"`));
+        return;
+    }
+    const pending = entries.filter((e) => !e.synced).length;
+    const lastEntry = entries.at(-1);
+    console.log(chalk.bold(`Journal: ${id}`));
+    console.log(`  Total events:   ${entries.length}`);
+    console.log(`  Pending sync:   ${pending}`);
+    console.log(`  Last event:     ${lastEntry.timestamp}`);
+    console.log(`  Last event type: ${lastEntry.type}`);
+}
+//# sourceMappingURL=journal-list.js.map

package/dist/commands/journal-status.d.ts

@@ -0,0 +1,2 @@
+export declare function journalStatusAction(): void;
+//# sourceMappingURL=journal-status.d.ts.map

package/dist/commands/journal-status.js

@@ -0,0 +1,18 @@
+import chalk from "chalk";
+import { getConfig } from "../config/config-manager.js";
+import { EventJournal } from "../lib/event-journal.js";
+export function journalStatusAction() {
+    const config = getConfig();
+    // Use orgId-scoped journal (matches connect.ts behavior)
+    const journal = new EventJournal(config.defaultOrgId ?? "default");
+    const pendingCount = journal.pendingCount();
+    const cursor = journal.getCursor();
+    const lastTimestamp = journal.lastEventTimestamp();
+    console.log(chalk.bold("Sync Status"));
+    console.log(`  Last sync:       ${config.lastSyncTimestamp ?? chalk.gray("never")}`);
+    console.log(`  Sync cursor:     ${config.lastSyncCursor ?? chalk.gray("none")}`);
+    console.log(`  Pending events:  ${pendingCount}`);
+    console.log(`  Journal cursor:  ${cursor || chalk.gray("empty")}`);
+    console.log(`  Last event at:   ${lastTimestamp ?? chalk.gray("no events")}`);
+}
+//# sourceMappingURL=journal-status.js.map

package/dist/commands/mcp-serve.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Handler for `forge mcp` command.
+ * Creates an MCP server with stdio transport, bridging the agent to Cloud.
+ * Each invocation is per-task — spawned by the agent process via MCP config.
+ */
+export declare function mcpServeAction(options: {
+    taskId: string;
+    projectId: string;
+    orgId: string;
+    workflowId?: string;
+    stepId?: string;
+}): Promise<void>;
+//# sourceMappingURL=mcp-serve.d.ts.map

package/dist/commands/mcp-serve.js

@@ -0,0 +1,74 @@
+import { getServerUrl } from "../config/config-manager.js";
+import { loadToken } from "../config/token-manager.js";
+import { createRestClient } from "../lib/rest-client.js";
+import { createSocketClient } from "../lib/socket-client.js";
+import { startMcpServer } from "../mcp/mcp-server.js";
+/**
+ * Handler for `forge mcp` command.
+ * Creates an MCP server with stdio transport, bridging the agent to Cloud.
+ * Each invocation is per-task — spawned by the agent process via MCP config.
+ */
+export async function mcpServeAction(options) {
+    const { taskId, projectId, orgId, workflowId, stepId } = options;
+    let isShuttingDown = false;
+    // Global error handlers — log to stderr so failures are diagnosable.
+    // Without these, unhandled errors crash silently and the agent sees no MCP tools.
+    process.on("uncaughtException", (err) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        console.error(`[mcp] Uncaught exception: ${err.message}`);
+        console.error(err.stack);
+        process.exit(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        console.error(`[mcp] Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
+        if (reason instanceof Error && reason.stack)
+            console.error(reason.stack);
+        process.exit(1);
+    });
+    const token = loadToken();
+    if (!token) {
+        console.error("[mcp] Not authenticated. Cannot start MCP bridge.");
+        process.exit(1);
+    }
+    const serverUrl = getServerUrl();
+    const restClient = createRestClient(serverUrl, token, orgId);
+    const socketClient = createSocketClient(serverUrl, token, orgId);
+    const shutdown = () => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        socketClient.disconnect();
+        process.exit(0);
+    };
+    // Handle stdin close (agent disconnected) → clean shutdown
+    process.stdin.on("end", shutdown);
+    try {
+        await startMcpServer({
+            taskId,
+            projectId,
+            orgId,
+            restClient,
+            socketClient,
+            currentTask: null,
+            projectRoot: null,
+            workflowId,
+            stepId,
+        }, process.stdin, process.stdout);
+    }
+    catch (err) {
+        console.error(`[mcp] Failed to start MCP server: ${err instanceof Error ? err.message : String(err)}`);
+        if (err instanceof Error && err.stack)
+            console.error(err.stack);
+        socketClient.disconnect();
+        process.exit(1);
+    }
+    // Register signal handlers only after server started successfully
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+}
+//# sourceMappingURL=mcp-serve.js.map

package/dist/commands/org-list.d.ts

@@ -0,0 +1,4 @@
+export declare function orgListAction(options: {
+    server?: string;
+}): Promise<void>;
+//# sourceMappingURL=org-list.d.ts.map

package/dist/commands/org-list.js

@@ -0,0 +1,56 @@
+import chalk from "chalk";
+import { getConfig, getServerUrl } from "../config/config-manager.js";
+import { loadToken } from "../config/token-manager.js";
+import { createRestClient } from "../lib/rest-client.js";
+async function getOrgConnectionStatus(serverUrl, token, orgId, cliId) {
+    try {
+        const restClient = createRestClient(serverUrl, token, orgId);
+        const state = await restClient.getProjectState();
+        const myCli = state.clis.find((c) => c.cliId === cliId);
+        if (!myCli)
+            return "not registered";
+        return myCli.status === "CONNECTED" ? "connected" : "disconnected";
+    }
+    catch {
+        return "unreachable";
+    }
+}
+export async function orgListAction(options) {
+    const token = loadToken();
+    if (!token) {
+        console.error(chalk.red("Not authenticated. Run `forge auth login` first."));
+        return;
+    }
+    const config = getConfig();
+    const serverUrl = options.server ?? getServerUrl();
+    if (!config.linkedOrgs || config.linkedOrgs.length === 0) {
+        console.log(chalk.yellow("No linked organizations. Run `forge auth login` to link."));
+        return;
+    }
+    console.log(chalk.bold(`\nLinked Organizations (${config.linkedOrgs.length}):\n`));
+    // Parallelize status queries for all orgs
+    const statuses = config.cliId
+        ? await Promise.all(config.linkedOrgs.map((org) => getOrgConnectionStatus(serverUrl, token, org.orgId, config.cliId)))
+        : config.linkedOrgs.map(() => "unknown");
+    for (const [i, org] of config.linkedOrgs.entries()) {
+        const status = statuses[i] ?? "unknown";
+        const isDefault = org.orgId === config.defaultOrgId;
+        const marker = isDefault ? chalk.green(" (default)") : "";
+        let statusColor;
+        if (status === "connected") {
+            statusColor = chalk.green;
+        }
+        else if (status === "unreachable") {
+            statusColor = chalk.red;
+        }
+        else {
+            statusColor = chalk.yellow;
+        }
+        const displayName = org.orgName ?? org.orgSlug;
+        console.log(`  ${chalk.bold(displayName)}${marker}`);
+        console.log(`    Slug: ${org.orgSlug}`);
+        console.log(`    Status: ${statusColor(status)}`);
+        console.log();
+    }
+}
+//# sourceMappingURL=org-list.js.map

package/dist/commands/org-unlink.d.ts

@@ -0,0 +1,4 @@
+export declare function orgUnlinkAction(slug: string, options: {
+    server?: string;
+}): Promise<void>;
+//# sourceMappingURL=org-unlink.d.ts.map

package/dist/commands/org-unlink.js

@@ -0,0 +1,63 @@
+import { createInterface } from "node:readline";
+import chalk from "chalk";
+import { getConfig, getServerUrl, removeLinkedOrg, } from "../config/config-manager.js";
+import { loadToken } from "../config/token-manager.js";
+import { createRestClient } from "../lib/rest-client.js";
+function confirm(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y");
+        });
+    });
+}
+export async function orgUnlinkAction(slug, options) {
+    const token = loadToken();
+    if (!token) {
+        console.error(chalk.red("Not authenticated. Run `forge auth login` first."));
+        return;
+    }
+    const config = getConfig();
+    const serverUrl = options.server ?? getServerUrl();
+    if (!config.linkedOrgs || config.linkedOrgs.length === 0) {
+        console.error(chalk.red("No linked organizations. Run `forge auth login` first."));
+        return;
+    }
+    const match = config.linkedOrgs.find((o) => o.orgSlug === slug);
+    if (!match) {
+        console.error(chalk.red(`Organization "${slug}" not found in linked orgs. Available: ${config.linkedOrgs.map((o) => o.orgSlug).join(", ")}`));
+        return;
+    }
+    if (!config.cliId) {
+        console.error(chalk.red("No CLI ID found. Run `forge connect` first to register this CLI."));
+        return;
+    }
+    // Warn if this is the last linked org
+    const isLastOrg = config.linkedOrgs.length === 1;
+    if (isLastOrg) {
+        console.warn(chalk.yellow("This is your last linked org. Run `forge auth logout` to fully disconnect."));
+    }
+    const confirmed = await confirm(`Are you sure you want to unlink CLI from "${slug}"? This will remove the CLI device registration. (y/N) `);
+    if (!confirmed) {
+        console.log("Cancelled.");
+        return;
+    }
+    const restClient = createRestClient(serverUrl, token, match.orgId);
+    // Disconnect WebSocket first (if connected), then unlink
+    try {
+        await restClient.disconnectCli({ cliId: config.cliId });
+    }
+    catch {
+        // Ignore disconnect errors — CLI may not be connected
+    }
+    try {
+        await restClient.unlinkCli({ cliId: config.cliId });
+        removeLinkedOrg(slug);
+        console.log(chalk.green(`CLI unlinked from "${slug}"`));
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to unlink from "${slug}": ${error instanceof Error ? error.message : String(error)}`));
+    }
+}
+//# sourceMappingURL=org-unlink.js.map

package/dist/commands/reconnect.d.ts

@@ -0,0 +1,4 @@
+export declare function reconnectAction(options: {
+    org?: string;
+}): Promise<void>;
+//# sourceMappingURL=reconnect.d.ts.map

package/dist/commands/reconnect.js

@@ -0,0 +1,46 @@
+import chalk from "chalk";
+import { sendIpcCommand, DaemonNotRunningError } from "../lib/ipc-client.js";
+/**
+ * Print reconnect status message.
+ */
+function printReconnectStatus(response) {
+    if ("status" in response) {
+        if (response.status === "already_connected") {
+            console.log(chalk.green("Already connected."));
+        }
+        else {
+            console.log(chalk.green("Reconnecting..."));
+        }
+    }
+    if ("orgs" in response && response.orgs) {
+        for (const org of response.orgs) {
+            const status = org.connected
+                ? chalk.green("connected")
+                : chalk.yellow("reconnecting");
+            console.log(`  ${org.slug}: ${status}`);
+        }
+    }
+}
+export async function reconnectAction(options) {
+    try {
+        const response = await sendIpcCommand({
+            cmd: "reconnect",
+            org: options.org,
+        });
+        if (response.ok) {
+            printReconnectStatus(response);
+        }
+        else {
+            console.error(chalk.red(response.error));
+        }
+    }
+    catch (error) {
+        if (error instanceof DaemonNotRunningError) {
+            console.error(chalk.red("No daemon running. Run `forge connect` first."));
+        }
+        else {
+            console.error(chalk.red(`Reconnect failed: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+}
+//# sourceMappingURL=reconnect.js.map

package/dist/commands/release-open.d.ts

@@ -0,0 +1,2 @@
+export declare function releaseOpenAction(releaseId: string): Promise<void>;
+//# sourceMappingURL=release-open.d.ts.map

package/dist/commands/release-open.js

@@ -0,0 +1,43 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import chalk from "chalk";
+import { getConfig, getServerUrl } from "../config/config-manager.js";
+import { loadToken } from "../config/token-manager.js";
+import { createRestClient } from "../lib/rest-client.js";
+import { cloneAndCheckout } from "../lib/clone-and-checkout.js";
+import { openDirectory } from "../lib/open-directory.js";
+export async function releaseOpenAction(releaseId) {
+    const token = loadToken();
+    if (!token) {
+        console.error(chalk.red('Not authenticated. Run "forge auth login" first.'));
+        process.exitCode = 1;
+        return;
+    }
+    const config = getConfig();
+    const orgId = config.defaultOrgId;
+    if (!orgId) {
+        console.error(chalk.red('No organization selected. Run "forge connect" first.'));
+        process.exitCode = 1;
+        return;
+    }
+    const serverUrl = getServerUrl();
+    const client = createRestClient(serverUrl, token, orgId);
+    const release = await client.getRelease(releaseId);
+    const branch = release.releaseBranch ?? release.targetBranch;
+    if (!branch) {
+        console.error(chalk.red("Release has no branch assigned yet."));
+        process.exitCode = 1;
+        return;
+    }
+    if (!release.project.repoUrl) {
+        console.error(chalk.red("Project has no repository URL configured."));
+        process.exitCode = 1;
+        return;
+    }
+    const branchSlug = branch.replaceAll("/", "--");
+    const targetDir = join(homedir(), ".forgeai", "open", release.project.slug, branchSlug);
+    await cloneAndCheckout(release.project.repoUrl, branch, targetDir);
+    openDirectory(targetDir, config.opener ?? "terminal");
+    console.log(chalk.green(`Opened release "${release.version}" at ${targetDir}`));
+}
+//# sourceMappingURL=release-open.js.map

package/dist/commands/session-respond.d.ts

@@ -0,0 +1,2 @@
+export declare function sessionRespondAction(taskId: string, response: string): Promise<void>;
+//# sourceMappingURL=session-respond.d.ts.map

package/dist/commands/session-respond.js

@@ -0,0 +1,29 @@
+import chalk from "chalk";
+import { getConfig, getServerUrl } from "../config/config-manager.js";
+import { loadToken } from "../config/token-manager.js";
+import { createRestClient } from "../lib/rest-client.js";
+export async function sessionRespondAction(taskId, response) {
+    const token = loadToken();
+    if (!token) {
+        console.error(chalk.red("Not authenticated. Run `forge auth login` first."));
+        process.exitCode = 1;
+        return;
+    }
+    const config = getConfig();
+    const serverUrl = getServerUrl();
+    if (!config.defaultOrgId) {
+        console.error(chalk.red("No organization configured. Run `forge auth login` to select one."));
+        process.exitCode = 1;
+        return;
+    }
+    const restClient = createRestClient(serverUrl, token, config.defaultOrgId);
+    try {
+        await restClient.respondToAgent(taskId, response);
+        console.log(chalk.green("Response sent — agent will resume shortly."));
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to send response: ${error instanceof Error ? error.message : String(error)}`));
+        process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=session-respond.js.map

package/dist/commands/task-open.d.ts

@@ -0,0 +1,2 @@
+export declare function taskOpenAction(taskId: string): Promise<void>;
+//# sourceMappingURL=task-open.d.ts.map

package/dist/commands/task-open.js

@@ -0,0 +1,42 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import chalk from "chalk";
+import { getConfig, getServerUrl } from "../config/config-manager.js";
+import { loadToken } from "../config/token-manager.js";
+import { createRestClient } from "../lib/rest-client.js";
+import { cloneAndCheckout } from "../lib/clone-and-checkout.js";
+import { openDirectory } from "../lib/open-directory.js";
+export async function taskOpenAction(taskId) {
+    const token = loadToken();
+    if (!token) {
+        console.error(chalk.red('Not authenticated. Run "forge auth login" first.'));
+        process.exitCode = 1;
+        return;
+    }
+    const config = getConfig();
+    const orgId = config.defaultOrgId;
+    if (!orgId) {
+        console.error(chalk.red('No organization selected. Run "forge connect" first.'));
+        process.exitCode = 1;
+        return;
+    }
+    const serverUrl = getServerUrl();
+    const client = createRestClient(serverUrl, token, orgId);
+    const task = await client.getTask(taskId);
+    if (!task.taskBranch) {
+        console.error(chalk.red("Task has no branch assigned yet."));
+        process.exitCode = 1;
+        return;
+    }
+    if (!task.project?.repoUrl) {
+        console.error(chalk.red("Project has no repository URL configured."));
+        process.exitCode = 1;
+        return;
+    }
+    const branchSlug = task.taskBranch.replaceAll("/", "--");
+    const targetDir = join(homedir(), ".forgeai", "open", task.project.slug, branchSlug);
+    await cloneAndCheckout(task.project.repoUrl, task.taskBranch, targetDir);
+    openDirectory(targetDir, config.opener ?? "terminal");
+    console.log(chalk.green(`Opened task "${task.title}" at ${targetDir}`));
+}
+//# sourceMappingURL=task-open.js.map

package/dist/commands/vm.d.ts

@@ -0,0 +1,21 @@
+/**
+ * forge vm init — Check Docker availability and pull/build agent image.
+ */
+export declare function vmInitAction(): Promise<void>;
+/**
+ * forge vm status — List active Docker container sessions.
+ */
+export declare function vmStatusAction(): Promise<void>;
+/**
+ * forge vm cleanup — Remove stopped session containers.
+ */
+export declare function vmCleanupAction(): Promise<void>;
+/**
+ * forge vm stop-all — Stop all containers and shut down.
+ */
+export declare function vmStopAllAction(): Promise<void>;
+/**
+ * forge auth setup-claude — Obtain a long-lived Claude Code OAuth token.
+ */
+export declare function setupClaudeTokenAction(): Promise<void>;
+//# sourceMappingURL=vm.d.ts.map