@getforgeai/cli 0.1.0-beta.1

package/dist/lib/connection-manager.d.ts

@@ -0,0 +1,58 @@
+import { createRestClient } from "./rest-client.js";
+import { createSocketClient } from "./socket-client.js";
+import { EventJournal } from "./event-journal.js";
+import { ResilientEmitter } from "./resilient-emitter.js";
+export type OrgConnection = {
+    orgId: string;
+    orgSlug: string;
+    socketClient: ReturnType<typeof createSocketClient>;
+    restClient: ReturnType<typeof createRestClient>;
+    journal: EventJournal;
+    emitter: ResilientEmitter;
+    heartbeatInterval: ReturnType<typeof setInterval>;
+};
+/** Active connections keyed by orgId. */
+export declare const activeConnections: Map<string, OrgConnection>;
+export type ConnectOptions = {
+    server?: string;
+    org?: string;
+};
+export type ResolvedConnectContext = {
+    token: string;
+    serverUrl: string;
+    cliId: string;
+    cliName: string;
+    agentType: string;
+    agentSlots: number;
+    targetOrgs: Array<{
+        orgId: string;
+        orgSlug: string;
+    }>;
+};
+/**
+ * Run MCP health probe and manage re-probe lifecycle.
+ * Called once after connections are established.
+ * If unhealthy, schedules periodic re-probes until healthy.
+ * Emits updated heartbeats to all active connections when health changes.
+ */
+export declare function runMcpProbe(ctx?: ResolvedConnectContext): Promise<void>;
+/** Get current MCP health state (exported for agent-spawner error handler). */
+export declare function getMcpHealthy(): boolean;
+/**
+ * Resolve token, config, and target orgs. Returns null if validation fails
+ * (error messages are printed to console).
+ */
+export declare function resolveConnectContext(options: ConnectOptions): ResolvedConnectContext | null;
+/**
+ * Establish connections for all target orgs.
+ * Populates the activeConnections map and sets up event handlers.
+ * When `append` is true, adds to existing connections without clearing them
+ * (used by daemon reconnect to re-establish server-disconnected orgs).
+ */
+export declare function establishConnections(ctx: ResolvedConnectContext, append?: boolean): void;
+/**
+ * Gracefully shutdown all active connections.
+ * Syncs pending events (with timeout), disconnects sockets, clears intervals.
+ */
+export declare function shutdownConnections(): Promise<void>;
+//# sourceMappingURL=connection-manager.d.ts.map

package/dist/lib/connection-manager.js

