@getforgeai/cli 0.1.0-beta.1

package/dist/lib/daemon-entry.js

@@ -0,0 +1,210 @@
+/**
+ * Daemon entry point — spawned as a detached child process by `spawnDaemon()`.
+ * Bootstraps the IPC server and establishes connections to all linked orgs.
+ */
+import chalk from "chalk";
+import { registerDaemonCleanup, DAEMON_PATHS } from "./daemon.js";
+import { createIpcServer, } from "./ipc-server.js";
+import { resolveConnectContext, establishConnections, activeConnections, shutdownConnections, runMcpProbe, } from "./connection-manager.js";
+import { isVmCapable, initVmManager } from "../vm/vm-manager-facade.js";
+// Register cleanup handlers first
+registerDaemonCleanup();
+console.log(`[daemon] Starting (PID: ${process.pid})`);
+// Resolve connection context (mutable — reconnect handler may update it)
+let ctx = resolveConnectContext({});
+if (!ctx) {
+    console.error("[daemon] Failed to resolve connection context — exiting");
+    process.exit(1);
+}
+// Check Claude OAuth token availability
+try {
+    const { loadClaudeToken } = await import("../vm/claude-token-manager.js");
+    if (!(await loadClaudeToken())) {
+        console.warn(chalk.yellow("[daemon] No Claude OAuth token stored — agents will fail to authenticate."));
+        console.warn(chalk.yellow("[daemon] Run: forge auth setup-claude"));
+    }
+}
+catch {
+    // Non-fatal
+}
+// Initialize VM manager (helper process or direct addon)
+if (isVmCapable()) {
+    try {
+        await initVmManager();
+        console.log(chalk.green("[daemon] VM manager initialized"));
+    }
+    catch (err) {
+        console.warn(chalk.yellow(`[daemon] VM manager failed: ${err instanceof Error ? err.message : String(err)}`));
+    }
+}
+else {
+    console.warn(chalk.yellow("[daemon] No VM capability — agent execution disabled"));
+}
+// Establish connections to all target orgs
+establishConnections(ctx);
+// Run MCP health probe (non-blocking — heartbeats update when result arrives)
+void runMcpProbe(ctx);
+console.log(`[daemon] Connected to ${ctx.targetOrgs.length} org(s): ${ctx.targetOrgs.map((o) => o.orgSlug).join(", ")}`);
+// Helper functions for IPC commands
+async function handleStatusCommand() {
+    const orgs = Array.from(activeConnections.values()).map((conn) => ({
+        slug: conn.orgSlug,
+        connected: conn.socketClient.socket.connected,
+    }));
+    return { ok: true, orgs };
+}
+function reconnectDisconnectedSockets(orgFilter) {
+    const conns = orgFilter
+        ? Array.from(activeConnections.values()).filter((c) => c.orgSlug === orgFilter)
+        : Array.from(activeConnections.values());
+    for (const conn of conns) {
+        if (!conn.socketClient.socket.connected) {
+            conn.socketClient.socket.connect();
+        }
+    }
+}
+async function handleReconnectCommand(cmd) {
+    // Re-read config from disk to pick up org/token changes (e.g., after re-login)
+    const freshCtx = resolveConnectContext({});
+    if (!freshCtx) {
+        return {
+            ok: false,
+            error: "Failed to resolve connection context (not authenticated?)",
+        };
+    }
+    const tokenChanged = freshCtx.token !== ctx?.token;
+    ctx = freshCtx;
+    const freshOrgIds = new Set(ctx.targetOrgs.map((o) => o.orgId));
+    // Remove stale connections: orgs no longer in config, or ALL if token changed
+    for (const [orgId, conn] of activeConnections) {
+        if (tokenChanged || !freshOrgIds.has(orgId)) {
+            clearInterval(conn.heartbeatInterval);
+            conn.socketClient.disconnect();
+            activeConnections.delete(orgId);
+            console.log(`[daemon] Removed stale org: ${conn.orgSlug}`);
+        }
+    }
+    // Reconnect existing connections that lost their socket
+    if (!tokenChanged) {
+        reconnectDisconnectedSockets(cmd.org);
+    }
+    // Establish connections for new/missing orgs
+    const newOrgs = ctx.targetOrgs.filter((o) => !activeConnections.has(o.orgId));
+    if (newOrgs.length > 0) {
+        establishConnections({ ...ctx, targetOrgs: newOrgs }, true);
+        console.log(`[daemon] Added org(s): ${newOrgs.map((o) => o.orgSlug).join(", ")}`);
+    }
+    // Build response
+    const allConns = cmd.org
+        ? Array.from(activeConnections.values()).filter((c) => c.orgSlug === cmd.org)
+        : Array.from(activeConnections.values());
+    const orgs = allConns.map((conn) => ({
+        slug: conn.orgSlug,
+        connected: conn.socketClient.socket.connected,
+    }));
+    const status = newOrgs.length === 0 && orgs.every((o) => o.connected)
+        ? "already_connected"
+        : "reconnecting";
+    return {
+        ok: true,
+        status,
+        orgs,
+    };
+}
+async function handleDisconnectCommand(cmd) {
+    const targetConns = cmd.org
+        ? Array.from(activeConnections.values()).filter((c) => c.orgSlug === cmd.org)
+        : Array.from(activeConnections.values());
+    if (targetConns.length === 0) {
+        return {
+            ok: false,
+            error: cmd.org
+                ? `Organization "${cmd.org}" not found in active connections`
+                : "No active connections",
+        };
+    }
+    for (const conn of targetConns) {
+        // REST disconnect call to notify Cloud
+        try {
+            const config = (await import("../config/config-manager.js")).getConfig();
+            if (config.cliId) {
+                await conn.restClient.disconnectCli({ cliId: config.cliId });
+            }
+        }
+        catch {
+            // Best-effort REST disconnect
+        }
+        // Close WebSocket — daemon stays alive
+        conn.socketClient.disconnect();
+    }
+    const orgs = targetConns.map((conn) => ({
+        slug: conn.orgSlug,
+        connected: false,
+    }));
+    return { ok: true, status: "disconnected", orgs };
+}
+async function handleReRegisterCommand() {
+    // Re-read config and re-register with Cloud using updated values
+    const freshCtxReg = resolveConnectContext({});
+    if (!freshCtxReg) {
+        return {
+            ok: false,
+            error: "Failed to resolve connection context",
+        };
+    }
+    ctx = freshCtxReg;
+    // Re-register on all active connections using PATCH to explicitly update config
+    // (PATCH includes agentSlots from the CLI config to sync with Cloud)
+    for (const conn of activeConnections.values()) {
+        try {
+            await conn.restClient.updateCliConfig({
+                cliId: ctx.cliId,
+                name: ctx.cliName,
+                agentType: ctx.agentType,
+                agentSlots: ctx.agentSlots,
+            });
+        }
+        catch {
+            // Best-effort re-registration
+        }
+    }
+    return { ok: true, status: "re-registered" };
+}
+async function handleShutdownCommand() {
+    console.log("[daemon] Shutdown requested via IPC");
+    // Graceful shutdown: sync pending events, disconnect, clean up
+    await shutdownConnections();
+    // Close IPC server
+    ipcServer.close();
+    // Remove PID/socket files (cleanup handler will also run on exit)
+    try {
+        const fs = await import("node:fs");
+        if (fs.existsSync(DAEMON_PATHS.pid))
+            fs.unlinkSync(DAEMON_PATHS.pid);
+        if (fs.existsSync(DAEMON_PATHS.sock))
+            fs.unlinkSync(DAEMON_PATHS.sock);
+    }
+    catch {
+        // Best-effort
+    }
+    // Respond before exiting
+    setTimeout(() => process.exit(0), 100);
+    return { ok: true, status: "shutting_down" };
+}
+// Start IPC server
+const ipcServer = createIpcServer(async (cmd) => {
+    switch (cmd.cmd) {
+        case "status":
+            return handleStatusCommand();
+        case "reconnect":
+            return handleReconnectCommand(cmd);
+        case "disconnect":
+            return handleDisconnectCommand(cmd);
+        case "re-register":
+            return handleReRegisterCommand();
+        case "shutdown":
+            return handleShutdownCommand();
+    }
+});
+console.log(`[daemon] IPC server listening on ${DAEMON_PATHS.sock}`);
+//# sourceMappingURL=daemon-entry.js.map

