@getforgeai/cli 0.1.0-beta.1

package/dist/orchestrator/agent-registry.d.ts

@@ -0,0 +1,53 @@
+import type { AgentEntry } from "./connectors/connector.js";
+/**
+ * In-memory registry tracking running agent subprocesses.
+ * Maps taskId → AgentEntry. No persistence — agents are ephemeral.
+ *
+ * Supports slot reservation to prevent over-allocation during async spawn pipelines.
+ * Flow: reserveSlot() → async spawn → confirmSlot() on success / releaseSlot() on failure.
+ */
+export declare class AgentRegistry {
+    private readonly agents;
+    private readonly pendingReservations;
+    maxSlots: number;
+    constructor(agentSlots: number);
+    /**
+     * Dynamically update the max slot capacity.
+     * Called when the server pushes a config update (e.g., admin changed agentSlots in UI).
+     */
+    updateMaxSlots(newMaxSlots: number): void;
+    register(entry: AgentEntry): void;
+    unregister(taskId: string): void;
+    getByTaskId(taskId: string): AgentEntry | undefined;
+    getActive(): AgentEntry[];
+    getActiveCount(): number;
+    /**
+     * Count agents that are provisioned (RUNNING or IDLE).
+     * Used for heartbeat reporting — IDLE agents still occupy a "visible" slot
+     * so the UI shows them as provisioned during the idle window.
+     */
+    getProvisionedCount(): number;
+    hasCapacity(): boolean;
+    getAll(): AgentEntry[];
+    /**
+     * Reserve a slot for an upcoming spawn. Returns false if no capacity.
+     * The reservation counts toward capacity to prevent concurrent over-allocation.
+     */
+    reserveSlot(taskId: string): boolean;
+    /**
+     * Confirm a reservation — converts pending reservation to a registered agent.
+     */
+    confirmSlot(taskId: string, entry: AgentEntry): void;
+    /**
+     * Release a reservation without registering (spawn failed).
+     */
+    releaseSlot(taskId: string): void;
+    getPendingReservationCount(): number;
+    /**
+     * Check if a task has a pending reservation (spawn in flight).
+     * Used to prevent dual-path race conditions where two concurrent spawn
+     * attempts pass the getByTaskId() check before either confirms.
+     */
+    hasPendingReservation(taskId: string): boolean;
+}
+//# sourceMappingURL=agent-registry.d.ts.map

package/dist/orchestrator/agent-registry.js

