@desplega.ai/agent-swarm 1.0.1 → 1.2.0

package/deploy/agent-swarm.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=Agent Swarm MCP Server
+After=network.target
+
+[Service]
+Type=simple
+User=root
+Group=root
+WorkingDirectory=/opt/agent-swarm
+ExecStart=/usr/local/bin/bun run start:http
+ExecStartPost=/bin/sh -c 'sleep 2 && curl -sf http://localhost:3013/health || exit 1'
+Restart=always
+RestartSec=5
+EnvironmentFile=/opt/agent-swarm/.env
+
+[Install]
+WantedBy=multi-user.target

package/deploy/install.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun";
+
+const APP_DIR = "/opt/agent-swarm";
+const SERVICE_FILE = "/etc/systemd/system/agent-swarm.service";
+const SCRIPT_DIR = import.meta.dir;
+const PROJECT_DIR = `${SCRIPT_DIR}/..`;
+
+// Detect bun path
+const bunPath = (await $`which bun`.text()).trim();
+console.log(`Using bun at: ${bunPath}`);
+
+// Copy project files
+await $`mkdir -p ${APP_DIR}`;
+await $`cp -r ${PROJECT_DIR}/src ${APP_DIR}/`;
+await $`cp ${PROJECT_DIR}/package.json ${PROJECT_DIR}/bun.lock ${PROJECT_DIR}/tsconfig.json ${APP_DIR}/`;
+
+// Install dependencies
+await $`cd ${APP_DIR} && bun install --frozen-lockfile --production`;
+
+// Create .env if not exists
+const envFile = Bun.file(`${APP_DIR}/.env`);
+if (!(await envFile.exists())) {
+  await Bun.write(envFile, `PORT=3013
+API_KEY=
+`);
+  console.log("Created .env - set API_KEY for authentication");
+}
+
+// Set ownership
+await $`chown -R root:root ${APP_DIR}`;
+
+// Install systemd service with detected bun path
+const serviceContent = `[Unit]
+Description=Agent Swarm MCP Server
+After=network.target
+
+[Service]
+Type=simple
+User=root
+Group=root
+WorkingDirectory=${APP_DIR}
+ExecStart=${bunPath} run start:http
+ExecStartPost=/bin/sh -c 'sleep 2 && curl -sf http://localhost:3013/health || exit 1'
+Restart=always
+RestartSec=5
+EnvironmentFile=${APP_DIR}/.env
+
+[Install]
+WantedBy=multi-user.target
+`;
+
+await Bun.write(SERVICE_FILE, serviceContent);
+
+// Healthcheck service (runs curl, restarts main service on failure)
+const healthcheckService = `[Unit]
+Description=Agent Swarm Health Check
+
+[Service]
+Type=oneshot
+ExecStart=/bin/sh -c 'curl -sf http://localhost:3013/health || systemctl restart agent-swarm'
+`;
+
+// Timer to run healthcheck every 30 seconds
+const healthcheckTimer = `[Unit]
+Description=Agent Swarm Health Check Timer
+
+[Timer]
+OnBootSec=30s
+OnUnitActiveSec=30s
+
+[Install]
+WantedBy=timers.target
+`;
+
+await Bun.write("/etc/systemd/system/agent-swarm-healthcheck.service", healthcheckService);
+await Bun.write("/etc/systemd/system/agent-swarm-healthcheck.timer", healthcheckTimer);
+
+await $`systemctl daemon-reload`;
+await $`systemctl enable agent-swarm agent-swarm-healthcheck.timer`;
+await $`systemctl restart agent-swarm`;
+await $`systemctl start agent-swarm-healthcheck.timer`;
+
+console.log("Installed and running with health checks every 30s.");