package/dist/lib/daemon.d.ts

@@ -0,0 +1,38 @@
+export declare const DAEMON_PATHS: {
+    readonly dir: string;
+    readonly pid: string;
+    readonly sock: string;
+    readonly log: string;
+};
+/**
+ * Read the stored daemon PID from the PID file.
+ * Returns null if no PID file exists or it's unreadable.
+ */
+export declare function readDaemonPid(): number | null;
+/**
+ * Check if a process with the given PID is currently alive.
+ * Uses signal 0 which checks existence without sending a signal.
+ */
+export declare function isProcessAlive(pid: number): boolean;
+/**
+ * Check if the daemon is currently running.
+ * Returns the PID if running, null if not.
+ */
+export declare function isDaemonRunning(): number | null;
+/**
+ * Remove stale PID file and socket file when the daemon process
+ * no longer exists.
+ */
+export declare function cleanStalePidFile(): void;
+/**
+ * Spawn the daemon as a detached background process.
+ * Returns the child PID.
+ */
+export declare function spawnDaemon(): number;
+/**
+ * Register cleanup handlers on the current process to ensure
+ * PID and socket files are removed on exit.
+ * Should be called from the daemon entry point.
+ */
+export declare function registerDaemonCleanup(): void;
+//# sourceMappingURL=daemon.d.ts.map