@@ -0,0 +1,96 @@
+import { vmLog } from "../vm/log.js";
+/**
+ * In-memory registry tracking running agent subprocesses.
+ * Maps taskId → AgentEntry. No persistence — agents are ephemeral.
+ *
+ * Supports slot reservation to prevent over-allocation during async spawn pipelines.
+ * Flow: reserveSlot() → async spawn → confirmSlot() on success / releaseSlot() on failure.
+ */
+export class AgentRegistry {
+    agents = new Map();
+    pendingReservations = new Set();
+    maxSlots;
+    constructor(agentSlots) {
+        this.maxSlots = agentSlots;
+    }
+    /**
+     * Dynamically update the max slot capacity.
+     * Called when the server pushes a config update (e.g., admin changed agentSlots in UI).
+     */
+    updateMaxSlots(newMaxSlots) {
+        this.maxSlots = newMaxSlots;
+    }
+    register(entry) {
+        if (this.getActiveCount() >= this.maxSlots) {
+            throw new Error(`Agent slot limit reached (${this.maxSlots}). Cannot spawn more agents.`);
+        }
+        this.agents.set(entry.taskId, entry);
+    }
+    unregister(taskId) {
+        this.agents.delete(taskId);
+        this.pendingReservations.delete(taskId);
+    }
+    getByTaskId(taskId) {
+        return this.agents.get(taskId);
+    }
+    getActive() {
+        return Array.from(this.agents.values()).filter((e) => e.status === "RUNNING");
+    }
+    getActiveCount() {
+        return this.getActive().length;
+    }
+    /**
+     * Count agents that are provisioned (RUNNING or IDLE).
+     * Used for heartbeat reporting — IDLE agents still occupy a "visible" slot
+     * so the UI shows them as provisioned during the idle window.
+     */
+    getProvisionedCount() {
+        return Array.from(this.agents.values()).filter((e) => e.status === "RUNNING" || e.status === "IDLE").length;
+    }
+    hasCapacity() {
+        return (this.getProvisionedCount() + this.pendingReservations.size < this.maxSlots);
+    }
+    getAll() {
+        return Array.from(this.agents.values());
+    }
+    /**
+     * Reserve a slot for an upcoming spawn. Returns false if no capacity.
+     * The reservation counts toward capacity to prevent concurrent over-allocation.
+     */
+    reserveSlot(taskId) {
+        if (!this.hasCapacity()) {
+            vmLog.dim("registry", `Slot reservation rejected for ${taskId} (${this.getProvisionedCount()} provisioned + ${this.pendingReservations.size} pending >= ${this.maxSlots} max)`);
+            return false;
+        }
+        this.pendingReservations.add(taskId);
+        vmLog.dim("registry", `Slot reserved for ${taskId} (${this.pendingReservations.size} pending)`);
+        return true;
+    }
+    /**
+     * Confirm a reservation — converts pending reservation to a registered agent.
+     */
+    confirmSlot(taskId, entry) {
+        this.pendingReservations.delete(taskId);
+        this.agents.set(entry.taskId, entry);
+        vmLog.dim("registry", `Slot confirmed for ${taskId} (${this.pendingReservations.size} pending)`);
+    }
+    /**
+     * Release a reservation without registering (spawn failed).
+     */
+    releaseSlot(taskId) {
+        this.pendingReservations.delete(taskId);
+        vmLog.dim("registry", `Slot released for ${taskId} (${this.pendingReservations.size} pending)`);
+    }
+    getPendingReservationCount() {
+        return this.pendingReservations.size;
+    }
+    /**
+     * Check if a task has a pending reservation (spawn in flight).
+     * Used to prevent dual-path race conditions where two concurrent spawn
+     * attempts pass the getByTaskId() check before either confirms.
+     */
+    hasPendingReservation(taskId) {
+        return this.pendingReservations.has(taskId);
+    }
+}
+//# sourceMappingURL=agent-registry.js.map

package/dist/orchestrator/agent-spawner.d.ts

