@getforgeai/cli 0.1.0-beta.1

package/dist/commands/vm.js

@@ -0,0 +1,122 @@
+import chalk from "chalk";
+import ora from "ora";
+import { initVmManager, getVmManager, } from "../vm/vm-manager-facade.js";
+import { ensureImage } from "../vm/image-manager.js";
+import { isDockerAvailable } from "../vm/docker-executor.js";
+/**
+ * forge vm init — Check Docker availability and pull/build agent image.
+ */
+export async function vmInitAction() {
+    const spinner = ora("Checking Docker availability...").start();
+    try {
+        const available = await isDockerAvailable();
+        if (!available) {
+            spinner.fail("Docker not available");
+            console.log(chalk.yellow("\nDocker Desktop is required. Install it from https://docker.com/products/docker-desktop"));
+            console.log(chalk.yellow("Ensure the Docker daemon is running."));
+            process.exit(1);
+        }
+        spinner.text = "Docker available. Checking agent image...";
+        const image = await ensureImage();
+        spinner.succeed(`Agent environment ready — image: ${image}`);
+    }
+    catch (err) {
+        spinner.fail(`Init failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}
+/**
+ * forge vm status — List active Docker container sessions.
+ */
+export async function vmStatusAction() {
+    try {
+        let sm;
+        try {
+            sm = getVmManager();
+        }
+        catch {
+            sm = await initVmManager();
+        }
+        const sessions = sm.getAllSessions();
+        if (sessions.length === 0) {
+            console.log(chalk.dim("No active sessions"));
+            console.log(chalk.dim(`Docker ready: ${sm.isVmRunning() ? "yes" : "no"}`));
+            return;
+        }
+        console.log(chalk.bold(`\nActive sessions (${sessions.length}):\n`));
+        for (const session of sessions) {
+            const color = session.status === "RUNNING"
+                ? chalk.green
+                : session.status === "SPAWNING"
+                    ? chalk.yellow
+                    : chalk.dim;
+            console.log(`  ${color("●")} ${session.id}  task: ${session.taskId}  status: ${color(session.status)}  container: ${session.containerId?.slice(0, 12) ?? "N/A"}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    }
+}
+/**
+ * forge vm cleanup — Remove stopped session containers.
+ */
+export async function vmCleanupAction() {
+    const spinner = ora("Cleaning up...").start();
+    try {
+        let sm;
+        try {
+            sm = getVmManager();
+        }
+        catch {
+            sm = await initVmManager();
+        }
+        const sessions = sm.getAllSessions();
+        let cleaned = 0;
+        for (const session of sessions) {
+            if (session.status === "STOPPED") {
+                await sm.destroySession(session.taskId);
+                cleaned++;
+            }
+        }
+        spinner.succeed(`Cleaned up ${cleaned} session(s)`);
+    }
+    catch (err) {
+        spinner.fail(`Cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * forge vm stop-all — Stop all containers and shut down.
+ */
+export async function vmStopAllAction() {
+    const spinner = ora("Stopping all containers...").start();
+    try {
+        let sm;
+        try {
+            sm = getVmManager();
+        }
+        catch {
+            sm = await initVmManager();
+        }
+        await sm.shutdown();
+        spinner.succeed("All containers stopped");
+    }
+    catch (err) {
+        spinner.fail(`Shutdown failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * forge auth setup-claude — Obtain a long-lived Claude Code OAuth token.
+ */
+export async function setupClaudeTokenAction() {
+    try {
+        const { runClaudeSetupToken } = await import("../vm/claude-token-manager.js");
+        await runClaudeSetupToken();
+        console.log(chalk.green("\nClaude OAuth token stored. Agents can now authenticate."));
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=vm.js.map

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

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

package/dist/commands/workflow-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 workflowOpenAction(workflowId) {
+    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 workflow = await client.getWorkflow(workflowId);
+    const branch = workflow.baseBranch ?? workflow.sourceBranch;
+    if (!branch) {
+        console.error(chalk.red("Workflow has no branch assigned yet."));
+        process.exitCode = 1;
+        return;
+    }
+    if (!workflow.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", workflow.project.slug, branchSlug);
+    await cloneAndCheckout(workflow.project.repoUrl, branch, targetDir);
+    openDirectory(targetDir, config.opener ?? "terminal");
+    console.log(chalk.green(`Opened workflow "${workflow.name}" at ${targetDir}`));
+}
+//# sourceMappingURL=workflow-open.js.map

package/dist/config/config-manager.d.ts

@@ -0,0 +1,31 @@
+export type Opener = "terminal" | "vscode" | "finder";
+export type CliConfig = {
+    serverUrl: string;
+    defaultOrg?: string;
+    defaultOrgId?: string;
+    linkedOrgs?: Array<{
+        orgId: string;
+        orgSlug: string;
+        orgName?: string;
+    }>;
+    cliId?: string;
+    cliName?: string;
+    agentType?: string;
+    agentSlots?: number;
+    opener?: Opener;
+    lastSyncCursor?: string;
+    lastSyncTimestamp?: string;
+    vmCpus?: number;
+    vmMemoryMB?: number;
+};
+export declare function getConfig(): CliConfig;
+export declare function setConfig(config: Partial<CliConfig>): void;
+export declare function removeLinkedOrg(orgSlug: string): void;
+/**
+ * Clear all session-specific config fields (orgs, CLI identity, sync state).
+ * Preserves machine-level settings (serverUrl, agentSlots, VM config).
+ * Called on logout to ensure a clean slate for the next login.
+ */
+export declare function clearSessionConfig(): void;
+export declare function getServerUrl(): string;
+//# sourceMappingURL=config-manager.d.ts.map

package/dist/config/config-manager.js

@@ -0,0 +1,70 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const FORGEAI_DIR = join(homedir(), ".forgeai");
+const CONFIG_FILE = join(FORGEAI_DIR, "config.json");
+const DEFAULT_SERVER_URL = "http://localhost:3000";
+function ensureDir() {
+    if (!existsSync(FORGEAI_DIR)) {
+        mkdirSync(FORGEAI_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+export function getConfig() {
+    ensureDir();
+    if (!existsSync(CONFIG_FILE)) {
+        return { serverUrl: DEFAULT_SERVER_URL };
+    }
+    try {
+        const raw = readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { serverUrl: DEFAULT_SERVER_URL };
+    }
+}
+export function setConfig(config) {
+    ensureDir();
+    const current = getConfig();
+    const merged = { ...current, ...config };
+    writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+}
+export function removeLinkedOrg(orgSlug) {
+    const config = getConfig();
+    if (!config.linkedOrgs)
+        return;
+    const filtered = config.linkedOrgs.filter((o) => o.orgSlug !== orgSlug);
+    setConfig({ linkedOrgs: filtered });
+}
+/**
+ * Clear all session-specific config fields (orgs, CLI identity, sync state).
+ * Preserves machine-level settings (serverUrl, agentSlots, VM config).
+ * Called on logout to ensure a clean slate for the next login.
+ */
+export function clearSessionConfig() {
+    ensureDir();
+    const config = getConfig();
+    const cleaned = { serverUrl: config.serverUrl };
+    if (config.agentType !== undefined) {
+        cleaned.agentType = config.agentType;
+    }
+    if (config.agentSlots !== undefined) {
+        cleaned.agentSlots = config.agentSlots;
+    }
+    if (config.vmCpus !== undefined) {
+        cleaned.vmCpus = config.vmCpus;
+    }
+    if (config.vmMemoryMB !== undefined) {
+        cleaned.vmMemoryMB = config.vmMemoryMB;
+    }
+    writeFileSync(CONFIG_FILE, JSON.stringify(cleaned, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+}
+export function getServerUrl() {
+    return getConfig().serverUrl;
+}
+//# sourceMappingURL=config-manager.js.map

package/dist/config/token-manager.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Get a stable machine hostname that doesn't change with network state.
+ * On macOS, `hostname()` returns the DNS hostname (e.g. "mac.home") which
+ * can change via DHCP. `scutil --get LocalHostName` returns the Bonjour
+ * hostname (e.g. "MacBook-Pro-de-Jeremy") which is stable.
+ */
+export declare function stableHostname(): string;
+export declare function saveToken(token: string): void;
+export declare function loadToken(): string | null;
+export declare function deleteToken(): void;
+//# sourceMappingURL=token-manager.d.ts.map

package/dist/config/token-manager.js

@@ -0,0 +1,87 @@
+import { execSync } from "node:child_process";
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync, } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir, hostname, userInfo } from "node:os";
+import { join } from "node:path";
+const AUTH_DIR = join(homedir(), ".forgeai", "auth");
+const CREDENTIALS_FILE = join(AUTH_DIR, "credentials.json");
+const ALGORITHM = "aes-256-gcm";
+const KEY_LENGTH = 32;
+const IV_LENGTH = 16;
+const SALT_LENGTH = 16;
+/**
+ * Get a stable machine hostname that doesn't change with network state.
+ * On macOS, `hostname()` returns the DNS hostname (e.g. "mac.home") which
+ * can change via DHCP. `scutil --get LocalHostName` returns the Bonjour
+ * hostname (e.g. "MacBook-Pro-de-Jeremy") which is stable.
+ */
+export function stableHostname() {
+    if (process.platform === "darwin") {
+        try {
+            return execSync("scutil --get LocalHostName", {
+                encoding: "utf-8",
+                timeout: 2000,
+            }).trim();
+        }
+        catch {
+            // Fallback if scutil is unavailable
+        }
+    }
+    return hostname().replace(/\.(home|local)$/i, "");
+}
+function deriveKey(salt) {
+    const machineId = `${stableHostname()}:${userInfo().username}`;
+    return scryptSync(machineId, salt, KEY_LENGTH);
+}
+function ensureAuthDir() {
+    if (!existsSync(AUTH_DIR)) {
+        mkdirSync(AUTH_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+export function saveToken(token) {
+    ensureAuthDir();
+    const salt = randomBytes(SALT_LENGTH);
+    const key = deriveKey(salt);
+    const iv = randomBytes(IV_LENGTH);
+    const cipher = createCipheriv(ALGORITHM, key, iv);
+    let encrypted = cipher.update(token, "utf-8", "hex");
+    encrypted += cipher.final("hex");
+    const tag = cipher.getAuthTag();
+    const credentials = {
+        iv: iv.toString("hex"),
+        data: encrypted,
+        tag: tag.toString("hex"),
+        salt: salt.toString("hex"),
+    };
+    writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+}
+export function loadToken() {
+    if (!existsSync(CREDENTIALS_FILE)) {
+        return null;
+    }
+    try {
+        const raw = readFileSync(CREDENTIALS_FILE, "utf-8");
+        const credentials = JSON.parse(raw);
+        const salt = Buffer.from(credentials.salt, "hex");
+        const key = deriveKey(salt);
+        const iv = Buffer.from(credentials.iv, "hex");
+        const tag = Buffer.from(credentials.tag, "hex");
+        const decipher = createDecipheriv(ALGORITHM, key, iv);
+        decipher.setAuthTag(tag);
+        let decrypted = decipher.update(credentials.data, "hex", "utf-8");
+        decrypted += decipher.final("utf-8");
+        return decrypted;
+    }
+    catch {
+        return null;
+    }
+}
+export function deleteToken() {
+    if (existsSync(CREDENTIALS_FILE)) {
+        unlinkSync(CREDENTIALS_FILE);
+    }
+}
+//# sourceMappingURL=token-manager.js.map

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The CLI version, read from package.json so `forge --version` can never drift
+ * from the published version (it used to be hardcoded here and silently
+ * reported a stale number). Falls back to "0.0.0-unknown" if package.json is
+ * unreadable, so version reporting never crashes the CLI.
+ */
+export declare const VERSION: string;
+export { createCliAuthClient } from "./lib/auth-client.js";
+export { getConfig, setConfig, getServerUrl } from "./config/config-manager.js";
+export { saveToken, loadToken, deleteToken } from "./config/token-manager.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,22 @@
+import { createRequire } from "node:module";
+/**
+ * The CLI version, read from package.json so `forge --version` can never drift
+ * from the published version (it used to be hardcoded here and silently
+ * reported a stale number). Falls back to "0.0.0-unknown" if package.json is
+ * unreadable, so version reporting never crashes the CLI.
+ */
+export const VERSION = (() => {
+    try {
+        const require = createRequire(import.meta.url);
+        // From dist/index.js (or src/index.ts), ../package.json is the CLI manifest.
+        const pkg = require("../package.json");
+        return pkg.version ?? "0.0.0-unknown";
+    }
+    catch {
+        return "0.0.0-unknown";
+    }
+})();
+export { createCliAuthClient } from "./lib/auth-client.js";
+export { getConfig, setConfig, getServerUrl } from "./config/config-manager.js";
+export { saveToken, loadToken, deleteToken } from "./config/token-manager.js";
+//# sourceMappingURL=index.js.map