@getforgeai/cli 0.1.0-beta.1

package/dist/vm/vsock-bridge.js

@@ -0,0 +1,140 @@
+import { EventEmitter } from "node:events";
+import { createConnection } from "node:net";
+import chalk from "chalk";
+// Vsock channels
+export const CHANNEL_CONTROL = 0;
+export const CHANNEL_STDOUT = 1;
+export const CHANNEL_STDERR = 2;
+export const CHANNEL_MCP = 3;
+const HEADER_SIZE = 5; // 1 byte channel + 4 bytes length
+const MAX_FRAME_SIZE = 16 * 1024 * 1024; // 16MB
+export class VsockBridge extends EventEmitter {
+    socketPath;
+    socket = null;
+    buffer = Buffer.alloc(0);
+    connected = false;
+    /**
+     * @param socketPath Unix domain socket path (vfkit exposes vsock as UDS on macOS)
+     */
+    constructor(socketPath) {
+        super();
+        this.socketPath = socketPath;
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            // vfkit exposes vsock as a Unix domain socket on macOS.
+            // QEMU/WSL2 may use TCP — the socketPath can be a path or host:port.
+            const socket = createConnection({ path: this.socketPath });
+            socket.on("connect", () => {
+                this.socket = socket;
+                this.connected = true;
+                this.setupDataHandler();
+                console.log(chalk.green(`[vsock] Connected via ${this.socketPath}`));
+                resolve();
+            });
+            socket.on("error", (err) => {
+                if (!this.connected) {
+                    reject(new Error(`vsock connect failed: ${err.message}`));
+                }
+                else {
+                    this.emit("error", err);
+                }
+            });
+            socket.on("close", () => {
+                this.connected = false;
+                this.emit("close");
+            });
+        });
+    }
+    setupDataHandler() {
+        if (!this.socket)
+            return;
+        this.socket.on("data", (data) => {
+            this.buffer = Buffer.concat([this.buffer, data]);
+            this.processBuffer();
+        });
+    }
+    processBuffer() {
+        while (this.buffer.length >= HEADER_SIZE) {
+            const channel = this.buffer[0];
+            const length = this.buffer.readUInt32BE(1);
+            if (length > MAX_FRAME_SIZE) {
+                console.warn(chalk.red(`[vsock] Frame too large (${length} bytes), disconnecting`));
+                this.disconnect();
+                return;
+            }
+            if (this.buffer.length < HEADER_SIZE + length) {
+                break; // Wait for more data
+            }
+            const payload = this.buffer.subarray(HEADER_SIZE, HEADER_SIZE + length);
+            this.buffer = this.buffer.subarray(HEADER_SIZE + length);
+            this.handleFrame(channel, payload);
+        }
+    }
+    handleFrame(channel, payload) {
+        switch (channel) {
+            case CHANNEL_CONTROL: {
+                try {
+                    const msg = JSON.parse(payload.toString());
+                    // Validate control message shape
+                    if (typeof msg.type !== "string") {
+                        console.warn(chalk.yellow("[vsock] Invalid control message: missing type"));
+                        break;
+                    }
+                    if (msg.type === "pid" &&
+                        (typeof msg.pid !== "number" || msg.pid <= 0)) {
+                        console.warn(chalk.yellow("[vsock] Invalid PID in control message"));
+                        break;
+                    }
+                    if (msg.type === "exit" && typeof msg.code !== "number") {
+                        console.warn(chalk.yellow("[vsock] Invalid exit code in control message"));
+                        break;
+                    }
+                    this.emit("control", msg);
+                }
+                catch {
+                    console.warn(chalk.yellow("[vsock] Invalid control message JSON"));
+                }
+                break;
+            }
+            case CHANNEL_STDOUT:
+                this.emit("stdout", payload);
+                break;
+            case CHANNEL_STDERR:
+                this.emit("stderr", payload);
+                break;
+            case CHANNEL_MCP:
+                this.emit("mcp", payload);
+                break;
+            default:
+                console.warn(chalk.yellow(`[vsock] Unknown channel: ${channel}`));
+        }
+    }
+    send(channel, data) {
+        if (!this.socket || !this.connected) {
+            throw new Error("vsock not connected");
+        }
+        const payload = typeof data === "string" ? Buffer.from(data) : data;
+        const header = Buffer.alloc(HEADER_SIZE);
+        header[0] = channel;
+        header.writeUInt32BE(payload.length, 1);
+        this.socket.write(Buffer.concat([header, payload]));
+    }
+    sendControl(msg) {
+        this.send(CHANNEL_CONTROL, JSON.stringify(msg));
+    }
+    sendMcp(data) {
+        this.send(CHANNEL_MCP, data);
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+            this.connected = false;
+        }
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+//# sourceMappingURL=vsock-bridge.js.map

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

