@desplega.ai/agent-swarm 1.20.0 → 1.51.2

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

@@ -0,0 +1,122 @@
+import { describe, expect, test } from "bun:test";
+import { createProviderAdapter } from "../providers";
+import { ClaudeAdapter } from "../providers/claude-adapter";
+import { PiMonoAdapter } from "../providers/pi-mono-adapter";
+import type { CostData, ProviderEvent } from "../providers/types";
+
+describe("createProviderAdapter", () => {
+  test("returns ClaudeAdapter for 'claude'", () => {
+    const adapter = createProviderAdapter("claude");
+    expect(adapter).toBeInstanceOf(ClaudeAdapter);
+    expect(adapter.name).toBe("claude");
+  });
+
+  test("returns PiMonoAdapter for 'pi'", () => {
+    const adapter = createProviderAdapter("pi");
+    expect(adapter).toBeInstanceOf(PiMonoAdapter);
+    expect(adapter.name).toBe("pi");
+  });
+
+  test("throws for unknown provider", () => {
+    expect(() => createProviderAdapter("unknown")).toThrow(
+      'Unknown HARNESS_PROVIDER: "unknown". Supported: claude, pi',
+    );
+  });
+
+  test("throws for empty string", () => {
+    expect(() => createProviderAdapter("")).toThrow("Unknown HARNESS_PROVIDER");
+  });
+});
+
+describe("ProviderEvent type narrowing", () => {
+  test("session_init event has sessionId", () => {
+    const event: ProviderEvent = { type: "session_init", sessionId: "abc-123" };
+    if (event.type === "session_init") {
+      expect(event.sessionId).toBe("abc-123");
+    }
+  });
+
+  test("result event has cost data", () => {
+    const cost: CostData = {
+      sessionId: "sess-1",
+      agentId: "agent-1",
+      totalCostUsd: 0.05,
+      inputTokens: 1000,
+      outputTokens: 500,
+      cacheReadTokens: 200,
+      cacheWriteTokens: 100,
+      durationMs: 5000,
+      numTurns: 3,
+      model: "opus",
+      isError: false,
+    };
+    const event: ProviderEvent = { type: "result", cost, isError: false };
+    if (event.type === "result") {
+      expect(event.cost.totalCostUsd).toBe(0.05);
+      expect(event.cost.inputTokens).toBe(1000);
+      expect(event.cost.outputTokens).toBe(500);
+    }
+  });
+
+  test("error event has message", () => {
+    const event: ProviderEvent = { type: "error", message: "boom", category: "api_error" };
+    if (event.type === "error") {
+      expect(event.message).toBe("boom");
+      expect(event.category).toBe("api_error");
+    }
+  });
+
+  test("raw_log event has content string", () => {
+    const event: ProviderEvent = { type: "raw_log", content: "some output" };
+    if (event.type === "raw_log") {
+      expect(event.content).toBe("some output");
+    }
+  });
+});
+
+describe("CostData shape", () => {
+  test("matches expected API fields", () => {
+    const cost: CostData = {
+      sessionId: "sess-1",
+      taskId: "task-1",
+      agentId: "agent-1",
+      totalCostUsd: 0.12,
+      inputTokens: 2000,
+      outputTokens: 1000,
+      cacheReadTokens: 500,
+      cacheWriteTokens: 300,
+      durationMs: 10000,
+      numTurns: 5,
+      model: "claude-opus-4-20250514",
+      isError: false,
+    };
+
+    // All required fields present
+    expect(cost.sessionId).toBe("sess-1");
+    expect(cost.taskId).toBe("task-1");
+    expect(cost.agentId).toBe("agent-1");
+    expect(cost.totalCostUsd).toBeGreaterThan(0);
+    expect(cost.durationMs).toBeGreaterThanOrEqual(0);
+    expect(cost.numTurns).toBeGreaterThan(0);
+    expect(cost.model).toBeTruthy();
+    expect(typeof cost.isError).toBe("boolean");
+  });
+
+  test("optional fields can be undefined", () => {
+    const cost: CostData = {
+      sessionId: "",
+      agentId: "agent-1",
+      totalCostUsd: 0,
+      durationMs: 0,
+      numTurns: 0,
+      model: "opus",
+      isError: false,
+    };
+
+    expect(cost.taskId).toBeUndefined();
+    expect(cost.inputTokens).toBeUndefined();
+    expect(cost.outputTokens).toBeUndefined();
+    expect(cost.cacheReadTokens).toBeUndefined();
+    expect(cost.cacheWriteTokens).toBeUndefined();
+  });
+});