@@ -0,0 +1,112 @@
+import { z } from "zod";
+import type { Socket } from "socket.io-client";
+import type { ClientToServerEvents, ServerToClientEvents } from "@getforgeai/protocol";
+import type { AgentConnector } from "./connectors/connector.js";
+import { AgentRegistry } from "./agent-registry.js";
+import type { createRestClient } from "../lib/rest-client.js";
+import type { createSocketClient } from "../lib/socket-client.js";
+import type { DispatchQueue, DrainContext } from "./dispatch-queue.js";
+type TypedClientSocket = Socket<ServerToClientEvents, ClientToServerEvents>;
+/** Wait for pending fallback REST calls to complete (with timeout). */
+export declare function awaitPendingFallbacks(timeoutMs: number): Promise<void>;
+export declare const DEFAULT_SKILL_NAME = "execute-task";
+/** Mark a task as having called forge_ask_human (called from MCP tool) */
+export declare function markAskHuman(taskId: string): void;
+/**
+ * Clear all idle windows and their timers.
+ * Called on socket disconnect to prevent stale timers emitting on dead sockets.
+ * Also unregisters IDLE agents from registry to free slots on reconnect.
+ */
+export declare function clearAllIdleWindows(socket: TypedClientSocket, agentSlots: number): void;
+export declare const TaskDispatchSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    projectId: z.ZodString;
+    assigneeId: z.ZodString;
+    taskCommand: z.ZodOptional<z.ZodString>;
+    skillSlug: z.ZodOptional<z.ZodString>;
+    workflowBaseBranch: z.ZodOptional<z.ZodString>;
+    taskBranch: z.ZodOptional<z.ZodString>;
+    taskSlug: z.ZodOptional<z.ZodString>;
+    projectSlug: z.ZodOptional<z.ZodString>;
+    repoUrl: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type DispatchParams = z.infer<typeof TaskDispatchSchema> & {
+    orgId: string;
+};
+export type SpawnerContext = {
+    restClient: ReturnType<typeof createRestClient>;
+    socketClient: ReturnType<typeof createSocketClient>;
+    agentType: string;
+    agentSlots: number;
+    queue: DispatchQueue;
+};
+/** Exported for testing */
+export declare function resetRegistry(): void;
+export declare function getAgentRegistry(agentSlots: number): AgentRegistry;
+export declare function resolveConnector(agentTypeOrName: string): AgentConnector;
+type ProcessHandlerArgs = {
+    taskId: string;
+    projectId: string;
+    registry: AgentRegistry;
+    socketClient: ReturnType<typeof createSocketClient>;
+    restClient: ReturnType<typeof createRestClient>;
+    queue: DispatchQueue;
+    spawnAgentFn: (params: DispatchParams) => Promise<void>;
+    label: string;
+    agentSlots: number;
+    /** Session/container ID for log context */
+    sessionId?: string;
+};
+/**
+ * Attach exit and error handlers to an agent process.
+ * Shared between spawnAgent and handleResume to deduplicate handler code.
+ */
+export declare function attachProcessHandlers(process: NodeJS.EventEmitter, args: ProcessHandlerArgs): void;
+type WorkflowProcessHandlerArgs = ProcessHandlerArgs & {
+    workflowId: string;
+    stepId: string;
+    conversationId: string;
+    /** Optional callback invoked on exit instead of default unregister+drain. */
+    onExit?: (code: number | null, accumulatedContent: string) => void;
+};
+/**
+ * Attach exit and error handlers to a workflow step agent process.
+ * Dual-emits: workflow:stream (wizard chat) + agent:stream (activity monitoring).
+ * On exit, emits workflow:stream:end with accumulated content for persistence.
+ */
+export declare function attachWorkflowProcessHandlers(process: NodeJS.EventEmitter, args: WorkflowProcessHandlerArgs): void;
+/**
+ * Main spawn pipeline — orchestrates the full agent lifecycle.
+ * Uses slot reservation to prevent over-allocation during async pipeline.
+ */
+export declare function spawnAgent(params: DispatchParams, ctx: SpawnerContext): Promise<void>;
+/**
+ * Stop a specific agent by taskId.
+ */
+export declare function stopAgent(taskId: string, ctx: SpawnerContext): Promise<void>;
+/**
+ * Graceful shutdown of all running agents.
+ * Clears queue, unregisters first (prevents exit handler race), then sends SIGTERM,
+ * waits up to 10s, then SIGKILL survivors.
+ */
+export declare function stopAllAgents(ctx: SpawnerContext): Promise<void>;
+/**
+ * Register the task:dispatch Socket.io handler on the CLI socket.
+ */
+export declare function registerDispatchHandler(socket: TypedClientSocket, orgId: string, ctx: SpawnerContext): DrainContext;
+/**
+ * Register the task:resume Socket.io handler on the CLI socket (Story 6.4).
+ */
+export declare function registerResumeHandler(socket: TypedClientSocket, orgId: string, ctx: SpawnerContext): void;
+/**
+ * Register the workflow:step:dispatch Socket.io handler on the CLI socket (Story 6b-7).
+ */
+export declare function registerWorkflowStepDispatchHandler(socket: TypedClientSocket, orgId: string, ctx: SpawnerContext): void;
+/**
+ * Register workflow:agent:dismiss handler — Cloud tells CLI to clear idle window.
+ * Called when user advances to next step after approving deliverables.
+ */
+export declare function registerWorkflowAgentDismissHandler(socket: TypedClientSocket, ctx: SpawnerContext): void;
+export {};
+//# sourceMappingURL=agent-spawner.d.ts.map