@@ -0,0 +1,436 @@
+import { randomUUID } from "node:crypto";
+import chalk from "chalk";
+import { getConfig, getServerUrl, setConfig, } from "../config/config-manager.js";
+import { loadToken, stableHostname } from "../config/token-manager.js";
+import { createRestClient, RestClientError } from "./rest-client.js";
+import { createSocketClient } from "./socket-client.js";
+import { EventJournal } from "./event-journal.js";
+import { ResilientEmitter } from "./resilient-emitter.js";
+import { registerArtifactHandlers } from "../methodology/artifact-manager.js";
+import { registerBranchHandlers } from "./branch-manager.js";
+import { registerDispatchHandler, registerResumeHandler, registerWorkflowStepDispatchHandler, registerWorkflowAgentDismissHandler, stopAllAgents, getAgentRegistry, clearAllIdleWindows, } from "../orchestrator/agent-spawner.js";
+import { dispatchQueue } from "../orchestrator/dispatch-queue.js";
+import { probeMcpHealth } from "../mcp/mcp-probe.js";
+const SYNC_SHUTDOWN_TIMEOUT_MS = 5_000;
+const MCP_REPROBE_INTERVAL_MS = 60_000; // Re-probe every 60s when unhealthy
+/** Module-level MCP health state shared across all heartbeats. */
+let mcpHealthy = true; // Optimistic default until first probe completes
+let mcpReprobeTimer = null;
+let mcpProbeInFlight = false; // Prevent concurrent probe runs
+/** Active connections keyed by orgId. */
+export const activeConnections = new Map();
+/**
+ * Run MCP health probe and manage re-probe lifecycle.
+ * Called once after connections are established.
+ * If unhealthy, schedules periodic re-probes until healthy.
+ * Emits updated heartbeats to all active connections when health changes.
+ */
+export async function runMcpProbe(ctx) {
+    if (mcpProbeInFlight)
+        return;
+    mcpProbeInFlight = true;
+    let healthy;
+    try {
+        healthy = await probeMcpHealth();
+    }
+    finally {
+        mcpProbeInFlight = false;
+    }
+    const changed = healthy !== mcpHealthy;
+    mcpHealthy = healthy;
+    if (changed) {
+        console.log(healthy
+            ? chalk.green("[mcp-probe] MCP health restored — dispatches will resume")
+            : chalk.yellow("[mcp-probe] MCP unhealthy — this CLI will not receive dispatches"));
+        // Broadcast updated heartbeat immediately so Cloud sees the change
+        if (ctx) {
+            broadcastHealthHeartbeat(ctx);
+        }
+    }
+    // Manage re-probe timer
+    if (!healthy && !mcpReprobeTimer) {
+        mcpReprobeTimer = setInterval(() => {
+            void runMcpProbe(ctx);
+        }, MCP_REPROBE_INTERVAL_MS);
+    }
+    else if (healthy && mcpReprobeTimer) {
+        clearInterval(mcpReprobeTimer);
+        mcpReprobeTimer = null;
+    }
+}
+/** Broadcast an immediate heartbeat to all active connections with current MCP health. */
+function broadcastHealthHeartbeat(ctx) {
+    const reg = getAgentRegistry(ctx.agentSlots);
+    for (const conn of activeConnections.values()) {
+        conn.emitter.emitCliHeartbeat({
+            cliId: ctx.cliId,
+            status: "CONNECTED",
+            name: ctx.cliName,
+            agentSlots: ctx.agentSlots,
+            activeAgents: reg.getProvisionedCount(),
+            runningAgents: reg.getActiveCount(),
+            mcpHealthy,
+        });
+    }
+}
+/** Get current MCP health state (exported for agent-spawner error handler). */
+export function getMcpHealthy() {
+    return mcpHealthy;
+}
+/**
+ * Resolve token, config, and target orgs. Returns null if validation fails
+ * (error messages are printed to console).
+ */
+export function resolveConnectContext(options) {
+    const token = loadToken();
+    if (!token) {
+        console.error(chalk.red("Not authenticated. Run `forge auth login` first."));
+        return null;
+    }
+    const config = getConfig();
+    const serverUrl = options.server ?? getServerUrl();
+    let targetOrgs;
+    if (config.linkedOrgs && config.linkedOrgs.length > 0) {
+        if (options.org) {
+            const match = config.linkedOrgs.find((o) => o.orgSlug === options.org);
+            if (!match) {
+                console.error(chalk.red(`Organization "${options.org}" not found in linked orgs. Available: ${config.linkedOrgs.map((o) => o.orgSlug).join(", ")}`));
+                return null;
+            }
+            targetOrgs = [match];
+        }
+        else {
+            targetOrgs = config.linkedOrgs;
+        }
+    }
+    else if (config.defaultOrgId) {
+        targetOrgs = [
+            {
+                orgId: config.defaultOrgId,
+                orgSlug: config.defaultOrg ?? "default",
+            },
+        ];
+    }
+    else {
+        console.error(chalk.red("No organization configured. Run `forge auth login` to select one."));
+        return null;
+    }
+    const cliId = config.cliId ??
+        (() => {
+            const newId = randomUUID();
+            setConfig({ cliId: newId });
+            return newId;
+        })();
+    const cliName = config.cliName ?? stableHostname();
+    const agentType = config.agentType ?? "CLAUDE_CODE";
+    const agentSlots = config.agentSlots ?? 5;
+    return {
+        token,
+        serverUrl,
+        cliId,
+        cliName,
+        agentType,
+        agentSlots,
+        targetOrgs,
+    };
+}
+/**
+ * Establish connections for all target orgs.
+ * Populates the activeConnections map and sets up event handlers.
+ * When `append` is true, adds to existing connections without clearing them
+ * (used by daemon reconnect to re-establish server-disconnected orgs).
+ */
+export function establishConnections(ctx, append = false) {
+    const config = getConfig();
+    if (!append) {
+        activeConnections.clear();
+    }
+    // Skip orgs that already have an active connection
+    const orgsToConnect = append
+        ? ctx.targetOrgs.filter((o) => !activeConnections.has(o.orgId))
+        : ctx.targetOrgs;
+    const totalOrgs = activeConnections.size + orgsToConnect.length;
+    const multiOrg = totalOrgs > 1;
+    if (orgsToConnect.length > 1) {
+        console.log(chalk.green(`Connecting to ${orgsToConnect.length} organizations: ${orgsToConnect.map((o) => o.orgSlug).join(", ")}`));
+    }
+    const prefix = (slug) => (multiOrg ? `[${slug}] ` : "");
+    let authFailures = 0;
+    for (const org of orgsToConnect) {
+        const client = createSocketClient(ctx.serverUrl, ctx.token, org.orgId);
+        const restClient = createRestClient(ctx.serverUrl, ctx.token, org.orgId);
+        const journal = new EventJournal(org.orgId);
+        let lastSyncCursor = config.lastSyncCursor ?? "";
+        const emitter = new ResilientEmitter({
+            socketClient: client,
+            restClient,
+            journal,
+            cliId: ctx.cliId,
+            orgId: org.orgId,
+            initialCursor: lastSyncCursor,
+            onSyncStart: () => {
+                const pending = journal.pendingCount();
+                if (pending > 0) {
+                    console.log(chalk.green(`${prefix(org.orgSlug)}Reconnected -- syncing ${pending} pending events`));
+                }
+            },
+            onSyncComplete: (count) => {
+                console.log(chalk.green(`${prefix(org.orgSlug)}Synced ${count} events to Cloud`));
+                lastSyncCursor = emitter.getLastSyncCursor();
+                setConfig({
+                    lastSyncCursor,
+                    lastSyncTimestamp: new Date().toISOString(),
+                });
+            },
+            onSyncError: (error) => {
+                console.warn(chalk.yellow(`${prefix(org.orgSlug)}Sync failed: ${error.message}`));
+            },
+        });
+        // Register methodology artifact handlers (Story 4.4)
+        registerArtifactHandlers(client.socket, org.orgId);
+        // Register branch handlers (Story 5c.1)
+        registerBranchHandlers(client.socket, org.orgId);
+        // Register agent dispatch handler (Story 6.3, queue added Story 6.5)
+        const drainCtx = registerDispatchHandler(client.socket, org.orgId, {
+            restClient,
+            socketClient: client,
+            agentType: ctx.agentType,
+            agentSlots: ctx.agentSlots,
+            queue: dispatchQueue,
+        });
+        // Register agent resume handler (Story 6.4, queue added Story 6.5)
+        registerResumeHandler(client.socket, org.orgId, {
+            restClient,
+            socketClient: client,
+            agentType: ctx.agentType,
+            agentSlots: ctx.agentSlots,
+            queue: dispatchQueue,
+        });
+        // Register workflow step dispatch handler (Story 6b-7)
+        registerWorkflowStepDispatchHandler(client.socket, org.orgId, {
+            restClient,
+            socketClient: client,
+            agentType: ctx.agentType,
+            agentSlots: ctx.agentSlots,
+            queue: dispatchQueue,
+        });
+        // Register workflow agent dismiss handler (Story 6b-10)
+        registerWorkflowAgentDismissHandler(client.socket, {
+            restClient,
+            socketClient: client,
+            agentType: ctx.agentType,
+            agentSlots: ctx.agentSlots,
+            queue: dispatchQueue,
+        });
+        // Listen for server-pushed config updates (e.g., admin changed agentSlots in UI)
+        client.socket.on("cli:config:updated", (payload) => {
+            if (payload.agentSlots != null && payload.agentSlots !== ctx.agentSlots) {
+                const previous = ctx.agentSlots;
+                ctx.agentSlots = payload.agentSlots;
+                // Update registry capacity
+                const reg = getAgentRegistry(previous);
+                reg.updateMaxSlots(payload.agentSlots);
+                // Persist to local config
+                setConfig({ agentSlots: payload.agentSlots });
+                console.log(chalk.green(`${prefix(org.orgSlug)}Agent slots updated by server: ${previous} → ${payload.agentSlots}`));
+                // Emit immediate heartbeat so server sees the new value without waiting 30s
+                emitter.emitCliHeartbeat({
+                    cliId: ctx.cliId,
+                    status: "CONNECTED",
+                    name: ctx.cliName,
+                    agentSlots: payload.agentSlots,
+                    activeAgents: reg.getProvisionedCount(),
+                    runningAgents: reg.getActiveCount(),
+                    mcpHealthy,
+                });
+                // Drain queued dispatches now that capacity increased
+                if (payload.agentSlots > previous && dispatchQueue.size() > 0) {
+                    void dispatchQueue.drainNext(drainCtx).catch((err) => {
+                        console.warn(chalk.yellow(`[dispatch-queue] Drain after slot increase failed: ${err instanceof Error ? err.message : String(err)}`));
+                    });
+                }
+            }
+        });
+        client.socket.on("connect", async () => {
+            authFailures = 0;
+            console.log(chalk.green(`${prefix(org.orgSlug)}Connected to ForgeAI Cloud`));
+            const connectReg = getAgentRegistry(ctx.agentSlots);
+            emitter.emitCliHeartbeat({
+                cliId: ctx.cliId,
+                status: "CONNECTED",
+                name: ctx.cliName,
+                agentSlots: ctx.agentSlots,
+                activeAgents: connectReg.getProvisionedCount(),
+                runningAgents: connectReg.getActiveCount(),
+                mcpHealthy,
+            });
+            try {
+                const device = await restClient.registerCli({
+                    cliId: ctx.cliId,
+                    name: ctx.cliName,
+                    agentType: ctx.agentType,
+                    agentSlots: ctx.agentSlots,
+                });
+                console.log(chalk.green(`${prefix(org.orgSlug)}CLI registered as "${ctx.cliName}"`));
+                // Join member room so we receive workflow:step:dispatch events
+                if (device.memberId) {
+                    client.socket.emit("join:member", device.memberId);
+                    console.log(chalk.dim(`${prefix(org.orgSlug)}Joined member room: ${device.memberId}`));
+                }
+            }
+            catch (error) {
+                let message = error instanceof Error ? error.message : String(error);
+                try {
+                    const jsonMatch = /\{[\s\S]*\}/.exec(message);
+                    if (jsonMatch) {
+                        const parsed = JSON.parse(jsonMatch[0]);
+                        if (parsed.message) {
+                            message = parsed.message;
+                        }
+                    }
+                }
+                catch {
+                    // Fall back to raw message
+                }
+                const isLimitError = message.includes("plan limit") ||
+                    message.includes("CLI limit") ||
+                    (error instanceof RestClientError && error.status === 403);
+                if (isLimitError) {
+                    console.warn(chalk.yellow(`\n${prefix(org.orgSlug)}${message}`));
+                    console.warn(chalk.yellow("Upgrade your plan or unlink an existing CLI with: forge org unlink <slug>"));
+                }
+                else {
+                    console.warn(chalk.yellow(`${prefix(org.orgSlug)}CLI registration warning: ${message}`));
+                }
+            }
+        });
+        client.socket.on("disconnect", (reason) => {
+            console.log(chalk.yellow(`${prefix(org.orgSlug)}Disconnected: ${reason} -- events will be journaled locally`));
+            // Clear dispatch queue on disconnect to prevent stale dispatches (Story 6.5)
+            dispatchQueue.clear();
+            if (reason === "io server disconnect") {
+                // Permanent disconnect: clean up idle windows (timers + registry slots)
+                clearAllIdleWindows(client.socket, ctx.agentSlots);
+                // Clean up heartbeat interval and connection for this org
+                const conn = activeConnections.get(org.orgId);
+                if (conn) {
+                    clearInterval(conn.heartbeatInterval);
+                    activeConnections.delete(org.orgId);
+                }
+                // Flush pending events via REST before fully releasing
+                const pending = emitter.getPendingCount();
+                if (pending > 0) {
+                    console.log(chalk.cyan(`${prefix(org.orgSlug)}Flushing ${pending} pending events...`));
+                    emitter.syncPendingEvents().then(() => console.log(chalk.green(`${prefix(org.orgSlug)}Events flushed`)), () => console.warn(chalk.yellow(`${prefix(org.orgSlug)}Flush failed -- events saved locally`)));
+                }
+                if (activeConnections.size === 0) {
+                    console.log(chalk.cyan("All connections closed by server. Run `forge connect` to reconnect."));
+                }
+            }
+        });
+        client.socket.on("connect_error", (err) => {
+            console.error(chalk.red(`${prefix(org.orgSlug)}Connection error: ${err.message}`));
+            const isAuthError = err.message.includes("Authentication") ||
+                err.message.includes("Invalid session") ||
+                err.message.includes("Authentication required");
+            if (isAuthError) {
+                authFailures++;
+                if (authFailures >= 3) {
+                    console.error(chalk.red("\nAuthentication failed repeatedly. Run `forge auth login` to re-authenticate."));
+                    for (const conn of activeConnections.values()) {
+                        conn.socketClient.disconnect();
+                    }
+                    process.exit(1);
+                }
+            }
+        });
+        const heartbeatInterval = setInterval(() => {
+            const reg = getAgentRegistry(ctx.agentSlots);
+            emitter.emitCliHeartbeat({
+                cliId: ctx.cliId,
+                status: "CONNECTED",
+                name: ctx.cliName,
+                agentSlots: ctx.agentSlots,
+                activeAgents: reg.getProvisionedCount(),
+                runningAgents: reg.getActiveCount(),
+                mcpHealthy,
+            });
+        }, 30_000);
+        activeConnections.set(org.orgId, {
+            orgId: org.orgId,
+            orgSlug: org.orgSlug,
+            socketClient: client,
+            restClient,
+            journal,
+            emitter,
+            heartbeatInterval,
+        });
+    }
+}
+/**
+ * Gracefully shutdown all active connections.
+ * Syncs pending events (with timeout), disconnects sockets, clears intervals.
+ */
+export async function shutdownConnections() {
+    // Clear MCP re-probe timer
+    if (mcpReprobeTimer) {
+        clearInterval(mcpReprobeTimer);
+        mcpReprobeTimer = null;
+    }
+    // Clear dispatch queue and stop all running agents before disconnecting sockets (Story 6.3 + 6.5)
+    dispatchQueue.clear();
+    const config = getConfig();
+    for (const conn of activeConnections.values()) {
+        try {
+            await stopAllAgents({
+                restClient: conn.restClient,
+                socketClient: conn.socketClient,
+                agentType: config.agentType ?? "CLAUDE_CODE",
+                agentSlots: config.agentSlots ?? 5,
+                queue: dispatchQueue,
+            });
+        }
+        catch {
+            // Best-effort agent shutdown
+        }
+    }
+    // Wait for agent exit handler REST calls (fallback advance/requeue) to complete
+    try {
+        const { awaitPendingFallbacks } = await import("../orchestrator/agent-spawner.js");
+        await awaitPendingFallbacks(5_000);
+    }
+    catch {
+        // Best-effort — agent-spawner may not be loaded
+    }
+    const multiOrg = activeConnections.size > 1;
+    const prefix = (slug) => (multiOrg ? `[${slug}] ` : "");
+    for (const conn of activeConnections.values()) {
+        clearInterval(conn.heartbeatInterval);
+        const pending = conn.emitter.getPendingCount();
+        if (pending > 0) {
+            console.log(chalk.cyan(`${prefix(conn.orgSlug)}Syncing ${pending} pending events before shutdown...`));
+            try {
+                await Promise.race([
+                    conn.emitter.syncPendingEvents(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Sync timeout")), SYNC_SHUTDOWN_TIMEOUT_MS)),
+                ]);
+                console.log(chalk.green(`${prefix(conn.orgSlug)}Final sync complete`));
+            }
+            catch {
+                console.warn(chalk.yellow(`${prefix(conn.orgSlug)}Final sync timed out -- events will be synced on next connect`));
+            }
+        }
+        conn.socketClient.disconnect();
+    }
+    activeConnections.clear();
+    // Shutdown VM session manager (graceful VM stop)
+    try {
+        const { getVmManager } = await import("../vm/vm-manager-facade.js");
+        const sm = getVmManager();
+        await sm.shutdown();
+    }
+    catch {
+        // Session manager may not be initialized
+    }
+}
+//# sourceMappingURL=connection-manager.js.map

package/dist/lib/daemon-entry.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=daemon-entry.d.ts.map