@desplega.ai/agent-swarm 1.113.0 → 1.115.0

package/src/tests/delete-page-tool.test.ts

@@ -0,0 +1,197 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import {
+  closeDb,
+  createAgent,
+  createPage,
+  createPageVersion,
+  createUser,
+  getDb,
+  getPage,
+  getPageVersions,
+  initDb,
+  listUserFavorites,
+  setUserFavorite,
+  upsertKv,
+} from "../be/db";
+import { registerDeletePageTool } from "../tools/delete-page";
+
+const TEST_DB_PATH = "./test-delete-page-tool.sqlite";
+
+type RegisteredTool = {
+  handler: (args: unknown, extra: unknown) => Promise<CallToolResult>;
+};
+
+function buildServer() {
+  const server = new McpServer({ name: "delete-page-test", version: "1.0.0" });
+  registerDeletePageTool(server);
+  const tools = (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
+    ._registeredTools;
+  const tool = tools["delete-page"];
+  if (!tool) throw new Error("delete-page tool not registered");
+  return tool;
+}
+
+function callDeletePage(args: Record<string, unknown>, callerAgentId?: string) {
+  const tool = buildServer();
+  return tool.handler(args, {
+    sessionId: "test-session",
+    requestInfo: callerAgentId ? { headers: { "x-agent-id": callerAgentId } } : { headers: {} },
+  });
+}
+
+function makePage(agentId: string, slug: string, title = slug) {
+  return createPage({
+    agentId,
+    slug,
+    title,
+    contentType: "text/html",
+    authMode: "public",
+    body: `<h1>${title}</h1>`,
+  });
+}
+
+let ownerId: string;
+let otherAgentId: string;
+let leadId: string;
+
+describe("delete-page MCP tool", () => {
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    ownerId = createAgent({ name: "delete-page-owner", isLead: false, status: "idle" }).id;
+    otherAgentId = createAgent({
+      name: "delete-page-other",
+      isLead: false,
+      status: "idle",
+    }).id;
+    leadId = createAgent({ name: "delete-page-lead", isLead: true, status: "idle" }).id;
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+  });
+
+  test("owner can delete by pageId and receives deleted page metadata", async () => {
+    const page = makePage(ownerId, "owner-id-delete", "Owner Delete");
+
+    const result = await callDeletePage({ pageId: page.id }, ownerId);
+    const sc = result.structuredContent as {
+      success: boolean;
+      deletedPage?: { id: string; slug: string; title: string };
+    };
+
+    expect(sc.success).toBe(true);
+    expect(sc.deletedPage).toEqual({
+      id: page.id,
+      slug: "owner-id-delete",
+      title: "Owner Delete",
+    });
+    expect(getPage(page.id)).toBeNull();
+  });
+
+  test("slug deletes only from the caller's page namespace", async () => {
+    const ownerPage = makePage(ownerId, "shared-slug", "Owner Shared Slug");
+    const otherPage = makePage(otherAgentId, "shared-slug", "Other Shared Slug");
+
+    const result = await callDeletePage({ slug: "shared-slug" }, ownerId);
+    const sc = result.structuredContent as { success: boolean; deletedPage?: { id: string } };
+
+    expect(sc.success).toBe(true);
+    expect(sc.deletedPage?.id).toBe(ownerPage.id);
+    expect(getPage(ownerPage.id)).toBeNull();
+    expect(getPage(otherPage.id)).not.toBeNull();
+  });
+
+  test("lead can delete another agent's page by pageId", async () => {
+    const page = makePage(ownerId, "lead-delete", "Lead Delete");
+
+    const result = await callDeletePage({ pageId: page.id }, leadId);
+    const sc = result.structuredContent as { success: boolean };
+
+    expect(sc.success).toBe(true);
+    expect(getPage(page.id)).toBeNull();
+  });
+
+  test("non-owner non-lead gets a clear permission error and page remains", async () => {
+    const page = makePage(ownerId, "deny-delete", "Deny Delete");
+
+    const result = await callDeletePage({ pageId: page.id }, otherAgentId);
+    const sc = result.structuredContent as { success: boolean; message: string };
+
+    expect(sc.success).toBe(false);
+    expect(sc.message).toBe("Only the lead or page owner can delete pages.");
+    expect(getPage(page.id)).not.toBeNull();
+  });
+
+  test("delete cascades versions and removes page-scoped KV and favorites", async () => {
+    const page = makePage(ownerId, "cascade-delete", "Cascade Delete");
+    createPageVersion({
+      pageId: page.id,
+      version: 1,
+      snapshot: {
+        title: page.title,
+        description: page.description,
+        contentType: page.contentType,
+        authMode: page.authMode,
+        body: page.body,
+        needsCredentials: page.needsCredentials,
+      },
+      changedByAgentId: ownerId,
+    });
+    upsertKv({
+      namespace: `task:page:${page.id}`,
+      key: "state",
+      value: { ok: true },
+      valueType: "json",
+    });
+    const user = createUser({ name: "Delete Page Favorite User" });
+    setUserFavorite({
+      userId: user.id,
+      itemType: "page",
+      itemId: page.id,
+      favorite: true,
+    });
+
+    const result = await callDeletePage({ pageId: page.id }, ownerId);
+    const sc = result.structuredContent as { success: boolean };
+
+    expect(sc.success).toBe(true);
+    expect(getPageVersions(page.id)).toHaveLength(0);
+    expect(
+      getDb()
+        .prepare<{ n: number }, [string]>(
+          "SELECT COUNT(*) AS n FROM kv_entries WHERE namespace = ?",
+        )
+        .get(`task:page:${page.id}`)?.n,
+    ).toBe(0);
+    expect(listUserFavorites({ userId: user.id, itemType: "page" })).toHaveLength(0);
+  });
+
+  test("missing selector or missing agent id returns success false", async () => {
+    const noSelector = await callDeletePage({}, ownerId);
+    expect((noSelector.structuredContent as { success: boolean; message: string }).success).toBe(
+      false,
+    );
+    expect((noSelector.structuredContent as { message: string }).message).toBe(
+      "Either pageId or slug must be provided.",
+    );
+
+    const noAgent = await callDeletePage({ pageId: "missing" });
+    expect((noAgent.structuredContent as { success: boolean; message: string }).success).toBe(
+      false,
+    );
+    expect((noAgent.structuredContent as { message: string }).message).toContain("Agent ID");
+  });
+});

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

