@desplega.ai/agent-swarm 1.0.2 → 1.2.0

package/src/commands/worker.ts

@@ -0,0 +1,225 @@
+import { mkdir } from "node:fs/promises";
+
+export interface WorkerOptions {
+  prompt?: string;
+  yolo?: boolean;
+  additionalArgs?: string[];
+}
+
+interface RunClaudeIterationOptions {
+  prompt: string;
+  logFile: string;
+  additionalArgs?: string[];
+}
+
+async function runClaudeIteration(opts: RunClaudeIterationOptions): Promise<number> {
+  const CMD = [
+    "claude",
+    "--verbose",
+    "--output-format",
+    "stream-json",
+    "--dangerously-skip-permissions",
+    "--allow-dangerously-skip-permissions",
+    "--permission-mode",
+    "bypassPermissions",
+    "-p",
+    opts.prompt,
+  ];
+
+  if (opts.additionalArgs && opts.additionalArgs.length > 0) {
+    CMD.push(...opts.additionalArgs);
+  }
+
+  console.log(`[worker] Running: claude ... -p "${opts.prompt}"`);
+
+  const logFileHandle = Bun.file(opts.logFile).writer();
+
+  // Collect stderr for better error reporting
+  let stderrOutput = "";
+
+  const proc = Bun.spawn(CMD, {
+    env: process.env,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  console.log(`[worker] Process spawned, PID: ${proc.pid}`);
+  console.log(`[worker] Waiting for output streams...`);
+
+  let stdoutChunks = 0;
+  let stderrChunks = 0;
+
+  // Read stdout and stderr concurrently
+  const stdoutPromise = (async () => {
+    console.log(`[worker] stdout stream: ${proc.stdout ? "available" : "not available"}`);
+    if (proc.stdout) {
+      for await (const chunk of proc.stdout) {
+        stdoutChunks++;
+        const text = new TextDecoder().decode(chunk);
+        logFileHandle.write(text);
+        console.log(`[worker] stdout chunk #${stdoutChunks} (${chunk.length} bytes)`);
+
+        // Also parse and log to console for visibility
+        const lines = text.split("\n");
+        for (const line of lines) {
+          if (line.trim() === "") continue;
+          try {
+            const json = JSON.parse(line.trim());
+            // Log a summary of what's happening
+            if (json.type === "assistant" && json.message) {
+              const preview = json.message.slice(0, 100);
+              console.log(
+                `[worker] Assistant: ${preview}${json.message.length > 100 ? "..." : ""}`,
+              );
+            } else if (json.type === "tool_use") {
+              console.log(`[worker] Tool: ${json.tool || json.name || "unknown"}`);
+            } else if (json.type === "result") {
+              // Log result details
+              const resultPreview = JSON.stringify(json).slice(0, 200);
+              console.log(
+                `[worker] Result: ${resultPreview}${JSON.stringify(json).length > 200 ? "..." : ""}`,
+              );
+            } else if (json.type === "error") {
+              console.error(
+                `[worker] Error from Claude: ${json.error || json.message || JSON.stringify(json)}`,
+              );
+            } else if (json.type === "system") {
+              // Log system message details
+              const msg = json.message || json.content || "";
+              const preview =
+                typeof msg === "string" ? msg.slice(0, 150) : JSON.stringify(msg).slice(0, 150);
+              console.log(`[worker] System: ${preview}${preview.length >= 150 ? "..." : ""}`);
+            } else {
+              // Log unknown event types with content
+              console.log(
+                `[worker] Event type: ${json.type} - ${JSON.stringify(json).slice(0, 100)}`,
+              );
+            }
+          } catch {
+            // Non-JSON line, just log it
+            if (line.trim()) {
+              console.log(`[worker] Raw output: ${line.trim()}`);
+            }
+          }
+        }
+      }
+      console.log(`[worker] stdout stream ended (total ${stdoutChunks} chunks)`);
+    }
+  })();
+
+  const stderrPromise = (async () => {
+    console.log(`[worker] stderr stream: ${proc.stderr ? "available" : "not available"}`);
+    if (proc.stderr) {
+      for await (const chunk of proc.stderr) {
+        stderrChunks++;
+        const text = new TextDecoder().decode(chunk);
+        stderrOutput += text;
+        // Log stderr to console immediately
+        console.error(`[worker] stderr chunk #${stderrChunks}: ${text.trim()}`);
+        logFileHandle.write(
+          JSON.stringify({ type: "stderr", content: text, timestamp: new Date().toISOString() }) +
+            "\n",
+        );
+      }
+      console.log(`[worker] stderr stream ended (total ${stderrChunks} chunks)`);
+    }
+  })();
+
+  // Wait for both streams to finish
+  console.log(`[worker] Waiting for streams to complete...`);
+  await Promise.all([stdoutPromise, stderrPromise]);
+
+  await logFileHandle.end();
+  console.log(`[worker] Waiting for process to exit...`);
+  const exitCode = await proc.exited;
+
+  // Log final status
+  console.log(`[worker] Claude exited with code ${exitCode}`);
+  console.log(`[worker] Total stdout chunks: ${stdoutChunks}, stderr chunks: ${stderrChunks}`);
+
+  if (exitCode !== 0 && stderrOutput) {
+    console.error(`[worker] Full stderr output:\n${stderrOutput}`);
+  }
+
+  if (stdoutChunks === 0 && stderrChunks === 0) {
+    console.warn(`[worker] WARNING: No output received from Claude at all!`);
+    console.warn(`[worker] This might indicate Claude failed to start or auth issues.`);
+  }
+
+  return exitCode ?? 1;
+}
+
+export async function runWorker(opts: WorkerOptions) {
+  const sessionId = process.env.SESSION_ID || crypto.randomUUID().slice(0, 8);
+  // WORKER_LOG_DIR env var for Docker, otherwise ./logs
+  const baseLogDir = process.env.WORKER_LOG_DIR || "./logs";
+  const logDir = `${baseLogDir}/${sessionId}`;
+
+  // Create log directory
+  await mkdir(logDir, { recursive: true });
+
+  const defaultPrompt = "/start-worker Start or continue the tasks your leader assigned you!";
+  const prompt = opts.prompt || defaultPrompt;
+
+  const isYolo = opts.yolo || process.env.WORKER_YOLO === "true";
+
+  console.log(`[worker] Starting worker`);
+  console.log(`[worker] Session ID: ${sessionId}`);
+  console.log(`[worker] Log directory: ${logDir}`);
+  console.log(`[worker] YOLO mode: ${isYolo ? "enabled" : "disabled"}`);
+  console.log(`[worker] Prompt: ${prompt}`);
+
+  let iteration = 0;
+
+  while (true) {
+    iteration++;
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const logFile = `${logDir}/${timestamp}.jsonl`;
+
+    console.log(`\n[worker] === Iteration ${iteration} ===`);
+    console.log(`[worker] Logging to: ${logFile}`);
+
+    // Write iteration metadata at the start of each log file
+    const metadata = {
+      type: "worker_metadata",
+      sessionId,
+      iteration,
+      timestamp: new Date().toISOString(),
+      prompt,
+      yolo: isYolo,
+    };
+    await Bun.write(logFile, `${JSON.stringify(metadata)}\n`);
+
+    const exitCode = await runClaudeIteration({
+      prompt,
+      logFile,
+      additionalArgs: opts.additionalArgs,
+    });
+
+    if (exitCode !== 0) {
+      const errorLog = {
+        timestamp: new Date().toISOString(),
+        iteration,
+        exitCode,
+        error: true,
+      };
+
+      // Append to errors.jsonl
+      const errorsFile = `${logDir}/errors.jsonl`;
+      const existingErrors = (await Bun.file(errorsFile).exists())
+        ? await Bun.file(errorsFile).text()
+        : "";
+      await Bun.write(errorsFile, `${existingErrors + JSON.stringify(errorLog)}\n`);
+
+      if (!isYolo) {
+        console.error(`[worker] Claude exited with code ${exitCode}. Stopping.`);
+        console.error(`[worker] Error logged to: ${errorsFile}`);
+        process.exit(exitCode);
+      }
+
+      console.warn(`[worker] Claude exited with code ${exitCode}. YOLO mode - continuing...`);
+    }
+
+    console.log(`[worker] Iteration ${iteration} complete. Starting next iteration...`);
+  }
+}

package/src/hooks/hook.ts

@@ -3,196 +3,201 @@
 import pkg from "../../package.json";
 import type { Agent } from "../types";
 
-// @ts-ignore
 const SERVER_NAME = pkg.config?.name ?? "agent-swarm";
 
 type McpServerConfig = {
-	url: string;
-	headers: {
-		Authorization: string;
-		"X-Agent-ID": string;
-	};
+  url: string;
+  headers: {
+    Authorization: string;
+    "X-Agent-ID": string;
+  };
 };
 
 interface HookMessage {
-	hook_event_name: string;
-	session_id?: string;
-	transcript_path?: string;
-	permission_mode?: string;
-	cwd?: string;
-	source?: string;
-	trigger?: string;
-	custom_instructions?: string;
-	tool_name?: string;
-	tool_input?: Record<string, unknown>;
-	tool_response?: Record<string, unknown>;
-	tool_use_id?: string;
-	prompt?: string;
-	stop_hook_active?: boolean;
+  hook_event_name: string;
+  session_id?: string;
+  transcript_path?: string;
+  permission_mode?: string;
+  cwd?: string;
+  source?: string;
+  trigger?: string;
+  custom_instructions?: string;
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  tool_response?: Record<string, unknown>;
+  tool_use_id?: string;
+  prompt?: string;
+  stop_hook_active?: boolean;
 }
 
 /**
  * Main hook handler - processes Claude Code hook events
  */
 export async function handleHook(): Promise<void> {
-	const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-
-	let mcpConfig: McpServerConfig | undefined;
-
-	try {
-		const mcpFile = Bun.file(`${projectDir}/.mcp.json`);
-		if (await mcpFile.exists()) {
-			const config = await mcpFile.json();
-			mcpConfig = config?.mcpServers?.[SERVER_NAME] as McpServerConfig;
-		}
-	} catch {
-		// No config found, proceed without MCP
-	}
-
-	let msg: HookMessage;
-	try {
-		msg = await Bun.stdin.json();
-	} catch {
-		// No stdin or invalid JSON - exit silently
-		return;
-	}
-
-	const getBaseUrl = (): string => {
-		if (!mcpConfig) return "";
-		try {
-			const url = new URL(mcpConfig.url);
-			return url.origin;
-		} catch {
-			return "";
-		}
-	};
-
-	const ping = async (): Promise<void> => {
-		if (!mcpConfig) return;
-
-		try {
-			await fetch(`${getBaseUrl()}/ping`, {
-				method: "POST",
-				headers: mcpConfig.headers,
-			});
-		} catch {
-			// Silently fail - server might not be running
-		}
-	};
-
-	const close = async (): Promise<void> => {
-		if (!mcpConfig) return;
-
-		try {
-			await fetch(`${getBaseUrl()}/close`, {
-				method: "POST",
-				headers: mcpConfig.headers,
-			});
-		} catch {
-			// Silently fail
-		}
-	};
-
-	const getAgentInfo = async (): Promise<Agent | undefined> => {
-		if (!mcpConfig) return;
-
-		try {
-			const resp = await fetch(`${getBaseUrl()}/me`, {
-				method: "GET",
-				headers: mcpConfig.headers,
-			});
-
-			if ([400, 404].includes(resp.status)) {
-				return;
-			}
-
-			return (await resp.json()) as Agent;
-		} catch {
-			// Silently fail
-		}
-
-		return;
-	};
-
-	// Ping the server to indicate activity
-	await ping();
-
-	// Get current agent info
-	const agentInfo = await getAgentInfo();
-
-	// Always output agent status
-	if (agentInfo) {
-		console.log(
-			`You are registered as ${agentInfo.isLead ? "lead" : "worker"} agent "${agentInfo.name}" with ID: ${agentInfo.id} (status: ${agentInfo.status}) as of ${new Date().toISOString()}.`,
-		);
-	} else {
-		console.log(
-			`You are not registered in the agent swarm yet. Use the join-swarm tool to register yourself, then check your status with my-agent-info.
-
-If the ${SERVER_NAME} server is not running or disabled, disregard this message.`,
-		);
-	}
-
-	// Handle specific hook events
-	switch (msg.hook_event_name) {
-		case "SessionStart":
-			if (!agentInfo) break;
-
-			if (agentInfo.isLead) {
-				console.log(
-					`As the lead agent, you are responsible for coordinating the swarm to fulfill the user's request efficiently. Use the ${SERVER_NAME} tools to assign tasks to worker agents and monitor their progress.`,
-				);
-			} else {
-				console.log(
-					`As a worker agent, you should call the poll-task tool to wait for tasks assigned by the lead agent, unless specified otherwise.`,
-				);
-			}
-			break;
-
-		case "PreCompact":
-			// Covered by SessionStart hook
-			break;
-
-		case "PreToolUse":
-			// Nothing to do here for now
-			break;
-
-		case "PostToolUse":
-			if (agentInfo) {
-				if (agentInfo.isLead) {
-					if (msg.tool_name?.endsWith("send-task")) {
-						const maybeTaskId = (msg.tool_response as { task?: { id?: string } })
-							?.task?.id;
-
-						console.log(
-							`Task sent successfully.${maybeTaskId ? ` Task ID: ${maybeTaskId}.` : ""} Monitor progress using the get-task-details tool periodically.`,
-						);
-					}
-				} else {
-					console.log(
-						`Remember to call store-progress periodically to update the lead agent on your progress.`,
-					);
-				}
-			}
-			break;
-
-		case "UserPromptSubmit":
-			// Nothing specific for now
-			break;
-
-		case "Stop":
-			// Mark the agent as offline
-			await close();
-			break;
-
-		default:
-			break;
-	}
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+  let mcpConfig: McpServerConfig | undefined;
+
+  try {
+    const mcpFile = Bun.file(`${projectDir}/.mcp.json`);
+    if (await mcpFile.exists()) {
+      const config = await mcpFile.json();
+      mcpConfig = config?.mcpServers?.[SERVER_NAME] as McpServerConfig;
+    }
+  } catch {
+    // No config found, proceed without MCP
+  }
+
+  let msg: HookMessage;
+  try {
+    msg = await Bun.stdin.json();
+  } catch {
+    // No stdin or invalid JSON - exit silently
+    return;
+  }
+
+  const getBaseUrl = (): string => {
+    if (!mcpConfig) return "";
+    try {
+      const url = new URL(mcpConfig.url);
+      return url.origin;
+    } catch {
+      return "";
+    }
+  };
+
+  const hasAgentIdHeader = (): boolean => {
+    if (!mcpConfig) return false;
+    return Boolean(mcpConfig.headers["X-Agent-ID"]);
+  };
+
+  const ping = async (): Promise<void> => {
+    if (!mcpConfig) return;
+
+    try {
+      await fetch(`${getBaseUrl()}/ping`, {
+        method: "POST",
+        headers: mcpConfig.headers,
+      });
+    } catch {
+      // Silently fail - server might not be running
+    }
+  };
+
+  const close = async (): Promise<void> => {
+    if (!mcpConfig) return;
+
+    try {
+      await fetch(`${getBaseUrl()}/close`, {
+        method: "POST",
+        headers: mcpConfig.headers,
+      });
+    } catch {
+      // Silently fail
+    }
+  };
+
+  const getAgentInfo = async (): Promise<Agent | undefined> => {
+    if (!mcpConfig) return;
+
+    try {
+      const resp = await fetch(`${getBaseUrl()}/me`, {
+        method: "GET",
+        headers: mcpConfig.headers,
+      });
+
+      if ([400, 404].includes(resp.status)) {
+        return;
+      }
+
+      return (await resp.json()) as Agent;
+    } catch {
+      // Silently fail
+    }
+
+    return;
+  };
+
+  // Ping the server to indicate activity
+  await ping();
+
+  // Get current agent info
+  const agentInfo = await getAgentInfo();
+
+  // Always output agent status
+  if (agentInfo) {
+    console.log(
+      `You are registered as ${agentInfo.isLead ? "lead" : "worker"} agent "${agentInfo.name}" with ID: ${agentInfo.id} (status: ${agentInfo.status}) as of ${new Date().toISOString()}.`,
+    );
+  } else {
+    console.log(
+      `You are not registered in the agent swarm yet. Use the join-swarm tool to register yourself, then check your status with my-agent-info.
+
+If the ${SERVER_NAME} server is not running or disabled, disregard this message.
+
+${hasAgentIdHeader() ? `You have a pre-defined agent ID via header: ${mcpConfig?.headers["X-Agent-ID"]}, it will be used automatically on join-swarm.` : "You do not have a pre-defined agent ID, you will receive one when you join the swarm, or optionally you can request one when calling join-swarm."}`,
+    );
+  }
+
+  // Handle specific hook events
+  switch (msg.hook_event_name) {
+    case "SessionStart":
+      if (!agentInfo) break;
+
+      if (agentInfo.isLead) {
+        console.log(
+          `As the lead agent, you are responsible for coordinating the swarm to fulfill the user's request efficiently. Use the ${SERVER_NAME} tools to assign tasks to worker agents and monitor their progress.`,
+        );
+      } else {
+        console.log(
+          `As a worker agent, you should call the poll-task tool to wait for tasks assigned by the lead agent, unless specified otherwise.`,
+        );
+      }
+      break;
+
+    case "PreCompact":
+      // Covered by SessionStart hook
+      break;
+
+    case "PreToolUse":
+      // Nothing to do here for now
+      break;
+
+    case "PostToolUse":
+      if (agentInfo) {
+        if (agentInfo.isLead) {
+          if (msg.tool_name?.endsWith("send-task")) {
+            const maybeTaskId = (msg.tool_response as { task?: { id?: string } })?.task?.id;
+
+            console.log(
+              `Task sent successfully.${maybeTaskId ? ` Task ID: ${maybeTaskId}.` : ""} Monitor progress using the get-task-details tool periodically.`,
+            );
+          }
+        } else {
+          console.log(
+            `Remember to call store-progress periodically to update the lead agent on your progress.`,
+          );
+        }
+      }
+      break;
+
+    case "UserPromptSubmit":
+      // Nothing specific for now
+      break;
+
+    case "Stop":
+      // Mark the agent as offline
+      await close();
+      break;
+
+    default:
+      break;
+  }
 }
 
 // Run directly when executed as a script
 const isMainModule = import.meta.main;
 if (isMainModule) {
-	await handleHook();
-	process.exit(0);
+  await handleHook();
+  process.exit(0);
 }

package/src/server.ts

@@ -1,4 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import pkg from "../package.json";
 import { initDb } from "./be/db";
 import { registerGetSwarmTool } from "./tools/get-swarm";
 import { registerGetTaskDetailsTool } from "./tools/get-task-details";
@@ -8,8 +9,6 @@ import { registerMyAgentInfoTool } from "./tools/my-agent-info";
 import { registerPollTaskTool } from "./tools/poll-task";
 import { registerSendTaskTool } from "./tools/send-task";
 import { registerStoreProgressTool } from "./tools/store-progress";
-import pkg from "../package.json";
-
 
 export function createServer() {
   // Initialize database with WAL mode

package/src/tools/get-task-details.ts

@@ -1,8 +1,8 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
-import { getTaskById } from "@/be/db";
+import { getLogsByTaskIdChronological, getTaskById } from "@/be/db";
 import { createToolRegistrar } from "@/tools/utils";
-import { AgentTaskSchema } from "@/types";
+import { AgentLogSchema, AgentTaskSchema } from "@/types";
 
 export const registerGetTaskDetailsTool = (server: McpServer) => {
   createToolRegistrar(server)(
@@ -10,7 +10,7 @@ export const registerGetTaskDetailsTool = (server: McpServer) => {
     {
       title: "Get task details",
       description:
-        "Returns detailed information about a specific task, including output and failure reason.",
+        "Returns detailed information about a specific task, including output, failure reason, and log history.",
       inputSchema: z.object({
         taskId: z.uuid().describe("The ID of the task to get details for."),
       }),
@@ -18,6 +18,7 @@ export const registerGetTaskDetailsTool = (server: McpServer) => {
         success: z.boolean(),
         message: z.string(),
         task: AgentTaskSchema.optional(),
+        logs: z.array(AgentLogSchema).optional(),
       }),
     },
     async ({ taskId }, requestInfo, _meta) => {
@@ -34,6 +35,8 @@ export const registerGetTaskDetailsTool = (server: McpServer) => {
         };
       }
 
+      const logs = getLogsByTaskIdChronological(taskId);
+
       return {
         content: [{ type: "text", text: `Task "${taskId}" details retrieved.` }],
         structuredContent: {
@@ -41,6 +44,7 @@ export const registerGetTaskDetailsTool = (server: McpServer) => {
           success: true,
           message: `Task "${taskId}" details retrieved.`,
           task,
+          logs,
         },
       };
     },