@desplega.ai/agent-swarm 1.0.1 → 1.0.2

package/Dockerfile

@@ -0,0 +1,16 @@
+FROM oven/bun:1-alpine
+
+WORKDIR /app
+
+COPY package.json bun.lock ./
+RUN bun install --frozen-lockfile --production
+
+COPY . .
+
+ENV PORT=3013
+EXPOSE 3013
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD wget -qO- http://localhost:3013/health || exit 1
+
+CMD ["bun", "run", "start:http"]

package/deploy/DEPLOY.md

@@ -0,0 +1,57 @@
+# Deployment
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `PORT` | `3013` | Server port |
+| `API_KEY` | _(empty)_ | Bearer token for auth (optional) |
+
+## Docker
+
+```bash
+# Build
+docker build -t agent-swarm .
+
+# Run (persists database to ./agent-swarm-db.sqlite on host)
+docker run -d --name agent-swarm -p 3013:3013 \
+  -e API_KEY=your-secret-key \
+  -v $(pwd)/agent-swarm-db.sqlite:/app/agent-swarm-db.sqlite \
+  agent-swarm
+```
+
+## systemd
+
+```bash
+# Install service
+sudo bun deploy/install.ts
+
+# Control
+sudo systemctl start agent-swarm
+sudo systemctl stop agent-swarm
+sudo systemctl status agent-swarm
+journalctl -u agent-swarm -f
+
+# Uninstall
+sudo bun deploy/uninstall.ts
+```
+
+## Caddy (reverse proxy)
+
+Add to your Caddyfile:
+
+```
+agent-swarm.example.com {
+    reverse_proxy localhost:3013
+}
+```
+
+Or with API key header injection:
+
+```
+agent-swarm.example.com {
+    reverse_proxy localhost:3013 {
+        header_up Authorization "Bearer {env.AGENT_SWARM_API_KEY}"
+    }
+}
+```

package/deploy/agent-swarm.service

@@ -0,0 +1,16 @@
+[Unit]
+Description=Agent Swarm MCP Server
+After=network.target
+
+[Service]
+Type=simple
+User=www-data
+Group=www-data
+WorkingDirectory=/opt/agent-swarm
+ExecStart=/usr/local/bin/bun run start:http
+Restart=always
+RestartSec=5
+EnvironmentFile=/opt/agent-swarm/.env
+
+[Install]
+WantedBy=multi-user.target

package/deploy/install.ts

@@ -0,0 +1,35 @@
+#!/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}/..`;
+
+// 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 ${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 www-data:www-data ${APP_DIR}`;
+
+// Install systemd service
+await $`cp ${SCRIPT_DIR}/agent-swarm.service ${SERVICE_FILE}`;
+await $`systemctl daemon-reload`;
+await $`systemctl enable agent-swarm`;
+
+console.log("Installed. Edit /opt/agent-swarm/.env then run: systemctl start agent-swarm");

package/deploy/uninstall.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Agent orchestration layer MCP for Claude Code, Codex, Gemini CLI, and more!",
   "module": "src/stdio.ts",
   "type": "module",

package/src/be/db.ts

@@ -1,9 +1,9 @@
 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 +38,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 +121,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 +137,23 @@ 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 +237,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 +253,18 @@ 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 +297,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 +306,24 @@ 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 +334,11 @@ 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 +369,99 @@ 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 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);
+}

package/src/commands/setup.tsx

@@ -198,20 +198,22 @@ export function Setup({ dryRun = false, restore = false }: SetupProps) {
 				addLog(".mcp.json exists");
 			}
 
-			// Check if it's a git repo
+			// Check if it's a git repo by finding the git root
 			let isGitRepo = false;
+			let gitRoot = "";
 			try {
-				const gitDir = Bun.file(`${cwd}/.git`);
-				isGitRepo = await gitDir.exists();
+				const result = await Bun.$`git -C ${cwd} rev-parse --show-toplevel`.quiet();
+				gitRoot = result.text().trim();
+				isGitRepo = result.exitCode === 0 && gitRoot.length > 0;
 			} catch {
 				isGitRepo = false;
 			}
 
 			if (isGitRepo) {
-				addLog("Git repository detected");
+				addLog(`Git repository detected (root: ${gitRoot})`);
 
-				// Check .gitignore
-				const gitignoreFile = Bun.file(`${cwd}/.gitignore`);
+				// Check .gitignore at git root
+				const gitignoreFile = Bun.file(`${gitRoot}/.gitignore`);
 				let gitignoreContent = "";
 
 				if (await gitignoreFile.exists()) {
@@ -228,7 +230,7 @@ export function Setup({ dryRun = false, restore = false }: SetupProps) {
 
 				if (entriesToAdd.length > 0) {
 					// Backup .gitignore before modifying
-					await createBackup(`${cwd}/.gitignore`);
+					await createBackup(`${gitRoot}/.gitignore`);
 					if (!dryRun) {
 						const newEntries = `# Added by ${SERVER_NAME} setup\n${entriesToAdd.join("\n")}\n\n`;
 						await Bun.write(gitignoreFile, newEntries + gitignoreContent);

package/src/http.ts

@@ -113,7 +113,7 @@ const httpServer = createHttpServer(async (req, res) => {
       if (!agent) {
         res.writeHead(404, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Agent not found" }));
-        return;
+        return false;
       }
 
       let status: AgentStatus = "idle";
@@ -123,9 +123,13 @@ const httpServer = createHttpServer(async (req, res) => {
       }
 
       updateAgentStatus(agent.id, status);
+
+      return true;
     });
 
-    tx();
+    if (!tx()) {
+      return;
+    }
 
     res.writeHead(204);
     res.end();
@@ -145,13 +149,17 @@ const httpServer = createHttpServer(async (req, res) => {
       if (!agent) {
         res.writeHead(404, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Agent not found" }));
-        return;
+        return false;
       }
 
       updateAgentStatus(agent.id, "offline");
+
+      return true;
     });
 
-    tx();
+    if (!tx()) {
+      return;
+    }
 
     res.writeHead(204);
     res.end();

package/src/types.ts

@@ -40,3 +40,27 @@ export type AgentTask = z.infer<typeof AgentTaskSchema>;
 export type AgentStatus = z.infer<typeof AgentStatusSchema>;
 export type Agent = z.infer<typeof AgentSchema>;
 export type AgentWithTasks = z.infer<typeof AgentWithTasksSchema>;
+
+// Agent Log Types
+export const AgentLogEventTypeSchema = z.enum([
+  "agent_joined",
+  "agent_status_change",
+  "agent_left",
+  "task_created",
+  "task_status_change",
+  "task_progress",
+]);
+
+export const AgentLogSchema = z.object({
+  id: z.uuid(),
+  eventType: AgentLogEventTypeSchema,
+  agentId: z.string().optional(),
+  taskId: z.string().optional(),
+  oldValue: z.string().optional(),
+  newValue: z.string().optional(),
+  metadata: z.string().optional(),
+  createdAt: z.iso.datetime(),
+});
+
+export type AgentLogEventType = z.infer<typeof AgentLogEventTypeSchema>;
+export type AgentLog = z.infer<typeof AgentLogSchema>;