@desplega.ai/agent-swarm 1.88.0 → 1.89.0

package/src/tests/heartbeat.test.ts

@@ -7,13 +7,17 @@ import {
   getActiveSessionForTask,
   getDb,
   getIdleWorkersWithCapacity,
+  getOrphanedInProgressTasksForAgent,
+  getPendingTaskForAgent,
   getStalledInProgressTasks,
   getTaskById,
   getUnassignedPoolTasks,
   initDb,
   insertActiveSession,
+  resetOrphanedInProgressTasksForAgent,
   startTask,
   updateAgentStatus,
+  updateTaskClaudeSessionId,
 } from "../be/db";
 import {
   codeLevelTriage,
@@ -157,6 +161,60 @@ describe("Heartbeat Triage", () => {
     });
   });
 
+  describe("orphaned in_progress recovery", () => {
+    test("resets stale in_progress task with no session and no claudeSessionId to pending", () => {
+      const agent = createAgent({ name: "orphan-worker", isLead: false, status: "idle" });
+      const task = createTaskExtended("Orphaned task", { agentId: agent.id });
+      startTask(task.id);
+
+      const oldTime = new Date(Date.now() - 2 * 60 * 1000).toISOString();
+      getDb().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [oldTime, task.id]);
+
+      const orphaned = getOrphanedInProgressTasksForAgent(agent.id, 60);
+      expect(orphaned.map((t) => t.id)).toContain(task.id);
+
+      const reset = resetOrphanedInProgressTasksForAgent(agent.id, 60);
+      expect(reset.map((t) => t.id)).toContain(task.id);
+
+      const updated = getTaskById(task.id);
+      expect(updated?.status).toBe("pending");
+      expect(getPendingTaskForAgent(agent.id)?.id).toBe(task.id);
+    });
+
+    test("does not reset tasks with active session, provider session, or fresh update", () => {
+      const agent = createAgent({ name: "live-worker", isLead: false, status: "idle" });
+      const withActiveSession = createTaskExtended("Live session task", { agentId: agent.id });
+      const withProviderSession = createTaskExtended("Provider session task", {
+        agentId: agent.id,
+      });
+      const fresh = createTaskExtended("Fresh task", { agentId: agent.id });
+
+      startTask(withActiveSession.id);
+      startTask(withProviderSession.id);
+      startTask(fresh.id);
+
+      const oldTime = new Date(Date.now() - 2 * 60 * 1000).toISOString();
+      getDb().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id IN (?, ?)", [
+        oldTime,
+        withActiveSession.id,
+        withProviderSession.id,
+      ]);
+      insertActiveSession({
+        agentId: agent.id,
+        taskId: withActiveSession.id,
+        triggerType: "task_assigned",
+      });
+      updateTaskClaudeSessionId(withProviderSession.id, "claude-live-session");
+
+      const reset = resetOrphanedInProgressTasksForAgent(agent.id, 60);
+      expect(reset.length).toBe(0);
+
+      expect(getTaskById(withActiveSession.id)?.status).toBe("in_progress");
+      expect(getTaskById(withProviderSession.id)?.status).toBe("in_progress");
+      expect(getTaskById(fresh.id)?.status).toBe("in_progress");
+    });
+  });
+
   describe("getIdleWorkersWithCapacity", () => {
     test("returns idle non-lead agents", () => {
       createAgent({ name: "idle-worker", isLead: false, status: "idle" });
@@ -306,10 +364,13 @@ describe("Heartbeat Triage", () => {
       expect(findings.autoAssigned.length).toBe(1);
       expect(findings.autoAssigned[0]!.agentId).toBe(worker.id);
 
-      // Verify task is now in_progress
+      // Verify task is pending so the worker's normal poll returns task_assigned.
       const task = getTaskById(findings.autoAssigned[0]!.taskId);
-      expect(task?.status).toBe("in_progress");
+      expect(task?.status).toBe("pending");
       expect(task?.agentId).toBe(worker.id);
+
+      const dispatchable = getPendingTaskForAgent(worker.id);
+      expect(dispatchable?.id).toBe(task?.id);
     });
 
     test("auto-assignment skips lead agents", async () => {
@@ -340,6 +401,26 @@ describe("Heartbeat Triage", () => {
       expect(findings.autoAssigned.length).toBe(0);
     });
 
+    test("auto-assignment counts pending reservations when assigning pool tasks", async () => {
+      const worker = createAgent({ name: "single-slot-worker", isLead: false, status: "idle" });
+      createTaskExtended("Pool task 1");
+      createTaskExtended("Pool task 2");
+
+      const findings = await codeLevelTriage();
+      expect(findings.autoAssigned.length).toBe(1);
+      expect(findings.autoAssigned[0]!.agentId).toBe(worker.id);
+
+      const assigned = getDb()
+        .query("SELECT COUNT(*) as count FROM agent_tasks WHERE agentId = ? AND status = 'pending'")
+        .get(worker.id) as { count: number };
+      const remaining = getDb()
+        .query("SELECT COUNT(*) as count FROM agent_tasks WHERE status = 'unassigned'")
+        .get() as { count: number };
+
+      expect(assigned.count).toBe(1);
+      expect(remaining.count).toBe(1);
+    });
+
     test("fixes worker with busy status but no active tasks", async () => {
       createAgent({ name: "ghost-busy", isLead: false, status: "busy" });
 
@@ -408,7 +489,7 @@ describe("Heartbeat Triage", () => {
 
       // Verify task was auto-assigned
       const tasks = getDb()
-        .query("SELECT * FROM agent_tasks WHERE status = 'in_progress' AND agentId = ?")
+        .query("SELECT * FROM agent_tasks WHERE status = 'pending' AND agentId = ?")
         .all(worker.id) as Array<{ id: string }>;
       expect(tasks.length).toBe(1);
     });

package/src/tests/http-api-integration.test.ts

@@ -13,6 +13,7 @@ import { Webhook } from "svix";
 const TEST_PORT = 19876;
 const TEST_DB_PATH = `/tmp/test-http-integration-${Date.now()}.sqlite`;
 const BASE = `http://localhost:${TEST_PORT}`;
+const TEST_API_KEY = "test-http-integration-key";
 
 let serverProc: Subprocess;
 
@@ -28,6 +29,7 @@ async function api(
 ): Promise<{ status: number; body: any; ok: boolean }> {
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
+    Authorization: `Bearer ${TEST_API_KEY}`,
     ...opts.headers,
   };
   if (opts.agentId) headers["x-agent-id"] = opts.agentId;
@@ -106,7 +108,7 @@ beforeAll(async () => {
       ...process.env,
       PORT: String(TEST_PORT),
       DATABASE_PATH: TEST_DB_PATH,
-      API_KEY: "", // no auth required
+      API_KEY: TEST_API_KEY,
       CAPABILITIES: "core,task-pool,messaging,profiles,services,scheduling,memory",
       // Disable optional integrations
       SLACK_BOT_TOKEN: "",

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

@@ -0,0 +1,247 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import crypto from "node:crypto";
+import { unlink } from "node:fs/promises";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import { closeDb, getMetricVersions, initDb } from "../be/db";
+import { handleMetrics } from "../http/metrics";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import type { Metric } from "../types";
+
+const TEST_DB_PATH = "./test-metrics-http.sqlite";
+const TEST_PORT = 13083;
+const BASE = `http://localhost:${TEST_PORT}`;
+
+type MetricRunResponse = {
+  widgets: Array<{
+    widget: { id: string };
+    result: {
+      columns: string[];
+      rows: Record<string, unknown>[];
+    };
+  }>;
+  result: {
+    columns: string[];
+    rows: Record<string, unknown>[];
+  };
+};
+
+function createTestServer(): Server {
+  return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    res.setHeader("Content-Type", "application/json");
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    const handled = await handleMetrics(req, res, pathSegments, queryParams, myAgentId);
+    if (!handled) {
+      res.writeHead(404);
+      res.end(JSON.stringify({ error: "not found" }));
+    }
+  });
+}
+
+describe("Metrics HTTP API", () => {
+  let server: Server;
+  const agentId = crypto.randomUUID();
+  const headers = { "Content-Type": "application/json", "X-Agent-ID": agentId };
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    server = createTestServer();
+    await new Promise<void>((resolve) => server.listen(TEST_PORT, () => resolve()));
+  });
+
+  afterAll(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+  });
+
+  test("fresh DB seeds starter metrics", async () => {
+    const res = await fetch(`${BASE}/api/metrics/definitions?fields=full`);
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { metrics: Metric[]; total: number };
+    expect(body.total).toBeGreaterThanOrEqual(1);
+    const starter = body.metrics.find((metric) => metric.slug === "swarm-operations-overview");
+    expect(starter?.definition.widgets.map((widget) => widget.viz.type)).toContain("multi-line");
+  });
+
+  test("create, run, update snapshots prior definition", async () => {
+    const created = await fetch(`${BASE}/api/metrics/definitions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "test-count",
+        title: "Test Count",
+        description: "Counts agent rows",
+        definition: {
+          version: 1,
+          widgets: [
+            {
+              id: "agent-count",
+              title: "Agent count",
+              query: { sql: "SELECT COUNT(*) AS count FROM agents", maxRows: 10 },
+              viz: { type: "stat", value: "count", format: "integer" },
+            },
+          ],
+        },
+      }),
+    });
+    expect(created.status).toBe(201);
+    const { id } = (await created.json()) as { id: string; version: number };
+
+    const run = await fetch(`${BASE}/api/metrics/definitions/${id}/run`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ variables: {} }),
+    });
+    expect(run.status).toBe(200);
+    const runBody = (await run.json()) as MetricRunResponse;
+    expect(runBody.widgets[0]?.result.columns).toEqual(["count"]);
+    expect(runBody.widgets[0]?.result.rows[0]).toHaveProperty("count");
+
+    const updated = await fetch(`${BASE}/api/metrics/definitions/${id}`, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify({
+        title: "Updated Count",
+        definition: {
+          version: 1,
+          widgets: [
+            {
+              id: "task-count",
+              title: "Task count",
+              query: { sql: "SELECT COUNT(*) AS count FROM agent_tasks", maxRows: 10 },
+              viz: { type: "stat", value: "count", format: "integer" },
+            },
+          ],
+        },
+      }),
+    });
+    expect(updated.status).toBe(200);
+    expect(getMetricVersions(id)).toHaveLength(1);
+    expect(getMetricVersions(id)[0]?.snapshot.title).toBe("Test Count");
+  });
+
+  test("humans can create metrics through the UI without an agent header", async () => {
+    const created = await fetch(`${BASE}/api/metrics/definitions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        slug: "ui-owned-count",
+        title: "UI Owned Count",
+        definition: {
+          version: 1,
+          widgets: [
+            {
+              id: "task-count",
+              title: "Task count",
+              query: { sql: "SELECT COUNT(*) AS count FROM agent_tasks", maxRows: 10 },
+              viz: { type: "stat", value: "count", format: "integer" },
+            },
+          ],
+        },
+      }),
+    });
+    expect(created.status).toBe(201);
+    const { id } = (await created.json()) as { id: string; version: number };
+
+    const run = await fetch(`${BASE}/api/metrics/definitions/${id}/run`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ variables: {} }),
+    });
+    expect(run.status).toBe(200);
+    const runBody = (await run.json()) as MetricRunResponse;
+    expect(runBody.widgets[0]?.result.rows[0]).toHaveProperty("count");
+  });
+
+  test("run binds metric variables into query params", async () => {
+    const created = await fetch(`${BASE}/api/metrics/definitions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "variable-count",
+        title: "Variable Count",
+        definition: {
+          version: 1,
+          variables: [
+            {
+              key: "status",
+              label: "Status",
+              type: "select",
+              defaultValue: "pending",
+              options: [
+                { label: "Pending", value: "pending" },
+                { label: "Completed", value: "completed" },
+              ],
+            },
+          ],
+          widgets: [
+            {
+              id: "status-count",
+              title: "Status count",
+              query: {
+                sql: "SELECT COUNT(*) AS count FROM agent_tasks WHERE status = ?",
+                params: ["{{status}}"],
+                maxRows: 10,
+              },
+              viz: { type: "stat", value: "count", format: "integer" },
+            },
+          ],
+        },
+      }),
+    });
+    expect(created.status).toBe(201);
+    const { id } = (await created.json()) as { id: string; version: number };
+
+    const run = await fetch(`${BASE}/api/metrics/definitions/${id}/run`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ variables: { status: "completed" } }),
+    });
+    expect(run.status).toBe(200);
+    const runBody = (await run.json()) as MetricRunResponse & {
+      variables: Record<string, string>;
+    };
+    expect(runBody.variables.status).toBe("completed");
+    expect(runBody.widgets[0]?.result.rows[0]).toHaveProperty("count");
+  });
+
+  test("saved metric SQL rejects writes and multiple statements", async () => {
+    for (const sql of ["DELETE FROM agent_tasks", "SELECT 1; SELECT 2"]) {
+      const res = await fetch(`${BASE}/api/metrics/definitions`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          title: "Bad Metric",
+          definition: {
+            version: 1,
+            widgets: [
+              {
+                id: "bad",
+                title: "Bad",
+                query: { sql },
+                viz: { type: "stat", value: "x" },
+              },
+            ],
+          },
+        }),
+      });
+      expect(res.status).toBe(400);
+    }
+  });
+});

package/src/tests/opencode-adapter.test.ts

@@ -48,7 +48,7 @@ let lastCreateOpencodeConfig: unknown;
 async function driveSession(
   events: OpencodeEvent[],
   cfg: ProviderSessionConfig = testConfig(),
-): Promise<{ emitted: ProviderEvent[]; result: ProviderResult }> {
+): Promise<{ emitted: ProviderEvent[]; result: ProviderResult; serverCloseCalls: () => number }> {
   const emitted: ProviderEvent[] = [];
 
   // Build the fake client/server pair used by the mock
@@ -68,7 +68,8 @@ async function driveSession(
     },
   };
 
-  const fakeServer = { url: "http://127.0.0.1:12345", close: mock(() => {}) };
+  const closeServer = mock(() => {});
+  const fakeServer = { url: "http://127.0.0.1:12345", close: closeServer };
 
   // Install mock BEFORE importing the adapter (Bun hoists mock.module)
   mock.module("@opencode-ai/sdk", () => ({
@@ -88,7 +89,54 @@ async function driveSession(
   await new Promise((r) => setTimeout(r, 0));
 
   const result = await session.waitForCompletion();
-  return { emitted, result };
+  return { emitted, result, serverCloseCalls: () => closeServer.mock.calls.length };
+}
+
+async function inspectSessionBeforeIdle(
+  cfg: ProviderSessionConfig,
+  inspect: () => Promise<void>,
+): Promise<void> {
+  const fakeSessionId = "sess-abc-123";
+  let releaseIdle!: () => void;
+  const idleReleased = new Promise<void>((resolve) => {
+    releaseIdle = resolve;
+  });
+
+  const fakeClient = {
+    session: {
+      create: async () => ({ data: { id: fakeSessionId }, error: undefined }),
+      prompt: async (args: unknown) => {
+        lastPromptArgs = args;
+        return { data: {}, error: undefined };
+      },
+    },
+    event: {
+      subscribe: async () => ({
+        stream: (async function* (): AsyncGenerator<OpencodeEvent> {
+          await idleReleased;
+          yield { type: "session.idle", properties: { sessionID: fakeSessionId } };
+        })(),
+      }),
+    },
+  };
+
+  const fakeServer = { url: "http://127.0.0.1:12345", close: mock(() => {}) };
+
+  mock.module("@opencode-ai/sdk", () => ({
+    createOpencode: async (opts: unknown) => {
+      lastCreateOpencodeConfig = opts;
+      return { client: fakeClient, server: fakeServer };
+    },
+  }));
+
+  const { OpencodeAdapter } = await import("../providers/opencode-adapter");
+  const adapter = new OpencodeAdapter();
+  const session = await adapter.createSession(cfg);
+  session.onEvent(() => {});
+  await new Promise((r) => setTimeout(r, 0));
+  await inspect();
+  releaseIdle();
+  await session.waitForCompletion();
 }
 
 // ── tests ─────────────────────────────────────────────────────────────────────
@@ -106,7 +154,7 @@ describe("OpencodeSession — SSE→ProviderEvent mapping", () => {
         properties: { sessionID: "sess-abc-123" },
       },
     ];
-    const { emitted, result } = await driveSession(events);
+    const { emitted, result, serverCloseCalls } = await driveSession(events);
 
     const resultEvent = emitted.find((e) => e.type === "result");
     expect(resultEvent).toBeDefined();
@@ -118,6 +166,21 @@ describe("OpencodeSession — SSE→ProviderEvent mapping", () => {
     expect(result.isError).toBe(false);
     expect(result.exitCode).toBe(0);
     expect(result.sessionId).toBe("sess-abc-123");
+    expect(serverCloseCalls()).toBe(1);
+  });
+
+  test("session.idle closes the server and drops later heartbeat events", async () => {
+    const events: OpencodeEvent[] = [
+      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+      { type: "server.heartbeat", properties: {} } as OpencodeEvent,
+    ];
+    const { emitted, serverCloseCalls } = await driveSession(events);
+
+    expect(serverCloseCalls()).toBe(1);
+    const rawLogContents = emitted
+      .filter((e): e is Extract<ProviderEvent, { type: "raw_log" }> => e.type === "raw_log")
+      .map((e) => e.content);
+    expect(rawLogContents.some((content) => content.includes("server.heartbeat"))).toBe(false);
   });
 
   test("session.error → emits error event and fails result", async () => {
@@ -130,7 +193,7 @@ describe("OpencodeSession — SSE→ProviderEvent mapping", () => {
         },
       },
     ];
-    const { emitted, result } = await driveSession(events);
+    const { emitted, result, serverCloseCalls } = await driveSession(events);
 
     const errorEvent = emitted.find((e) => e.type === "error");
     expect(errorEvent).toBeDefined();
@@ -140,6 +203,7 @@ describe("OpencodeSession — SSE→ProviderEvent mapping", () => {
     expect(result.isError).toBe(true);
     expect(result.exitCode).toBe(1);
     expect(result.failureReason).toContain("provider overloaded");
+    expect(serverCloseCalls()).toBe(1);
   });
 
   test("prompt Model not found refreshes OpenRouter cache and retries once", async () => {
@@ -600,42 +664,38 @@ describe("OpencodeAdapter — per-task isolation (DES-300)", () => {
   });
 
   test("per-task agent file is written with system prompt", async () => {
-    const events: OpencodeEvent[] = [
-      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
-    ];
     const cwd = `/tmp/opencode-test-agent-${Date.now()}`;
     await Bun.$`mkdir -p ${cwd}`.quiet();
     const cfg = testConfig({ taskId: "task-agent-file", systemPrompt: "be a coder", cwd });
-    await driveSession(events, cfg);
+    await inspectSessionBeforeIdle(cfg, async () => {
+      const agentFile = Bun.file(join(cwd, ".opencode", "agents", "swarm-task-agent-file.md"));
+      const exists = await agentFile.exists();
+      expect(exists).toBe(true);
+      if (exists) {
+        const content = await agentFile.text();
+        expect(content).toContain("be a coder");
+      }
+    });
 
-    const agentFile = Bun.file(join(cwd, ".opencode", "agents", "swarm-task-agent-file.md"));
-    const exists = await agentFile.exists();
-    expect(exists).toBe(true);
-    if (exists) {
-      const content = await agentFile.text();
-      expect(content).toContain("be a coder");
-    }
     // Cleanup
     await Bun.$`rm -rf ${cwd}`.quiet().nothrow();
   });
 
   test("per-task config file is written as valid JSON", async () => {
-    const events: OpencodeEvent[] = [
-      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
-    ];
     const cfg = testConfig({ taskId: "task-cfg-json" });
-    await driveSession(events, cfg);
+    await inspectSessionBeforeIdle(cfg, async () => {
+      const configFile = Bun.file("/tmp/opencode-task-cfg-json.json");
+      const exists = await configFile.exists();
+      expect(exists).toBe(true);
+      if (exists) {
+        const text = await configFile.text();
+        expect(() => JSON.parse(text)).not.toThrow();
+        const parsed = JSON.parse(text) as { mcp?: unknown; permission?: unknown };
+        expect(parsed.mcp).toBeDefined();
+        expect(parsed.permission).toBeDefined();
+      }
+    });
 
-    const configFile = Bun.file("/tmp/opencode-task-cfg-json.json");
-    const exists = await configFile.exists();
-    expect(exists).toBe(true);
-    if (exists) {
-      const text = await configFile.text();
-      expect(() => JSON.parse(text)).not.toThrow();
-      const parsed = JSON.parse(text) as { mcp?: unknown; permission?: unknown };
-      expect(parsed.mcp).toBeDefined();
-      expect(parsed.permission).toBeDefined();
-    }
     // Cleanup
     await Bun.$`rm -f /tmp/opencode-task-cfg-json.json`.quiet().nothrow();
     await Bun.$`rm -rf /tmp/opencode-data-task-cfg-json`.quiet().nothrow();