package/src/tests/provider-command-format.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test";
+import { ClaudeAdapter } from "../providers/claude-adapter";
+import { createProviderAdapter } from "../providers/index";
+import { PiMonoAdapter } from "../providers/pi-mono-adapter";
+
+describe("ProviderAdapter.formatCommand", () => {
+  const claude = new ClaudeAdapter();
+  const pi = new PiMonoAdapter();
+
+  test("claude formats commands with / prefix", () => {
+    expect(claude.formatCommand("work-on-task")).toBe("/work-on-task");
+    expect(claude.formatCommand("review-offered-task")).toBe("/review-offered-task");
+    expect(claude.formatCommand("swarm-chat")).toBe("/swarm-chat");
+  });
+
+  test("pi formats commands with /skill: prefix", () => {
+    expect(pi.formatCommand("work-on-task")).toBe("/skill:work-on-task");
+    expect(pi.formatCommand("review-offered-task")).toBe("/skill:review-offered-task");
+    expect(pi.formatCommand("swarm-chat")).toBe("/skill:swarm-chat");
+  });
+
+  test("adapter name matches expected provider", () => {
+    expect(claude.name).toBe("claude");
+    expect(pi.name).toBe("pi");
+  });
+
+  test("createProviderAdapter returns adapters that implement formatCommand", () => {
+    const claudeAdapter = createProviderAdapter("claude");
+    const piAdapter = createProviderAdapter("pi");
+    expect(typeof claudeAdapter.formatCommand).toBe("function");
+    expect(typeof piAdapter.formatCommand).toBe("function");
+    expect(claudeAdapter.formatCommand("work-on-task")).toBe("/work-on-task");
+    expect(piAdapter.formatCommand("work-on-task")).toBe("/skill:work-on-task");
+  });
+});
+
+describe("regression: pi worker prompt must use /skill: prefix", () => {
+  const pi = new PiMonoAdapter();
+  const claude = new ClaudeAdapter();
+
+  function simulateTaskAssignedPrompt(
+    adapter: { formatCommand: (cmd: string) => string },
+    taskId: string,
+    taskDesc: string,
+  ): string {
+    let prompt = `${adapter.formatCommand("work-on-task")} ${taskId}`;
+    prompt += `\n\nTask: "${taskDesc}"`;
+    prompt += `\n\nWhen done, use \`store-progress\` with status: "completed" and include your output.`;
+    return prompt;
+  }
+
+  function simulateTaskOfferedPrompt(
+    adapter: { formatCommand: (cmd: string) => string },
+    taskId: string,
+    taskDesc: string,
+  ): string {
+    let prompt = `${adapter.formatCommand("review-offered-task")} ${taskId}`;
+    prompt += `\n\nA task has been offered to you:\n"${taskDesc}"`;
+    prompt += `\n\nAccept if you have capacity and skills. Reject with a reason if you cannot handle it.`;
+    return prompt;
+  }
+
+  function simulateResumePrompt(
+    adapter: { formatCommand: (cmd: string) => string },
+    taskId: string,
+  ): string {
+    return `${adapter.formatCommand("work-on-task")} ${taskId}\n\n**RESUMED TASK**`;
+  }
+
+  test("pi task_assigned prompt starts with /skill:work-on-task", () => {
+    const prompt = simulateTaskAssignedPrompt(pi, "abc-123", "Review the PR");
+    expect(prompt).toStartWith("/skill:work-on-task abc-123");
+    expect(prompt).not.toStartWith("/work-on-task abc-123");
+  });
+
+  test("pi task_offered prompt starts with /skill:review-offered-task", () => {
+    const prompt = simulateTaskOfferedPrompt(pi, "def-456", "Check deployment");
+    expect(prompt).toStartWith("/skill:review-offered-task def-456");
+    expect(prompt).not.toStartWith("/review-offered-task def-456");
+  });
+
+  test("pi resume prompt starts with /skill:work-on-task", () => {
+    const prompt = simulateResumePrompt(pi, "ghi-789");
+    expect(prompt).toStartWith("/skill:work-on-task ghi-789");
+  });
+
+  test("claude task_assigned prompt starts with /work-on-task (no /skill:)", () => {
+    const prompt = simulateTaskAssignedPrompt(claude, "abc-123", "Review the PR");
+    expect(prompt).toStartWith("/work-on-task abc-123");
+    expect(prompt).not.toContain("/skill:");
+  });
+
+  test("claude task_offered prompt starts with /review-offered-task (no /skill:)", () => {
+    const prompt = simulateTaskOfferedPrompt(claude, "def-456", "Check deployment");
+    expect(prompt).toStartWith("/review-offered-task def-456");
+    expect(prompt).not.toContain("/skill:");
+  });
+});

