@desplega.ai/agent-swarm 1.82.0 → 1.83.0

package/src/tests/slack-attachments-block.test.ts

@@ -0,0 +1,240 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { buildCompletedBlocks, formatAttachmentsBlockForSlack } from "../slack/blocks";
+import type { TaskAttachment } from "../types";
+
+// Slack block types are open unions — the builder returns `any`; we read it
+// as `any` in the test to inspect the runtime shape.
+// biome-ignore lint/suspicious/noExplicitAny: see comment above
+type SlackBlock = any;
+
+function mkAttachment(overrides: Partial<TaskAttachment>): TaskAttachment {
+  return {
+    id: crypto.randomUUID(),
+    taskId: "00000000-0000-0000-0000-000000000000",
+    agentId: null,
+    name: overrides.name ?? "attachment.txt",
+    kind: overrides.kind ?? "url",
+    isPrimary: overrides.isPrimary ?? false,
+    createdAt: "2026-05-22T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+function sectionTexts(blocks: SlackBlock[]): string[] {
+  return blocks
+    .filter((b: SlackBlock) => b.type === "section")
+    .map((b: SlackBlock) => b.text?.text ?? "");
+}
+
+describe("formatAttachmentsBlockForSlack", () => {
+  test("returns empty string when there are no attachments", () => {
+    expect(formatAttachmentsBlockForSlack([])).toBe("");
+  });
+
+  test("renders url kind as a plain URL (no mrkdwn link shortcut)", () => {
+    const out = formatAttachmentsBlockForSlack([
+      mkAttachment({ kind: "url", name: "report", url: "https://example.com/r.pdf" }),
+    ]);
+    expect(out).toContain("• *report*");
+    expect(out).toContain("https://example.com/r.pdf");
+    // Crucially: NOT the mrkdwn `<url|label>` shortcut — that triggers
+    // `invalid_blocks` in some Slack configurations and the spec mandates
+    // plain URLs so Slack auto-unfurls them.
+    expect(out).not.toContain("<https://example.com");
+  });
+
+  test("uses intent in italics; falls back to description; omits both when absent", () => {
+    const intent = mkAttachment({ kind: "url", url: "u1", intent: "primary deliverable" });
+    const desc = mkAttachment({ kind: "url", url: "u2", description: "supporting" });
+    const neither = mkAttachment({ kind: "url", url: "u3" });
+    const out = formatAttachmentsBlockForSlack([intent, desc, neither]);
+    expect(out).toContain("_primary deliverable_");
+    expect(out).toContain("_supporting_");
+    // Neither — only one " — " separator between name and url.
+    const neitherLine = out.split("\n").find((l) => l.includes("u3") && l.startsWith("•"));
+    expect(neitherLine).toBeDefined();
+    expect(neitherLine).not.toContain("__");
+  });
+
+  test("page kind resolves via APP_URL", () => {
+    const origAppUrl = process.env.APP_URL;
+    process.env.APP_URL = "https://app.example.test";
+    try {
+      const out = formatAttachmentsBlockForSlack([
+        mkAttachment({ kind: "page", pageId: "abc123" }),
+      ]);
+      expect(out).toContain("https://app.example.test/pages/abc123");
+    } finally {
+      if (origAppUrl === undefined) {
+        delete process.env.APP_URL;
+      } else {
+        process.env.APP_URL = origAppUrl;
+      }
+    }
+  });
+
+  test("agent-fs falls back to raw path display when org/drive ids are missing", () => {
+    const origOrg = process.env.AGENT_FS_DEFAULT_ORG_ID;
+    const origDrive = process.env.AGENT_FS_DEFAULT_DRIVE_ID;
+    delete process.env.AGENT_FS_DEFAULT_ORG_ID;
+    delete process.env.AGENT_FS_DEFAULT_DRIVE_ID;
+    try {
+      const out = formatAttachmentsBlockForSlack([
+        mkAttachment({ kind: "agent-fs", name: "doc", path: "/thoughts/a.md" }),
+      ]);
+      expect(out).toContain("agent-fs:/thoughts/a.md");
+      expect(out).not.toContain("live.agent-fs.dev");
+    } finally {
+      if (origOrg === undefined) delete process.env.AGENT_FS_DEFAULT_ORG_ID;
+      else process.env.AGENT_FS_DEFAULT_ORG_ID = origOrg;
+      if (origDrive === undefined) delete process.env.AGENT_FS_DEFAULT_DRIVE_ID;
+      else process.env.AGENT_FS_DEFAULT_DRIVE_ID = origDrive;
+    }
+  });
+
+  test("agent-fs with row-level orgId + driveId emits the live-host URL", () => {
+    const origHost = process.env.AGENT_FS_LIVE_URL;
+    delete process.env.AGENT_FS_LIVE_URL;
+    try {
+      const out = formatAttachmentsBlockForSlack([
+        mkAttachment({
+          kind: "agent-fs",
+          name: "doc",
+          path: "/thoughts/a.md",
+          orgId: "org-1",
+          driveId: "drive-1",
+        }),
+      ]);
+      // Live URL strips the leading slash from `path` so the join is clean.
+      expect(out).toContain("https://live.agent-fs.dev/file/~/org-1/drive-1/thoughts/a.md");
+      expect(out).not.toContain("agent-fs:/thoughts/a.md");
+    } finally {
+      if (origHost === undefined) delete process.env.AGENT_FS_LIVE_URL;
+      else process.env.AGENT_FS_LIVE_URL = origHost;
+    }
+  });
+
+  test("agent-fs uses AGENT_FS_DEFAULT_* env-var fallback when row has no ids", () => {
+    const origOrg = process.env.AGENT_FS_DEFAULT_ORG_ID;
+    const origDrive = process.env.AGENT_FS_DEFAULT_DRIVE_ID;
+    process.env.AGENT_FS_DEFAULT_ORG_ID = "fallback-org";
+    process.env.AGENT_FS_DEFAULT_DRIVE_ID = "fallback-drive";
+    try {
+      const out = formatAttachmentsBlockForSlack([
+        mkAttachment({ kind: "agent-fs", name: "doc", path: "thoughts/a.md" }),
+      ]);
+      expect(out).toContain(
+        "https://live.agent-fs.dev/file/~/fallback-org/fallback-drive/thoughts/a.md",
+      );
+    } finally {
+      if (origOrg === undefined) delete process.env.AGENT_FS_DEFAULT_ORG_ID;
+      else process.env.AGENT_FS_DEFAULT_ORG_ID = origOrg;
+      if (origDrive === undefined) delete process.env.AGENT_FS_DEFAULT_DRIVE_ID;
+      else process.env.AGENT_FS_DEFAULT_DRIVE_ID = origDrive;
+    }
+  });
+
+  test("agent-fs row-level org/drive ids win over env-var fallbacks", () => {
+    const origOrg = process.env.AGENT_FS_DEFAULT_ORG_ID;
+    const origDrive = process.env.AGENT_FS_DEFAULT_DRIVE_ID;
+    process.env.AGENT_FS_DEFAULT_ORG_ID = "fallback-org";
+    process.env.AGENT_FS_DEFAULT_DRIVE_ID = "fallback-drive";
+    try {
+      const out = formatAttachmentsBlockForSlack([
+        mkAttachment({
+          kind: "agent-fs",
+          name: "doc",
+          path: "thoughts/a.md",
+          orgId: "row-org",
+          driveId: "row-drive",
+        }),
+      ]);
+      expect(out).toContain("https://live.agent-fs.dev/file/~/row-org/row-drive/thoughts/a.md");
+      expect(out).not.toContain("fallback-org");
+      expect(out).not.toContain("fallback-drive");
+    } finally {
+      if (origOrg === undefined) delete process.env.AGENT_FS_DEFAULT_ORG_ID;
+      else process.env.AGENT_FS_DEFAULT_ORG_ID = origOrg;
+      if (origDrive === undefined) delete process.env.AGENT_FS_DEFAULT_DRIVE_ID;
+      else process.env.AGENT_FS_DEFAULT_DRIVE_ID = origDrive;
+    }
+  });
+
+  test("shared-fs displays the path verbatim", () => {
+    const out = formatAttachmentsBlockForSlack([
+      mkAttachment({ kind: "shared-fs", name: "log", path: "/var/log/x.log" }),
+    ]);
+    expect(out).toContain("shared-fs:/var/log/x.log");
+  });
+
+  test("caps at 20 lines but still prints the true count in the header", () => {
+    const attachments = Array.from({ length: 25 }, (_, i) =>
+      mkAttachment({ kind: "url", url: `https://x.test/${i}`, name: `n${i}` }),
+    );
+    const out = formatAttachmentsBlockForSlack(attachments);
+    // Header reports the real count.
+    expect(out).toContain("Attachments (25)");
+    // Body capped to 20 bullets.
+    const bulletCount = (out.match(/\n• /g) ?? []).length;
+    expect(bulletCount).toBe(20);
+  });
+
+  test("starts with two newlines so it concatenates cleanly with the output body", () => {
+    const out = formatAttachmentsBlockForSlack([
+      mkAttachment({ kind: "url", url: "https://x.test", name: "x" }),
+    ]);
+    expect(out.startsWith("\n\n")).toBe(true);
+  });
+});
+
+describe("buildCompletedBlocks trailer", () => {
+  const baseOpts = { agentName: "tester", taskId: crypto.randomUUID(), body: "Done." };
+
+  test("includes the body block when minimal=false", () => {
+    const blocks = buildCompletedBlocks(baseOpts);
+    const texts = sectionTexts(blocks);
+    expect(texts.some((t) => t.includes("Done."))).toBe(true);
+  });
+
+  test("suppresses body when minimal=true and no trailer", () => {
+    const blocks = buildCompletedBlocks({ ...baseOpts, minimal: true });
+    const texts = sectionTexts(blocks);
+    expect(texts.some((t) => t.includes("Done."))).toBe(false);
+  });
+
+  test("renders the trailer (attachments) even when minimal=true", () => {
+    const blocks = buildCompletedBlocks({
+      ...baseOpts,
+      minimal: true,
+      trailer: "\n\n*Attachments (1):*\n• *report* — https://x.test",
+    });
+    const texts = sectionTexts(blocks);
+    // Header line is always present.
+    expect(texts.some((t) => t.includes("tester"))).toBe(true);
+    // Trailer rendered — body still suppressed.
+    expect(texts.some((t) => t.includes("Attachments (1)"))).toBe(true);
+    expect(texts.some((t) => t.includes("Done."))).toBe(false);
+  });
+});
+
+describe("Slack attachments block — env hygiene", () => {
+  let originalAppUrl: string | undefined;
+  beforeEach(() => {
+    originalAppUrl = process.env.APP_URL;
+  });
+  afterEach(() => {
+    if (originalAppUrl === undefined) {
+      delete process.env.APP_URL;
+    } else {
+      process.env.APP_URL = originalAppUrl;
+    }
+  });
+
+  test("page-link falls back to DEFAULT_APP_URL when APP_URL is unset", () => {
+    delete process.env.APP_URL;
+    const out = formatAttachmentsBlockForSlack([mkAttachment({ kind: "page", pageId: "p42" })]);
+    // DEFAULT_APP_URL is https://app.agent-swarm.dev — the production fallback
+    // so links rendered out of the box still work.
+    expect(out).toContain("https://app.agent-swarm.dev/pages/p42");
+  });
+});

package/src/tests/slack-blocks.test.ts

@@ -13,6 +13,7 @@ import {
   markdownToSlack,
   type TreeNode,
 } from "../slack/blocks";
+import type { TaskAttachment } from "../types";
 
 describe("markdownToSlack", () => {
   test("converts bold correctly without italic interference", () => {
@@ -909,3 +910,164 @@ describe("buildTreeBlocks", () => {
     expect(text).not.toContain("Should not appear");
   });
 });
+
+// --- buildTreeBlocks attachment rendering (Phase 2a follow-up) ---
+
+function mkAttachment(overrides: Partial<TaskAttachment>): TaskAttachment {
+  return {
+    id: crypto.randomUUID(),
+    taskId: "00000000-0000-0000-0000-000000000000",
+    agentId: null,
+    name: overrides.name ?? "attachment.txt",
+    kind: overrides.kind ?? "url",
+    isPrimary: overrides.isPrimary ?? false,
+    createdAt: "2026-05-22T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: section blocks are loose plain objects
+type AnyBlock = any;
+
+function sectionTexts(blocks: AnyBlock[]): string[] {
+  return blocks
+    .filter((b: AnyBlock) => b.type === "section")
+    .map((b: AnyBlock) => b.text?.text ?? "");
+}
+
+describe("buildTreeBlocks — attachments rendering", () => {
+  test("tree with no attachments emits no extra section blocks", () => {
+    const root: TreeNode = {
+      taskId: makeTaskId("aatt0001"),
+      agentName: "Lead",
+      status: "completed",
+      duration: "10s",
+      children: [
+        {
+          taskId: makeTaskId("aatt0002"),
+          agentName: "Worker",
+          status: "completed",
+          duration: "5s",
+          slackReplySent: true,
+          // No attachments field
+          children: [],
+        },
+      ],
+    };
+
+    const blocks = buildTreeBlocks([root]);
+    // Exactly one section block (the tree text); no attachment add-ons; no
+    // cancel buttons (everything is terminal).
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].type).toBe("section");
+    expect(blocks[0].text.text).not.toContain("Attachments");
+  });
+
+  test("completed node with 2 attachments adds a dedicated attachment block", () => {
+    const root: TreeNode = {
+      taskId: makeTaskId("aatt0010"),
+      agentName: "Lead",
+      status: "completed",
+      duration: "1m",
+      children: [
+        {
+          taskId: makeTaskId("aatt0011"),
+          agentName: "Worker",
+          status: "completed",
+          duration: "30s",
+          slackReplySent: true,
+          attachments: [
+            mkAttachment({ kind: "url", name: "report", url: "https://x.test/r" }),
+            mkAttachment({ kind: "url", name: "log", url: "https://x.test/l" }),
+          ],
+          children: [],
+        },
+      ],
+    };
+
+    const blocks = buildTreeBlocks([root]);
+    // 1 tree section + 1 attachment section.
+    expect(blocks.length).toBe(2);
+    const texts = sectionTexts(blocks);
+    // Tree section contains the worker.
+    expect(texts[0]).toContain("*Worker*");
+    // Attachment section contains the header AND the two attachments.
+    const attachmentSection = texts[1];
+    expect(attachmentSection).toContain("*Worker*");
+    expect(attachmentSection).toContain("Attachments (2):");
+    expect(attachmentSection).toContain("https://x.test/r");
+    expect(attachmentSection).toContain("https://x.test/l");
+  });
+
+  test("non-completed nodes never emit attachment blocks even if attachments is populated", () => {
+    // Watcher won't populate these for non-completed, but guard the renderer.
+    const root: TreeNode = {
+      taskId: makeTaskId("aatt0020"),
+      agentName: "Lead",
+      status: "in_progress",
+      attachments: [mkAttachment({ kind: "url", name: "x", url: "https://x.test" })],
+      children: [],
+    };
+
+    const blocks = buildTreeBlocks([root]);
+    // Tree section + cancel button only.
+    expect(blocks.length).toBe(2);
+    expect(blocks[0].type).toBe("section");
+    expect(blocks[0].text.text).not.toContain("Attachments");
+    expect(blocks[1].type).toBe("actions");
+  });
+
+  test("per-tree-message cap: 12 completed children with attachments → 10 blocks + footer", () => {
+    const children: TreeNode[] = Array.from({ length: 12 }, (_, i) => ({
+      taskId: makeTaskId(`aatt${(30 + i).toString().padStart(4, "0")}`),
+      agentName: `Worker${i}`,
+      status: "completed",
+      duration: "1s",
+      slackReplySent: true,
+      attachments: [mkAttachment({ kind: "url", name: `a${i}`, url: `https://x.test/${i}` })],
+      children: [],
+    }));
+    const root: TreeNode = {
+      taskId: makeTaskId("aatt0029"),
+      agentName: "Lead",
+      status: "completed",
+      duration: "1m",
+      children,
+    };
+
+    const blocks = buildTreeBlocks([root]);
+    // 1 tree section + 10 attachment sections + 1 context footer.
+    const sectionBlocks = blocks.filter((b: AnyBlock) => b.type === "section");
+    const contextBlocks = blocks.filter((b: AnyBlock) => b.type === "context");
+    expect(sectionBlocks.length).toBe(1 + 10);
+    expect(contextBlocks.length).toBe(1);
+    const footerText = contextBlocks[0].elements[0].text as string;
+    expect(footerText).toContain("2 more");
+    expect(footerText).toContain("completed task");
+  });
+
+  test("singular footer when exactly one attachment block is hidden", () => {
+    const children: TreeNode[] = Array.from({ length: 11 }, (_, i) => ({
+      taskId: makeTaskId(`aatt${(50 + i).toString().padStart(4, "0")}`),
+      agentName: `Worker${i}`,
+      status: "completed",
+      duration: "1s",
+      slackReplySent: true,
+      attachments: [mkAttachment({ kind: "url", name: `a${i}`, url: `https://x.test/${i}` })],
+      children: [],
+    }));
+    const root: TreeNode = {
+      taskId: makeTaskId("aatt0049"),
+      agentName: "Lead",
+      status: "completed",
+      duration: "1m",
+      children,
+    };
+
+    const blocks = buildTreeBlocks([root]);
+    const contextBlocks = blocks.filter((b: AnyBlock) => b.type === "context");
+    expect(contextBlocks.length).toBe(1);
+    const footerText = contextBlocks[0].elements[0].text as string;
+    expect(footerText).toContain("1 more completed task with attachments");
+  });
+});

package/src/tests/slack-watcher.test.ts

@@ -10,6 +10,7 @@ import {
   getCompletedSlackTasks,
   getInProgressSlackTasks,
   initDb,
+  insertTaskAttachment,
   startTask,
 } from "../be/db";
 import {
@@ -335,6 +336,88 @@ describe("buildTreeNodes", () => {
     // Missing task should be skipped, not crash
     expect(nodes.length).toBe(0);
   });
+
+  test("populates attachments for completed nodes (root + child)", () => {
+    const lead = createAgent({ name: "AttachLead", isLead: true, status: "idle" });
+    const worker = createAgent({ name: "AttachWorker", isLead: false, status: "idle" });
+
+    const parent = createTaskExtended("parent with attachments", {
+      agentId: lead.id,
+      source: "slack",
+      slackChannelId: "C_ATTACH",
+      slackThreadTs: "2020202020.000001",
+      slackUserId: "U_ATTACH",
+    });
+    const child = createTaskExtended("child with attachments", {
+      agentId: worker.id,
+      source: "slack",
+      parentTaskId: parent.id,
+    });
+    // Mark both completed so the watcher pulls their attachments.
+    completeTask(parent.id, "done");
+    completeTask(child.id, "done");
+
+    insertTaskAttachment({
+      taskId: parent.id,
+      agentId: lead.id,
+      name: "parent-report.pdf",
+      kind: "url",
+      url: "https://example.com/parent.pdf",
+    });
+    insertTaskAttachment({
+      taskId: child.id,
+      agentId: worker.id,
+      name: "child-log.txt",
+      kind: "agent-fs",
+      path: "/logs/child.txt",
+      orgId: "org-1",
+      driveId: "drive-1",
+    });
+
+    const messageTs = "2020202020.000002";
+    registerTreeMessage(parent.id, "C_ATTACH", "2020202020.000001", messageTs);
+
+    const tree = _getTreeMessages().get(messageTs)!;
+    const nodes = buildTreeNodes(tree);
+
+    expect(nodes.length).toBe(1);
+    expect(nodes[0].attachments?.length).toBe(1);
+    expect(nodes[0].attachments?.[0].name).toBe("parent-report.pdf");
+    expect(nodes[0].children.length).toBe(1);
+    expect(nodes[0].children[0].attachments?.length).toBe(1);
+    expect(nodes[0].children[0].attachments?.[0].orgId).toBe("org-1");
+    expect(nodes[0].children[0].attachments?.[0].driveId).toBe("drive-1");
+  });
+
+  test("does NOT fetch attachments for non-completed nodes (pending parent)", () => {
+    const agent = createAgent({ name: "NoFetchAgent", isLead: true, status: "idle" });
+    const task = createTaskExtended("pending no fetch", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_NOFETCH",
+      slackThreadTs: "3030303030.000001",
+      slackUserId: "U_NOFETCH",
+    });
+    // Pre-populate an attachment even though the task is still pending.
+    insertTaskAttachment({
+      taskId: task.id,
+      agentId: agent.id,
+      name: "should-not-render.pdf",
+      kind: "url",
+      url: "https://example.com/notyet.pdf",
+    });
+
+    const messageTs = "3030303030.000002";
+    registerTreeMessage(task.id, "C_NOFETCH", "3030303030.000001", messageTs);
+
+    const tree = _getTreeMessages().get(messageTs)!;
+    const nodes = buildTreeNodes(tree);
+
+    expect(nodes.length).toBe(1);
+    // Pending tasks should not have attachments populated — the renderer
+    // never shows them in that state, so the query is skipped.
+    expect(nodes[0].attachments).toBeUndefined();
+  });
 });
 
 // --- Phase 5: processTreeMessages tests ---