@desplega.ai/agent-swarm 1.52.1 → 1.53.0

package/src/tests/events-http.test.ts

@@ -0,0 +1,267 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import type { Subprocess } from "bun";
+
+const TEST_PORT = 13033;
+const TEST_DB_PATH = `/tmp/test-events-http-${Date.now()}.sqlite`;
+const BASE = `http://localhost:${TEST_PORT}`;
+
+let serverProc: Subprocess;
+
+async function api(
+  method: string,
+  path: string,
+  opts: { body?: unknown } = {},
+): Promise<{ status: number; body: any }> {
+  const res = await fetch(`${BASE}${path}`, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+  });
+  const text = await res.text();
+  let body: any;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    body = text;
+  }
+  return { status: res.status, body };
+}
+
+const get = (p: string) => api("GET", p);
+const post = (p: string, body?: unknown) => api("POST", p, { body });
+
+async function waitForServer(url: string, timeoutMs = 15000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const r = await fetch(url);
+      if (r.ok) return;
+    } catch {}
+    await Bun.sleep(200);
+  }
+  throw new Error(`Server did not start within ${timeoutMs}ms`);
+}
+
+beforeAll(async () => {
+  try {
+    await unlink(TEST_DB_PATH);
+  } catch {}
+
+  serverProc = Bun.spawn(["bun", "src/http.ts"], {
+    cwd: `${import.meta.dir}/../..`,
+    env: {
+      ...process.env,
+      PORT: String(TEST_PORT),
+      DATABASE_PATH: TEST_DB_PATH,
+      API_KEY: "",
+      CAPABILITIES: "core",
+      SLACK_BOT_TOKEN: "",
+      GITHUB_WEBHOOK_SECRET: "",
+      AGENTMAIL_API_KEY: "",
+    },
+    stdout: "ignore",
+    stderr: "ignore",
+  });
+
+  await waitForServer(`${BASE}/health`);
+}, 20000);
+
+afterAll(async () => {
+  if (serverProc) {
+    serverProc.kill();
+    try {
+      await serverProc.exited;
+    } catch {}
+  }
+  await Bun.sleep(300);
+  try {
+    await unlink(TEST_DB_PATH);
+    await unlink(`${TEST_DB_PATH}-wal`);
+    await unlink(`${TEST_DB_PATH}-shm`);
+  } catch {}
+});
+
+describe("POST /api/events — single event", () => {
+  test("creates event with required fields", async () => {
+    const { status, body } = await post("/api/events", {
+      category: "tool",
+      event: "tool.start",
+      source: "worker",
+    });
+    expect(status).toBe(201);
+    expect(body.success).toBe(true);
+    expect(body.event.id).toBeDefined();
+    expect(body.event.category).toBe("tool");
+    expect(body.event.event).toBe("tool.start");
+    expect(body.event.status).toBe("ok");
+    expect(body.event.source).toBe("worker");
+  });
+
+  test("creates event with all optional fields", async () => {
+    const { status, body } = await post("/api/events", {
+      category: "skill",
+      event: "skill.invoke",
+      source: "worker",
+      status: "error",
+      agentId: "agent-1",
+      taskId: "task-1",
+      sessionId: "session-1",
+      parentEventId: "parent-1",
+      numericValue: 3.14,
+      durationMs: 500,
+      data: { skillName: "commit" },
+    });
+    expect(status).toBe(201);
+    expect(body.event.status).toBe("error");
+    expect(body.event.agentId).toBe("agent-1");
+    expect(body.event.data.skillName).toBe("commit");
+    expect(body.event.numericValue).toBe(3.14);
+    expect(body.event.durationMs).toBe(500);
+  });
+
+  test("rejects invalid category", async () => {
+    const { status } = await post("/api/events", {
+      category: "invalid",
+      event: "tool.start",
+      source: "worker",
+    });
+    expect(status).toBe(400);
+  });
+
+  test("rejects invalid event name", async () => {
+    const { status } = await post("/api/events", {
+      category: "tool",
+      event: "invalid.event",
+      source: "worker",
+    });
+    expect(status).toBe(400);
+  });
+
+  test("rejects missing required fields", async () => {
+    const { status } = await post("/api/events", { category: "tool" });
+    expect(status).toBe(400);
+  });
+});
+
+describe("POST /api/events/batch", () => {
+  test("creates multiple events", async () => {
+    const { status, body } = await post("/api/events/batch", {
+      events: [
+        { category: "tool", event: "tool.start", source: "worker", data: { toolName: "Read" } },
+        { category: "tool", event: "tool.start", source: "worker", data: { toolName: "Bash" } },
+        {
+          category: "skill",
+          event: "skill.invoke",
+          source: "worker",
+          data: { skillName: "commit" },
+        },
+      ],
+    });
+    expect(status).toBe(201);
+    expect(body.success).toBe(true);
+    expect(body.count).toBe(3);
+  });
+
+  test("rejects empty events array", async () => {
+    const { status } = await post("/api/events/batch", { events: [] });
+    expect(status).toBe(400);
+  });
+
+  test("rejects batch with invalid event", async () => {
+    const { status } = await post("/api/events/batch", {
+      events: [
+        { category: "tool", event: "tool.start", source: "worker" },
+        { category: "bad", event: "tool.start", source: "worker" },
+      ],
+    });
+    expect(status).toBe(400);
+  });
+});
+
+describe("GET /api/events", () => {
+  test("returns events list", async () => {
+    const { status, body } = await get("/api/events");
+    expect(status).toBe(200);
+    expect(Array.isArray(body.events)).toBe(true);
+    expect(body.events.length).toBeGreaterThanOrEqual(1);
+  });
+
+  test("filters by category", async () => {
+    const { status, body } = await get("/api/events?category=skill");
+    expect(status).toBe(200);
+    for (const evt of body.events) {
+      expect(evt.category).toBe("skill");
+    }
+  });
+
+  test("filters by event name", async () => {
+    const { status, body } = await get("/api/events?event=tool.start");
+    expect(status).toBe(200);
+    for (const evt of body.events) {
+      expect(evt.event).toBe("tool.start");
+    }
+  });
+
+  test("filters by source", async () => {
+    const { status, body } = await get("/api/events?source=worker");
+    expect(status).toBe(200);
+    for (const evt of body.events) {
+      expect(evt.source).toBe("worker");
+    }
+  });
+
+  test("respects limit parameter", async () => {
+    const { status, body } = await get("/api/events?limit=2");
+    expect(status).toBe(200);
+    expect(body.events.length).toBeLessThanOrEqual(2);
+  });
+
+  test("filters by agentId", async () => {
+    const { body } = await get("/api/events?agentId=agent-1");
+    for (const evt of body.events) {
+      expect(evt.agentId).toBe("agent-1");
+    }
+  });
+
+  test("returns empty array for non-matching filters", async () => {
+    const { status, body } = await get("/api/events?agentId=nonexistent");
+    expect(status).toBe(200);
+    expect(body.events).toEqual([]);
+  });
+});
+
+describe("GET /api/events/counts", () => {
+  test("returns counts grouped by event name", async () => {
+    const { status, body } = await get("/api/events/counts");
+    expect(status).toBe(200);
+    expect(Array.isArray(body.counts)).toBe(true);
+    expect(body.counts.length).toBeGreaterThanOrEqual(1);
+    const first = body.counts[0];
+    expect(first.event).toBeDefined();
+    expect(first.count).toBeGreaterThanOrEqual(1);
+  });
+
+  test("counts are in descending order", async () => {
+    const { body } = await get("/api/events/counts");
+    for (let i = 1; i < body.counts.length; i++) {
+      expect(body.counts[i - 1].count).toBeGreaterThanOrEqual(body.counts[i].count);
+    }
+  });
+
+  test("filters counts by category", async () => {
+    const { body } = await get("/api/events/counts?category=tool");
+    for (const c of body.counts) {
+      expect(c.event.startsWith("tool.")).toBe(true);
+    }
+  });
+
+  test("filters counts by agentId", async () => {
+    const { body: all } = await get("/api/events/counts");
+    const { body: filtered } = await get("/api/events/counts?agentId=agent-1");
+    // Filtered should be a subset
+    const filteredTotal = filtered.counts.reduce((s: number, c: any) => s + c.count, 0);
+    const allTotal = all.counts.reduce((s: number, c: any) => s + c.count, 0);
+    expect(filteredTotal).toBeLessThanOrEqual(allTotal);
+  });
+});