@@ -0,0 +1,98 @@
+/**
+ * vsock protocol constants and message types shared between host and VM.
+ * The host TypeScript layer (SessionManager) sends HostToVmMessage frames
+ * over the control channel; vminitd inside the VM responds with VmToHostMessage frames.
+ *
+ * Wire format: [4 bytes length BE][JSON payload]
+ */
+/** vsock port assignment for the control channel (host <-> vminitd) */
+export declare const VSOCK_CONTROL_PORT = 1024;
+/**
+ * Calculate session-specific vsock ports for stdout, stderr, and MCP streams.
+ * Each session gets 3 contiguous ports starting at 1025.
+ */
+export declare function sessionPorts(sessionIndex: number): {
+    stdout: number;
+    stderr: number;
+    mcp: number;
+};
+/**
+ * Base fields shared by all host-to-VM messages.
+ * `authToken` is required for control channel authentication (Fix #2).
+ * vminitd generates a random token at boot and validates it on every message.
+ */
+type HostToVmBase = {
+    authToken: string;
+};
+export type SpawnMessage = HostToVmBase & {
+    type: "spawn";
+    sessionId: string;
+    sessionIndex: number;
+    cmd: string;
+    args: string[];
+    env: Record<string, string>;
+    cwd: string;
+    sandboxConfig: {
+        uid: number;
+        gid: number;
+        workspacePath: string;
+    };
+};
+export type ExecMessage = HostToVmBase & {
+    type: "exec";
+    requestId: string;
+    cmd: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+};
+export type KillMessage = HostToVmBase & {
+    type: "kill";
+    sessionId: string;
+    signal: string;
+};
+export type ShutdownMessage = HostToVmBase & {
+    type: "shutdown";
+};
+export type HostToVmMessage = SpawnMessage | ExecMessage | KillMessage | ShutdownMessage;
+export type ReadyMessage = {
+    type: "ready";
+};
+export type PidMessage = {
+    type: "pid";
+    sessionId: string;
+    pid: number;
+};
+export type ExitMessage = {
+    type: "exit";
+    sessionId: string;
+    code: number;
+};
+export type ExecResultMessage = {
+    type: "exec-result";
+    requestId: string;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+};
+export type ErrorMessage = {
+    type: "error";
+    sessionId: string;
+    message: string;
+};
+export type VmToHostMessage = ReadyMessage | PidMessage | ExitMessage | ExecResultMessage | ErrorMessage;
+/**
+ * Encode a message for vsock transmission.
+ * Format: [4 bytes length BE][JSON payload as UTF-8]
+ */
+export declare function encodeMessage(msg: HostToVmMessage | VmToHostMessage): Buffer;
+/**
+ * Frame decoder that accumulates incoming chunks and yields complete messages.
+ * Handles partial reads — safe when chunks split in the middle of a frame.
+ */
+export declare class FrameDecoder {
+    private buffer;
+    push(chunk: Buffer): VmToHostMessage[];
+}
+export {};
+//# sourceMappingURL=vsock-protocol.d.ts.map

package/dist/vm/vsock-protocol.js

