@getforgeai/cli 0.1.0-beta.1

package/dist/vm/vm-helper.js

@@ -0,0 +1,156 @@
+/**
+ * VM Helper Process — child process entry point.
+ *
+ * Runs under node-vm (signed with com.apple.security.virtualization entitlement).
+ * Loads the native addon, creates a real SessionManager, and proxies commands
+ * from the parent CLI process over Node.js IPC.
+ *
+ * Usage: node-vm dist/vm/vm-helper.js
+ */
+import { initSessionManager } from "./session-manager.js";
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+const sm = initSessionManager();
+/** Active agent proxies keyed by taskId — for streaming relay and kill routing */
+const proxies = new Map();
+// ---------------------------------------------------------------------------
+// IPC helpers
+// ---------------------------------------------------------------------------
+function sendResponse(reqId, value) {
+    const msg = { type: "res", reqId, ok: true, value };
+    process.send(msg);
+}
+function sendError(reqId, error) {
+    const msg = { type: "res", reqId, ok: false, error };
+    process.send(msg);
+}
+function sendEvent(event) {
+    process.send(event);
+}
+// Forward vmLog to parent
+function sendLog(level, prefix, message) {
+    sendEvent({ type: "log", level, prefix, message });
+}
+// ---------------------------------------------------------------------------
+// Request dispatch
+// ---------------------------------------------------------------------------
+async function handleRequest(req) {
+    const { reqId } = req;
+    try {
+        switch (req.method) {
+            case "ensureVmRunning": {
+                await sm.ensureVmRunning();
+                sendResponse(reqId, null);
+                break;
+            }
+            case "createSession": {
+                const sessionId = await sm.createSession(req.taskId);
+                sendResponse(reqId, sessionId);
+                break;
+            }
+            case "cloneRepo": {
+                await sm.cloneRepo(req.sessionId, req.repoUrl, req.branch, req.baseBranch);
+                sendResponse(reqId, null);
+                break;
+            }
+            case "spawnAgent": {
+                const proxy = await sm.spawnAgent(req.taskId, req.cmd, req.args, req.env);
+                // Store for kill routing
+                proxies.set(req.taskId, proxy);
+                // Relay stdout/stderr to parent
+                proxy.stdout.on("data", (chunk) => {
+                    sendEvent({
+                        type: "stream",
+                        taskId: req.taskId,
+                        channel: "stdout",
+                        data: chunk,
+                    });
+                });
+                proxy.stderr.on("data", (chunk) => {
+                    sendEvent({
+                        type: "stream",
+                        taskId: req.taskId,
+                        channel: "stderr",
+                        data: chunk,
+                    });
+                });
+                // Relay exit to parent
+                proxy.on("exit", (code) => {
+                    sendEvent({ type: "exit", taskId: req.taskId, code });
+                    proxies.delete(req.taskId);
+                });
+                sendResponse(reqId, { pid: proxy.pid, sessionId: req.taskId });
+                break;
+            }
+            case "killAgent": {
+                await sm.killAgent(req.taskIdOrSessionId, req.signal);
+                sendResponse(reqId, null);
+                break;
+            }
+            case "destroySession": {
+                await sm.destroySession(req.taskId);
+                proxies.delete(req.taskId);
+                sendResponse(reqId, null);
+                break;
+            }
+            case "exec": {
+                const result = await sm.exec(req.cmd, req.args, req.cwd);
+                sendResponse(reqId, result);
+                break;
+            }
+            case "shutdown": {
+                await sm.shutdown();
+                sendResponse(reqId, null);
+                // Give response time to flush, then exit
+                setTimeout(() => process.exit(0), 500);
+                break;
+            }
+            case "isVmRunning": {
+                sendResponse(reqId, sm.isVmRunning());
+                break;
+            }
+            case "getAllSessions": {
+                sendResponse(reqId, sm.getAllSessions());
+                break;
+            }
+            case "getSessionByTaskId": {
+                sendResponse(reqId, sm.getSessionByTaskId(req.taskId) ?? null);
+                break;
+            }
+            default: {
+                sendError(reqId, `Unknown method: ${req.method}`);
+            }
+        }
+    }
+    catch (err) {
+        sendError(reqId, err instanceof Error ? err.message : String(err));
+    }
+}
+// ---------------------------------------------------------------------------
+// Message listener
+// ---------------------------------------------------------------------------
+process.on("message", (msg) => {
+    const m = msg;
+    if (m?.type === "req" && m.reqId && m.method) {
+        handleRequest(m).catch((err) => {
+            sendError(m.reqId, `Unhandled: ${err instanceof Error ? err.message : err}`);
+        });
+    }
+});
+// Graceful shutdown when parent disconnects
+process.on("disconnect", () => {
+    sendLog("info", "vm-helper", "Parent disconnected, shutting down...");
+    sm.shutdown()
+        .catch(() => { })
+        .finally(() => process.exit(0));
+});
+// Prevent unhandled errors from crashing the helper
+process.on("uncaughtException", (err) => {
+    sendLog("error", "vm-helper", `Uncaught: ${err.message}`);
+});
+process.on("unhandledRejection", (reason) => {
+    sendLog("error", "vm-helper", `Unhandled rejection: ${reason}`);
+});
+sendLog("info", "vm-helper", "Helper process started");
+//# sourceMappingURL=vm-helper.js.map