package/src/tests/reload-config.test.ts

@@ -0,0 +1,170 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { createServer as createHttpServer, type Server } from "node:http";
+import { initAgentMail, resetAgentMail } from "../agentmail";
+import { closeDb, getResolvedConfig, initDb, upsertSwarmConfig } from "../be/db";
+import { initGitHub, resetGitHub } from "../github";
+
+const TEST_DB_PATH = "./test-reload-config.sqlite";
+const TEST_PORT = 13023;
+
+/**
+ * Mirrors the loadGlobalConfigsIntoEnv logic from http.ts
+ */
+function loadGlobalConfigsIntoEnv(override = false): string[] {
+  const globalConfigs = getResolvedConfig();
+  const updated: string[] = [];
+  for (const config of globalConfigs) {
+    if (override || !process.env[config.key]) {
+      process.env[config.key] = config.value;
+      updated.push(config.key);
+    }
+  }
+  return updated;
+}
+
+// Minimal HTTP handler for the reload-config endpoint
+function createTestServer(): Server {
+  return createHttpServer(async (req, res) => {
+    if (req.method === "POST" && req.url === "/internal/reload-config") {
+      try {
+        const updated = loadGlobalConfigsIntoEnv(true);
+
+        const integrations: string[] = [];
+
+        resetAgentMail();
+        if (initAgentMail()) integrations.push("agentmail");
+
+        resetGitHub();
+        if (initGitHub()) integrations.push("github");
+
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            success: true,
+            configsLoaded: updated.length,
+            keysUpdated: updated,
+            integrationsReinitialized: integrations,
+          }),
+        );
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Failed to reload config", details: message }));
+      }
+      return;
+    }
+
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  });
+}
+
+describe("reload-config", () => {
+  let server: Server;
+  const baseUrl = `http://localhost:${TEST_PORT}`;
+
+  // Track env keys we set so we can clean them up
+  const envKeysToClean: string[] = [];
+
+  beforeAll(async () => {
+    initDb(TEST_DB_PATH);
+
+    server = createTestServer();
+    await new Promise<void>((resolve) => {
+      server.listen(TEST_PORT, () => resolve());
+    });
+  });
+
+  afterAll(async () => {
+    server.close();
+    closeDb();
+    // Clean up env vars we set
+    for (const key of envKeysToClean) {
+      delete process.env[key];
+    }
+    await unlink(TEST_DB_PATH).catch(() => {});
+  });
+
+  test("POST /internal/reload-config returns 200 with empty DB", async () => {
+    const res = await fetch(`${baseUrl}/internal/reload-config`, { method: "POST" });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.success).toBe(true);
+    expect(body.configsLoaded).toBe(0);
+    expect(body.keysUpdated).toEqual([]);
+  });
+
+  test("loadGlobalConfigsIntoEnv loads DB configs into process.env", () => {
+    const testKey = `__TEST_RELOAD_KEY_${Date.now()}`;
+    envKeysToClean.push(testKey);
+
+    upsertSwarmConfig({
+      scope: "global",
+      key: testKey,
+      value: "test-value-123",
+    });
+
+    const updated = loadGlobalConfigsIntoEnv(false);
+    expect(updated).toContain(testKey);
+    expect(process.env[testKey]).toBe("test-value-123");
+  });
+
+  test("loadGlobalConfigsIntoEnv does not override existing env vars when override=false", () => {
+    const testKey = `__TEST_NO_OVERRIDE_${Date.now()}`;
+    envKeysToClean.push(testKey);
+
+    process.env[testKey] = "original-value";
+
+    upsertSwarmConfig({
+      scope: "global",
+      key: testKey,
+      value: "db-value",
+    });
+
+    const updated = loadGlobalConfigsIntoEnv(false);
+    expect(updated).not.toContain(testKey);
+    expect(process.env[testKey]).toBe("original-value");
+  });
+
+  test("loadGlobalConfigsIntoEnv overrides existing env vars when override=true", () => {
+    const testKey = `__TEST_OVERRIDE_${Date.now()}`;
+    envKeysToClean.push(testKey);
+
+    process.env[testKey] = "original-value";
+
+    upsertSwarmConfig({
+      scope: "global",
+      key: testKey,
+      value: "new-db-value",
+    });
+
+    const updated = loadGlobalConfigsIntoEnv(true);
+    expect(updated).toContain(testKey);
+    expect(process.env[testKey]).toBe("new-db-value");
+  });
+
+  test("POST /internal/reload-config loads configs and returns summary", async () => {
+    const testKey = `__TEST_RELOAD_ENDPOINT_${Date.now()}`;
+    envKeysToClean.push(testKey);
+
+    upsertSwarmConfig({
+      scope: "global",
+      key: testKey,
+      value: "endpoint-test-value",
+    });
+
+    const res = await fetch(`${baseUrl}/internal/reload-config`, { method: "POST" });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.success).toBe(true);
+    expect(body.configsLoaded).toBeGreaterThan(0);
+    expect(body.keysUpdated).toContain(testKey);
+    expect(process.env[testKey]).toBe("endpoint-test-value");
+  });
+
+  test("unknown endpoint returns 404", async () => {
+    const res = await fetch(`${baseUrl}/nonexistent`, { method: "POST" });
+    expect(res.status).toBe(404);
+  });
+});