@@ -0,0 +1,57 @@
+/**
+ * vsock protocol constants and message types shared between host and VM.
+ * The host TypeScript layer (SessionManager) sends HostToVmMessage frames
+ * over the control channel; vminitd inside the VM responds with VmToHostMessage frames.
+ *
+ * Wire format: [4 bytes length BE][JSON payload]
+ */
+/** vsock port assignment for the control channel (host <-> vminitd) */
+export const VSOCK_CONTROL_PORT = 1024;
+/**
+ * Calculate session-specific vsock ports for stdout, stderr, and MCP streams.
+ * Each session gets 3 contiguous ports starting at 1025.
+ */
+export function sessionPorts(sessionIndex) {
+    const base = 1025 + sessionIndex * 3;
+    return {
+        stdout: base,
+        stderr: base + 1,
+        mcp: base + 2,
+    };
+}
+// ---------------------------------------------------------------------------
+// Wire encoding / decoding
+// ---------------------------------------------------------------------------
+/**
+ * Encode a message for vsock transmission.
+ * Format: [4 bytes length BE][JSON payload as UTF-8]
+ */
+export function encodeMessage(msg) {
+    const json = JSON.stringify(msg);
+    const payload = Buffer.from(json, "utf-8");
+    const frame = Buffer.allocUnsafe(4 + payload.length);
+    frame.writeUInt32BE(payload.length, 0);
+    payload.copy(frame, 4);
+    return frame;
+}
+/**
+ * Frame decoder that accumulates incoming chunks and yields complete messages.
+ * Handles partial reads — safe when chunks split in the middle of a frame.
+ */
+export class FrameDecoder {
+    buffer = Buffer.alloc(0);
+    push(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        const messages = [];
+        while (this.buffer.length >= 4) {
+            const len = this.buffer.readUInt32BE(0);
+            if (this.buffer.length < 4 + len)
+                break;
+            const payload = this.buffer.subarray(4, 4 + len);
+            this.buffer = this.buffer.subarray(4 + len);
+            messages.push(JSON.parse(payload.toString("utf-8")));
+        }
+        return messages;
+    }
+}
+//# sourceMappingURL=vsock-protocol.js.map

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@getforgeai/cli",
+  "version": "0.1.0-beta.1",
+  "description": "ForgeAI CLI — runs AI coding agents in local Docker containers with your own AI tokens, and connects them to the ForgeAI cockpit.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "rootfs/Dockerfile",
+    "rootfs/forge-mcp-relay.mjs"
+  ],
+  "bin": {
+    "forge": "./dist/bin/forgeai.js",
+    "forgeai": "./dist/bin/forgeai.js"
+  },
+  "engines": {
+    "node": ">=20.11"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://forgeai-production-382c.up.railway.app/docs",
+  "bugs": {
+    "url": "https://forgeai-production-382c.up.railway.app/contact"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "cli",
+    "claude-code",
+    "docker",
+    "mcp",
+    "developer-tools",
+    "forgeai"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.1",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "async-mutex": "^0.5.0",
+    "better-auth": "^1.4.18",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "open": "^10.2.0",
+    "ora": "^8.2.0",
+    "socket.io-client": "^4.8.3",
+    "zod": "^4.3.6",
+    "@getforgeai/protocol": "0.1.0-beta.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.2",
+    "@vitest/coverage-v8": "^4.0.18",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15"
+  },
+  "scripts": {
+    "build": "tsc",
+    "ts": "tsc --noEmit",
+    "dev": "tsc --watch",
+    "build:native": "cd native && swift build -c release && node-gyp rebuild",
+    "test:ci": "vitest run"
+  }
+}

package/rootfs/Dockerfile