package/src/tests/prompt-template-remaining.test.ts

@@ -1,7 +1,7 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, initDb } from "../be/db";
-import { getAllTemplateDefinitions, getTemplateDefinition } from "../prompts/registry";
+import { getAllTemplateDefinitions } from "../prompts/registry";
 import { resolveTemplate } from "../prompts/resolver";
 
 // Side-effect imports: register all templates from each source
@@ -21,10 +21,10 @@ const TEST_DB_PATH = "./test-prompt-remaining.sqlite";
  * Needed because other test files may call clearTemplateDefinitions() in parallel.
  */
 async function ensureTemplatesRegistered(): Promise<void> {
-  // Check if templates are still registered (another test may have cleared them)
-  if (getTemplateDefinition("gitlab.merge_request.opened")) return;
-
-  // Force re-evaluation by importing with cache-busting query param
+  // Always re-import all template modules unconditionally.
+  // Other test files (prompt-template-resolver, prompt-template-session) call
+  // clearTemplateDefinitions() in beforeEach/beforeAll, and since Bun shares
+  // module state across parallel test files, a single-template check is racy.
   const ts = Date.now();
   await import(`../gitlab/templates?t=${ts}`);
   await import(`../agentmail/templates?t=${ts}`);

package/src/tests/tool-annotations.test.ts

@@ -338,9 +338,9 @@ describe("Tool Annotations & Classification", () => {
   test("registered tool count matches expected total", () => {
     const count = Object.keys(tools).length;
     // We expect all tools to be registered when all capabilities are enabled (default)
-    // Includes 11 skill tools added in the skill system feature
+    // Includes 11 skill tools and 7 MCP server tools
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(85);
+    expect(count).toBeLessThanOrEqual(95);
   });
 
   test("core tools are fewer than deferred tools", () => {

package/src/tests/vcs-tracking.test.ts

@@ -0,0 +1,176 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  findTaskByVcs,
+  initDb,
+  updateTaskVcs,
+} from "../be/db";
+
+const TEST_DB_PATH = "./test-vcs-tracking.sqlite";
+
+beforeAll(async () => {
+  try {
+    await unlink(TEST_DB_PATH);
+  } catch {}
+  initDb(TEST_DB_PATH);
+
+  createAgent({
+    id: "vcs-track-agent-001",
+    name: "VcsTrackingTestAgent",
+    status: "idle",
+    isLead: false,
+  });
+});
+
+afterAll(async () => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+
+describe("updateTaskVcs", () => {
+  test("sets all VCS fields correctly", () => {
+    const task = createTaskExtended("Test task for VCS update", {
+      agentId: "vcs-track-agent-001",
+      source: "api",
+    });
+
+    const updated = updateTaskVcs(task.id, {
+      vcsProvider: "github",
+      vcsRepo: "desplega-ai/agent-swarm",
+      vcsNumber: 42,
+      vcsUrl: "https://github.com/desplega-ai/agent-swarm/pull/42",
+    });
+
+    expect(updated).not.toBeNull();
+    expect(updated!.vcsProvider).toBe("github");
+    expect(updated!.vcsRepo).toBe("desplega-ai/agent-swarm");
+    expect(updated!.vcsNumber).toBe(42);
+    expect(updated!.vcsUrl).toBe("https://github.com/desplega-ai/agent-swarm/pull/42");
+  });
+
+  test("returns null for non-existent task", () => {
+    const result = updateTaskVcs("non-existent-id", {
+      vcsProvider: "github",
+      vcsRepo: "owner/repo",
+      vcsNumber: 1,
+      vcsUrl: "https://github.com/owner/repo/pull/1",
+    });
+    expect(result).toBeNull();
+  });
+
+  test("updates lastUpdatedAt", () => {
+    const task = createTaskExtended("Test lastUpdatedAt", {
+      agentId: "vcs-track-agent-001",
+      source: "api",
+    });
+
+    const before = new Date(task.lastUpdatedAt).getTime();
+
+    // Small delay to ensure timestamp differs
+    const updated = updateTaskVcs(task.id, {
+      vcsProvider: "github",
+      vcsRepo: "owner/repo",
+      vcsNumber: 10,
+      vcsUrl: "https://github.com/owner/repo/pull/10",
+    });
+
+    expect(updated).not.toBeNull();
+    const after = new Date(updated!.lastUpdatedAt).getTime();
+    expect(after).toBeGreaterThanOrEqual(before);
+  });
+
+  test("overwrites existing VCS fields (last PR wins)", () => {
+    const task = createTaskExtended("Test overwrite VCS", {
+      agentId: "vcs-track-agent-001",
+      source: "github",
+      vcsProvider: "github",
+      vcsRepo: "owner/repo",
+      vcsNumber: 1,
+      vcsUrl: "https://github.com/owner/repo/pull/1",
+    });
+
+    expect(task.vcsNumber).toBe(1);
+
+    const updated = updateTaskVcs(task.id, {
+      vcsProvider: "github",
+      vcsRepo: "owner/repo",
+      vcsNumber: 2,
+      vcsUrl: "https://github.com/owner/repo/pull/2",
+    });
+
+    expect(updated).not.toBeNull();
+    expect(updated!.vcsNumber).toBe(2);
+    expect(updated!.vcsUrl).toBe("https://github.com/owner/repo/pull/2");
+  });
+
+  test("findTaskByVcs finds task after updateTaskVcs", () => {
+    const task = createTaskExtended("Test findTaskByVcs linkage", {
+      agentId: "vcs-track-agent-001",
+      source: "api",
+    });
+
+    // Before update — no VCS fields, shouldn't be found
+    const notFound = findTaskByVcs("owner/findme", 99);
+    expect(notFound).toBeNull();
+
+    updateTaskVcs(task.id, {
+      vcsProvider: "github",
+      vcsRepo: "owner/findme",
+      vcsNumber: 99,
+      vcsUrl: "https://github.com/owner/findme/pull/99",
+    });
+
+    // After update — should be found (task is pending, not completed/failed)
+    const found = findTaskByVcs("owner/findme", 99);
+    expect(found).not.toBeNull();
+    expect(found!.id).toBe(task.id);
+  });
+
+  test("idempotent: calling twice with same data both succeed", () => {
+    const task = createTaskExtended("Test idempotency", {
+      agentId: "vcs-track-agent-001",
+      source: "api",
+    });
+
+    const vcs = {
+      vcsProvider: "github" as const,
+      vcsRepo: "owner/idem",
+      vcsNumber: 50,
+      vcsUrl: "https://github.com/owner/idem/pull/50",
+    };
+
+    const first = updateTaskVcs(task.id, vcs);
+    const second = updateTaskVcs(task.id, vcs);
+
+    expect(first).not.toBeNull();
+    expect(second).not.toBeNull();
+    expect(first!.vcsNumber).toBe(50);
+    expect(second!.vcsNumber).toBe(50);
+  });
+
+  test("supports gitlab provider", () => {
+    const task = createTaskExtended("Test gitlab VCS", {
+      agentId: "vcs-track-agent-001",
+      source: "api",
+    });
+
+    const updated = updateTaskVcs(task.id, {
+      vcsProvider: "gitlab",
+      vcsRepo: "group/project",
+      vcsNumber: 7,
+      vcsUrl: "https://gitlab.com/group/project/-/merge_requests/7",
+    });
+
+    expect(updated).not.toBeNull();
+    expect(updated!.vcsProvider).toBe("gitlab");
+    expect(updated!.vcsRepo).toBe("group/project");
+    expect(updated!.vcsNumber).toBe(7);
+  });
+});

package/src/tests/workflow-executors.test.ts

@@ -1,6 +1,12 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, initDb } from "../be/db";
+
+// Mock slack/app to avoid dynamic import issues in parallel test execution
+mock.module("../slack/app", () => ({
+  getSlackApp: () => null,
+}));
+
 import type { ExecutorMeta } from "../types";
 import type { ExecutorDependencies, ExecutorInput } from "../workflows/executors/base";
 import { CodeMatchExecutor, CodeMatchOutputSchema } from "../workflows/executors/code-match";
@@ -363,6 +369,7 @@ describe("NotifyExecutor", () => {
     const result = await executor.run(
       input({ channel: "slack", target: "#general", template: "hi" }, {}),
     );
+    expect(result.status).toBe("success");
     const out = result.output as { sent: boolean };
     expect(out.sent).toBe(false);
   });

package/src/tools/mcp-servers/index.ts

@@ -0,0 +1,7 @@
+export { registerMcpServerCreateTool } from "./mcp-server-create";
+export { registerMcpServerDeleteTool } from "./mcp-server-delete";
+export { registerMcpServerGetTool } from "./mcp-server-get";
+export { registerMcpServerInstallTool } from "./mcp-server-install";
+export { registerMcpServerListTool } from "./mcp-server-list";
+export { registerMcpServerUninstallTool } from "./mcp-server-uninstall";
+export { registerMcpServerUpdateTool } from "./mcp-server-update";

package/src/tools/mcp-servers/mcp-server-create.ts

@@ -0,0 +1,138 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createMcpServer, getAgentById, installMcpServer } from "@/be/db";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerMcpServerCreateTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "mcp-server-create",
+    {
+      title: "Create MCP Server",
+      annotations: { destructiveHint: false },
+      description:
+        "Create a new MCP server definition. Agent-scope servers are auto-installed for the creating agent. Swarm/global scope requires lead.",
+      inputSchema: z.object({
+        name: z.string().describe("Server name"),
+        description: z.string().optional().describe("Server description"),
+        transport: z.enum(["stdio", "http", "sse"]).describe("Transport type"),
+        scope: z
+          .enum(["global", "swarm", "agent"])
+          .default("agent")
+          .optional()
+          .describe("Scope: agent (personal), swarm (shared), or global. Default: agent"),
+        command: z.string().optional().describe("Command to run (required for stdio transport)"),
+        args: z.string().optional().describe("JSON array of command arguments (stdio only)"),
+        url: z.string().optional().describe("Server URL (required for http/sse transport)"),
+        headers: z
+          .string()
+          .optional()
+          .describe("JSON object of non-secret headers (http/sse only)"),
+        envConfigKeys: z
+          .string()
+          .optional()
+          .describe("JSON object mapping env var names to config key paths"),
+        headerConfigKeys: z
+          .string()
+          .optional()
+          .describe("JSON object mapping header names to config key paths for secret headers"),
+      }),
+      outputSchema: z.object({
+        yourAgentId: z.string().uuid().optional(),
+        success: z.boolean(),
+        message: z.string(),
+        server: z.any().optional(),
+      }),
+    },
+    async (args, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: "Agent ID not found." }],
+          structuredContent: { success: false, message: "Agent ID not found." },
+        };
+      }
+
+      try {
+        // Validate transport-specific fields
+        if (args.transport === "stdio" && !args.command) {
+          return {
+            content: [{ type: "text", text: "stdio transport requires a command." }],
+            structuredContent: {
+              yourAgentId: requestInfo.agentId,
+              success: false,
+              message: "stdio transport requires a command.",
+            },
+          };
+        }
+
+        if ((args.transport === "http" || args.transport === "sse") && !args.url) {
+          return {
+            content: [{ type: "text", text: `${args.transport} transport requires a url.` }],
+            structuredContent: {
+              yourAgentId: requestInfo.agentId,
+              success: false,
+              message: `${args.transport} transport requires a url.`,
+            },
+          };
+        }
+
+        // Swarm/global scope requires lead
+        const scope = args.scope ?? "agent";
+        if (scope === "swarm" || scope === "global") {
+          const agent = getAgentById(requestInfo.agentId);
+          if (!agent?.isLead) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Only lead agents can create ${scope}-scope MCP servers.`,
+                },
+              ],
+              structuredContent: {
+                yourAgentId: requestInfo.agentId,
+                success: false,
+                message: `Only lead agents can create ${scope}-scope MCP servers.`,
+              },
+            };
+          }
+        }
+
+        const created = createMcpServer({
+          name: args.name,
+          description: args.description,
+          transport: args.transport,
+          scope,
+          ownerAgentId: requestInfo.agentId,
+          command: args.command,
+          args: args.args,
+          url: args.url,
+          headers: args.headers,
+          envConfigKeys: args.envConfigKeys,
+          headerConfigKeys: args.headerConfigKeys,
+        });
+
+        // Auto-install for the creating agent
+        installMcpServer(requestInfo.agentId, created.id);
+
+        return {
+          content: [{ type: "text", text: `Created MCP server "${created.name}" (${created.id})` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: true,
+            message: `Created and installed MCP server "${created.name}".`,
+            server: created,
+          },
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Failed to create MCP server: ${message}` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `Failed: ${message}`,
+          },
+        };
+      }
+    },
+  );
+};