package/src/tests/runner-polling-api.test.ts

@@ -108,17 +108,21 @@ async function handleRequest(
         };
       }
 
-      if (agent.isLead) {
-        const inbox = getInboxSummary(myAgentId);
-        if (inbox.mentionsCount > 0) {
-          return {
-            trigger: {
-              type: "unread_mentions",
-              mentionsCount: inbox.mentionsCount,
-            },
-          };
-        }
+      // Check for unread mentions - all agents can be woken by @mentions
+      const inbox = getInboxSummary(myAgentId);
+      if (inbox.mentionsCount > 0) {
+        return {
+          trigger: {
+            type: "unread_mentions",
+            mentionsCount: inbox.mentionsCount,
+          },
+        };
+      }
 
+      if (agent.isLead) {
+        // Lead-specific triggers would go here (inbox, epics, etc.)
+      } else {
+        // Worker-specific: check for unassigned tasks in pool
         const unassignedCount = getUnassignedTasksCount();
         if (unassignedCount > 0) {
           return {
@@ -454,7 +458,7 @@ describe("Runner-Level Polling API", () => {
       expect(data.trigger.taskId).toBe(task.id);
     });
 
-    test("should return pool_tasks_available for lead when unassigned tasks exist", async () => {
+    test("lead should NOT see pool_tasks_available (pool tasks are worker-only)", async () => {
       const leadId = "test-lead-poll";
 
       // Create lead agent
@@ -487,13 +491,12 @@ describe("Runner-Level Polling API", () => {
         status?: string;
         trigger?: unknown;
       };
-      expect(data.trigger).not.toBeNull();
-      expect(data.trigger.type).toBe("pool_tasks_available");
-      expect(data.trigger.count).toBeGreaterThan(0);
+      // Leads don't see pool_tasks_available — only workers do
+      expect(data.trigger).toBeNull();
     });
 
-    test("worker should NOT see pool_tasks_available trigger", async () => {
-      const workerId = "test-worker-no-pool";
+    test("worker should see pool_tasks_available trigger when unassigned tasks exist", async () => {
+      const workerId = "test-worker-pool";
 
       // Create worker agent (not lead)
       await fetch(`${baseUrl}/api/agents`, {
@@ -502,7 +505,7 @@ describe("Runner-Level Polling API", () => {
           "Content-Type": "application/json",
           "X-Agent-ID": workerId,
         },
-        body: JSON.stringify({ name: "Worker No Pool Access", isLead: false }),
+        body: JSON.stringify({ name: "Worker Pool Access", isLead: false }),
       });
 
       // There's already an unassigned task from previous test
@@ -519,10 +522,12 @@ describe("Runner-Level Polling API", () => {
         id?: string;
         name?: string;
         status?: string;
-        trigger?: unknown;
+        trigger?: { type: string; count?: number };
       };
-      // Worker should NOT see pool tasks
-      expect(data.trigger).toBeNull();
+      // Workers should see pool tasks so they can compete to claim them
+      expect(data.trigger).not.toBeNull();
+      expect(data.trigger!.type).toBe("pool_tasks_available");
+      expect(data.trigger!.count).toBeGreaterThan(0);
     });
   });
 });

package/src/tests/scheduled-tasks.test.ts

@@ -498,4 +498,108 @@ describe("Scheduled Tasks Integration", () => {
       expect(tasks.count).toBe(2);
     });
   });
+
+  describe("One-Time Schedules", () => {
+    test("create one-time schedule with delayMs computes nextRunAt", () => {
+      const before = Date.now();
+      const schedule = createScheduledTask({
+        name: "one-time-delay-test",
+        taskTemplate: "One-time delay task",
+        scheduleType: "one_time",
+        nextRunAt: new Date(before + 60000).toISOString(),
+        createdByAgentId: testAgent.id,
+      });
+
+      expect(schedule.scheduleType).toBe("one_time");
+      expect(schedule.nextRunAt).toBeDefined();
+      expect(schedule.enabled).toBe(true);
+      expect(schedule.cronExpression).toBeUndefined();
+      expect(schedule.intervalMs).toBeUndefined();
+    });
+
+    test("create one-time schedule with runAt stores nextRunAt", () => {
+      const runAt = new Date(Date.now() + 120000).toISOString();
+      const schedule = createScheduledTask({
+        name: "one-time-runat-test",
+        taskTemplate: "One-time runAt task",
+        scheduleType: "one_time",
+        nextRunAt: runAt,
+        createdByAgentId: testAgent.id,
+      });
+
+      expect(schedule.scheduleType).toBe("one_time");
+      expect(schedule.nextRunAt).toBe(runAt);
+    });
+
+    test("one-time schedule does not require cronExpression or intervalMs", () => {
+      const schedule = createScheduledTask({
+        name: "one-time-no-cron-test",
+        taskTemplate: "No cron needed",
+        scheduleType: "one_time",
+        nextRunAt: new Date(Date.now() + 60000).toISOString(),
+      });
+
+      expect(schedule.scheduleType).toBe("one_time");
+      expect(schedule.cronExpression).toBeUndefined();
+      expect(schedule.intervalMs).toBeUndefined();
+    });
+
+    test("executing one-time schedule auto-disables it", async () => {
+      const schedule = createScheduledTask({
+        name: "one-time-exec-test",
+        taskTemplate: "Execute and disable",
+        scheduleType: "one_time",
+        nextRunAt: new Date(Date.now() - 1000).toISOString(), // due now
+        createdByAgentId: testAgent.id,
+      });
+
+      // Run it manually
+      await runScheduleNow(schedule.id);
+
+      const updated = getScheduledTaskById(schedule.id);
+      expect(updated).not.toBeNull();
+      expect(updated!.enabled).toBe(false);
+      expect(updated!.lastRunAt).toBeDefined();
+      expect(updated!.nextRunAt).toBeUndefined();
+    });
+
+    test("one-time schedules hidden by default in list", () => {
+      // The executed one-time schedule from the previous test should be hidden
+      const allSchedules = getScheduledTasks({ hideCompleted: true });
+      const executedOneTime = allSchedules.find((s) => s.name === "one-time-exec-test");
+      expect(executedOneTime).toBeUndefined();
+
+      // But visible when hideCompleted is false
+      const allIncluding = getScheduledTasks({ hideCompleted: false });
+      const found = allIncluding.find((s) => s.name === "one-time-exec-test");
+      expect(found).toBeDefined();
+      expect(found!.scheduleType).toBe("one_time");
+    });
+
+    test("filter by scheduleType works", () => {
+      const oneTimeOnly = getScheduledTasks({
+        scheduleType: "one_time",
+        hideCompleted: false,
+      });
+      expect(oneTimeOnly.length).toBeGreaterThan(0);
+      for (const s of oneTimeOnly) {
+        expect(s.scheduleType).toBe("one_time");
+      }
+
+      const recurringOnly = getScheduledTasks({ scheduleType: "recurring" });
+      for (const s of recurringOnly) {
+        expect(s.scheduleType).toBe("recurring");
+      }
+    });
+
+    test("existing recurring schedules default to scheduleType recurring", () => {
+      const schedule = createScheduledTask({
+        name: "recurring-default-test",
+        taskTemplate: "Should be recurring",
+        cronExpression: "0 * * * *",
+      });
+
+      expect(schedule.scheduleType).toBe("recurring");
+    });
+  });
 });