@@ -119,11 +119,11 @@ function makeCommentEvent(senderLogin: string, body: string): CommentEvent {
   };
 }
 
-function makeReviewEvent(senderLogin: string): PullRequestReviewEvent {
+function makeReviewEvent(senderLogin: string, reviewId = 1): PullRequestReviewEvent {
   return {
     action: "submitted",
     review: {
-      id: 1,
+      id: reviewId,
       body: "Looks good",
       state: "approved",
       html_url: "https://github.com/test/repo/pull/99#pullrequestreview-1",
@@ -153,6 +153,13 @@ function getMappedUserTaskCount(userId: string): number {
   return row?.n ?? 0;
 }
 
+function getLatestTaskText(): string | null {
+  const row = getDb()
+    .prepare<{ task: string }, []>("SELECT task FROM agent_tasks ORDER BY rowid DESC LIMIT 1")
+    .get();
+  return row?.task ?? null;
+}
+
 // ── Known sender → mapped requestedByUserId, no unmapped writes ──
 
 describe("known github sender", () => {
@@ -216,6 +223,17 @@ describe("known github sender", () => {
     expect(getKv(UNMAPPED_NAMESPACE, "reviewer:meta")).toBeNull();
     expect(getKv(UNMAPPED_NAMESPACE, "reviewer:count")).toBeNull();
   });
+
+  test("review event from mapped user renders the resolved identity pair, never the raw login", async () => {
+    const user = createUser({ name: "Pair Reviewer", email: "pair-reviewer@example.com" });
+    linkIdentity(user.id, "github", "pair-reviewer", SYSTEM_ACTOR);
+
+    const result = await handlePullRequestReview(makeReviewEvent("pair-reviewer", 1001));
+    expect(result.created).toBe(true);
+
+    const text = getLatestTaskText();
+    expect(text).toContain("Pair Reviewer (github:pair-reviewer)");
+  });
 });
 
 // ── Unknown sender → unmapped kv tracker ──
@@ -290,6 +308,14 @@ describe("unknown github sender", () => {
     const metaValue = meta?.value as { sampleContext: string };
     expect(metaValue.sampleContext.length).toBeLessThanOrEqual(100);
   });
+
+  test("review event from unknown user renders the UNKNOWN sentinel, never a bare login", async () => {
+    const result = await handlePullRequestReview(makeReviewEvent("sentinel-ghost", 1002));
+    expect(result.created).toBe(true);
+
+    const text = getLatestTaskText();
+    expect(text).toContain("github:sentinel-ghost (unknown user)");
+  });
 });
 
 // ── Negative: no email-enrichment helper exists for GitHub ──

package/src/tests/gitlab-handlers.test.ts

@@ -979,5 +979,130 @@ describe("identity resolution — Note handler", () => {
     expect((meta?.sampleContext as string).length).toBeLessThanOrEqual(100);
     expect((meta?.sampleContext as string).startsWith(`@${GITLAB_BOT_NAME}`)).toBe(true);
     expect(getUnmappedCount("noteghost")).toBe(1);
+
+    // The dead-coded `_requestedByUserId` is now wired: undefined for an
+    // unresolvable sender, and the UNKNOWN sentinel (never the raw
+    // username) is rendered as the comment author in the task text.
+    const task = getTaskById(result.taskId!);
+    expect(task?.requestedByUserId).toBeFalsy();
+    expect(task?.task).toContain("gitlab:noteghost (unknown user)");
+    expect(task?.task).not.toContain("Note Ghost");
+  });
+
+  test("known GitLab user commenting -> requestedByUserId populated + rendered pair, never the raw username", async () => {
+    const known = createUser({ name: "Known Commenter" });
+    linkIdentity(known.id, "gitlab", "knowncommenter", { kind: "system", id: "test" });
+
+    const event = makeNoteEvent({
+      user: { id: 32, name: "Known Commenter", username: "knowncommenter", avatar_url: "" },
+      object_attributes: {
+        id: 961,
+        note: `@${GITLAB_BOT_NAME} please take a look`,
+        noteable_type: "MergeRequest",
+        noteable_id: 101,
+        url: "https://gitlab.com/group/project/-/merge_requests/2#note_961",
+        author_id: 32,
+        type: null,
+      },
+      merge_request: {
+        id: 101,
+        iid: 961,
+        title: "Known Commenter MR",
+        description: "",
+        state: "opened",
+        action: "open",
+        source_branch: "feat-knowncommenter",
+        target_branch: "main",
+        url: "https://gitlab.com/group/project/-/merge_requests/961",
+        last_commit: null,
+        author_id: 32,
+      },
+    });
+
+    const result = await handleNote(event);
+    expect(result.created).toBe(true);
+
+    const task = getTaskById(result.taskId!);
+    expect(task?.requestedByUserId).toBe(known.id);
+    expect(task?.task).toContain("Known Commenter (gitlab:knowncommenter)");
+  });
+});
+
+describe("identity resolution — Pipeline handler", () => {
+  test("known GitLab user triggers pipeline -> requestedByUserId populated on the task", async () => {
+    const known = createUser({ name: "Pipeline Trigger" });
+    linkIdentity(known.id, "gitlab", "pipelinetrigger", { kind: "system", id: "test" });
+
+    createTaskExtended("[GitLab MR #970] Pipeline identity test", {
+      source: "gitlab",
+      vcsProvider: "gitlab",
+      vcsRepo: "group/project",
+      vcsEventType: "merge_request",
+      vcsNumber: 970,
+      vcsUrl: "https://gitlab.com/group/project/-/merge_requests/970",
+      agentId: "lead-gl-001",
+    });
+
+    const event = makePipelineEvent({
+      user: { id: 41, name: "Pipeline Trigger", username: "pipelinetrigger", avatar_url: "" },
+      object_attributes: {
+        id: 500,
+        ref: "feature",
+        status: "failed",
+        source: "push",
+        detailed_status: "failed",
+      },
+      merge_request: {
+        id: 200,
+        iid: 970,
+        title: "MR with known pipeline trigger",
+        url: "https://gitlab.com/group/project/-/merge_requests/970",
+        source_branch: "feature",
+        target_branch: "main",
+      },
+    });
+
+    const result = await handlePipeline(event);
+    expect(result.created).toBe(true);
+
+    const task = getTaskById(result.taskId!);
+    expect(task?.requestedByUserId).toBe(known.id);
+  });
+
+  test("unknown GitLab user triggers pipeline -> requestedByUserId stays undefined", async () => {
+    createTaskExtended("[GitLab MR #971] Pipeline identity test", {
+      source: "gitlab",
+      vcsProvider: "gitlab",
+      vcsRepo: "group/project",
+      vcsEventType: "merge_request",
+      vcsNumber: 971,
+      vcsUrl: "https://gitlab.com/group/project/-/merge_requests/971",
+      agentId: "lead-gl-001",
+    });
+
+    const event = makePipelineEvent({
+      user: { id: 42, name: "Pipeline Ghost", username: "pipelineghost", avatar_url: "" },
+      object_attributes: {
+        id: 501,
+        ref: "feature",
+        status: "failed",
+        source: "push",
+        detailed_status: "failed",
+      },
+      merge_request: {
+        id: 201,
+        iid: 971,
+        title: "MR with unknown pipeline trigger",
+        url: "https://gitlab.com/group/project/-/merge_requests/971",
+        source_branch: "feature",
+        target_branch: "main",
+      },
+    });
+
+    const result = await handlePipeline(event);
+    expect(result.created).toBe(true);
+
+    const task = getTaskById(result.taskId!);
+    expect(task?.requestedByUserId).toBeFalsy();
   });
 });