package/dist/lib/daemon.js

@@ -0,0 +1,148 @@
+import { existsSync, readFileSync, writeFileSync, unlinkSync, openSync, } from "node:fs";
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+const FORGEAI_DIR = join(homedir(), ".forgeai");
+export const DAEMON_PATHS = {
+    dir: FORGEAI_DIR,
+    pid: join(FORGEAI_DIR, "daemon.pid"),
+    sock: join(FORGEAI_DIR, "daemon.sock"),
+    log: join(FORGEAI_DIR, "daemon.log"),
+};
+/**
+ * Read the stored daemon PID from the PID file.
+ * Returns null if no PID file exists or it's unreadable.
+ */
+export function readDaemonPid() {
+    try {
+        if (!existsSync(DAEMON_PATHS.pid))
+            return null;
+        const content = readFileSync(DAEMON_PATHS.pid, "utf-8").trim();
+        const pid = Number.parseInt(content, 10);
+        return Number.isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a process with the given PID is currently alive.
+ * Uses signal 0 which checks existence without sending a signal.
+ */
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        // ESRCH = no such process (stale)
+        // EPERM = process exists but no permission (alive)
+        if (code === "EPERM")
+            return true;
+        return false;
+    }
+}
+/**
+ * Check if the daemon is currently running.
+ * Returns the PID if running, null if not.
+ */
+export function isDaemonRunning() {
+    const pid = readDaemonPid();
+    if (pid === null)
+        return null;
+    if (isProcessAlive(pid)) {
+        return pid;
+    }
+    // PID exists but process is dead — clean up stale files
+    cleanStalePidFile();
+    return null;
+}
+/**
+ * Remove stale PID file and socket file when the daemon process
+ * no longer exists.
+ */
+export function cleanStalePidFile() {
+    try {
+        if (existsSync(DAEMON_PATHS.pid)) {
+            unlinkSync(DAEMON_PATHS.pid);
+        }
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+    try {
+        if (existsSync(DAEMON_PATHS.sock)) {
+            unlinkSync(DAEMON_PATHS.sock);
+        }
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+/**
+ * Spawn the daemon as a detached background process.
+ * Returns the child PID.
+ */
+export function spawnDaemon() {
+    // Resolve daemon entry point relative to this file's location
+    // In compiled output: dist/lib/daemon.ts → dist/lib/daemon-entry.js
+    const daemonEntryPath = resolve(import.meta.dirname, "daemon-entry.js");
+    // Open log file in append mode for daemon stdout/stderr
+    const logFd = openSync(DAEMON_PATHS.log, "a");
+    const child = spawn(process.execPath, [daemonEntryPath], {
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+        env: { ...process.env, FORGEAI_DAEMON: "1" },
+    });
+    child.unref();
+    const pid = child.pid;
+    if (pid === undefined) {
+        throw new Error("Failed to spawn daemon: no PID returned");
+    }
+    writeFileSync(DAEMON_PATHS.pid, String(pid), "utf-8");
+    return pid;
+}
+/**
+ * Register cleanup handlers on the current process to ensure
+ * PID and socket files are removed on exit.
+ * Should be called from the daemon entry point.
+ */
+export function registerDaemonCleanup() {
+    const cleanup = () => {
+        try {
+            if (existsSync(DAEMON_PATHS.pid))
+                unlinkSync(DAEMON_PATHS.pid);
+        }
+        catch {
+            // Best-effort cleanup
+        }
+        try {
+            if (existsSync(DAEMON_PATHS.sock))
+                unlinkSync(DAEMON_PATHS.sock);
+        }
+        catch {
+            // Best-effort cleanup
+        }
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", () => {
+        cleanup();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        cleanup();
+        process.exit(0);
+    });
+    process.on("uncaughtException", (err) => {
+        console.error("Daemon uncaught exception:", err);
+        cleanup();
+        process.exit(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+        // Log but don't exit — unhandled rejections are often recoverable
+        // (e.g., socket emit on disconnected socket, async spawn errors)
+        console.error("Daemon unhandled rejection:", reason instanceof Error ? reason : String(reason));
+    });
+}
+//# sourceMappingURL=daemon.js.map

package/dist/lib/event-journal.d.ts

@@ -0,0 +1,24 @@
+export type JournalEntry = {
+    eventId: string;
+    type: string;
+    timestamp: string;
+    cliId: string;
+    orgId: string;
+    projectId: string | null;
+    payload: Record<string, unknown>;
+    synced: boolean;
+};
+export type JournalAppendInput = Omit<JournalEntry, "eventId" | "synced">;
+export declare class EventJournal {
+    private readonly filePath;
+    constructor(projectId: string);
+    private ensureDir;
+    append(event: JournalAppendInput): JournalEntry;
+    readAll(): JournalEntry[];
+    readSince(cursor: string): JournalEntry[];
+    getCursor(): string;
+    clear(upToCursor: string): void;
+    pendingCount(): number;
+    lastEventTimestamp(): string | null;
+}
+//# sourceMappingURL=event-journal.d.ts.map

package/dist/lib/event-journal.js

@@ -0,0 +1,76 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const EVENTS_DIR = join(homedir(), ".forgeai", "events");
+export class EventJournal {
+    filePath;
+    constructor(projectId) {
+        this.filePath = join(EVENTS_DIR, `${projectId}.ndjson`);
+        this.ensureDir();
+    }
+    ensureDir() {
+        if (!existsSync(EVENTS_DIR)) {
+            mkdirSync(EVENTS_DIR, { recursive: true, mode: 0o700 });
+        }
+    }
+    append(event) {
+        const entry = {
+            ...event,
+            eventId: randomUUID(),
+            synced: false,
+        };
+        appendFileSync(this.filePath, JSON.stringify(entry) + "\n", "utf-8");
+        return entry;
+    }
+    readAll() {
+        if (!existsSync(this.filePath))
+            return [];
+        const content = readFileSync(this.filePath, "utf-8");
+        const lines = content.split("\n").filter(Boolean);
+        const entries = [];
+        for (const line of lines) {
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch {
+                // Skip corrupted lines gracefully
+            }
+        }
+        return entries;
+    }
+    readSince(cursor) {
+        const entries = this.readAll();
+        if (!cursor)
+            return entries;
+        const cursorIndex = entries.findIndex((e) => e.eventId === cursor);
+        if (cursorIndex === -1)
+            return entries;
+        return entries.slice(cursorIndex + 1);
+    }
+    getCursor() {
+        const entries = this.readAll();
+        if (entries.length === 0)
+            return "";
+        return entries.at(-1).eventId;
+    }
+    clear(upToCursor) {
+        const entries = this.readAll();
+        const cursorIndex = entries.findIndex((e) => e.eventId === upToCursor);
+        if (cursorIndex === -1)
+            return;
+        const remaining = entries.slice(cursorIndex + 1);
+        const content = remaining.map((e) => JSON.stringify(e)).join("\n");
+        writeFileSync(this.filePath, content ? content + "\n" : "", "utf-8");
+    }
+    pendingCount() {
+        return this.readAll().length;
+    }
+    lastEventTimestamp() {
+        const entries = this.readAll();
+        if (entries.length === 0)
+            return null;
+        return entries.at(-1).timestamp;
+    }
+}
+//# sourceMappingURL=event-journal.js.map

package/dist/lib/ipc-client.d.ts

@@ -0,0 +1,10 @@
+import type { IpcCommand, IpcResponse } from "./ipc-server.js";
+/**
+ * Send a command to the daemon via IPC (Unix domain socket).
+ * Returns the parsed response or throws on connection/timeout errors.
+ */
+export declare function sendIpcCommand(cmd: IpcCommand, timeoutMs?: number): Promise<IpcResponse>;
+export declare class DaemonNotRunningError extends Error {
+    constructor();
+}
+//# sourceMappingURL=ipc-client.d.ts.map

package/dist/lib/ipc-client.js

@@ -0,0 +1,70 @@
+import { createConnection } from "node:net";
+import { DAEMON_PATHS } from "./daemon.js";
+const DEFAULT_TIMEOUT_MS = 5_000;
+/**
+ * Send a command to the daemon via IPC (Unix domain socket).
+ * Returns the parsed response or throws on connection/timeout errors.
+ */
+export async function sendIpcCommand(cmd, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+        const socket = createConnection(DAEMON_PATHS.sock);
+        let buffer = "";
+        let settled = false;
+        const timeout = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                socket.destroy();
+                reject(new Error("IPC command timed out"));
+            }
+        }, timeoutMs);
+        socket.on("connect", () => {
+            socket.write(JSON.stringify(cmd) + "\n");
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString("utf8");
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(timeout);
+                    socket.destroy();
+                    try {
+                        resolve(JSON.parse(line));
+                    }
+                    catch (err) {
+                        reject(new Error(`Invalid IPC response: ${err instanceof Error ? err.message : String(err)}`));
+                    }
+                }
+            }
+        });
+        socket.on("error", (err) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timeout);
+                if (err.code === "ECONNREFUSED" || err.code === "ENOENT") {
+                    reject(new DaemonNotRunningError());
+                }
+                else {
+                    reject(new Error(`IPC connection error: ${err.message}`));
+                }
+            }
+        });
+        socket.on("close", () => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timeout);
+                reject(new Error("IPC connection closed before response"));
+            }
+        });
+    });
+}
+export class DaemonNotRunningError extends Error {
+    constructor() {
+        super("No daemon running. Run `forge connect` first.");
+        this.name = "DaemonNotRunningError";
+    }
+}
+//# sourceMappingURL=ipc-client.js.map

