@desplega.ai/agent-swarm 1.52.1 → 1.53.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.52.1",
+  "version": "1.53.0",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",
@@ -79,10 +79,13 @@
     "pm2-stop": "pm2 stop ecosystem.config.cjs",
     "pm2-restart": "pm2 restart ecosystem.config.cjs",
     "pm2-logs": "pm2 logs swarm-api swarm-ui swarm-lead swarm-worker",
-    "pm2-status": "pm2 status swarm-api swarm-ui swarm-lead swarm-worker"
+    "pm2-status": "pm2 status swarm-api swarm-ui swarm-lead swarm-worker",
+    "seed": "bun scripts/seed.ts",
+    "seed:clean": "bun scripts/seed.ts --clean"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.10",
+    "@faker-js/faker": "^10.4.0",
     "@types/bun": "latest"
   },
   "peerDependencies": {

package/src/be/db.ts

@@ -5,6 +5,7 @@ import type {
   Agent,
   AgentLog,
   AgentLogEventType,
+  AgentMcpServer,
   AgentMemory,
   AgentMemoryScope,
   AgentMemorySource,
@@ -18,6 +19,8 @@ import type {
   Channel,
   ChannelMessage,
   ChannelType,
+  ContextSnapshot,
+  ContextSnapshotEventType,
   ContextVersion,
   CooldownConfig,
   Epic,
@@ -26,6 +29,10 @@ import type {
   InboxMessage,
   InboxMessageStatus,
   InputValue,
+  McpServer,
+  McpServerScope,
+  McpServerTransport,
+  McpServerWithInstallInfo,
   PromptTemplate,
   PromptTemplateHistory,
   ScheduledTask,
@@ -717,6 +724,10 @@ type AgentTaskRow = {
   failureReason: string | null;
   output: string | null;
   progress: string | null;
+  compactionCount: number | null;
+  peakContextPercent: number | null;
+  totalContextTokensUsed: number | null;
+  contextWindowSize: number | null;
 };
 
 function rowToAgentTask(row: AgentTaskRow): AgentTask {
@@ -759,6 +770,10 @@ function rowToAgentTask(row: AgentTaskRow): AgentTask {
     workflowRunId: row.workflowRunId ?? undefined,
     workflowRunStepId: row.workflowRunStepId ?? undefined,
     outputSchema: row.outputSchema ? JSON.parse(row.outputSchema) : undefined,
+    compactionCount: row.compactionCount ?? undefined,
+    peakContextPercent: row.peakContextPercent ?? undefined,
+    totalContextTokensUsed: row.totalContextTokensUsed ?? undefined,
+    contextWindowSize: row.contextWindowSize ?? undefined,
     createdAt: row.createdAt,
     lastUpdatedAt: row.lastUpdatedAt,
     finishedAt: row.finishedAt ?? undefined,
@@ -936,6 +951,25 @@ export function updateTaskClaudeSessionId(
   return row ? rowToAgentTask(row) : null;
 }
 
+export function updateTaskVcs(
+  taskId: string,
+  vcs: {
+    vcsProvider: "github" | "gitlab";
+    vcsRepo: string;
+    vcsNumber: number;
+    vcsUrl: string;
+  },
+): AgentTask | null {
+  const row = getDb()
+    .prepare<AgentTaskRow, [string, string, number, string, string, string]>(
+      `UPDATE agent_tasks
+       SET vcsProvider = ?, vcsRepo = ?, vcsNumber = ?, vcsUrl = ?, lastUpdatedAt = ?
+       WHERE id = ? RETURNING *`,
+    )
+    .get(vcs.vcsProvider, vcs.vcsRepo, vcs.vcsNumber, vcs.vcsUrl, new Date().toISOString(), taskId);
+  return row ? rowToAgentTask(row) : null;
+}
+
 export function getTasksByAgentId(agentId: string): AgentTask[] {
   return taskQueries.getByAgentId().all(agentId).map(rowToAgentTask);
 }
@@ -7391,3 +7425,499 @@ export function toggleAgentSkill(agentId: string, skillId: string, isActive: boo
     .run(isActive ? 1 : 0, agentId, skillId);
   return result.changes > 0;
 }
+
+// ── MCP Servers ──────────────────────────────────────────────────────────
+
+type McpServerRow = {
+  id: string;
+  name: string;
+  description: string | null;
+  scope: string;
+  ownerAgentId: string | null;
+  transport: string;
+  command: string | null;
+  args: string | null;
+  url: string | null;
+  headers: string | null;
+  envConfigKeys: string | null;
+  headerConfigKeys: string | null;
+  isEnabled: number;
+  version: number;
+  createdAt: string;
+  lastUpdatedAt: string;
+};
+
+type AgentMcpServerRow = {
+  id: string;
+  agentId: string;
+  mcpServerId: string;
+  isActive: number;
+  installedAt: string;
+};
+
+type McpServerWithInstallRow = McpServerRow & { isActive: number; installedAt: string };
+
+function rowToMcpServer(row: McpServerRow): McpServer {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    scope: row.scope as McpServerScope,
+    ownerAgentId: row.ownerAgentId,
+    transport: row.transport as McpServerTransport,
+    command: row.command,
+    args: row.args,
+    url: row.url,
+    headers: row.headers,
+    envConfigKeys: row.envConfigKeys,
+    headerConfigKeys: row.headerConfigKeys,
+    isEnabled: row.isEnabled === 1,
+    version: row.version,
+    createdAt: row.createdAt,
+    lastUpdatedAt: row.lastUpdatedAt,
+  };
+}
+
+function rowToAgentMcpServer(row: AgentMcpServerRow): AgentMcpServer {
+  return {
+    id: row.id,
+    agentId: row.agentId,
+    mcpServerId: row.mcpServerId,
+    isActive: row.isActive === 1,
+    installedAt: row.installedAt,
+  };
+}
+
+function rowToMcpServerWithInstall(row: McpServerWithInstallRow): McpServerWithInstallInfo {
+  return {
+    ...rowToMcpServer(row),
+    isActive: row.isActive === 1,
+    installedAt: row.installedAt,
+  };
+}
+
+export interface McpServerInsert {
+  name: string;
+  transport: McpServerTransport;
+  description?: string;
+  scope?: McpServerScope;
+  ownerAgentId?: string;
+  command?: string;
+  args?: string;
+  url?: string;
+  headers?: string;
+  envConfigKeys?: string;
+  headerConfigKeys?: string;
+}
+
+export function createMcpServer(data: McpServerInsert): McpServer {
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+
+  const row = getDb()
+    .prepare<McpServerRow, (string | number | null)[]>(
+      `INSERT INTO mcp_servers (
+        id, name, description, scope, ownerAgentId, transport,
+        command, args, url, headers,
+        envConfigKeys, headerConfigKeys,
+        isEnabled, version, createdAt, lastUpdatedAt
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, 1, ?, ?) RETURNING *`,
+    )
+    .get(
+      id,
+      data.name,
+      data.description ?? null,
+      data.scope ?? "agent",
+      data.ownerAgentId ?? null,
+      data.transport,
+      data.command ?? null,
+      data.args ?? null,
+      data.url ?? null,
+      data.headers ?? null,
+      data.envConfigKeys ?? null,
+      data.headerConfigKeys ?? null,
+      now,
+      now,
+    );
+
+  if (!row) throw new Error("Failed to create MCP server");
+  return rowToMcpServer(row);
+}
+
+export function updateMcpServer(
+  id: string,
+  updates: Partial<McpServerInsert> & { isEnabled?: boolean },
+): McpServer | null {
+  const existing = getMcpServerById(id);
+  if (!existing) return null;
+
+  const now = new Date().toISOString();
+  const sets: string[] = ["lastUpdatedAt = ?"];
+  const params: (string | number | null)[] = [now];
+
+  if (updates.name !== undefined) {
+    sets.push("name = ?");
+    params.push(updates.name);
+  }
+  if (updates.description !== undefined) {
+    sets.push("description = ?");
+    params.push(updates.description ?? null);
+  }
+  if (updates.scope !== undefined) {
+    sets.push("scope = ?");
+    params.push(updates.scope);
+  }
+  if (updates.transport !== undefined) {
+    sets.push("transport = ?");
+    params.push(updates.transport);
+  }
+  if (updates.command !== undefined) {
+    sets.push("command = ?");
+    params.push(updates.command ?? null);
+  }
+  if (updates.args !== undefined) {
+    sets.push("args = ?");
+    params.push(updates.args ?? null);
+  }
+  if (updates.url !== undefined) {
+    sets.push("url = ?");
+    params.push(updates.url ?? null);
+  }
+  if (updates.headers !== undefined) {
+    sets.push("headers = ?");
+    params.push(updates.headers ?? null);
+  }
+  if (updates.envConfigKeys !== undefined) {
+    sets.push("envConfigKeys = ?");
+    params.push(updates.envConfigKeys ?? null);
+  }
+  if (updates.headerConfigKeys !== undefined) {
+    sets.push("headerConfigKeys = ?");
+    params.push(updates.headerConfigKeys ?? null);
+  }
+  if (updates.isEnabled !== undefined) {
+    sets.push("isEnabled = ?");
+    params.push(updates.isEnabled ? 1 : 0);
+  }
+  if (updates.ownerAgentId !== undefined) {
+    sets.push("ownerAgentId = ?");
+    params.push(updates.ownerAgentId ?? null);
+  }
+
+  // Bump version on config changes
+  const configFields = [
+    "command",
+    "args",
+    "url",
+    "headers",
+    "envConfigKeys",
+    "headerConfigKeys",
+    "transport",
+  ];
+  if (configFields.some((f) => (updates as Record<string, unknown>)[f] !== undefined)) {
+    sets.push("version = version + 1");
+  }
+
+  params.push(id);
+  const row = getDb()
+    .prepare<McpServerRow, (string | number | null)[]>(
+      `UPDATE mcp_servers SET ${sets.join(", ")} WHERE id = ? RETURNING *`,
+    )
+    .get(...params);
+
+  return row ? rowToMcpServer(row) : null;
+}
+
+export function deleteMcpServer(id: string): boolean {
+  const result = getDb().prepare("DELETE FROM mcp_servers WHERE id = ?").run(id);
+  return result.changes > 0;
+}
+
+export function getMcpServerById(id: string): McpServer | null {
+  const row = getDb()
+    .prepare<McpServerRow, [string]>("SELECT * FROM mcp_servers WHERE id = ?")
+    .get(id);
+  return row ? rowToMcpServer(row) : null;
+}
+
+export function getMcpServerByName(
+  name: string,
+  scope: McpServerScope,
+  ownerAgentId: string | null,
+): McpServer | null {
+  const row = getDb()
+    .prepare<McpServerRow, [string, string, string]>(
+      "SELECT * FROM mcp_servers WHERE name = ? AND scope = ? AND COALESCE(ownerAgentId, '') = ?",
+    )
+    .get(name, scope, ownerAgentId ?? "");
+  return row ? rowToMcpServer(row) : null;
+}
+
+export interface McpServerFilters {
+  scope?: McpServerScope;
+  ownerAgentId?: string;
+  transport?: McpServerTransport;
+  isEnabled?: boolean;
+  search?: string;
+}
+
+export function listMcpServers(filters?: McpServerFilters): McpServer[] {
+  let query = "SELECT * FROM mcp_servers WHERE 1=1";
+  const params: (string | number)[] = [];
+
+  if (filters?.scope) {
+    query += " AND scope = ?";
+    params.push(filters.scope);
+  }
+  if (filters?.ownerAgentId) {
+    query += " AND ownerAgentId = ?";
+    params.push(filters.ownerAgentId);
+  }
+  if (filters?.transport) {
+    query += " AND transport = ?";
+    params.push(filters.transport);
+  }
+  if (filters?.isEnabled !== undefined) {
+    query += " AND isEnabled = ?";
+    params.push(filters.isEnabled ? 1 : 0);
+  }
+  if (filters?.search) {
+    query += " AND (name LIKE ? OR description LIKE ?)";
+    const term = `%${filters.search}%`;
+    params.push(term, term);
+  }
+
+  query += " ORDER BY name ASC";
+
+  return getDb()
+    .prepare<McpServerRow, (string | number)[]>(query)
+    .all(...params)
+    .map(rowToMcpServer);
+}
+
+export function installMcpServer(agentId: string, mcpServerId: string): AgentMcpServer {
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+
+  const row = getDb()
+    .prepare<AgentMcpServerRow, [string, string, string, string]>(
+      `INSERT INTO agent_mcp_servers (id, agentId, mcpServerId, isActive, installedAt)
+       VALUES (?, ?, ?, 1, ?)
+       ON CONFLICT(agentId, mcpServerId) DO UPDATE SET isActive = 1
+       RETURNING *`,
+    )
+    .get(id, agentId, mcpServerId, now);
+
+  if (!row) throw new Error("Failed to install MCP server");
+  return rowToAgentMcpServer(row);
+}
+
+export function uninstallMcpServer(agentId: string, mcpServerId: string): boolean {
+  const result = getDb()
+    .prepare("DELETE FROM agent_mcp_servers WHERE agentId = ? AND mcpServerId = ?")
+    .run(agentId, mcpServerId);
+  return result.changes > 0;
+}
+
+export function getAgentMcpServers(agentId: string, activeOnly = true): McpServerWithInstallInfo[] {
+  const query = `
+    SELECT ms.*, ams.isActive, ams.installedAt
+    FROM mcp_servers ms
+    JOIN agent_mcp_servers ams ON ms.id = ams.mcpServerId
+    WHERE ams.agentId = ?
+      ${activeOnly ? "AND ams.isActive = 1" : ""}
+      AND ms.isEnabled = 1
+    ORDER BY ms.name ASC
+  `;
+
+  return getDb()
+    .prepare<McpServerWithInstallRow, [string]>(query)
+    .all(agentId)
+    .map(rowToMcpServerWithInstall);
+}
+
+// ============================================================================
+// Context Usage Snapshots
+// ============================================================================
+
+type ContextSnapshotRow = {
+  id: string;
+  taskId: string;
+  agentId: string;
+  sessionId: string;
+  contextUsedTokens: number | null;
+  contextTotalTokens: number | null;
+  contextPercent: number | null;
+  eventType: ContextSnapshotEventType;
+  compactTrigger: string | null;
+  preCompactTokens: number | null;
+  cumulativeInputTokens: number;
+  cumulativeOutputTokens: number;
+  createdAt: string;
+};
+
+function rowToContextSnapshot(row: ContextSnapshotRow): ContextSnapshot {
+  return {
+    id: row.id,
+    taskId: row.taskId,
+    agentId: row.agentId,
+    sessionId: row.sessionId,
+    contextUsedTokens: row.contextUsedTokens ?? undefined,
+    contextTotalTokens: row.contextTotalTokens ?? undefined,
+    contextPercent: row.contextPercent ?? undefined,
+    eventType: row.eventType,
+    compactTrigger: (row.compactTrigger as "auto" | "manual" | null) ?? undefined,
+    preCompactTokens: row.preCompactTokens ?? undefined,
+    cumulativeInputTokens: row.cumulativeInputTokens,
+    cumulativeOutputTokens: row.cumulativeOutputTokens,
+    createdAt: row.createdAt,
+  };
+}
+
+const contextSnapshotQueries = {
+  insert: () =>
+    getDb().prepare<
+      ContextSnapshotRow,
+      [
+        string,
+        string,
+        string,
+        string,
+        number | null,
+        number | null,
+        number | null,
+        string,
+        string | null,
+        number | null,
+        number,
+        number,
+        string,
+      ]
+    >(
+      `INSERT INTO task_context_snapshots (id, taskId, agentId, sessionId, contextUsedTokens, contextTotalTokens, contextPercent, eventType, compactTrigger, preCompactTokens, cumulativeInputTokens, cumulativeOutputTokens, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ),
+
+  getByTaskId: () =>
+    getDb().prepare<ContextSnapshotRow, [string, number]>(
+      "SELECT * FROM task_context_snapshots WHERE taskId = ? ORDER BY createdAt ASC LIMIT ?",
+    ),
+
+  getBySessionId: () =>
+    getDb().prepare<ContextSnapshotRow, [string, number]>(
+      "SELECT * FROM task_context_snapshots WHERE sessionId = ? ORDER BY createdAt ASC LIMIT ?",
+    ),
+};
+
+export interface CreateContextSnapshotInput {
+  taskId: string;
+  agentId: string;
+  sessionId: string;
+  contextUsedTokens?: number;
+  contextTotalTokens?: number;
+  contextPercent?: number;
+  eventType: ContextSnapshotEventType;
+  compactTrigger?: "auto" | "manual";
+  preCompactTokens?: number;
+  cumulativeInputTokens?: number;
+  cumulativeOutputTokens?: number;
+}
+
+export function createContextSnapshot(input: CreateContextSnapshotInput): ContextSnapshot {
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+
+  contextSnapshotQueries
+    .insert()
+    .run(
+      id,
+      input.taskId,
+      input.agentId,
+      input.sessionId,
+      input.contextUsedTokens ?? null,
+      input.contextTotalTokens ?? null,
+      input.contextPercent ?? null,
+      input.eventType,
+      input.compactTrigger ?? null,
+      input.preCompactTokens ?? null,
+      input.cumulativeInputTokens ?? 0,
+      input.cumulativeOutputTokens ?? 0,
+      now,
+    );
+
+  // Update aggregate columns on agent_tasks
+  if (input.contextPercent != null) {
+    getDb()
+      .prepare(
+        `UPDATE agent_tasks SET peakContextPercent = MAX(COALESCE(peakContextPercent, 0), ?)
+         WHERE id = ?`,
+      )
+      .run(input.contextPercent, input.taskId);
+  }
+
+  if (input.eventType === "compaction") {
+    getDb()
+      .prepare(
+        "UPDATE agent_tasks SET compactionCount = COALESCE(compactionCount, 0) + 1 WHERE id = ?",
+      )
+      .run(input.taskId);
+  }
+
+  if (input.eventType === "completion") {
+    getDb()
+      .prepare(
+        `UPDATE agent_tasks SET totalContextTokensUsed = ?, contextWindowSize = ?
+         WHERE id = ?`,
+      )
+      .run(input.contextUsedTokens ?? null, input.contextTotalTokens ?? null, input.taskId);
+  }
+
+  return {
+    id,
+    taskId: input.taskId,
+    agentId: input.agentId,
+    sessionId: input.sessionId,
+    contextUsedTokens: input.contextUsedTokens,
+    contextTotalTokens: input.contextTotalTokens,
+    contextPercent: input.contextPercent,
+    eventType: input.eventType,
+    compactTrigger: input.compactTrigger,
+    preCompactTokens: input.preCompactTokens,
+    cumulativeInputTokens: input.cumulativeInputTokens ?? 0,
+    cumulativeOutputTokens: input.cumulativeOutputTokens ?? 0,
+    createdAt: now,
+  };
+}
+
+export function getContextSnapshotsByTaskId(taskId: string, limit = 500): ContextSnapshot[] {
+  return contextSnapshotQueries.getByTaskId().all(taskId, limit).map(rowToContextSnapshot);
+}
+
+export function getContextSnapshotsBySessionId(sessionId: string, limit = 500): ContextSnapshot[] {
+  return contextSnapshotQueries.getBySessionId().all(sessionId, limit).map(rowToContextSnapshot);
+}
+
+export interface ContextSummary {
+  compactionCount: number;
+  peakContextPercent: number | null;
+  totalContextTokensUsed: number | null;
+  contextWindowSize: number | null;
+  snapshotCount: number;
+}
+
+export function getContextSummaryByTaskId(taskId: string): ContextSummary {
+  const task = getTaskById(taskId);
+  const countRow = getDb()
+    .prepare<{ cnt: number }, [string]>(
+      "SELECT COUNT(*) as cnt FROM task_context_snapshots WHERE taskId = ?",
+    )
+    .get(taskId);
+
+  return {
+    compactionCount: task?.compactionCount ?? 0,
+    peakContextPercent: task?.peakContextPercent ?? null,
+    totalContextTokensUsed: task?.totalContextTokensUsed ?? null,
+    contextWindowSize: task?.contextWindowSize ?? null,
+    snapshotCount: countRow?.cnt ?? 0,
+  };
+}