package/src/tests/heartbeat.test.ts

@@ -559,7 +559,7 @@ describe("Heartbeat Triage", () => {
       expect(affected.length).toBe(0);
     });
 
-    test("auto-fails in_progress task with no session and creates retry", async () => {
+    test("auto-fails in_progress task with no session and pins retry to the recovered agent", async () => {
       const agent = createAgent({ name: "dead-worker", isLead: false, status: "busy" });
       const task = createTaskExtended("Interrupted task", { agentId: agent.id });
       startTask(task.id);
@@ -586,8 +586,13 @@ describe("Heartbeat Triage", () => {
       expect(retryTask).not.toBeNull();
       expect(retryTask!.parentTaskId).toBe(task.id);
       expect(retryTask!.task).toBe(task.task);
-      // No agentId → goes to pool as "unassigned", auto-assign will route it
-      expect(retryTask!.status).toBe("unassigned");
+      // Routing affinity (Phase 3): the failed task frees up the agent's only
+      // slot, so it looks recoverable (row exists, not offline, has capacity)
+      // by retry-creation time — the retry pins back to it instead of the
+      // role-blind pool.
+      expect(retryTask!.status).toBe("pending");
+      expect(retryTask!.agentId).toBe(agent.id);
+      expect(retryTask!.routingAffinity?.sourceAgentId).toBe(agent.id);
 
       // Verify retry has correct tags
       const retryRow = getDb()
@@ -596,6 +601,46 @@ describe("Heartbeat Triage", () => {
       const tags = JSON.parse(retryRow.tags);
       expect(tags).toContain("reboot-retry");
       expect(tags).toContain("auto-generated");
+      expect(tags).toContain("reboot-retry-pin");
+    });
+
+    test("falls back to an affinity-stamped pool retry when the agent is at capacity", async () => {
+      const agent = createAgent({
+        name: "full-worker",
+        isLead: false,
+        status: "busy",
+        maxTasks: 1,
+      });
+      const task = createTaskExtended("Interrupted task", { agentId: agent.id });
+      startTask(task.id);
+      // A second in-progress task with a LIVE session survives the same sweep
+      // (session-exists → skip, never reaped) and keeps the agent at capacity
+      // by the time `task`'s retry is evaluated — so `task`'s retry does NOT
+      // look recoverable and must fall to the affinity-gated pool.
+      const other = createTaskExtended("Other in-progress task", { agentId: agent.id });
+      startTask(other.id);
+      insertActiveSession({ agentId: agent.id, taskId: other.id, triggerType: "task_assigned" });
+
+      const past = new Date(Date.now() - 1000).toISOString();
+      getDb().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [past, task.id]);
+
+      await runRebootSweep();
+
+      const affected = getRebootAffectedTasks();
+      expect(affected.length).toBe(1);
+      const retryTask = getTaskById(affected[0]!.retryTaskId!);
+      expect(retryTask).not.toBeNull();
+      // No agentId → falls to the pool as "unassigned", but still carries the
+      // routing-affinity snapshot so it's gated (not role-blind).
+      expect(retryTask!.status).toBe("unassigned");
+      expect(retryTask!.agentId).toBeNull();
+      expect(retryTask!.routingAffinity?.sourceAgentId).toBe(agent.id);
+
+      const retryRow = getDb()
+        .query("SELECT tags FROM agent_tasks WHERE id = ?")
+        .get(affected[0]!.retryTaskId!) as { tags: string };
+      const tags = JSON.parse(retryRow.tags);
+      expect(tags).not.toContain("reboot-retry-pin");
     });
 
     test("skips in_progress task that has an active session", async () => {

package/src/tests/identity.test.ts

@@ -0,0 +1,117 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, createUser, initDb } from "../be/db";
+import { renderIdentity, resolveIdentity, resolveIdentityByEmail } from "../be/identity";
+import { type IdentityActor, linkIdentity } from "../be/users";
+
+const TEST_DB_PATH = "./test-identity.sqlite";
+
+const SYSTEM_ACTOR: IdentityActor = { kind: "system", id: "test" };
+
+beforeAll(async () => {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {}
+  }
+  closeDb();
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {}
+  }
+});
+
+describe("resolveIdentity", () => {
+  test("resolved: linked (kind, externalId) returns the user", () => {
+    const user = createUser({ name: "Luis", email: "luis@example.com" });
+    linkIdentity(user.id, "slack", "U016H7XKZGS", SYSTEM_ACTOR);
+
+    const resolution = resolveIdentity("slack", "U016H7XKZGS");
+    expect(resolution).toEqual({
+      status: "resolved",
+      kind: "slack",
+      externalId: "U016H7XKZGS",
+      userId: user.id,
+      name: "Luis",
+      email: "luis@example.com",
+    });
+  });
+
+  test("unknown: unlinked (kind, externalId) returns the sentinel value, never a name", () => {
+    const resolution = resolveIdentity("slack", "U_DOES_NOT_EXIST");
+    expect(resolution).toEqual({
+      status: "unknown",
+      kind: "slack",
+      externalId: "U_DOES_NOT_EXIST",
+    });
+  });
+
+  test("is provider-agnostic — any kind string works identically", () => {
+    const user = createUser({ name: "Jira Reporter", email: "jira-reporter@example.com" });
+    linkIdentity(user.id, "jira", "5b10a2844c20165700ede21g", SYSTEM_ACTOR);
+
+    const resolution = resolveIdentity("jira", "5b10a2844c20165700ede21g");
+    expect(resolution.status).toBe("resolved");
+    expect(resolution.status === "resolved" && resolution.userId).toBe(user.id);
+  });
+});
+
+describe("resolveIdentityByEmail", () => {
+  test("resolved: known email returns the user with kind 'email'", () => {
+    const user = createUser({ name: "Alberto", email: "alberto@example.com" });
+
+    const resolution = resolveIdentityByEmail("alberto@example.com");
+    expect(resolution).toEqual({
+      status: "resolved",
+      kind: "email",
+      externalId: "alberto@example.com",
+      userId: user.id,
+      name: "Alberto",
+      email: "alberto@example.com",
+    });
+  });
+
+  test("unknown: unregistered email returns the sentinel value", () => {
+    const resolution = resolveIdentityByEmail("nobody@example.com");
+    expect(resolution).toEqual({
+      status: "unknown",
+      kind: "email",
+      externalId: "nobody@example.com",
+    });
+  });
+});
+
+describe("renderIdentity", () => {
+  test("resolved renders 'Name (kind:externalId)'", () => {
+    const rendered = renderIdentity({
+      status: "resolved",
+      kind: "slack",
+      externalId: "U016H7XKZGS",
+      userId: "u1",
+      name: "Luis",
+    });
+    expect(rendered).toBe("Luis (slack:U016H7XKZGS)");
+  });
+
+  test("unknown renders 'kind:externalId (unknown user)' — the sentinel never contains a name", () => {
+    const rendered = renderIdentity({
+      status: "unknown",
+      kind: "slack",
+      externalId: "U016H7XKZGS",
+    });
+    expect(rendered).toBe("slack:U016H7XKZGS (unknown user)");
+    expect(rendered).not.toContain("Luis");
+  });
+
+  test("the sentinel is deterministic for the same input", () => {
+    const resolution = resolveIdentity("github", "octocat-unlinked");
+    expect(renderIdentity(resolution)).toBe(renderIdentity(resolution));
+    expect(renderIdentity(resolution)).toBe("github:octocat-unlinked (unknown user)");
+  });
+});