package/dist/vm/vm-ipc-protocol.d.ts

@@ -0,0 +1,84 @@
+/**
+ * IPC protocol between the main CLI process (parent) and the VM helper
+ * process (child running under node-vm with Apple Virtualization entitlements).
+ *
+ * Uses Node.js built-in IPC with `serialization: 'advanced'` (structured clone)
+ * so Buffer objects transfer natively without base64 encoding.
+ */
+import type { SessionState } from "./session-manager.js";
+type IpcRequestBase = {
+    type: "req";
+    reqId: string;
+};
+export type IpcRequest = IpcRequestBase & ({
+    method: "ensureVmRunning";
+} | {
+    method: "createSession";
+    taskId: string;
+} | {
+    method: "cloneRepo";
+    sessionId: string;
+    repoUrl?: string;
+    branch?: string;
+    baseBranch?: string;
+} | {
+    method: "spawnAgent";
+    taskId: string;
+    cmd: string;
+    args: string[];
+    env: Record<string, string>;
+} | {
+    method: "killAgent";
+    taskIdOrSessionId: string;
+    signal?: string;
+} | {
+    method: "destroySession";
+    taskId: string;
+} | {
+    method: "exec";
+    cmd: string;
+    args: string[];
+    cwd?: string;
+} | {
+    method: "shutdown";
+} | {
+    method: "isVmRunning";
+} | {
+    method: "getAllSessions";
+} | {
+    method: "getSessionByTaskId";
+    taskId: string;
+});
+export type IpcResponse = {
+    type: "res";
+    reqId: string;
+    ok: true;
+    value: unknown;
+} | {
+    type: "res";
+    reqId: string;
+    ok: false;
+    error: string;
+};
+export type IpcEvent = {
+    type: "stream";
+    taskId: string;
+    channel: "stdout" | "stderr";
+    data: Buffer;
+} | {
+    type: "exit";
+    taskId: string;
+    code: number;
+} | {
+    type: "log";
+    level: string;
+    prefix: string;
+    message: string;
+};
+export type IpcMessage = IpcRequest | IpcResponse | IpcEvent;
+export type IpcSpawnResult = {
+    pid: number;
+    sessionId: string;
+};
+export type { SessionState };
+//# sourceMappingURL=vm-ipc-protocol.d.ts.map

package/dist/vm/vm-ipc-protocol.js

@@ -0,0 +1,9 @@
+/**
+ * IPC protocol between the main CLI process (parent) and the VM helper
+ * process (child running under node-vm with Apple Virtualization entitlements).
+ *
+ * Uses Node.js built-in IPC with `serialization: 'advanced'` (structured clone)
+ * so Buffer objects transfer natively without base64 encoding.
+ */
+export {};
+//# sourceMappingURL=vm-ipc-protocol.js.map

package/dist/vm/vm-manager-facade.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Facade for the Docker-backed session manager.
+ * Consumers import getVmManager() / initVmManager() to get a SessionManager.
+ */
+import { type SessionManager } from "./session-manager.js";
+export type VmManager = SessionManager;
+/**
+ * Initialize the Docker-backed session manager.
+ * Checks Docker daemon availability before proceeding.
+ */
+export declare function initVmManager(): Promise<VmManager>;
+/**
+ * Get the initialized session manager.
+ * Throws if initVmManager() hasn't been called yet.
+ */
+export declare function getVmManager(): VmManager;
+/**
+ * Check if Docker-based agent execution is possible.
+ * Always returns true (Docker is expected on all platforms).
+ * Actual daemon availability is verified in initVmManager().
+ */
+export declare function isVmCapable(): boolean;
+//# sourceMappingURL=vm-manager-facade.d.ts.map

package/dist/vm/vm-manager-facade.js

