@getforgeai/cli 0.1.0-beta.1

package/dist/lib/rest-client.js

@@ -0,0 +1,139 @@
+const DEFAULT_TIMEOUT_MS = 10_000;
+const DEFAULT_MAX_RETRIES = 2;
+const RETRY_BASE_DELAY_MS = 1_000;
+function validateJsonResponse(json, status) {
+    if (json === null || typeof json !== "object") {
+        throw new RestClientError("Invalid response format from server", status);
+    }
+}
+export function createRestClient(serverUrl, token, orgId, options) {
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const retryDelayMs = options?.retryDelayMs ?? RETRY_BASE_DELAY_MS;
+    const baseHeaders = {
+        Authorization: `Bearer ${token}`,
+        "X-Org-Id": orgId,
+        "Content-Type": "application/json",
+    };
+    function handleResponseError(response, errorBody, attempt) {
+        if (response.status === 401) {
+            throw new RestClientError(`Authentication failed. Run "forge auth login" to re-authenticate.`, response.status);
+        }
+        if (response.status === 403) {
+            throw new RestClientError(errorBody ||
+                "Access denied. You may not be a member of this organization.", response.status);
+        }
+        if (response.status >= 500 && attempt < maxRetries) {
+            return new RestClientError(`Request failed: ${response.status} ${errorBody}`, response.status);
+        }
+        throw new RestClientError(`Request failed: ${response.status} ${errorBody}`, response.status);
+    }
+    function handleFetchError(error) {
+        if (error instanceof RestClientError)
+            throw error;
+        if (error instanceof DOMException && error.name === "AbortError") {
+            throw new RestClientError(`Request timed out after ${timeoutMs}ms`, 0);
+        }
+        throw new RestClientError(`Network error: ${error instanceof Error ? error.message : String(error)}`, 0);
+    }
+    async function request(method, path, body) {
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            if (attempt > 0) {
+                await sleep(retryDelayMs * attempt);
+            }
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetch(`${serverUrl}${path}`, {
+                    method,
+                    headers: baseHeaders,
+                    body: body ? JSON.stringify(body) : undefined,
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    const errorBody = await response.text().catch(() => "Unknown error");
+                    const error = handleResponseError(response, errorBody, attempt);
+                    if (error) {
+                        lastError = error;
+                        continue;
+                    }
+                }
+                const json = await response.json();
+                validateJsonResponse(json, response.status);
+                return json;
+            }
+            catch (error) {
+                handleFetchError(error);
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        }
+        throw lastError ?? new RestClientError("Request failed after retries", 0);
+    }
+    return {
+        heartbeat: (data) => request("POST", "/api/cli/heartbeat", data),
+        getTasks: () => request("GET", "/api/cli/tasks"),
+        getTask: (taskId) => request("GET", `/api/cli/tasks/${encodeURIComponent(taskId)}`),
+        updateTaskStatus: (data) => request("POST", "/api/cli/tasks", data),
+        updateTaskSubStatus: (data) => request("POST", "/api/cli/tasks", data),
+        requeueTask: (taskId, reason, errorReason, resetAt) => request("POST", `/api/cli/tasks/${encodeURIComponent(taskId)}/requeue`, { reason, errorReason, resetAt }),
+        advanceTask: (taskId, options) => request("POST", `/api/cli/tasks/${encodeURIComponent(taskId)}/advance${options?.fallback ? "?fallback=true" : ""}`),
+        respondToAgent: (taskId, response) => request("POST", `/api/cli/tasks/${encodeURIComponent(taskId)}/respond`, { response }),
+        syncEvents: (data) => request("POST", "/api/cli/sync", data),
+        registerCli: (data) => request("POST", "/api/cli/register", data),
+        updateCliConfig: (data) => request("PATCH", "/api/cli/register", data),
+        listCliDevices: () => request("GET", "/api/cli/devices"),
+        unlinkCli: (data) => request("DELETE", `/api/cli/register?cliId=${encodeURIComponent(data.cliId)}`),
+        disconnectCli: (data) => request("POST", "/api/cli/disconnect", data),
+        getProjectState: (projectId) => {
+            const query = projectId
+                ? `?projectId=${encodeURIComponent(projectId)}`
+                : "";
+            return request("GET", `/api/cli/state${query}`);
+        },
+        getSkill: (skillName) => request("GET", `/api/cli/skills?name=${encodeURIComponent(skillName)}`),
+        getWorkflow: (workflowId) => request("GET", `/api/cli/workflows/${encodeURIComponent(workflowId)}`),
+        getRelease: (releaseId) => request("GET", `/api/cli/releases/${encodeURIComponent(releaseId)}`),
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function getOrgSelection(serverUrl, token, userCode) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+    try {
+        const response = await fetch(`${serverUrl}/api/cli/auth/org-selection?userCode=${encodeURIComponent(userCode)}`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return { orgIds: [], orgSlugs: [] };
+        }
+        const json = (await response.json());
+        if (!json || !Array.isArray(json.orgIds) || !Array.isArray(json.orgSlugs)) {
+            return { orgIds: [], orgSlugs: [] };
+        }
+        return json;
+    }
+    catch {
+        return { orgIds: [], orgSlugs: [] };
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+export class RestClientError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.name = "RestClientError";
+        this.status = status;
+    }
+}
+//# sourceMappingURL=rest-client.js.map

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

@@ -0,0 +1,23 @@
+import type { SkillPullResponse } from "@getforgeai/protocol";
+type SkillRestClient = {
+    getSkill: (skillName: string) => Promise<unknown>;
+};
+/**
+ * Read a cached skill from disk.
+ */
+export declare function getCachedSkill(skillId: string, version: number): SkillPullResponse | null;
+/**
+ * Remove all cached versions for a skill.
+ */
+export declare function clearSkillCache(skillId: string): void;
+/**
+ * Pull a skill from Cloud API and cache it locally.
+ * Returns the skill data or null if unavailable.
+ */
+export declare function pullSkill(skillName: string, restClient: SkillRestClient): Promise<SkillPullResponse | null>;
+/**
+ * Deposit skill files from cache into an agent's worktree.
+ */
+export declare function depositSkill(skill: SkillPullResponse, worktreePath: string, agentType: string): void;
+export {};
+//# sourceMappingURL=skill-manager.d.ts.map

package/dist/lib/skill-manager.js

@@ -0,0 +1,167 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, normalize } from "node:path";
+import { SkillPullResponseSchema } from "@getforgeai/protocol";
+import { RestClientError } from "./rest-client.js";
+import { vmLog } from "../vm/log.js";
+const CACHE_BASE = join(homedir(), ".forgeai", "cache", "skills");
+function getCacheDir(skillId, version) {
+    return join(CACHE_BASE, `${skillId}-v${version}`);
+}
+function findExistingCacheVersion(skillId) {
+    if (!existsSync(CACHE_BASE))
+        return null;
+    const prefix = `${skillId}-v`;
+    const entries = readdirSync(CACHE_BASE, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.startsWith(prefix)) {
+            const versionStr = entry.name.slice(prefix.length);
+            const version = Number.parseInt(versionStr, 10);
+            if (!Number.isNaN(version)) {
+                return { version, dir: join(CACHE_BASE, entry.name) };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Read a cached skill from disk.
+ */
+export function getCachedSkill(skillId, version) {
+    const cacheDir = getCacheDir(skillId, version);
+    const metadataPath = join(cacheDir, "skill.json");
+    if (!existsSync(metadataPath))
+        return null;
+    try {
+        const raw = readFileSync(metadataPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const result = SkillPullResponseSchema.safeParse(parsed);
+        return result.success ? result.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Remove all cached versions for a skill.
+ */
+export function clearSkillCache(skillId) {
+    if (!existsSync(CACHE_BASE))
+        return;
+    const prefix = `${skillId}-v`;
+    const entries = readdirSync(CACHE_BASE, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.startsWith(prefix)) {
+            rmSync(join(CACHE_BASE, entry.name), { recursive: true, force: true });
+        }
+    }
+}
+function writeSkillToCache(skill) {
+    // Invalidate old version if exists
+    const existing = findExistingCacheVersion(skill.id);
+    if (existing && existing.version !== skill.version) {
+        rmSync(existing.dir, { recursive: true, force: true });
+    }
+    const cacheDir = getCacheDir(skill.id, skill.version);
+    mkdirSync(cacheDir, { recursive: true });
+    // Write metadata
+    writeFileSync(join(cacheDir, "skill.json"), JSON.stringify(skill, null, 2), "utf-8");
+    // Write individual files
+    for (const file of skill.files) {
+        const safePath = normalize(file.path);
+        const resolved = join(cacheDir, safePath);
+        if (!resolved.startsWith(cacheDir + "/") && resolved !== cacheDir) {
+            continue; // prevent path traversal
+        }
+        mkdirSync(dirname(resolved), { recursive: true });
+        writeFileSync(resolved, file.content, "utf-8");
+    }
+}
+/**
+ * Pull a skill from Cloud API and cache it locally.
+ * Returns the skill data or null if unavailable.
+ */
+export async function pullSkill(skillName, restClient) {
+    try {
+        const rawResponse = await restClient.getSkill(skillName);
+        const result = SkillPullResponseSchema.safeParse(rawResponse);
+        if (!result.success) {
+            vmLog.warn("skill", `Invalid skill response for skill ${skillName}`);
+            return null;
+        }
+        const skill = result.data;
+        // Check cache — if same version exists, return cached
+        const cached = getCachedSkill(skill.id, skill.version);
+        if (cached) {
+            vmLog.dim("skill", `Cache hit: ${skill.name} v${skill.version}`);
+            return cached;
+        }
+        // Write to cache (handles version invalidation)
+        writeSkillToCache(skill);
+        vmLog.info("skill", `Pulled: ${skill.name} v${skill.version} (${skill.files.length} files)`);
+        return skill;
+    }
+    catch (error) {
+        if (error instanceof RestClientError && error.status === 404) {
+            vmLog.dim("skill", `No skill found for skill ${skillName}`);
+            return null;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        vmLog.warn("skill", `Failed to pull skill: ${message}`);
+        // Open Core fallback: if Cloud is unreachable, return any cached skill
+        const fallback = findAnyCachedSkill();
+        if (fallback) {
+            vmLog.dim("skill", `Using cached fallback: ${fallback.name} v${fallback.version}`);
+            return fallback;
+        }
+        return null;
+    }
+}
+/**
+ * Scan the cache directory for any valid cached skill (Open Core fallback).
+ */
+function findAnyCachedSkill() {
+    if (!existsSync(CACHE_BASE))
+        return null;
+    const entries = readdirSync(CACHE_BASE, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const metadataPath = join(CACHE_BASE, entry.name, "skill.json");
+        if (!existsSync(metadataPath))
+            continue;
+        try {
+            const raw = readFileSync(metadataPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            const result = SkillPullResponseSchema.safeParse(parsed);
+            if (result.success)
+                return result.data;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+const AGENT_TYPE_DIRS = {
+    CLAUDE_CODE: ".claude",
+    OPENCODE: ".opencode",
+};
+/**
+ * Deposit skill files from cache into an agent's worktree.
+ */
+export function depositSkill(skill, worktreePath, agentType) {
+    const agentDir = AGENT_TYPE_DIRS[agentType] ?? ".claude";
+    const depositBase = join(worktreePath, agentDir, "skills", skill.name);
+    for (const file of skill.files) {
+        const safePath = normalize(file.path);
+        const resolved = join(depositBase, safePath);
+        if (!resolved.startsWith(depositBase + "/") && resolved !== depositBase) {
+            continue; // prevent path traversal
+        }
+        mkdirSync(dirname(resolved), { recursive: true });
+        writeFileSync(resolved, file.content, "utf-8");
+    }
+    vmLog.info("skill", `Deposited ${skill.name} (${skill.files.length} files) in ${depositBase}`);
+}
+//# sourceMappingURL=skill-manager.js.map

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

@@ -0,0 +1,68 @@
+import { type Socket } from "socket.io-client";
+import type { ClientToServerEvents, ServerToClientEvents, AgentStatusPayload, AgentStreamPayload, AgentToolActivityPayload, TaskUpdatePayload, CliHeartbeatPayload, TaskAskHumanEventPayload, WorkflowStepCompletePayload, WorkflowStreamPayload, WorkflowStreamEndPayload, WorkflowAgentIdlePayload, WorkflowAgentTimeoutPayload, WorkflowQuestionPayload, WorkflowToolActivityPayload, WorkflowTokenUsagePayload, ForgeCreateTaskGroupPayload, ForgeAddGroupDependencyPayload, ForgeCreateTaskPayload, ForgeAddTaskDependencyPayload, ForgeUpdateTaskPayload, ForgeDeleteTaskPayload, ForgeUpdateTaskGroupPayload, ForgeDeleteTaskGroupPayload, ForgeRemoveTaskDependencyPayload, ForgeRemoveGroupDependencyPayload } from "@getforgeai/protocol";
+type TypedClientSocket = Socket<ServerToClientEvents, ClientToServerEvents>;
+type McpAckError = {
+    error: string;
+    message?: string;
+    name?: string;
+    title?: string;
+};
+type TaskGroupCreateAck = {
+    id: string;
+    name: string;
+} | McpAckError;
+type TaskGroupAddDependencyAck = {
+    success: true;
+} | McpAckError;
+type TaskCreateAck = {
+    id: string;
+    title: string;
+} | McpAckError;
+type TaskAddDependencyAck = {
+    success: true;
+} | McpAckError;
+type McpUpdateAck = {
+    success: true;
+    id: string;
+} | McpAckError;
+type McpDeleteAck = {
+    success: true;
+    id: string;
+} | McpAckError;
+type McpRemoveDependencyAck = {
+    success: true;
+} | McpAckError;
+export declare function createSocketClient(serverUrl: string, token: string, orgId: string): {
+    socket: TypedClientSocket;
+    emitAgentStatus: (payload: Omit<AgentStatusPayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitAgentStream: (payload: Omit<AgentStreamPayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitAgentToolActivity: (payload: Omit<AgentToolActivityPayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitTaskUpdate: (payload: Omit<TaskUpdatePayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitCliHeartbeat: (payload: Omit<CliHeartbeatPayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitTaskAskHuman: (payload: Omit<TaskAskHumanEventPayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitWorkflowStream: (payload: Omit<WorkflowStreamPayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitWorkflowStreamEnd: (payload: Omit<WorkflowStreamEndPayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitWorkflowQuestion: (payload: Omit<WorkflowQuestionPayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitWorkflowToolActivity: (payload: Omit<WorkflowToolActivityPayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitWorkflowTokenUsage: (payload: Omit<WorkflowTokenUsagePayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitStepComplete: (payload: Omit<WorkflowStepCompletePayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitWorkflowAgentIdle: (payload: Omit<WorkflowAgentIdlePayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitWorkflowAgentTimeout: (payload: Omit<WorkflowAgentTimeoutPayload, "orgId" | "timestamp">) => TypedClientSocket;
+    emitTaskGroupCreate: (payload: Omit<ForgeCreateTaskGroupPayload, "orgId" | "timestamp">) => Promise<TaskGroupCreateAck>;
+    emitTaskGroupAddDependency: (payload: Omit<ForgeAddGroupDependencyPayload, "orgId" | "timestamp">) => Promise<TaskGroupAddDependencyAck>;
+    emitTaskCreate: (payload: Omit<ForgeCreateTaskPayload, "orgId" | "timestamp">) => Promise<TaskCreateAck>;
+    emitTaskAddDependency: (payload: Omit<ForgeAddTaskDependencyPayload, "orgId" | "timestamp">) => Promise<TaskAddDependencyAck>;
+    emitMcpTaskUpdate: (payload: Omit<ForgeUpdateTaskPayload, "orgId" | "timestamp">) => Promise<McpUpdateAck>;
+    emitMcpTaskDelete: (payload: Omit<ForgeDeleteTaskPayload, "orgId" | "timestamp">) => Promise<McpDeleteAck>;
+    emitMcpTaskGroupUpdate: (payload: Omit<ForgeUpdateTaskGroupPayload, "orgId" | "timestamp">) => Promise<McpUpdateAck>;
+    emitMcpTaskGroupDelete: (payload: Omit<ForgeDeleteTaskGroupPayload, "orgId" | "timestamp">) => Promise<McpDeleteAck>;
+    emitMcpTaskRemoveDependency: (payload: Omit<ForgeRemoveTaskDependencyPayload, "orgId" | "timestamp">) => Promise<McpRemoveDependencyAck>;
+    emitMcpTaskGroupRemoveDependency: (payload: Omit<ForgeRemoveGroupDependencyPayload, "orgId" | "timestamp">) => Promise<McpRemoveDependencyAck>;
+    joinProject: (projectId: string) => TypedClientSocket;
+    leaveProject: (projectId: string) => TypedClientSocket;
+    joinMember: (memberId: string) => TypedClientSocket;
+    leaveMember: (memberId: string) => TypedClientSocket;
+    disconnect: () => TypedClientSocket;
+};
+export {};
+//# sourceMappingURL=socket-client.d.ts.map

package/dist/lib/socket-client.js

@@ -0,0 +1,160 @@
+import { io } from "socket.io-client";
+export function createSocketClient(serverUrl, token, orgId) {
+    const socket = io(`${serverUrl}/org:${orgId}`, {
+        auth: { token },
+        transports: ["websocket"],
+        reconnection: true,
+        reconnectionDelay: 1000,
+        reconnectionDelayMax: 30000,
+        reconnectionAttempts: Infinity,
+    });
+    return {
+        socket,
+        emitAgentStatus: (payload) => socket.emit("agent:status", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitAgentStream: (payload) => socket.emit("agent:stream", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitAgentToolActivity: (payload) => socket.emit("agent:tool-activity", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitTaskUpdate: (payload) => socket.emit("task:update", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitCliHeartbeat: (payload) => socket.emit("cli:heartbeat", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitTaskAskHuman: (payload) => socket.emit("task:ask-human", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitWorkflowStream: (payload) => socket.emit("workflow:stream", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitWorkflowStreamEnd: (payload) => socket.emit("workflow:stream:end", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitWorkflowQuestion: (payload) => socket.emit("workflow:question", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitWorkflowToolActivity: (payload) => socket.emit("workflow:tool-activity", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitWorkflowTokenUsage: (payload) => socket.emit("workflow:token-usage", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitStepComplete: (payload) => socket.emit("workflow:step:complete", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitWorkflowAgentIdle: (payload) => socket.emit("workflow:agent:idle", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitWorkflowAgentTimeout: (payload) => socket.emit("workflow:agent:timeout", {
+            ...payload,
+            orgId,
+            timestamp: new Date().toISOString(),
+        }),
+        emitTaskGroupCreate: (payload) => new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("Socket ack timeout for taskGroup:mcp:create (30s)")), 30_000);
+            socket.emit("taskGroup:mcp:create", { ...payload, orgId, timestamp: new Date().toISOString() }, (ack) => {
+                clearTimeout(timer);
+                resolve(ack);
+            });
+        }),
+        emitTaskGroupAddDependency: (payload) => new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("Socket ack timeout for taskGroup:mcp:add-dependency (30s)")), 30_000);
+            socket.emit("taskGroup:mcp:add-dependency", { ...payload, orgId, timestamp: new Date().toISOString() }, (ack) => {
+                clearTimeout(timer);
+                resolve(ack);
+            });
+        }),
+        emitTaskCreate: (payload) => new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("Socket ack timeout for task:mcp:create (30s)")), 30_000);
+            socket.emit("task:mcp:create", { ...payload, orgId, timestamp: new Date().toISOString() }, (ack) => {
+                clearTimeout(timer);
+                resolve(ack);
+            });
+        }),
+        emitTaskAddDependency: (payload) => new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("Socket ack timeout for task:mcp:add-dependency (30s)")), 30_000);
+            socket.emit("task:mcp:add-dependency", { ...payload, orgId, timestamp: new Date().toISOString() }, (ack) => {
+                clearTimeout(timer);
+                resolve(ack);
+            });
+        }),
+        emitMcpTaskUpdate: (payload) => new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("Socket ack timeout for task:mcp:update (30s)")), 30_000);
+            socket.emit("task:mcp:update", { ...payload, orgId, timestamp: new Date().toISOString() }, (ack) => {
+                clearTimeout(timer);
+                resolve(ack);
+            });
+        }),
+        emitMcpTaskDelete: (payload) => new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("Socket ack timeout for task:mcp:delete (30s)")), 30_000);
+            socket.emit("task:mcp:delete", { ...payload, orgId, timestamp: new Date().toISOString() }, (ack) => {
+                clearTimeout(timer);
+                resolve(ack);
+            });
+        }),
+        emitMcpTaskGroupUpdate: (payload) => new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("Socket ack timeout for taskGroup:mcp:update (30s)")), 30_000);
+            socket.emit("taskGroup:mcp:update", { ...payload, orgId, timestamp: new Date().toISOString() }, (ack) => {
+                clearTimeout(timer);
+                resolve(ack);
+            });
+        }),
+        emitMcpTaskGroupDelete: (payload) => new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("Socket ack timeout for taskGroup:mcp:delete (30s)")), 30_000);
+            socket.emit("taskGroup:mcp:delete", { ...payload, orgId, timestamp: new Date().toISOString() }, (ack) => {
+                clearTimeout(timer);
+                resolve(ack);
+            });
+        }),
+        emitMcpTaskRemoveDependency: (payload) => new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("Socket ack timeout for task:mcp:remove-dependency (30s)")), 30_000);
+            socket.emit("task:mcp:remove-dependency", { ...payload, orgId, timestamp: new Date().toISOString() }, (ack) => {
+                clearTimeout(timer);
+                resolve(ack);
+            });
+        }),
+        emitMcpTaskGroupRemoveDependency: (payload) => new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("Socket ack timeout for taskGroup:mcp:remove-dependency (30s)")), 30_000);
+            socket.emit("taskGroup:mcp:remove-dependency", { ...payload, orgId, timestamp: new Date().toISOString() }, (ack) => {
+                clearTimeout(timer);
+                resolve(ack);
+            });
+        }),
+        joinProject: (projectId) => socket.emit("join:project", projectId),
+        leaveProject: (projectId) => socket.emit("leave:project", projectId),
+        joinMember: (memberId) => socket.emit("join:member", memberId),
+        leaveMember: (memberId) => socket.emit("leave:member", memberId),
+        disconnect: () => socket.disconnect(),
+    };
+}
+//# sourceMappingURL=socket-client.js.map