package/dist/lib/ipc-server.d.ts

@@ -0,0 +1,36 @@
+import { type Server } from "node:net";
+export type IpcCommand = {
+    cmd: "status";
+} | {
+    cmd: "reconnect";
+    org?: string;
+} | {
+    cmd: "disconnect";
+    org?: string;
+} | {
+    cmd: "re-register";
+} | {
+    cmd: "shutdown";
+};
+export type OrgStatus = {
+    slug: string;
+    connected: boolean;
+};
+export type IpcResponse = {
+    ok: true;
+    orgs: OrgStatus[];
+} | {
+    ok: true;
+    status: string;
+    orgs?: OrgStatus[];
+} | {
+    ok: false;
+    error: string;
+};
+export type IpcCommandHandler = (cmd: IpcCommand) => Promise<IpcResponse>;
+/**
+ * Create and start the IPC server on a Unix domain socket.
+ * Uses JSON Lines protocol (one JSON object per line, delimited by \n).
+ */
+export declare function createIpcServer(handler: IpcCommandHandler): Server;
+//# sourceMappingURL=ipc-server.d.ts.map

package/dist/lib/ipc-server.js

@@ -0,0 +1,70 @@
+import { createServer } from "node:net";
+import { existsSync, unlinkSync } from "node:fs";
+import { DAEMON_PATHS } from "./daemon.js";
+/**
+ * Create and start the IPC server on a Unix domain socket.
+ * Uses JSON Lines protocol (one JSON object per line, delimited by \n).
+ */
+export function createIpcServer(handler) {
+    const server = createServer((socket) => {
+        let buffer = "";
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString("utf8");
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? ""; // keep incomplete trailing line
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                void (async () => {
+                    try {
+                        const cmd = JSON.parse(line);
+                        const response = await handler(cmd);
+                        const responseLine = JSON.stringify(response) + "\n";
+                        if (!socket.destroyed) {
+                            socket.write(responseLine);
+                        }
+                    }
+                    catch (err) {
+                        const errorResponse = {
+                            ok: false,
+                            error: err instanceof Error ? err.message : String(err),
+                        };
+                        if (!socket.destroyed) {
+                            socket.write(JSON.stringify(errorResponse) + "\n");
+                        }
+                    }
+                })();
+            }
+        });
+        socket.on("error", () => {
+            // Prevent ECONNRESET/EPIPE crashes — client disconnected unexpectedly
+        });
+    });
+    server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+            // Stale socket file — remove and retry
+            try {
+                unlinkSync(DAEMON_PATHS.sock);
+            }
+            catch {
+                // Ignore
+            }
+            server.listen(DAEMON_PATHS.sock);
+        }
+        else {
+            console.error("IPC server error:", err);
+        }
+    });
+    // Remove stale socket file before listening
+    if (existsSync(DAEMON_PATHS.sock)) {
+        try {
+            unlinkSync(DAEMON_PATHS.sock);
+        }
+        catch {
+            // Ignore
+        }
+    }
+    server.listen(DAEMON_PATHS.sock);
+    return server;
+}
+//# sourceMappingURL=ipc-server.js.map

package/dist/lib/node-version-guard.d.ts

@@ -0,0 +1,8 @@
+/** True when `current` is at least `required`. Exported for tests. */
+export declare function isSupportedNodeVersion(current: string, required: string): boolean;
+/**
+ * Print an actionable message and exit(1) when Node is too old.
+ * Called once from the CLI entry point, before anything else runs.
+ */
+export declare function assertSupportedNodeVersion(current?: string, required?: string): void;
+//# sourceMappingURL=node-version-guard.d.ts.map