@getforgeai/cli 0.1.0-beta.1

package/dist/vm/docker-executor.js

@@ -0,0 +1,360 @@
+/**
+ * Low-level Docker CLI wrapper using child_process.
+ * Zero npm dependencies — shells out to `docker` commands directly.
+ *
+ * All containers get labels:
+ *  - forgeai.managed=true
+ *  - forgeai.session-id=<sessionId>
+ *  - forgeai.task-id=<taskId>
+ *
+ * On Linux, adds `--add-host host.docker.internal:host-gateway` to enable
+ * communication from container to host. macOS/Windows Docker Desktop handles
+ * this automatically.
+ */
+import { execFile as execFileCallback, spawn as spawnCallback, } from "node:child_process";
+import { promisify } from "node:util";
+import { vmLog } from "./log.js";
+const execFile = promisify(execFileCallback);
+// ---------------------------------------------------------------------------
+// Platform Detection
+// ---------------------------------------------------------------------------
+function getPlatformAddHost() {
+    if (process.platform === "linux") {
+        return ["--add-host", "host.docker.internal:host-gateway"];
+    }
+    return [];
+}
+// ---------------------------------------------------------------------------
+// Network
+// ---------------------------------------------------------------------------
+const FALLBACK_BRIDGE_GATEWAY_IP = "172.17.0.1";
+let cachedBridgeGatewayIp = null;
+/**
+ * Resolve the gateway IP of the default Docker bridge network (Linux).
+ * This is the host-side address containers reach via
+ * `--add-host host.docker.internal:host-gateway`. Cached after first lookup.
+ * Falls back to the Docker default 172.17.0.1 if inspection fails.
+ */
+export async function getDockerBridgeGatewayIp() {
+    if (cachedBridgeGatewayIp)
+        return cachedBridgeGatewayIp;
+    try {
+        const { stdout } = await execFile("docker", [
+            "network",
+            "inspect",
+            "bridge",
+            "--format",
+            "{{(index .IPAM.Config 0).Gateway}}",
+        ], { timeout: 5000 });
+        const ip = stdout.trim();
+        if (ip.length > 0) {
+            cachedBridgeGatewayIp = ip;
+            return ip;
+        }
+    }
+    catch (error) {
+        vmLog.warn("docker", `Failed to inspect bridge network gateway: ${String(error)}`);
+    }
+    cachedBridgeGatewayIp = FALLBACK_BRIDGE_GATEWAY_IP;
+    return cachedBridgeGatewayIp;
+}
+// ---------------------------------------------------------------------------
+// Docker Availability
+// ---------------------------------------------------------------------------
+/**
+ * Check if Docker is available on the system.
+ * Runs `docker info --format '{{.ID}}'` with 5s timeout.
+ * Returns true if exit code 0, false otherwise.
+ */
+export async function isDockerAvailable() {
+    try {
+        const { stdout } = await execFile("docker", ["info", "--format", "{{.ID}}"], {
+            timeout: 5000,
+        });
+        return stdout.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Image Operations
+// ---------------------------------------------------------------------------
+/**
+ * Pull a Docker image.
+ * Runs `docker pull <image>` and logs progress.
+ */
+export async function pullImage(image) {
+    vmLog.info("docker", `Pulling image ${image}...`);
+    try {
+        await execFile("docker", ["pull", image]);
+        vmLog.info("docker", `Successfully pulled ${image}`);
+    }
+    catch (error) {
+        vmLog.error("docker", `Failed to pull ${image}: ${String(error)}`);
+        throw new Error(`Docker pull failed for ${image}`);
+    }
+}
+/**
+ * Check if a Docker image exists locally.
+ * Runs `docker image inspect <image>`.
+ * Returns true if exit code 0, false otherwise.
+ */
+export async function imageExists(image) {
+    try {
+        await execFile("docker", ["image", "inspect", image]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create a Docker container.
+ *
+ * Runs:
+ *   docker create --name <name> --platform linux/arm64 \
+ *     -v <mounts...> \
+ *     -e <envs...> \
+ *     --label forgeai.managed=true \
+ *     --label forgeai.session-id=<sessionId> \
+ *     --label forgeai.task-id=<taskId> \
+ *     [--label <custom labels...>] \
+ *     [--add-host host.docker.internal:host-gateway (Linux only)] \
+ *     <image> sleep infinity
+ *
+ * Returns the container ID from stdout.
+ */
+export async function createContainer(opts) {
+    const args = [
+        "create",
+        "--name",
+        opts.name,
+        "--platform",
+        "linux/arm64",
+    ];
+    // Add volume mounts
+    for (const vol of opts.volumes) {
+        const mountStr = vol.readOnly
+            ? `${vol.hostPath}:${vol.containerPath}:ro`
+            : `${vol.hostPath}:${vol.containerPath}`;
+        args.push("-v", mountStr);
+    }
+    // Add environment variables
+    if (opts.env) {
+        for (const [key, value] of Object.entries(opts.env)) {
+            args.push("-e", `${key}=${value}`);
+        }
+    }
+    // Add mandatory labels
+    args.push("--label", "forgeai.managed=true");
+    args.push("--label", `forgeai.session-id=${opts.sessionId}`);
+    args.push("--label", `forgeai.task-id=${opts.taskId}`);
+    // Add custom labels
+    if (opts.labels) {
+        for (const [key, value] of Object.entries(opts.labels)) {
+            args.push("--label", `${key}=${value}`);
+        }
+    }
+    // Add Linux host gateway mapping
+    args.push(...getPlatformAddHost());
+    // Add image and command
+    args.push(opts.image);
+    args.push("sleep");
+    args.push("infinity");
+    try {
+        const { stdout } = await execFile("docker", args);
+        const containerId = stdout.trim();
+        vmLog.info("docker", `Created container ${containerId} (${opts.name})`);
+        return containerId;
+    }
+    catch (error) {
+        vmLog.error("docker", `Failed to create container: ${String(error)}`);
+        throw new Error(`Docker create failed: ${String(error)}`);
+    }
+}
+/**
+ * Start a Docker container.
+ * Runs `docker start <containerId>`.
+ */
+export async function startContainer(containerId) {
+    try {
+        await execFile("docker", ["start", containerId]);
+        vmLog.info("docker", `Started container ${containerId}`);
+    }
+    catch (error) {
+        vmLog.error("docker", `Failed to start ${containerId}: ${String(error)}`);
+        throw new Error(`Docker start failed: ${String(error)}`);
+    }
+}
+/**
+ * Execute a command inside a running container.
+ *
+ * Runs:
+ *   docker exec [-w <cwd>] [-e KEY=VAL...] [-e SECRET...] <containerId> <cmd...>
+ *
+ * Returns { stdout, stderr, exitCode }.
+ * Does NOT throw on non-zero exit — caller can check exitCode.
+ */
+export async function execInContainer(containerId, cmd, opts) {
+    const args = ["exec"];
+    if (opts?.cwd) {
+        args.push("-w", opts.cwd);
+    }
+    if (opts?.env) {
+        for (const [key, value] of Object.entries(opts.env)) {
+            args.push("-e", `${key}=${value}`);
+        }
+    }
+    // Name-only -e for secrets: value stays out of argv, sourced from our env.
+    if (opts?.secretEnv) {
+        for (const key of Object.keys(opts.secretEnv)) {
+            args.push("-e", key);
+        }
+    }
+    args.push(containerId);
+    args.push(...cmd);
+    try {
+        const { stdout, stderr } = await execFile("docker", args, {
+            timeout: opts?.timeout,
+            env: opts?.secretEnv
+                ? { ...process.env, ...opts.secretEnv }
+                : process.env,
+        });
+        return { stdout, stderr, exitCode: 0 };
+    }
+    catch (error) {
+        const execError = error;
+        return {
+            stdout: execError.stdout || "",
+            stderr: execError.stderr || "",
+            exitCode: typeof execError.code === "number" ? execError.code : 1,
+        };
+    }
+}
+/**
+ * Spawn a long-running command inside a container with stdin attached.
+ *
+ * Runs:
+ *   docker exec -i [-w <cwd>] [-e KEY=VAL...] <containerId> <cmd...>
+ *
+ * The `-i` flag keeps stdin open. Returns the raw ChildProcess.
+ */
+export function spawnInContainer(containerId, cmd, opts) {
+    const args = ["exec"];
+    // Run as non-root user (Claude Code refuses --dangerously-skip-permissions as root)
+    if (opts?.user) {
+        args.push("--user", opts.user);
+    }
+    if (opts?.cwd) {
+        args.push("-w", opts.cwd);
+    }
+    if (opts?.env) {
+        for (const [key, value] of Object.entries(opts.env)) {
+            args.push("-e", `${key}=${value}`);
+        }
+    }
+    // Name-only -e for secrets: value stays out of argv, sourced from our env.
+    if (opts?.secretEnv) {
+        for (const key of Object.keys(opts.secretEnv)) {
+            args.push("-e", key);
+        }
+    }
+    args.push(containerId);
+    args.push(...cmd);
+    return spawnCallback("docker", args, {
+        env: opts?.secretEnv ? { ...process.env, ...opts.secretEnv } : process.env,
+    });
+}
+// ---------------------------------------------------------------------------
+// Container Termination
+// ---------------------------------------------------------------------------
+/**
+ * Kill a container.
+ * Runs `docker kill [--signal <signal>] <containerId>`.
+ */
+export async function killContainer(containerId, signal) {
+    const args = ["kill"];
+    if (signal) {
+        args.push("--signal", signal);
+    }
+    args.push(containerId);
+    try {
+        await execFile("docker", args);
+        vmLog.info("docker", `Killed container ${containerId}`);
+    }
+    catch (error) {
+        vmLog.warn("docker", `Failed to kill ${containerId}: ${String(error)}`);
+    }
+}
+/**
+ * Remove a container.
+ * Runs `docker rm [-f] <containerId>`.
+ * Ignores errors (container may already be gone).
+ */
+export async function removeContainer(containerId, force) {
+    const args = ["rm"];
+    if (force) {
+        args.push("-f");
+    }
+    args.push(containerId);
+    try {
+        await execFile("docker", args);
+        vmLog.info("docker", `Removed container ${containerId}`);
+    }
+    catch (error) {
+        vmLog.dim("docker", `Container ${containerId} already removed`);
+    }
+}
+/**
+ * List all ForgeAI-managed containers.
+ * Runs `docker ps -a --filter label=forgeai.managed=true --format '{{json .}}'`.
+ * Parses JSON output and returns array of containers with extracted labels.
+ */
+export async function listForgeContainers() {
+    try {
+        const { stdout } = await execFile("docker", [
+            "ps",
+            "-a",
+            "--filter",
+            "label=forgeai.managed=true",
+            "--format",
+            "{{json .}}",
+        ]);
+        const lines = stdout
+            .trim()
+            .split("\n")
+            .filter((line) => line.length > 0);
+        const containers = [];
+        for (const line of lines) {
+            try {
+                const data = JSON.parse(line);
+                const labels = {};
+                if (data.Labels) {
+                    const pairs = data.Labels.split(",");
+                    for (const pair of pairs) {
+                        const [key, value] = pair.split("=");
+                        if (key && value) {
+                            labels[key] = value;
+                        }
+                    }
+                }
+                containers.push({
+                    id: data.ID,
+                    name: data.Names || data.ID,
+                    status: data.Status,
+                    labels,
+                });
+            }
+            catch (parseErr) {
+                vmLog.warn("docker", `Failed to parse container JSON: ${line}`);
+            }
+        }
+        return containers;
+    }
+    catch (error) {
+        vmLog.warn("docker", `Failed to list containers: ${String(error)}`);
+        return [];
+    }
+}
+//# sourceMappingURL=docker-executor.js.map

package/dist/vm/docker-process-proxy.d.ts

@@ -0,0 +1,31 @@
+/**
+ * EventEmitter-based proxy that wraps a ChildProcess from `docker exec` into AgentProcess.
+ *
+ * Unlike VmProcessProxy which communicates with the VM via vsock, this class
+ * directly wraps a local ChildProcess (from docker exec) and pipes its streams.
+ * The kill function is injected to avoid a dependency on SessionManager.
+ */
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+import type { ChildProcess } from "node:child_process";
+import type { AgentProcess } from "../orchestrator/connectors/connector.js";
+export declare class DockerProcessProxy extends EventEmitter implements AgentProcess {
+    private readonly sessionId;
+    private readonly dockerExecProcess;
+    private readonly killFn;
+    readonly stdout: PassThrough;
+    readonly stderr: PassThrough;
+    pid: number;
+    exitCode: number | null;
+    killed: boolean;
+    /** Set to true when exit was caused by an authentication error */
+    isAuthError: boolean;
+    constructor(sessionId: string, dockerExecProcess: ChildProcess, killFn: (signal?: string) => Promise<void>);
+    /**
+     * Kill the agent process via the injected kill function.
+     * Returns true if the kill signal was sent, false if the process was already dead.
+     * Per AgentProcess interface, this must be synchronous (returns boolean, not Promise).
+     */
+    kill(signal?: string): boolean;
+}
+//# sourceMappingURL=docker-process-proxy.d.ts.map

package/dist/vm/docker-process-proxy.js

@@ -0,0 +1,105 @@
+/**
+ * EventEmitter-based proxy that wraps a ChildProcess from `docker exec` into AgentProcess.
+ *
+ * Unlike VmProcessProxy which communicates with the VM via vsock, this class
+ * directly wraps a local ChildProcess (from docker exec) and pipes its streams.
+ * The kill function is injected to avoid a dependency on SessionManager.
+ */
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+import { vmLog } from "./log.js";
+export class DockerProcessProxy extends EventEmitter {
+    sessionId;
+    dockerExecProcess;
+    killFn;
+    stdout;
+    stderr;
+    pid = -1;
+    exitCode = null;
+    killed = false;
+    /** Set to true when exit was caused by an authentication error */
+    isAuthError = false;
+    constructor(sessionId, dockerExecProcess, killFn) {
+        super();
+        this.sessionId = sessionId;
+        this.dockerExecProcess = dockerExecProcess;
+        this.killFn = killFn;
+        this.stdout = new PassThrough();
+        this.stderr = new PassThrough();
+        // Set PID from docker exec process
+        this.pid = dockerExecProcess.pid ?? -1;
+        // Pipe docker exec stdout/stderr to PassThrough streams
+        if (dockerExecProcess.stdout) {
+            dockerExecProcess.stdout.pipe(this.stdout);
+        }
+        if (dockerExecProcess.stderr) {
+            dockerExecProcess.stderr.pipe(this.stderr);
+        }
+        // Capture stderr and stdout for error logging
+        let stderrBuffer = "";
+        let stdoutBuffer = "";
+        if (dockerExecProcess.stderr) {
+            dockerExecProcess.stderr.on("data", (chunk) => {
+                stderrBuffer += chunk.toString("utf-8");
+            });
+        }
+        if (dockerExecProcess.stdout) {
+            dockerExecProcess.stdout.on("data", (chunk) => {
+                // Only keep last 1KB of stdout for error diagnosis
+                stdoutBuffer += chunk.toString("utf-8");
+                if (stdoutBuffer.length > 1024) {
+                    stdoutBuffer = stdoutBuffer.slice(-1024);
+                }
+            });
+        }
+        // Handle exit
+        dockerExecProcess.on("exit", (code, signal) => {
+            this.exitCode = code ?? (signal ? 128 : -1);
+            if (this.exitCode !== 0) {
+                const combined = (stderrBuffer.trim() +
+                    " " +
+                    stdoutBuffer.trim()).trim();
+                if (combined) {
+                    // Always log the actual error first for debugging
+                    vmLog.error("agent-stderr", `Session ${sessionId} exit=${this.exitCode}: ${combined.slice(0, 500)}`, this.sessionId);
+                    // Flag as auth error on specific patterns:
+                    // - stderr: explicit auth failures from Claude Code CLI
+                    // - combined: authentication_error JSON from API (arrives via stdout stream-json)
+                    const stderrOnly = stderrBuffer.trim();
+                    const isAuthError = stderrOnly.includes("Not logged in") ||
+                        stderrOnly.includes("Invalid or expired token") ||
+                        stderrOnly.includes("CLAUDE_CODE_OAUTH_TOKEN") ||
+                        combined.includes('"authentication_error"') ||
+                        combined.includes("Failed to authenticate");
+                    if (isAuthError) {
+                        this.isAuthError = true;
+                        vmLog.error("agent-auth", "Claude OAuth token expired or invalid. Run: forge auth setup-claude", this.sessionId);
+                    }
+                }
+                else {
+                    vmLog.error("agent-stderr", `Session ${sessionId} exit=${this.exitCode} (no output captured)`, this.sessionId);
+                }
+            }
+            this.emit("exit", this.exitCode, signal);
+            this.emit("close", this.exitCode, signal);
+        });
+        dockerExecProcess.on("error", (err) => {
+            this.emit("error", err);
+        });
+    }
+    /**
+     * Kill the agent process via the injected kill function.
+     * Returns true if the kill signal was sent, false if the process was already dead.
+     * Per AgentProcess interface, this must be synchronous (returns boolean, not Promise).
+     */
+    kill(signal) {
+        if (this.exitCode !== null || this.killed)
+            return false;
+        this.killed = true;
+        this.killFn(signal ?? "SIGTERM").catch(() => {
+            /* best effort — process may already be gone */
+        });
+        return true;
+    }
+}
+//# sourceMappingURL=docker-process-proxy.js.map

package/dist/vm/forge-vm-agent.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * forge-vm-agent — In-VM daemon for ForgeAI agent execution.
+ *
+ * Runs inside the VM, listens on vsock for commands from the host.
+ * Spawns agent processes, multiplexes stdout/stderr back to host.
+ *
+ * This file is baked into the VM rootfs image.
+ */
+export {};
+//# sourceMappingURL=forge-vm-agent.d.ts.map

package/dist/vm/forge-vm-agent.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * forge-vm-agent — In-VM daemon for ForgeAI agent execution.
+ *
+ * Runs inside the VM, listens on vsock for commands from the host.
+ * Spawns agent processes, multiplexes stdout/stderr back to host.
+ *
+ * This file is baked into the VM rootfs image.
+ */
+import { createServer } from "node:net";
+import { spawn } from "node:child_process";
+const CHANNEL_CONTROL = 0;
+const CHANNEL_STDOUT = 1;
+const CHANNEL_STDERR = 2;
+const CHANNEL_MCP = 3;
+const HEADER_SIZE = 5;
+const DISCONNECT_KILL_GRACE_MS = 5_000;
+const VSOCK_PORT = parseInt(process.env.FORGE_VSOCK_PORT ?? "6789", 10);
+let activeProcess = null;
+let hostSocket = null;
+function sendFrame(socket, channel, data) {
+    const payload = typeof data === "string" ? Buffer.from(data) : data;
+    const header = Buffer.alloc(HEADER_SIZE);
+    header[0] = channel;
+    header.writeUInt32BE(payload.length, 1);
+    socket.write(Buffer.concat([header, payload]));
+}
+function sendControl(socket, msg) {
+    sendFrame(socket, CHANNEL_CONTROL, JSON.stringify(msg));
+}
+function handleSpawn(socket, msg) {
+    if (activeProcess) {
+        sendControl(socket, { type: "error", message: "Agent already running" });
+        return;
+    }
+    const ALLOWED_COMMANDS = new Set(["claude", "opencode"]);
+    if (!ALLOWED_COMMANDS.has(msg.command)) {
+        sendControl(socket, {
+            type: "error",
+            message: `Command not allowed: ${msg.command}`,
+        });
+        return;
+    }
+    try {
+        const child = spawn(msg.command, msg.args, {
+            cwd: msg.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: false,
+            env: {
+                HOME: "/root",
+                PATH: "/usr/local/bin:/usr/bin:/bin",
+                LANG: process.env.LANG ?? "en_US.UTF-8",
+                TERM: process.env.TERM ?? "xterm-256color",
+                NODE_ENV: "production",
+            },
+        });
+        if (child.pid === undefined) {
+            sendControl(socket, {
+                type: "error",
+                message: "Failed to spawn — no PID assigned",
+            });
+            return;
+        }
+        activeProcess = child;
+        // Send PID to host
+        sendControl(socket, { type: "pid", pid: child.pid });
+        // Pipe stdout/stderr to host via vsock channels
+        child.stdout?.on("data", (data) => {
+            sendFrame(socket, CHANNEL_STDOUT, data);
+        });
+        child.stderr?.on("data", (data) => {
+            sendFrame(socket, CHANNEL_STDERR, data);
+        });
+        child.on("exit", (code) => {
+            sendControl(socket, { type: "exit", code: code ?? 1 });
+            activeProcess = null;
+        });
+        child.on("error", (err) => {
+            sendControl(socket, { type: "error", message: err.message });
+            activeProcess = null;
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        sendControl(socket, { type: "error", message: `Spawn failed: ${message}` });
+    }
+}
+function handleKill(msg) {
+    if (!activeProcess)
+        return;
+    try {
+        const signal = msg.signal === "SIGKILL" ? "SIGKILL" : "SIGTERM";
+        activeProcess.kill(signal);
+    }
+    catch {
+        // Best-effort kill
+    }
+}
+function processBuffer(socket, buffer) {
+    while (buffer.data.length >= HEADER_SIZE) {
+        const channel = buffer.data[0];
+        const length = buffer.data.readUInt32BE(1);
+        if (buffer.data.length < HEADER_SIZE + length)
+            break;
+        const payload = buffer.data.subarray(HEADER_SIZE, HEADER_SIZE + length);
+        buffer.data = buffer.data.subarray(HEADER_SIZE + length);
+        if (channel === CHANNEL_CONTROL) {
+            try {
+                const msg = JSON.parse(payload.toString());
+                if (msg.type === "spawn")
+                    handleSpawn(socket, msg);
+                else if (msg.type === "kill")
+                    handleKill(msg);
+            }
+            catch {
+                // Invalid control message, ignore
+            }
+        }
+        // MCP channel forwarding could be added here
+    }
+}
+// Start vsock server (using TCP for development, AF_VSOCK in production)
+const server = createServer((socket) => {
+    console.log("[forge-vm-agent] Host connected");
+    hostSocket = socket;
+    const buffer = { data: Buffer.alloc(0) };
+    socket.on("data", (data) => {
+        buffer.data = Buffer.concat([buffer.data, data]);
+        processBuffer(socket, buffer);
+    });
+    socket.on("close", () => {
+        console.log("[forge-vm-agent] Host disconnected");
+        hostSocket = null;
+        // Kill active process if host disconnects
+        if (activeProcess) {
+            activeProcess.kill("SIGTERM");
+            setTimeout(() => {
+                if (activeProcess && activeProcess.exitCode === null) {
+                    activeProcess.kill("SIGKILL");
+                }
+            }, DISCONNECT_KILL_GRACE_MS);
+        }
+    });
+    socket.on("error", (err) => {
+        console.error(`[forge-vm-agent] Socket error: ${err.message}`);
+    });
+});
+server.listen(VSOCK_PORT, "127.0.0.1", () => {
+    console.log(`[forge-vm-agent] Listening on port ${VSOCK_PORT}`);
+});
+// Graceful shutdown
+process.on("SIGTERM", () => {
+    if (activeProcess) {
+        activeProcess.kill("SIGTERM");
+    }
+    server.close();
+    process.exit(0);
+});
+//# sourceMappingURL=forge-vm-agent.js.map