package/dist/mcp/mcp-probe.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Probe the MCP server to verify it can start and respond to JSON-RPC initialize.
+ *
+ * Spawns `forgeai mcp --task-id probe --project-id probe --org-id probe`,
+ * sends a JSON-RPC initialize request, and verifies a response arrives
+ * within the timeout.
+ *
+ * Returns true if the MCP server is healthy, false otherwise.
+ */
+export declare function probeMcpHealth(): Promise<boolean>;
+//# sourceMappingURL=mcp-probe.d.ts.map

package/dist/mcp/mcp-probe.js

@@ -0,0 +1,106 @@
+import { spawn } from "node:child_process";
+import chalk from "chalk";
+const PROBE_TIMEOUT_MS = 10_000;
+/**
+ * Resolve the ForgeAI CLI binary for MCP probe.
+ * Same logic as agent-spawner's resolveForgeBinary.
+ */
+function resolveForgeBinary() {
+    const scriptPath = process.argv[1];
+    if (scriptPath) {
+        return { command: process.execPath, prefixArgs: [scriptPath] };
+    }
+    return { command: "forgeai", prefixArgs: [] };
+}
+/**
+ * Probe the MCP server to verify it can start and respond to JSON-RPC initialize.
+ *
+ * Spawns `forgeai mcp --task-id probe --project-id probe --org-id probe`,
+ * sends a JSON-RPC initialize request, and verifies a response arrives
+ * within the timeout.
+ *
+ * Returns true if the MCP server is healthy, false otherwise.
+ */
+export async function probeMcpHealth() {
+    const { command, prefixArgs } = resolveForgeBinary();
+    const args = [
+        ...prefixArgs,
+        "mcp",
+        "--task-id",
+        "probe",
+        "--project-id",
+        "probe",
+        "--org-id",
+        "probe",
+    ];
+    return new Promise((resolve) => {
+        let settled = false;
+        let stdout = "";
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            console.warn(chalk.yellow("[mcp-probe] Timeout — MCP server did not respond"));
+            child.kill("SIGTERM");
+            // Force kill if SIGTERM doesn't work after 2s
+            setTimeout(() => {
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    // Process already exited
+                }
+            }, 2_000);
+            resolve(false);
+        }, PROBE_TIMEOUT_MS);
+        const child = spawn(command, args, {
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: false,
+            env: { ...process.env },
+        });
+        child.on("error", (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            console.warn(chalk.yellow(`[mcp-probe] Failed to spawn MCP process: ${err.message}`));
+            resolve(false);
+        });
+        child.on("exit", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            // If process exits before we get a response, it's unhealthy
+            console.warn(chalk.yellow(`[mcp-probe] MCP process exited with code ${code}`));
+            resolve(false);
+        });
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+            // Look for JSON-RPC response with "result" containing "serverInfo"
+            // The MCP server responds with: {"jsonrpc":"2.0","id":0,"result":{"protocolVersion":"...","serverInfo":{"name":"forgeai",...},...}}
+            if (stdout.includes('"serverInfo"') && stdout.includes('"result"')) {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                console.log(chalk.green("[mcp-probe] MCP server is healthy"));
+                child.kill("SIGTERM");
+                resolve(true);
+            }
+        });
+        // Send JSON-RPC initialize request
+        const initRequest = JSON.stringify({
+            jsonrpc: "2.0",
+            id: 0,
+            method: "initialize",
+            params: {
+                protocolVersion: "2024-11-05",
+                capabilities: {},
+                clientInfo: { name: "forgeai-probe", version: "1.0.0" },
+            },
+        });
+        child.stdin?.write(initRequest + "\n");
+    });
+}
+//# sourceMappingURL=mcp-probe.js.map