@@ -0,0 +1,43 @@
+/**
+ * Facade for the Docker-backed session manager.
+ * Consumers import getVmManager() / initVmManager() to get a SessionManager.
+ */
+import { isDockerAvailable } from "./docker-executor.js";
+import { initSessionManager, getSessionManager, } from "./session-manager.js";
+import { vmLog } from "./log.js";
+let initialized = false;
+/**
+ * Initialize the Docker-backed session manager.
+ * Checks Docker daemon availability before proceeding.
+ */
+export async function initVmManager() {
+    if (initialized)
+        return getVmManager();
+    const available = await isDockerAvailable();
+    if (!available) {
+        throw new Error("Docker not available. Install Docker Desktop and ensure the daemon is running.");
+    }
+    vmLog.info("vm-facade", "Using Docker containers for agent execution");
+    const sm = initSessionManager();
+    initialized = true;
+    return sm;
+}
+/**
+ * Get the initialized session manager.
+ * Throws if initVmManager() hasn't been called yet.
+ */
+export function getVmManager() {
+    if (!initialized) {
+        throw new Error("VM manager not initialized — call initVmManager() first");
+    }
+    return getSessionManager();
+}
+/**
+ * Check if Docker-based agent execution is possible.
+ * Always returns true (Docker is expected on all platforms).
+ * Actual daemon availability is verified in initVmManager().
+ */
+export function isVmCapable() {
+    return true;
+}
+//# sourceMappingURL=vm-manager-facade.js.map

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

@@ -0,0 +1,74 @@
+import type { ChildProcess } from "node:child_process";
+import type { VmProvider, VmInfo, SessionConfig, SessionFiles, SessionInfo } from "./types.js";
+/**
+ * TCP bridge that runs `forge mcp` on the host and exposes it as a TCP server.
+ * Each client connection (from the VM via SSH reverse tunnel) gets its own
+ * `forge mcp` subprocess with stdio piped through TCP.
+ */
+declare class McpTcpBridge {
+    private context;
+    private server;
+    port: number;
+    constructor(context: {
+        taskId: string;
+        projectId: string;
+        orgId: string;
+        workflowId?: string;
+        stepId?: string;
+    });
+    start(): Promise<void>;
+    stop(): void;
+}
+export declare function getVmManager(): VmManager;
+export declare function initVmManager(provider: VmProvider): VmManager;
+export declare class VmManager {
+    private provider;
+    private sessions;
+    constructor(provider: VmProvider);
+    createSession(taskId: string, config: SessionConfig): Promise<string>;
+    bootVm(sessionId: string): Promise<VmInfo>;
+    cloneRepo(sessionId: string, repoUrl: string | undefined, branch: string | undefined, baseBranch?: string): Promise<void>;
+    prepareWorkspace(sessionId: string, files: SessionFiles): Promise<void>;
+    /**
+     * Provision the VM with required tools after boot.
+     * Skips if image is pre-baked (claude already installed via build.sh).
+     * Fallback installs Node.js + Claude CLI if using a stock Ubuntu image.
+     */
+    private provisionVm;
+    /**
+     * Inject Claude Code credentials into the VM.
+     * Supports:
+     * - macOS Keychain (Pro/Max subscription via OAuth)
+     * - ~/.claude/.credentials.json (Linux/manual setup)
+     * - ANTHROPIC_API_KEY env var (API key fallback — handled at spawn time)
+     */
+    private injectClaudeCredentials;
+    /**
+     * Resolve an authenticated clone URL by extracting credentials from the host.
+     * Uses `git credential fill` which delegates to the user's credential helper
+     * (osxkeychain, wincred, credential-store, GitHub CLI, etc.).
+     *
+     * For SSH URLs, returns as-is (SSH agent forwarding handles auth).
+     * For HTTPS URLs, injects the token into the URL (ephemeral, never persisted in VM).
+     */
+    private resolveAuthenticatedUrl;
+    spawnAgent(sessionId: string, cmd: string, args: string[], mcpContext?: {
+        taskId: string;
+        projectId: string;
+        orgId: string;
+        workflowId?: string;
+        stepId?: string;
+    }): Promise<{
+        pid: number;
+        process: ChildProcess;
+        mcpBridge?: McpTcpBridge;
+    }>;
+    stopVm(sessionId: string): Promise<void>;
+    destroySession(sessionId: string): Promise<void>;
+    getSession(taskId: string): SessionInfo | undefined;
+    getAllSessions(): SessionInfo[];
+    private findSession;
+    private findSessionOptional;
+}
+export {};
+//# sourceMappingURL=vm-manager.d.ts.map