@@ -0,0 +1,50 @@
+FROM ubuntu:24.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Base packages
+RUN apt-get update -qq && \
+    apt-get install -y -qq --no-install-recommends \
+      ca-certificates curl git openssh-client build-essential \
+      python3 procps less sudo gnupg && \
+    rm -rf /var/lib/apt/lists/*
+
+# Node.js 20 LTS via NodeSource
+RUN curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | \
+      gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg && \
+    echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" | \
+      tee /etc/apt/sources.list.d/nodesource.list && \
+    apt-get update -qq && \
+    apt-get install -y -qq nodejs && \
+    rm -rf /var/lib/apt/lists/*
+
+# Claude Code CLI
+RUN npm install -g @anthropic-ai/claude-code 2>&1 | tail -3
+
+# ForgeAI MCP relay (baked-in copy for reference only — at runtime the CLI
+# stages its own copy into /session/forge-mcp-relay.mjs so the relay version
+# always matches the CLI build, including the MCP bridge auth handshake)
+RUN mkdir -p /opt/forgeai
+COPY forge-mcp-relay.mjs /opt/forgeai/forge-mcp-relay.mjs
+
+# Create non-root user (Claude Code refuses --dangerously-skip-permissions as root)
+RUN apt-get update -qq && apt-get install -y -qq --no-install-recommends passwd && \
+    rm -rf /var/lib/apt/lists/* && \
+    useradd -m -s /bin/bash -u 1001 agent
+
+# Working directories (owned by agent user)
+RUN mkdir -p /workspace /session /shared && \
+    chown -R agent:agent /workspace /session /shared
+
+# Set hostname
+RUN echo "forgeai-agent" > /etc/hostname
+
+# Clean up
+RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+# Run as non-root user
+USER agent
+WORKDIR /session/workspace
+
+# Keep container alive for docker exec
+CMD ["sleep", "infinity"]

package/rootfs/forge-mcp-relay.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+/**
+ * forge-mcp-relay -- MCP JSON-RPC forwarder for ForgeAI agent sandboxes.
+ *
+ * This runs INSIDE a bubblewrap sandbox, launched by the agent (e.g. Claude
+ * Code) as an MCP server.
+ *
+ * Data flow:
+ *   Agent (Claude Code) <--stdin/stdout--> forge-mcp-relay <--TCP--> vminitd <--vsock--> host
+ *
+ * The relay:
+ *   1. Reads JSON-RPC messages from stdin (line-delimited, as per MCP spec)
+ *   2. Forwards them over a TCP connection to vminitd's per-session MCP port
+ *   3. Reads responses from vminitd and writes them to stdout
+ *
+ * Environment variables:
+ *   FORGEAI_MCP_PORT -- TCP port on 127.0.0.1 where vminitd's MCP bridge listens
+ *   FORGEAI_MCP_TOKEN -- Per-session shared secret; sent as the first line
+ *                        (`FORGEAI_AUTH <token>`) to authenticate to the bridge
+ *   FORGEAI_SESSION_ID -- Session identifier (for logging)
+ */
+
+import { createConnection } from "node:net";
+import { createInterface } from "node:readline";
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+const MCP_PORT = parseInt(process.argv[2] || process.env.FORGEAI_MCP_PORT || "0", 10);
+const MCP_TOKEN = process.env.FORGEAI_MCP_TOKEN || "";
+const SESSION_ID = process.env.FORGEAI_SESSION_ID ?? "unknown";
+
+function log(msg) {
+  process.stderr.write(`[mcp-relay:${SESSION_ID}] ${msg}\n`);
+}
+
+if (!MCP_PORT) {
+  log("ERROR: FORGEAI_MCP_PORT not set or invalid");
+  process.exit(1);
+}
+
+if (!MCP_TOKEN) {
+  log("ERROR: FORGEAI_MCP_TOKEN not set -- cannot authenticate to MCP bridge");
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// TCP connection to vminitd MCP bridge
+// ---------------------------------------------------------------------------
+
+let socket = null;
+let connected = false;
+let pendingMessages = [];
+
+function connectToVminitd() {
+  const MCP_HOST = process.env.FORGEAI_MCP_HOST || "127.0.0.1";
+  socket = createConnection({ host: MCP_HOST, port: MCP_PORT }, () => {
+    connected = true;
+    log(`Connected to vminitd MCP bridge on port ${MCP_PORT}`);
+
+    // Authenticate FIRST: the bridge requires this exact line before it
+    // will process any MCP traffic, and destroys the socket otherwise.
+    socket.write(`FORGEAI_AUTH ${MCP_TOKEN}\n`);
+
+    // Flush any messages that arrived before connection was ready
+    for (const msg of pendingMessages) {
+      socket.write(msg);
+    }
+    pendingMessages = [];
+  });
+
+  // Data from vminitd -> stdout (back to the agent)
+  socket.on("data", (chunk) => {
+    try {
+      process.stdout.write(chunk);
+    } catch {
+      /* stdout closed */
+    }
+  });
+
+  socket.on("error", (err) => {
+    log(`Socket error: ${err.message}`);
+  });
+
+  socket.on("close", () => {
+    connected = false;
+    log("Connection to vminitd closed");
+    // If vminitd closes the MCP channel, we should exit
+    process.exit(0);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// stdin -> TCP (agent requests to host)
+// ---------------------------------------------------------------------------
+
+function startStdinRelay() {
+  const rl = createInterface({
+    input: process.stdin,
+    crlfDelay: Infinity,
+  });
+
+  rl.on("line", (line) => {
+    // Forward the line as-is plus newline to maintain JSON-RPC line-delimited format
+    const data = line + "\n";
+
+    if (connected && socket) {
+      socket.write(data);
+    } else {
+      // Queue messages until connected
+      pendingMessages.push(data);
+    }
+  });
+
+  rl.on("close", () => {
+    log("stdin closed (agent disconnected)");
+    if (socket) {
+      socket.end();
+    }
+    process.exit(0);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Signal handling
+// ---------------------------------------------------------------------------
+
+process.on("SIGTERM", () => {
+  log("Received SIGTERM, shutting down");
+  if (socket) {
+    socket.end();
+  }
+  process.exit(0);
+});
+
+process.on("SIGINT", () => {
+  log("Received SIGINT, shutting down");
+  if (socket) {
+    socket.end();
+  }
+  process.exit(0);
+});
+
+// Prevent crashes from propagating
+process.on("uncaughtException", (err) => {
+  log(`Uncaught exception: ${err.message}`);
+  process.exit(1);
+});
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+log(`Starting MCP relay (port=${MCP_PORT})`);
+connectToVminitd();
+startStdinRelay();