package/deploy/prod-db.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun";
+import * as readline from "node:readline";
+
+const DB_PATH = "/opt/agent-swarm/agent-swarm-db.sqlite";
+const SSH_HOST = process.argv[2] || "hetzner";
+
+console.log(`Connected to ${SSH_HOST}:${DB_PATH}`);
+console.log("Type SQL queries or .tables, .schema, etc. Ctrl+C to exit.\n");
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  prompt: "sqlite> ",
+});
+
+rl.prompt();
+
+rl.on("line", async (line) => {
+  const query = line.trim();
+  if (!query) {
+    rl.prompt();
+    return;
+  }
+
+  try {
+    // Escape single quotes in query and wrap in single quotes for remote shell
+    const escaped = query.replace(/'/g, "'\\''");
+    const result = await $`ssh ${SSH_HOST} sqlite3 -header -column ${DB_PATH} ${"'" + escaped + "'"}`.text();
+    if (result) console.log(result);
+  } catch (e: any) {
+    console.error(e.stderr?.toString() || e.message);
+  }
+
+  rl.prompt();
+});
+
+rl.on("close", () => {
+  console.log("\nBye!");
+  process.exit(0);
+});

package/deploy/uninstall.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun";
+
+await $`systemctl stop agent-swarm agent-swarm-healthcheck.timer`.nothrow();
+await $`systemctl disable agent-swarm agent-swarm-healthcheck.timer`.nothrow();
+await $`rm -f /etc/systemd/system/agent-swarm.service`;
+await $`rm -f /etc/systemd/system/agent-swarm-healthcheck.service`;
+await $`rm -f /etc/systemd/system/agent-swarm-healthcheck.timer`;
+await $`systemctl daemon-reload`;
+
+console.log("Service removed. Data remains at /opt/agent-swarm");

package/deploy/update.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun";
+
+const APP_DIR = "/opt/agent-swarm";
+const SCRIPT_DIR = import.meta.dir;
+const PROJECT_DIR = `${SCRIPT_DIR}/..`;
+
+console.log("Updating agent-swarm...");
+
+// Copy project files
+await $`cp -r ${PROJECT_DIR}/src ${APP_DIR}/`;
+await $`cp ${PROJECT_DIR}/package.json ${PROJECT_DIR}/bun.lock ${PROJECT_DIR}/tsconfig.json ${APP_DIR}/`;
+
+// Install dependencies
+await $`cd ${APP_DIR} && bun install --frozen-lockfile --production`;
+
+// Restart service
+await $`systemctl restart agent-swarm`;
+
+console.log("Updated and restarted.");

package/docker-compose.worker.yml

@@ -0,0 +1,35 @@
+# Docker Compose for Agent Swarm Worker
+#
+# Usage:
+#   docker-compose -f docker-compose.worker.yml up --build
+#
+# Required environment variables (in .env.docker or passed directly):
+#   - CLAUDE_CODE_OAUTH_TOKEN: OAuth token for Claude CLI
+#   - API_KEY: API key for MCP server authentication
+#
+# Optional environment variables:
+#   - AGENT_ID: UUID for agent identification (assigned on join if not set)
+#   - MCP_BASE_URL: MCP server URL (default: http://host.docker.internal:3013)
+#   - SESSION_ID: Folder name for logs (auto-generated if not provided)
+#   - WORKER_YOLO: If "true", continue on errors (default: false)
+
+services:
+  worker:
+    build:
+      context: .
+      dockerfile: Dockerfile.worker
+    environment:
+      - CLAUDE_CODE_OAUTH_TOKEN=${CLAUDE_CODE_OAUTH_TOKEN}
+      - API_KEY=${API_KEY}
+      - AGENT_ID=${AGENT_ID:-}
+      # Use host.docker.internal to reach host's localhost on Mac/Windows
+      # On Linux, use --add-host=host.docker.internal:host-gateway or --network host
+      - MCP_BASE_URL=${MCP_BASE_URL:-http://host.docker.internal:3013}
+      - SESSION_ID=${SESSION_ID:-}
+      - WORKER_YOLO=${WORKER_YOLO:-false}
+    volumes:
+      - ./logs:/logs
+      # Optional: mount a workspace directory for persistent work
+      # - ./workspace:/workspace
+    restart: unless-stopped
+    # No port mappings needed - worker only makes outbound connections

package/docker-entrypoint.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+set -e
+
+# Validate required environment variables
+if [ -z "$CLAUDE_CODE_OAUTH_TOKEN" ]; then
+    echo "Error: CLAUDE_CODE_OAUTH_TOKEN environment variable is required"
+    exit 1
+fi
+
+if [ -z "$API_KEY" ]; then
+    echo "Error: API_KEY environment variable is required"
+    exit 1
+fi
+
+MCP_URL="${MCP_BASE_URL:-http://host.docker.internal:3013}"
+
+echo "=== Agent Swarm Worker ==="
+echo "Agent ID: ${AGENT_ID:-<not set>}"
+echo "MCP Base URL: $MCP_URL"
+echo "YOLO Mode: ${WORKER_YOLO:-false}"
+echo "Session ID: ${SESSION_ID:-<auto-generated>}"
+echo "Working Directory: /workspace"
+echo "=========================="
+
+# Create .mcp.json in /workspace (project-level config)
+echo "Creating MCP config in /workspace..."
+if [ -n "$AGENT_ID" ]; then
+    # With AGENT_ID header
+    cat > /workspace/.mcp.json << EOF
+{
+  "mcpServers": {
+    "agent-swarm": {
+      "type": "http",
+      "url": "${MCP_URL}/mcp",
+      "headers": {
+        "Authorization": "Bearer ${API_KEY}",
+        "X-Agent-ID": "${AGENT_ID}"
+      }
+    }
+  }
+}
+EOF
+else
+    # Without AGENT_ID header
+    cat > /workspace/.mcp.json << EOF
+{
+  "mcpServers": {
+    "agent-swarm": {
+      "type": "http",
+      "url": "${MCP_URL}/mcp",
+      "headers": {
+        "Authorization": "Bearer ${API_KEY}"
+      }
+    }
+  }
+}
+EOF
+fi
+
+# Run the worker using compiled binary
+echo "Starting worker..."
+exec /usr/local/bin/agent-swarm worker "$@"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "Agent orchestration layer MCP for Claude Code, Codex, Gemini CLI, and more!",
   "module": "src/stdio.ts",
   "type": "module",
@@ -17,6 +17,8 @@
     "hook": "bun src/hooks/hook.ts",
     "claude": "bun src/cli.tsx claude",
     "claude:headless": "bun src/cli.tsx claude --headless",
+    "worker": "bun src/cli.tsx worker",
+    "worker:yolo": "bun src/cli.tsx worker --yolo",
     "dev": "bun --hot src/stdio.ts",
     "dev:http": "bun --hot src/http.ts",
     "start": "bun src/stdio.ts",
@@ -25,7 +27,11 @@
     "inspector:http": "bunx @modelcontextprotocol/inspector --transport http http://localhost:3013/mcp",
     "lint": "biome check src",
     "lint:fix": "biome check --write src",
-    "format": "biome format --write src"
+    "format": "biome format --write src",
+    "build:binary": "bun build ./src/cli.tsx --compile --target=bun-linux-x64 --outfile ./dist/agent-swarm",
+    "build:binary:arm64": "bun build ./src/cli.tsx --compile --target=bun-linux-arm64 --outfile ./dist/agent-swarm",
+    "docker:build:worker": "docker build -f Dockerfile.worker -t agent-swarm-worker .",
+    "docker:run:worker": "docker run --rm -it --env-file .env.docker -v ./logs:/logs agent-swarm-worker"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.9",
@@ -41,6 +47,7 @@
     "date-fns": "^4.1.0",
     "ink": "^6.5.1",
     "react": "^19.2.3",
+    "react-devtools-core": "^7.0.1",
     "zod": "^4.2.1"
   }
 }

