@desplega.ai/agent-swarm 1.10.0 → 1.10.3

package/.claude/settings.local.json

@@ -22,7 +22,9 @@
       "Bash(bun run build:*)",
       "Bash(pnpm run build:*)",
       "WebFetch(domain:geminicli.com)",
-      "Bash(bun run docs:mcp:*)"
+      "Bash(bun run docs:mcp:*)",
+      "Bash(bun test:*)",
+      "Bash(curl:*)"
     ]
   },
   "enableAllProjectMcpServers": true,

package/Dockerfile.worker

@@ -118,7 +118,7 @@ WORKDIR /workspace
 VOLUME ["/logs"]
 
 RUN mkdir -p ./personal ./shared
-VOLUME ["/workspace/personal" "/workspace/shared"]
+VOLUME ["/workspace/personal", "/workspace/shared"]
 
 # Expose service port for PM2 processes
 EXPOSE 3000

package/package.json

@@ -1,7 +1,26 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.10.0",
+  "version": "1.10.3",
   "description": "Agent orchestration layer MCP for Claude Code, Codex, Gemini CLI, and more!",
+  "license": "MIT",
+  "author": "desplega.ai <contact@desplega.ai>",
+  "maintainers": [
+    {
+      "name": "Taras",
+      "email": "t@desplega.ai"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/desplega-ai/agent-swarm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/desplega-ai/agent-swarm/issues"
+  },
+  "homepage": "https://github.com/desplega-ai/agent-swarm#readme",
+  "publishConfig": {
+    "access": "public"
+  },
   "module": "src/http.ts",
   "type": "module",
   "bin": {

package/src/be/db.ts

@@ -13,6 +13,7 @@ import type {
   ChannelType,
   Service,
   ServiceStatus,
+  SessionLog,
 } from "../types";
 
 let db: Database | null = null;
@@ -149,6 +150,21 @@ export function initDb(dbPath = "./agent-swarm-db.sqlite"): Database {
 
     CREATE INDEX IF NOT EXISTS idx_services_agentId ON services(agentId);
     CREATE INDEX IF NOT EXISTS idx_services_status ON services(status);
+
+    -- Session logs table (raw CLI output from runner)
+    CREATE TABLE IF NOT EXISTS session_logs (
+      id TEXT PRIMARY KEY,
+      taskId TEXT,
+      sessionId TEXT NOT NULL,
+      iteration INTEGER NOT NULL,
+      cli TEXT NOT NULL DEFAULT 'claude',
+      content TEXT NOT NULL,
+      lineNumber INTEGER NOT NULL,
+      createdAt TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_logs_taskId ON session_logs(taskId);
+    CREATE INDEX IF NOT EXISTS idx_session_logs_sessionId ON session_logs(sessionId);
   `);
 
   // Seed default general channel if it doesn't exist
@@ -1919,3 +1935,88 @@ export function deleteServicesByAgentId(agentId: string): number {
   const result = getDb().run("DELETE FROM services WHERE agentId = ?", [agentId]);
   return result.changes;
 }
+
+// ============================================================================
+// Session Log Operations (raw CLI output)
+// ============================================================================
+
+type SessionLogRow = {
+  id: string;
+  taskId: string | null;
+  sessionId: string;
+  iteration: number;
+  cli: string;
+  content: string;
+  lineNumber: number;
+  createdAt: string;
+};
+
+function rowToSessionLog(row: SessionLogRow): SessionLog {
+  return {
+    id: row.id,
+    taskId: row.taskId ?? undefined,
+    sessionId: row.sessionId,
+    iteration: row.iteration,
+    cli: row.cli,
+    content: row.content,
+    lineNumber: row.lineNumber,
+    createdAt: row.createdAt,
+  };
+}
+
+export const sessionLogQueries = {
+  insert: () =>
+    getDb().prepare<SessionLogRow, [string, string | null, string, number, string, string, number]>(
+      `INSERT INTO session_logs (id, taskId, sessionId, iteration, cli, content, lineNumber, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) RETURNING *`,
+    ),
+
+  insertBatch: () =>
+    getDb().prepare<null, [string, string | null, string, number, string, string, number]>(
+      `INSERT INTO session_logs (id, taskId, sessionId, iteration, cli, content, lineNumber, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`,
+    ),
+
+  getByTaskId: () =>
+    getDb().prepare<SessionLogRow, [string]>(
+      "SELECT * FROM session_logs WHERE taskId = ? ORDER BY iteration ASC, lineNumber ASC",
+    ),
+
+  getBySessionId: () =>
+    getDb().prepare<SessionLogRow, [string, number]>(
+      "SELECT * FROM session_logs WHERE sessionId = ? AND iteration = ? ORDER BY lineNumber ASC",
+    ),
+};
+
+export function createSessionLogs(logs: {
+  taskId?: string;
+  sessionId: string;
+  iteration: number;
+  cli: string;
+  lines: string[];
+}): void {
+  const stmt = sessionLogQueries.insertBatch();
+  getDb().transaction(() => {
+    for (let i = 0; i < logs.lines.length; i++) {
+      const line = logs.lines[i];
+      if (line === undefined) continue;
+      stmt.run(
+        crypto.randomUUID(),
+        logs.taskId ?? null,
+        logs.sessionId,
+        logs.iteration,
+        logs.cli,
+        line,
+        i,
+      );
+    }
+  })();
+}
+
+export function getSessionLogsByTaskId(taskId: string): SessionLog[] {
+  return sessionLogQueries.getByTaskId().all(taskId).map(rowToSessionLog);
+}
+
+export function getSessionLogsBySession(sessionId: string, iteration: number): SessionLog[] {
+  return sessionLogQueries.getBySessionId().all(sessionId, iteration).map(rowToSessionLog);
+}

package/src/commands/runner.ts

@@ -53,6 +53,71 @@ interface RunClaudeIterationOptions {
   systemPrompt?: string;
   additionalArgs?: string[];
   role: string;
+  // New fields for log streaming
+  apiUrl?: string;
+  apiKey?: string;
+  agentId?: string;
+  sessionId?: string;
+  iteration?: number;
+  taskId?: string;
+}
+
+/** Buffer for session logs */
+interface LogBuffer {
+  lines: string[];
+  lastFlush: number;
+}
+
+/** Configuration for log streaming */
+const LOG_BUFFER_SIZE = 50; // Flush after this many lines
+const LOG_FLUSH_INTERVAL_MS = 5000; // Flush every 5 seconds
+
+/** Push buffered logs to the API */
+async function flushLogBuffer(
+  buffer: LogBuffer,
+  opts: {
+    apiUrl: string;
+    apiKey: string;
+    agentId: string;
+    sessionId: string;
+    iteration: number;
+    taskId?: string;
+    cli?: string;
+  },
+): Promise<void> {
+  if (buffer.lines.length === 0) return;
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "X-Agent-ID": opts.agentId,
+  };
+  if (opts.apiKey) {
+    headers.Authorization = `Bearer ${opts.apiKey}`;
+  }
+
+  try {
+    const response = await fetch(`${opts.apiUrl}/api/session-logs`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        sessionId: opts.sessionId,
+        iteration: opts.iteration,
+        taskId: opts.taskId,
+        cli: opts.cli || "claude",
+        lines: buffer.lines,
+      }),
+    });
+
+    if (!response.ok) {
+      console.warn(`[runner] Failed to push logs: ${response.status}`);
+    }
+  } catch (error) {
+    console.warn(`[runner] Error pushing logs: ${error}`);
+  }
+
+  // Clear buffer after flush
+  buffer.lines = [];
+  buffer.lastFlush = Date.now();
 }
 
 /** Trigger types returned by the poll API */
@@ -206,6 +271,10 @@ async function runClaudeIteration(opts: RunClaudeIterationOptions): Promise<numb
 
   const stdoutPromise = (async () => {
     if (proc.stdout) {
+      // Initialize log buffer for API streaming
+      const logBuffer: LogBuffer = { lines: [], lastFlush: Date.now() };
+      const shouldStream = opts.apiUrl && opts.sessionId && opts.iteration;
+
       for await (const chunk of proc.stdout) {
         stdoutChunks++;
         const text = new TextDecoder().decode(chunk);
@@ -214,8 +283,43 @@ async function runClaudeIteration(opts: RunClaudeIterationOptions): Promise<numb
         const lines = text.split("\n");
         for (const line of lines) {
           prettyPrintLine(line, role);
+
+          // Buffer non-empty lines for API streaming
+          if (shouldStream && line.trim()) {
+            logBuffer.lines.push(line.trim());
+
+            // Check if we should flush (buffer full or time elapsed)
+            const shouldFlush =
+              logBuffer.lines.length >= LOG_BUFFER_SIZE ||
+              Date.now() - logBuffer.lastFlush >= LOG_FLUSH_INTERVAL_MS;
+
+            if (shouldFlush) {
+              await flushLogBuffer(logBuffer, {
+                apiUrl: opts.apiUrl!,
+                apiKey: opts.apiKey || "",
+                agentId: opts.agentId || "",
+                sessionId: opts.sessionId!,
+                iteration: opts.iteration!,
+                taskId: opts.taskId,
+                cli: "claude",
+              });
+            }
+          }
         }
       }
+
+      // Final flush for remaining buffered logs
+      if (shouldStream && logBuffer.lines.length > 0) {
+        await flushLogBuffer(logBuffer, {
+          apiUrl: opts.apiUrl!,
+          apiKey: opts.apiKey || "",
+          agentId: opts.agentId || "",
+          sessionId: opts.sessionId!,
+          iteration: opts.iteration!,
+          taskId: opts.taskId,
+          cli: "claude",
+        });
+      }
     }
   })();
 
@@ -398,6 +502,13 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
         systemPrompt: resolvedSystemPrompt,
         additionalArgs: opts.additionalArgs,
         role,
+        // Add streaming options
+        apiUrl,
+        apiKey,
+        agentId,
+        sessionId,
+        iteration,
+        taskId: trigger.taskId,
       });
 
       if (exitCode !== 0) {

package/src/http.ts

@@ -11,6 +11,7 @@ import { createServer } from "@/server";
 import {
   closeDb,
   createAgent,
+  createSessionLogs,
   getAgentById,
   getAgentWithTasks,
   getAllAgents,
@@ -28,6 +29,7 @@ import {
   getOfferedTasksForAgent,
   getPendingTaskForAgent,
   getServicesByAgentId,
+  getSessionLogsByTaskId,
   getTaskById,
   getUnassignedTasksCount,
   postMessage,
@@ -354,6 +356,76 @@ const httpServer = createHttpServer(async (req, res) => {
     return;
   }
 
+  // POST /api/session-logs - Store session logs (batch)
+  if (req.method === "POST" && pathSegments[0] === "api" && pathSegments[1] === "session-logs") {
+    // Parse request body
+    const chunks: Buffer[] = [];
+    for await (const chunk of req) {
+      chunks.push(chunk);
+    }
+    const body = JSON.parse(Buffer.concat(chunks).toString());
+
+    // Validate required fields
+    if (!body.sessionId || typeof body.sessionId !== "string") {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Missing or invalid 'sessionId' field" }));
+      return;
+    }
+
+    if (typeof body.iteration !== "number" || body.iteration < 1) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Missing or invalid 'iteration' field" }));
+      return;
+    }
+
+    if (!Array.isArray(body.lines) || body.lines.length === 0) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Missing or invalid 'lines' array" }));
+      return;
+    }
+
+    try {
+      createSessionLogs({
+        taskId: body.taskId || undefined,
+        sessionId: body.sessionId,
+        iteration: body.iteration,
+        cli: body.cli || "claude",
+        lines: body.lines,
+      });
+
+      res.writeHead(201, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true, count: body.lines.length }));
+    } catch (error) {
+      console.error("[HTTP] Failed to create session logs:", error);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Failed to store session logs" }));
+    }
+    return;
+  }
+
+  // GET /api/tasks/:id/session-logs - Get session logs for a task
+  if (
+    req.method === "GET" &&
+    pathSegments[0] === "api" &&
+    pathSegments[1] === "tasks" &&
+    pathSegments[2] &&
+    pathSegments[3] === "session-logs"
+  ) {
+    const taskId = pathSegments[2];
+    const task = getTaskById(taskId);
+
+    if (!task) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Task not found" }));
+      return;
+    }
+
+    const logs = getSessionLogsByTaskId(taskId);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ logs }));
+    return;
+  }
+
   // GET /ecosystem - Generate PM2 ecosystem config for agent's services
   if (req.method === "GET" && req.url === "/ecosystem") {
     if (!myAgentId) {