@desplega.ai/agent-swarm 1.87.0 → 1.89.0

package/src/tests/github-handlers-cancel-config.test.ts

@@ -0,0 +1,262 @@
+/**
+ * Tests for the runtime-config flags that control whether GitHub unassign and
+ * review-request-removed events terminate the linked swarm task.
+ *
+ * Flags (scope "global"):
+ *   github.cancelOnUnassign              — PR unassigned + issue unassigned
+ *   github.cancelOnReviewRequestRemoved  — PR review_request_removed
+ *
+ * Absent / any value ≠ "false" → cancel (current behavior, default).
+ * Value "false" → leave task untouched, return { created: false }.
+ */
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  deleteSwarmConfig,
+  getDb,
+  getSwarmConfigs,
+  getTaskById,
+  initDb,
+  upsertSwarmConfig,
+} from "../be/db";
+import { handleIssue, handlePullRequest } from "../github/handlers";
+import { GITHUB_BOT_NAME } from "../github/mentions";
+import type { IssueEvent, PullRequestEvent } from "../github/types";
+
+const TEST_DB_PATH = "./test-github-handlers-cancel-config.sqlite";
+
+const BASE_REPO = { full_name: "test/repo", html_url: "https://github.com/test/repo" };
+const BASE_PR = {
+  number: 1,
+  title: "Test PR",
+  body: null as string | null,
+  html_url: "https://github.com/test/repo/pull/1",
+  user: { login: "sender" },
+  head: { ref: "feature", sha: "abc1234567890" },
+  base: { ref: "main" },
+  merged: false,
+  merged_by: undefined,
+};
+const BASE_ISSUE = {
+  number: 10,
+  title: "Test Issue",
+  body: null as string | null,
+  html_url: "https://github.com/test/repo/issues/10",
+  user: { login: "sender" },
+};
+
+// ── Setup ──
+
+beforeAll(async () => {
+  await unlink(TEST_DB_PATH).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+  initDb(TEST_DB_PATH);
+  createAgent({
+    id: "lead-cancel-config-test",
+    name: "CancelConfigTestLead",
+    status: "idle",
+    isLead: true,
+  });
+});
+
+afterAll(async () => {
+  closeDb();
+  await unlink(TEST_DB_PATH).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+});
+
+// Clear tasks and config rows between tests.
+beforeEach(() => {
+  const db = getDb();
+  db.prepare("DELETE FROM agent_tasks").run();
+  // Remove both flag rows so each test starts from a clean slate.
+  for (const key of ["github.cancelOnUnassign", "github.cancelOnReviewRequestRemoved"]) {
+    const rows = getSwarmConfigs({ scope: "global", key });
+    for (const row of rows) deleteSwarmConfig(row.id);
+  }
+});
+
+// ── Helpers ──
+
+function seedTask(vcsNumber: number, kind: "pr" | "issue"): string {
+  const task = createTaskExtended("test task", {
+    agentId: "lead-cancel-config-test",
+    source: "github",
+    vcsProvider: "github",
+    vcsRepo: BASE_REPO.full_name,
+    vcsNumber,
+    vcsEventType: kind === "pr" ? "pull_request" : "issues",
+  });
+  return task.id;
+}
+
+function setConfigFlag(key: string, value: string) {
+  upsertSwarmConfig({ scope: "global", key, value });
+}
+
+function getTaskStatus(taskId: string): string | undefined {
+  return getTaskById(taskId)?.status;
+}
+
+// ── github.cancelOnUnassign — PR unassigned ──
+
+describe("PR unassigned — github.cancelOnUnassign", () => {
+  test("default (no config row): unassign cancels the task", async () => {
+    const taskId = seedTask(BASE_PR.number, "pr");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: PullRequestEvent = {
+      action: "unassigned",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handlePullRequest(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+
+  test("config = 'false': unassign leaves task untouched", async () => {
+    setConfigFlag("github.cancelOnUnassign", "false");
+    const taskId = seedTask(BASE_PR.number, "pr");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: PullRequestEvent = {
+      action: "unassigned",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handlePullRequest(event);
+
+    expect(result.created).toBe(false);
+    // Task must NOT have been failed — still pending.
+    expect(getTaskStatus(taskId)).toBe("pending");
+  });
+});
+
+// ── github.cancelOnUnassign — issue unassigned ──
+
+describe("issue unassigned — github.cancelOnUnassign", () => {
+  test("default (no config row): unassign cancels the task", async () => {
+    const taskId = seedTask(BASE_ISSUE.number, "issue");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: IssueEvent = {
+      action: "unassigned",
+      issue: { ...BASE_ISSUE },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handleIssue(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+
+  test("config = 'false': unassign leaves task untouched", async () => {
+    setConfigFlag("github.cancelOnUnassign", "false");
+    const taskId = seedTask(BASE_ISSUE.number, "issue");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: IssueEvent = {
+      action: "unassigned",
+      issue: { ...BASE_ISSUE },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handleIssue(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("pending");
+  });
+});
+
+// ── github.cancelOnReviewRequestRemoved ──
+
+describe("PR review_request_removed — github.cancelOnReviewRequestRemoved", () => {
+  test("default (no config row): review removal cancels the task", async () => {
+    const taskId = seedTask(BASE_PR.number, "pr");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: PullRequestEvent = {
+      action: "review_request_removed",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      requested_reviewer: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handlePullRequest(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+
+  test("config = 'false': review removal leaves task untouched", async () => {
+    setConfigFlag("github.cancelOnReviewRequestRemoved", "false");
+    const taskId = seedTask(BASE_PR.number, "pr");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: PullRequestEvent = {
+      action: "review_request_removed",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      requested_reviewer: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handlePullRequest(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("pending");
+  });
+});
+
+// ── Independence: flags do not bleed into each other ──
+
+describe("flag independence", () => {
+  test("cancelOnUnassign=false does NOT affect review_request_removed (still cancels)", async () => {
+    // Only disable the unassign flag; leave review-request flag absent (default = cancel).
+    setConfigFlag("github.cancelOnUnassign", "false");
+    const taskId = seedTask(BASE_PR.number, "pr");
+
+    const event: PullRequestEvent = {
+      action: "review_request_removed",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      requested_reviewer: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    await handlePullRequest(event);
+
+    // review_request_removed STILL cancels because its own flag is absent (default true).
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+
+  test("cancelOnReviewRequestRemoved=false does NOT affect unassign (still cancels)", async () => {
+    // Only disable the review-request flag; leave unassign flag absent (default = cancel).
+    setConfigFlag("github.cancelOnReviewRequestRemoved", "false");
+    const taskId = seedTask(BASE_PR.number, "pr");
+
+    const event: PullRequestEvent = {
+      action: "unassigned",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    await handlePullRequest(event);
+
+    // unassigned STILL cancels because its own flag is absent (default true).
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+});

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: "",
@@ -1257,6 +1259,119 @@ describe("Memory", () => {
     expect(body.memoryIds).toBeDefined();
   });
 
+  test("POST /api/memory/index — gates runner session summaries for automatic task classes", async () => {
+    const automaticCases = [
+      { label: "schedule source", source: "schedule", taskType: "maintenance", tags: [] },
+      { label: "system source", source: "system", taskType: "maintenance", tags: [] },
+      { label: "scheduled tag", source: "mcp", taskType: "maintenance", tags: ["scheduled"] },
+      { label: "schedule tag", source: "mcp", taskType: "maintenance", tags: ["schedule:test"] },
+      {
+        label: "auto-generated tag",
+        source: "mcp",
+        taskType: "maintenance",
+        tags: ["auto-generated"],
+      },
+      { label: "heartbeat", source: "mcp", taskType: "heartbeat", tags: [] },
+      { label: "heartbeat checklist", source: "mcp", taskType: "heartbeat-checklist", tags: [] },
+      { label: "boot triage", source: "mcp", taskType: "boot-triage", tags: [] },
+      { label: "health check", source: "mcp", taskType: "health-check", tags: [] },
+      {
+        label: "monitor suffix",
+        source: "mcp",
+        taskType: "claude-code-changelog-monitor",
+        tags: [],
+      },
+      { label: "digest suffix", source: "mcp", taskType: "daily-blocker-digest", tags: [] },
+    ];
+
+    for (const taskCase of automaticCases) {
+      const task = await post("/api/tasks", {
+        agentId: ids.leadAgent,
+        body: {
+          task: `Automatic memory integration test: ${taskCase.label}`,
+          agentId: ids.workerAgent,
+          source: taskCase.source,
+          taskType: taskCase.taskType,
+          tags: taskCase.tags,
+        },
+      });
+      expect(task.status).toBe(201);
+
+      const { status, body } = await post("/api/memory/index", {
+        agentId: ids.workerAgent,
+        body: {
+          content: `Runner summary that should not persist for ${taskCase.label}.`,
+          name: `automatic-session-summary-${taskCase.label}`,
+          scope: "agent",
+          source: "session_summary",
+          sourceTaskId: task.body.id,
+        },
+      });
+      expect(status).toBe(202);
+      expect(body.queued).toBe(false);
+      expect(body.memoryIds).toEqual([]);
+      expect(body.skipped).toBe("automatic_task_memory_disabled");
+    }
+  });
+
+  test("POST /api/memory/index — lets runner session summaries opt in for automatic tasks", async () => {
+    const task = await post("/api/tasks", {
+      agentId: ids.leadAgent,
+      body: {
+        task: "Scheduled memory integration opt-in test",
+        agentId: ids.workerAgent,
+        source: "schedule",
+        taskType: "daily-digest",
+        tags: ["schedule:test"],
+      },
+    });
+    expect(task.status).toBe(201);
+
+    const { status, body } = await post("/api/memory/index", {
+      agentId: ids.workerAgent,
+      body: {
+        content: "Runner summary with reusable learning that explicitly opts into persistence.",
+        name: "automatic-session-summary-opt-in",
+        scope: "agent",
+        source: "session_summary",
+        sourceTaskId: task.body.id,
+        persistMemory: true,
+      },
+    });
+    expect(status).toBe(202);
+    expect(body.queued).toBe(true);
+    expect(body.memoryIds.length).toBeGreaterThan(0);
+  });
+
+  test("POST /api/memory/index — keeps runner session summaries for manual tasks", async () => {
+    const task = await post("/api/tasks", {
+      agentId: ids.leadAgent,
+      body: {
+        task: "Manual memory integration test",
+        agentId: ids.workerAgent,
+      },
+    });
+    expect(task.status).toBe(201);
+
+    const { status, body } = await post("/api/memory/index", {
+      agentId: ids.workerAgent,
+      body: {
+        content: "Runner summary that should persist for a manual task.",
+        name: "manual-session-summary",
+        scope: "agent",
+        source: "session_summary",
+        sourceTaskId: task.body.id,
+      },
+    });
+    expect(status).toBe(202);
+    expect(body.queued).toBe(true);
+    expect(body.memoryIds.length).toBeGreaterThan(0);
+
+    const memory = await get(`/api/memory/${body.memoryIds[0]}`, { agentId: ids.workerAgent });
+    expect(memory.status).toBe(200);
+    expect(memory.body.memory.sourceTaskId).toBe(task.body.id);
+  });
+
   test("POST /api/memory/search — missing query returns 400", async () => {
     const { status } = await post("/api/memory/search", {
       body: {},

package/src/tests/kapso-client.test.ts

@@ -1,5 +1,9 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { sendKapsoText } from "../integrations/kapso/client";
+import {
+  markKapsoMessageRead,
+  sendKapsoReaction,
+  sendKapsoText,
+} from "../integrations/kapso/client";
 
 const originalFetch = globalThis.fetch;
 
@@ -92,3 +96,72 @@ describe("sendKapsoText", () => {
     expect(result.errorMessage).toContain("Invalid API key");
   });
 });
+
+describe("Kapso message actions", () => {
+  test("markKapsoMessageRead can include the typing indicator", async () => {
+    let captured: { url: string; body: unknown } | null = null;
+    globalThis.fetch = (async (url: string, init: RequestInit) => {
+      captured = { url, body: JSON.parse(init.body as string) };
+      return new Response(JSON.stringify({ success: true }), { status: 200 });
+    }) as typeof fetch;
+
+    const result = await markKapsoMessageRead({
+      apiBaseUrl: "https://api.kapso.ai",
+      apiKey: "k",
+      phoneNumberId: "p",
+      messageId: "wamid.IN",
+      typingIndicatorType: "text",
+    });
+
+    expect(result.ok).toBe(true);
+    expect(captured!.url).toBe("https://api.kapso.ai/meta/whatsapp/v24.0/p/messages");
+    expect(captured!.body).toEqual({
+      messaging_product: "whatsapp",
+      status: "read",
+      message_id: "wamid.IN",
+      typing_indicator: { type: "text" },
+    });
+  });
+
+  test("sendKapsoReaction posts the eyes reaction payload", async () => {
+    let body: Record<string, unknown> | null = null;
+    globalThis.fetch = (async (_url: string, init: RequestInit) => {
+      body = JSON.parse(init.body as string);
+      return new Response(JSON.stringify({ messages: [{ id: "wamid.REACT" }] }), {
+        status: 200,
+      });
+    }) as typeof fetch;
+
+    const result = await sendKapsoReaction({
+      apiBaseUrl: "https://api.kapso.ai",
+      apiKey: "k",
+      phoneNumberId: "p",
+      to: "34679077777",
+      messageId: "wamid.IN",
+      emoji: "👀",
+    });
+
+    expect(result.ok).toBe(true);
+    expect(body).toEqual({
+      messaging_product: "whatsapp",
+      recipient_type: "individual",
+      to: "34679077777",
+      type: "reaction",
+      reaction: { message_id: "wamid.IN", emoji: "👀" },
+    });
+  });
+
+  test("message action errors return structured failures", async () => {
+    mockFetch(400, { error: { message: "bad message id" } });
+
+    const result = await markKapsoMessageRead({
+      apiBaseUrl: "https://api.kapso.ai",
+      apiKey: "k",
+      phoneNumberId: "p",
+      messageId: "wamid.BAD",
+    });
+
+    expect(result.ok).toBe(false);
+    expect(result.errorMessage).toBe("bad message id");
+  });
+});