package/src/be/db.ts

@@ -1,9 +1,17 @@
 import { Database } from "bun:sqlite";
-import type { Agent, AgentStatus, AgentTask, AgentTaskStatus, AgentWithTasks } from "../types";
+import type {
+  Agent,
+  AgentLog,
+  AgentLogEventType,
+  AgentStatus,
+  AgentTask,
+  AgentTaskStatus,
+  AgentWithTasks,
+} from "../types";
 
 let db: Database | null = null;
 
-export function initDb(dbPath = "./cc-orch.sqlite"): Database {
+export function initDb(dbPath = "./agent-swarm-db.sqlite"): Database {
   if (db) {
     return db;
   }
@@ -38,6 +46,22 @@ export function initDb(dbPath = "./cc-orch.sqlite"): Database {
 
     CREATE INDEX IF NOT EXISTS idx_agent_tasks_agentId ON agent_tasks(agentId);
     CREATE INDEX IF NOT EXISTS idx_agent_tasks_status ON agent_tasks(status);
+
+    CREATE TABLE IF NOT EXISTS agent_log (
+      id TEXT PRIMARY KEY,
+      eventType TEXT NOT NULL,
+      agentId TEXT,
+      taskId TEXT,
+      oldValue TEXT,
+      newValue TEXT,
+      metadata TEXT,
+      createdAt TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_log_agentId ON agent_log(agentId);
+    CREATE INDEX IF NOT EXISTS idx_agent_log_taskId ON agent_log(taskId);
+    CREATE INDEX IF NOT EXISTS idx_agent_log_eventType ON agent_log(eventType);
+    CREATE INDEX IF NOT EXISTS idx_agent_log_createdAt ON agent_log(createdAt);
   `);
 
   return db;
@@ -105,6 +129,9 @@ export function createAgent(
   const id = agent.id ?? crypto.randomUUID();
   const row = agentQueries.insert().get(id, agent.name, agent.isLead ? 1 : 0, agent.status);
   if (!row) throw new Error("Failed to create agent");
+  try {
+    createLogEntry({ eventType: "agent_joined", agentId: id, newValue: agent.status });
+  } catch {}
   return rowToAgent(row);
 }
 
@@ -118,11 +145,28 @@ export function getAllAgents(): Agent[] {
 }
 
 export function updateAgentStatus(id: string, status: AgentStatus): Agent | null {
+  const oldAgent = getAgentById(id);
   const row = agentQueries.updateStatus().get(status, id);
+  if (row && oldAgent) {
+    try {
+      createLogEntry({
+        eventType: "agent_status_change",
+        agentId: id,
+        oldValue: oldAgent.status,
+        newValue: status,
+      });
+    } catch {}
+  }
   return row ? rowToAgent(row) : null;
 }
 
 export function deleteAgent(id: string): boolean {
+  const agent = getAgentById(id);
+  if (agent) {
+    try {
+      createLogEntry({ eventType: "agent_left", agentId: id, oldValue: agent.status });
+    } catch {}
+  }
   const result = getDb().run("DELETE FROM agents WHERE id = ?", [id]);
   return result.changes > 0;
 }
@@ -206,6 +250,9 @@ export function createTask(agentId: string, task: string): AgentTask {
   const id = crypto.randomUUID();
   const row = taskQueries.insert().get(id, agentId, task, "pending");
   if (!row) throw new Error("Failed to create task");
+  try {
+    createLogEntry({ eventType: "task_created", agentId, taskId: id, newValue: "pending" });
+  } catch {}
   return rowToAgentTask(row);
 }
 
@@ -219,12 +266,24 @@ export function getPendingTaskForAgent(agentId: string): AgentTask | null {
 }
 
 export function startTask(taskId: string): AgentTask | null {
+  const oldTask = getTaskById(taskId);
   const row = getDb()
     .prepare<AgentTaskRow, [string]>(
       `UPDATE agent_tasks SET status = 'in_progress', lastUpdatedAt = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
        WHERE id = ? RETURNING *`,
     )
     .get(taskId);
+  if (row && oldTask) {
+    try {
+      createLogEntry({
+        eventType: "task_status_change",
+        taskId,
+        agentId: row.agentId,
+        oldValue: oldTask.status,
+        newValue: "in_progress",
+      });
+    } catch {}
+  }
   return row ? rowToAgentTask(row) : null;
 }
 
@@ -257,6 +316,7 @@ export function getAllTasks(status?: AgentTaskStatus): AgentTask[] {
 }
 
 export function completeTask(id: string, output?: string): AgentTask | null {
+  const oldTask = getTaskById(id);
   const finishedAt = new Date().toISOString();
   let row = taskQueries.updateStatus().get("completed", finishedAt, id);
   if (!row) return null;
@@ -265,12 +325,37 @@ export function completeTask(id: string, output?: string): AgentTask | null {
     row = taskQueries.setOutput().get(output, id);
   }
 
+  if (row && oldTask) {
+    try {
+      createLogEntry({
+        eventType: "task_status_change",
+        taskId: id,
+        agentId: row.agentId,
+        oldValue: oldTask.status,
+        newValue: "completed",
+      });
+    } catch {}
+  }
+
   return row ? rowToAgentTask(row) : null;
 }
 
 export function failTask(id: string, reason: string): AgentTask | null {
+  const oldTask = getTaskById(id);
   const finishedAt = new Date().toISOString();
   const row = taskQueries.setFailure().get(reason, finishedAt, id);
+  if (row && oldTask) {
+    try {
+      createLogEntry({
+        eventType: "task_status_change",
+        taskId: id,
+        agentId: row.agentId,
+        oldValue: oldTask.status,
+        newValue: "failed",
+        metadata: { reason },
+      });
+    } catch {}
+  }
   return row ? rowToAgentTask(row) : null;
 }
 
@@ -281,6 +366,16 @@ export function deleteTask(id: string): boolean {
 
 export function updateTaskProgress(id: string, progress: string): AgentTask | null {
   const row = taskQueries.setProgress().get(progress, id);
+  if (row) {
+    try {
+      createLogEntry({
+        eventType: "task_progress",
+        taskId: id,
+        agentId: row.agentId,
+        newValue: progress,
+      });
+    } catch {}
+  }
   return row ? rowToAgentTask(row) : null;
 }
 
@@ -311,3 +406,110 @@ export function getAllAgentsWithTasks(): AgentWithTasks[] {
 
   return txn();
 }
+
+// ============================================================================
+// Agent Log Queries
+// ============================================================================
+
+type AgentLogRow = {
+  id: string;
+  eventType: AgentLogEventType;
+  agentId: string | null;
+  taskId: string | null;
+  oldValue: string | null;
+  newValue: string | null;
+  metadata: string | null;
+  createdAt: string;
+};
+
+function rowToAgentLog(row: AgentLogRow): AgentLog {
+  return {
+    id: row.id,
+    eventType: row.eventType,
+    agentId: row.agentId ?? undefined,
+    taskId: row.taskId ?? undefined,
+    oldValue: row.oldValue ?? undefined,
+    newValue: row.newValue ?? undefined,
+    metadata: row.metadata ?? undefined,
+    createdAt: row.createdAt,
+  };
+}
+
+export const logQueries = {
+  insert: () =>
+    getDb().prepare<
+      AgentLogRow,
+      [string, string, string | null, string | null, string | null, string | null, string | null]
+    >(
+      `INSERT INTO agent_log (id, eventType, agentId, taskId, oldValue, newValue, metadata, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) RETURNING *`,
+    ),
+
+  getByAgentId: () =>
+    getDb().prepare<AgentLogRow, [string]>(
+      "SELECT * FROM agent_log WHERE agentId = ? ORDER BY createdAt DESC",
+    ),
+
+  getByTaskId: () =>
+    getDb().prepare<AgentLogRow, [string]>(
+      "SELECT * FROM agent_log WHERE taskId = ? ORDER BY createdAt DESC",
+    ),
+
+  getByEventType: () =>
+    getDb().prepare<AgentLogRow, [string]>(
+      "SELECT * FROM agent_log WHERE eventType = ? ORDER BY createdAt DESC",
+    ),
+
+  getAll: () => getDb().prepare<AgentLogRow, []>("SELECT * FROM agent_log ORDER BY createdAt DESC"),
+};
+
+export function createLogEntry(entry: {
+  eventType: AgentLogEventType;
+  agentId?: string;
+  taskId?: string;
+  oldValue?: string;
+  newValue?: string;
+  metadata?: Record<string, unknown>;
+}): AgentLog {
+  const id = crypto.randomUUID();
+  const row = logQueries
+    .insert()
+    .get(
+      id,
+      entry.eventType,
+      entry.agentId ?? null,
+      entry.taskId ?? null,
+      entry.oldValue ?? null,
+      entry.newValue ?? null,
+      entry.metadata ? JSON.stringify(entry.metadata) : null,
+    );
+  if (!row) throw new Error("Failed to create log entry");
+  return rowToAgentLog(row);
+}
+
+export function getLogsByAgentId(agentId: string): AgentLog[] {
+  return logQueries.getByAgentId().all(agentId).map(rowToAgentLog);
+}
+
+export function getLogsByTaskId(taskId: string): AgentLog[] {
+  return logQueries.getByTaskId().all(taskId).map(rowToAgentLog);
+}
+
+export function getLogsByTaskIdChronological(taskId: string): AgentLog[] {
+  return getDb()
+    .prepare<AgentLogRow, [string]>(
+      "SELECT * FROM agent_log WHERE taskId = ? ORDER BY createdAt ASC",
+    )
+    .all(taskId)
+    .map(rowToAgentLog);
+}
+
+export function getAllLogs(limit?: number): AgentLog[] {
+  if (limit) {
+    return getDb()
+      .prepare<AgentLogRow, [number]>("SELECT * FROM agent_log ORDER BY createdAt DESC LIMIT ?")
+      .all(limit)
+      .map(rowToAgentLog);
+  }
+  return logQueries.getAll().all().map(rowToAgentLog);
+}