@desplega.ai/agent-swarm 2.3.0 → 2.4.1

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

@@ -128,6 +128,61 @@ describe("slack-update", () => {
     });
   });
 
+  test("splits a long message into sections under Slack's cap", async () => {
+    const message = Array.from(
+      { length: 120 },
+      (_, index) => `line ${String(index).padStart(3, "0")} radar item with some words`,
+    )
+      .join("\n")
+      .slice(0, 3946);
+    const tool = buildTool();
+    const result = await tool.handler(
+      { channelId: "C1", messageTs: "1783411554.596189", message },
+      meta(leadAgentId),
+    );
+
+    expect(result.structuredContent.success).toBe(true);
+    const payload = mockChatUpdate.mock.calls[0][0] as {
+      text: string;
+      blocks: { type: string; text: { type: string; text: string } }[];
+    };
+    expect(payload.text).toBe(message);
+    expect(payload.blocks.length).toBeGreaterThanOrEqual(2);
+    for (const block of payload.blocks) {
+      expect(block.type).toBe("section");
+      expect(block.text.text.length).toBeLessThanOrEqual(2900);
+    }
+    const joined = payload.blocks.map((block) => block.text.text).join("");
+    expect(joined.replace(/\s/g, "")).toBe(message.replace(/\s/g, ""));
+  });
+
+  test("keeps a 2,931-char message with an emoji at 2,900 in one intact section", async () => {
+    const message = `${"x".repeat(2899)}😀${"y".repeat(30)}`;
+    expect(message.length).toBe(2931);
+    const tool = buildTool();
+    const result = await tool.handler(
+      { channelId: "C1", messageTs: "1783411554.596189", message },
+      meta(leadAgentId),
+    );
+
+    expect(result.structuredContent.success).toBe(true);
+    expect(mockChatUpdate.mock.calls[0][0].blocks).toEqual([
+      { type: "section", text: { type: "mrkdwn", text: message } },
+    ]);
+  });
+
+  test("keeps a short message in exactly one section", async () => {
+    const tool = buildTool();
+    await tool.handler(
+      { channelId: "C1", messageTs: "1783411554.596189", message: "short" },
+      meta(leadAgentId),
+    );
+
+    expect(mockChatUpdate.mock.calls[0][0]).toMatchObject({
+      blocks: [{ type: "section", text: { type: "mrkdwn", text: "short" } }],
+    });
+  });
+
   test.each([
     ["message_not_found", "No message found at that timestamp in this channel."],
     [

package/src/tests/slack-user-dm.test.ts

@@ -0,0 +1,177 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { closeDb, createAgent, getSlackMessageByChannelTs, initDb } from "../be/db";
+import { isSlackUserId } from "../slack/dm";
+import { registerSlackPostTool } from "../tools/slack-post";
+import { registerSlackReadTool } from "../tools/slack-read";
+import { registerSlackStartThreadTool } from "../tools/slack-start-thread";
+
+const TEST_DB_PATH = "./test-slack-user-dm.sqlite";
+const USER_ID = "U08USERDM";
+// The bot's own IM with USER_ID: readable, writable, delivers message.im events.
+const BOT_DM = "D0BOTDM01";
+// Where Slack puts a bot post addressed to the bare user id: the bot is not a member.
+const FOREIGN_DM = "D0FOREIGN";
+
+function slackError(code: string): Error {
+  return Object.assign(new Error(`An API error occurred: ${code}`), {
+    data: { ok: false, error: code },
+  });
+}
+
+let tsCounter = 0;
+const postMessage = mock(async (args: { channel: string; thread_ts?: string }) => {
+  if (args.channel === FOREIGN_DM) throw slackError("channel_not_found");
+  const ts = `500.${++tsCounter}`;
+  return { ok: true, ts, channel: args.channel === USER_ID ? FOREIGN_DM : args.channel };
+});
+const conversationsOpen = mock(async (args: { users: string }) => {
+  if (args.users !== USER_ID) throw slackError("user_not_found");
+  return { ok: true, channel: { id: BOT_DM } };
+});
+const conversationsReplies = mock(async (args: { channel: string; ts: string }) => {
+  if (args.channel !== BOT_DM) throw slackError("channel_not_found");
+  return { ok: true, messages: [{ user: USER_ID, text: "reply from human", ts: args.ts }] };
+});
+
+mock.module("../slack/app", () => ({
+  getSlackApp: () => ({
+    client: {
+      chat: { postMessage },
+      conversations: { open: conversationsOpen, replies: conversationsReplies },
+      auth: { test: async () => ({ ok: true, user_id: "UBOT" }) },
+      users: { info: async () => ({ ok: true, user: { real_name: "Human" } }) },
+    },
+  }),
+}));
+
+type ToolResult = {
+  structuredContent: {
+    success: boolean;
+    message: string;
+    channelId?: string;
+    ts?: string;
+    messages?: Array<{ text: string }>;
+  };
+};
+type RegisteredTool = { handler: (args: unknown, extra: unknown) => Promise<ToolResult> };
+
+function buildTools() {
+  const server = new McpServer({ name: "slack-user-dm-test", version: "1.0.0" });
+  registerSlackPostTool(server);
+  registerSlackReadTool(server);
+  registerSlackStartThreadTool(server);
+  return (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
+    ._registeredTools;
+}
+
+function meta(agentId: string) {
+  return { sessionId: "s1", requestInfo: { headers: { "x-agent-id": agentId } } };
+}
+
+async function removeDbFiles() {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+}
+
+let leadId: string;
+
+beforeAll(async () => {
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+  leadId = (await createAgent({ name: "Lead DM", isLead: true, status: "idle" })).id;
+});
+
+beforeEach(() => {
+  postMessage.mockClear();
+  conversationsOpen.mockClear();
+  conversationsReplies.mockClear();
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles();
+});
+
+describe("Slack tools addressed with a user id", () => {
+  test("isSlackUserId matches user ids only", () => {
+    expect(isSlackUserId("U08NR6QD6CS")).toBe(true);
+    expect(isSlackUserId("W012ABCDEF")).toBe(true);
+    expect(isSlackUserId("D0A4T383FMF")).toBe(false);
+    expect(isSlackUserId("C0AR967K0KZ")).toBe(false);
+    expect(isSlackUserId("G01PRIVATE")).toBe(false);
+  });
+
+  test("slack-start-thread opens the bot DM and returns an id that reads and writes work on", async () => {
+    const tools = buildTools();
+
+    const started = await tools["slack-start-thread"]!.handler(
+      { channelId: USER_ID, message: "hello" },
+      meta(leadId),
+    );
+    expect(started.structuredContent.success).toBe(true);
+    expect(conversationsOpen).toHaveBeenCalledWith({ users: USER_ID });
+    expect(postMessage.mock.calls[0]![0].channel).toBe(BOT_DM);
+    expect(started.structuredContent.channelId).toBe(BOT_DM);
+    const threadTs = started.structuredContent.ts!;
+    // The recorded message points at the bot DM, so inbound replies match it.
+    expect((await getSlackMessageByChannelTs(BOT_DM, threadTs))?.threadTs).toBe(threadTs);
+
+    const posted = await tools["slack-post"]!.handler(
+      { channelId: BOT_DM, threadTs, message: "follow-up" },
+      meta(leadId),
+    );
+    expect(posted.structuredContent.success).toBe(true);
+    expect(postMessage.mock.calls[1]![0]).toMatchObject({ channel: BOT_DM, thread_ts: threadTs });
+
+    const read = await tools["slack-read"]!.handler({ channelId: BOT_DM, threadTs }, meta(leadId));
+    expect(read.structuredContent.success).toBe(true);
+    expect(read.structuredContent.messages?.[0]?.text).toContain("reply from human");
+  });
+
+  test("slack-post and slack-read with the user id resolve to the same bot DM", async () => {
+    const tools = buildTools();
+
+    const posted = await tools["slack-post"]!.handler(
+      { channelId: USER_ID, threadTs: "500.1", message: "by user id" },
+      meta(leadId),
+    );
+    expect(posted.structuredContent.success).toBe(true);
+    expect(postMessage.mock.calls[0]![0]).toMatchObject({ channel: BOT_DM, thread_ts: "500.1" });
+
+    const read = await tools["slack-read"]!.handler(
+      { channelId: USER_ID, threadTs: "500.1" },
+      meta(leadId),
+    );
+    expect(read.structuredContent.success).toBe(true);
+    expect(conversationsReplies.mock.calls[0]![0].channel).toBe(BOT_DM);
+  });
+
+  test("conversation ids pass through without opening a DM", async () => {
+    const tools = buildTools();
+
+    const started = await tools["slack-start-thread"]!.handler(
+      { channelId: "C0CHANNEL1", message: "channel post" },
+      meta(leadId),
+    );
+    expect(started.structuredContent.channelId).toBe("C0CHANNEL1");
+    expect(postMessage.mock.calls[0]![0].channel).toBe("C0CHANNEL1");
+    expect(conversationsOpen).not.toHaveBeenCalled();
+  });
+
+  test("a user id Slack cannot open a DM with fails without posting", async () => {
+    const tools = buildTools();
+
+    const started = await tools["slack-start-thread"]!.handler(
+      { channelId: "U0NOBODY1", message: "hello" },
+      meta(leadId),
+    );
+    expect(started.structuredContent.success).toBe(false);
+    expect(started.structuredContent.message).toContain("user_not_found");
+    expect(postMessage).not.toHaveBeenCalled();
+  });
+});

package/src/tests/swarm-tool-result-gate.test.ts

@@ -288,7 +288,7 @@ describe("finalizeSwarmToolResult", () => {
     expect((nonEmpty.structuredContent as { nudge?: string }).nudge).toBeUndefined();
   });
 
-  test("NUDGES map: app-get steers to the callable surface only when one exists", async () => {
+  test("NUDGES map: app-get steers to queries and actions only when the app has them", async () => {
     const withSurface = await finalizeSwarmToolResult("app-get", {
       ok: true,
       message: 'App "PM Inbox" (a1).',
@@ -302,9 +302,7 @@ describe("finalizeSwarmToolResult", () => {
         },
       },
     });
-    expect((withSurface.structuredContent as { nudge?: string }).nudge).toContain(
-      "callable surface",
-    );
+    expect((withSurface.structuredContent as { nudge?: string }).nudge).toContain("app-action-run");
 
     const bare = await finalizeSwarmToolResult("app-get", {
       ok: true,

package/src/tests/telemetry-context.test.ts

@@ -1,11 +1,13 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
-import { closeDb, createUser, initDb } from "../be/db";
+import { closeDb, createUser, getDbClient, initDb, updateUser, upsertSwarmConfig } from "../be/db";
 import { attachRole, detachRole } from "../be/rbac-roles";
+import { loadGlobalConfigsIntoEnv } from "../http/core";
 import {
   _getOrgIdForTests,
   _resetTelemetryStateForTests,
   initTelemetry,
+  setTelemetryFunctionResolver,
   setTelemetryOrgDomain,
   track,
 } from "../telemetry";
@@ -19,12 +21,22 @@ import {
   validOrgDomain,
   validOrgId,
 } from "../telemetry-context";
-import { _resetTelemetryIdentityForTests, computeOrgDomain } from "../telemetry-identity";
+import {
+  _resetTelemetryIdentityForTests,
+  cachedUserFunction,
+  computeOrgDomain,
+  primeUserRole,
+} from "../telemetry-identity";
 
 // initTelemetry no-ops when ANONYMIZED_TELEMETRY=false, and the CI env may set it.
 process.env.ANONYMIZED_TELEMETRY = "true";
 
 const TEST_DB_PATH = "./test-telemetry-context.sqlite";
+const PROFILE_KEYS = [
+  "SWARM_ORG_TEAM_SIZE",
+  "SWARM_ORG_USE_CASE",
+  "SWARM_ORG_ACQUISITION_SOURCE",
+] as const;
 
 async function removeTestDb(): Promise<void> {
   for (const suffix of ["", "-wal", "-shm"]) {
@@ -116,6 +128,30 @@ describe("telemetry context helpers", () => {
     expect(mapTriggerSurface(null)).toBe("other");
   });
 
+  test("buildContext omits invalid profile values and a function without an actor", () => {
+    const base = {
+      orgId: "org_0123456789abcdef",
+      installationId: "install_test",
+      isCloud: false,
+      isE2b: false,
+      swarmVersion: "1.2.3",
+    };
+    const context = buildContext({
+      ...base,
+      teamSize: "invalid",
+      useCase: "invalid",
+      acquisitionSource: "invalid",
+      userFunction: "founder",
+    });
+    expect(context).not.toHaveProperty("team_size");
+    expect(context).not.toHaveProperty("use_case");
+    expect(context).not.toHaveProperty("user_function");
+    expect(context.acquisition_source).toBeNull();
+    expect(
+      buildContext({ ...base, actor: { userId: "u-1" }, userFunction: "administrator" }),
+    ).not.toHaveProperty("user_function");
+  });
+
   test("normalizeProperties keeps an event alive when one optional value is unsendable", () => {
     const out = normalizeProperties("task.completed", {
       taskId: "t-1",
@@ -248,6 +284,19 @@ describe("telemetry envelope", () => {
     }
   });
 
+  test("track resolves the actor's job function without changing the RBAC role", async () => {
+    const config = memoryConfig({ telemetry_installation_id: "install_function" });
+    await initTelemetry("api-server", config.get, config.set, { generateIfMissing: true });
+    setTelemetryFunctionResolver(() => "founder");
+    track({
+      event: "workflow.deleted",
+      properties: { workflowId: "wf-1" },
+      actor: { userId: "u-1", role: "member" },
+    });
+    await tick();
+    expect(sent[0]?.context).toMatchObject({ user_function: "founder", user_role: "member" });
+  });
+
   test("an org with no ID yet sends nothing instead of a half-identified event", async () => {
     // A worker on an old server: installation ID known, no org ID stored.
     const config = memoryConfig({ telemetry_installation_id: "install_noorg" });
@@ -270,18 +319,95 @@ describe("telemetry envelope", () => {
 });
 
 describe("org email domain", () => {
+  const savedProfile = Object.fromEntries(PROFILE_KEYS.map((key) => [key, process.env[key]]));
+
   beforeEach(async () => {
     closeDb();
     await removeTestDb();
     initDb(TEST_DB_PATH);
     _resetTelemetryIdentityForTests();
+    for (const key of PROFILE_KEYS) delete process.env[key];
   });
 
   afterEach(async () => {
+    for (const key of PROFILE_KEYS) {
+      if (savedProfile[key] === undefined) delete process.env[key];
+      else process.env[key] = savedProfile[key];
+    }
     closeDb();
     await removeTestDb();
   });
 
+  test("stored company profile reaches context after reload and clears without restart", async () => {
+    const values = ["11-50", "features", "hacker_news"];
+    for (const [index, key] of PROFILE_KEYS.entries()) {
+      await upsertSwarmConfig({ scope: "global", key, value: values[index] as string });
+    }
+    await loadGlobalConfigsIntoEnv(true);
+    const originalFetch = globalThis.fetch;
+    const sent: Array<{ context: Record<string, unknown> }> = [];
+    globalThis.fetch = (async (_url: string, init?: { body?: string }) => {
+      if (init?.body) sent.push(JSON.parse(init.body));
+      return new Response(null, { status: 204 });
+    }) as typeof fetch;
+    _resetTelemetryStateForTests();
+    try {
+      const config = memoryConfig({
+        telemetry_installation_id: "install_profile",
+        telemetry_org_id: "org_0123456789abcdef",
+      });
+      await initTelemetry("api-server", config.get, config.set);
+      track({ event: "server.started", properties: { port: 3013 } });
+      expect(sent).toHaveLength(1);
+      expect(sent[0]?.context).toMatchObject({
+        team_size: "11-50",
+        use_case: "features",
+        acquisition_source: "hacker_news",
+      });
+      for (const key of PROFILE_KEYS) {
+        await upsertSwarmConfig({ scope: "global", key, value: "" });
+      }
+      await loadGlobalConfigsIntoEnv(true);
+      track({ event: "server.started", properties: { port: 3013 } });
+      expect(sent).toHaveLength(2);
+      expect(sent[1]?.context).not.toHaveProperty("team_size");
+      expect(sent[1]?.context).not.toHaveProperty("use_case");
+      expect(sent[1]?.context.acquisition_source).toBeNull();
+    } finally {
+      globalThis.fetch = originalFetch;
+      _resetTelemetryStateForTests();
+    }
+  });
+
+  test("job function uses the role cache and invalidates after a committed user update", async () => {
+    const user = await createUser({
+      name: "Founder",
+      role: "admin",
+      metadata: { jobFunction: "founder" },
+    });
+    await primeUserRole(user.id);
+    expect(cachedUserFunction(user.id)).toBe("founder");
+    await getDbClient().transaction(async () => {
+      await updateUser(user.id, { metadata: { jobFunction: "engineer" } });
+      expect(cachedUserFunction(user.id)).toBe("founder");
+    });
+    await primeUserRole(user.id);
+    expect(cachedUserFunction(user.id)).toBe("engineer");
+    await updateUser(user.id, { metadata: { jobFunction: "a free-text legacy role" } });
+    await primeUserRole(user.id);
+    expect(cachedUserFunction(user.id)).toBeUndefined();
+    const context = buildContext({
+      orgId: "org_0123456789abcdef",
+      installationId: "install_profile",
+      isCloud: false,
+      isE2b: false,
+      swarmVersion: "1.2.3",
+      actor: { userId: user.id },
+      userFunction: cachedUserFunction(user.id),
+    });
+    expect(context).not.toHaveProperty("user_function");
+  });
+
   test("is undefined with no users", async () => {
     expect(await computeOrgDomain()).toBeUndefined();
   });

package/src/tests/telemetry-ui-route.test.ts

@@ -5,6 +5,7 @@ import { isPublicRoute } from "../http/route-def";
 import { handleTelemetryUi } from "../http/telemetry-ui";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 import { _resetTelemetryStateForTests, initTelemetry } from "../telemetry";
+import catalog from "../telemetry-contract/catalog.json";
 import { UI_EVENT_NAMES, validateUiEvent } from "../telemetry-ui-events";
 import type { HttpRequestAuth } from "../utils/request-auth-context";
 import { setRequestAuth } from "../utils/request-auth-context";
@@ -118,6 +119,128 @@ describe("POST /api/telemetry/ui-event", () => {
     expect(sent).toHaveLength(0);
   });
 
+  test.each([
+    { event: "identity.lookup", properties: { matched: true } },
+    ...["identity_modal", "setup"].map((surface) => ({
+      event: "identity.user_created",
+      properties: { surface, email_kind: "work", has_function: true, has_company: true },
+    })),
+    {
+      event: "fleet_benchmark.unlocked",
+      properties: { fields: ["website", "team_size", "use_case"] },
+    },
+    ...["compose", "docker", "kubernetes"].map((target) => ({
+      event: "setup.worker_command_copied",
+      properties: { target, harness: "codex" },
+    })),
+    ...[
+      "prompt",
+      "setup",
+      "settings",
+      "org_name_popup",
+      "feedback",
+      "fleet_benchmark",
+      "telemetry_banner",
+      "identity_modal",
+    ].map((surface) => ({
+      event: "org.profile_updated",
+      properties: {
+        fields: ["name", "website", "team_size", "use_case", "acquisition_source"],
+        surface,
+      },
+    })),
+    {
+      event: "popup.submitted",
+      properties: {
+        popup: "feedback",
+        has_message: false,
+        has_contact: false,
+        answered: 3,
+        perks: ["used_by", "slack_connect"],
+      },
+    },
+    ...["notification.viewed", "notification.dismissed", "notification.submitted"].flatMap(
+      (event) =>
+        ["task_failed", "first_workflow", "default"].map((moment) => ({
+          event,
+          properties: {
+            key: "slack_connect_invite",
+            moment,
+            ...(event === "notification.submitted" ? { user_function: "engineer" } : {}),
+          },
+        })),
+    ),
+  ])("accepts the company-profile catalog event $event with $properties", async ({
+    event,
+    properties,
+  }) => {
+    const result = await post({ event, properties });
+    await flush();
+    expect(result.statusCode).toBe(204);
+    expect(sent).toHaveLength(1);
+    expect(sent[0]).toMatchObject({ event, source: "ui", properties });
+  });
+
+  test.each([
+    {
+      event: "identity.user_created",
+      properties: {
+        surface: "invalid",
+        email_kind: "work",
+        has_function: true,
+        has_company: false,
+      },
+    },
+    { event: "setup.worker_command_copied", properties: { target: "invalid", harness: "codex" } },
+    { event: "org.profile_updated", properties: { fields: ["team_size"], surface: "invalid" } },
+    { event: "org.profile_updated", properties: { fields: ["invalid"], surface: "settings" } },
+    { event: "fleet_benchmark.unlocked", properties: { fields: ["invalid"] } },
+    {
+      event: "popup.submitted",
+      properties: { popup: "feedback", has_message: false, has_contact: false, perks: ["invalid"] },
+    },
+    {
+      event: "notification.submitted",
+      properties: { key: "slack_connect_invite", moment: "invalid" },
+    },
+    {
+      event: "notification.submitted",
+      properties: { key: "slack_connect_invite", user_function: "invalid" },
+    },
+  ])("rejects a bad enum in $event with $properties", async ({ event, properties }) => {
+    const result = await post({ event, properties });
+    expect(result.statusCode).toBe(400);
+    expect(sent).toHaveLength(0);
+  });
+
+  test("array item references enforce the referenced enum", async () => {
+    const entry = catalog.events.find((entry) => entry.event === "fleet_benchmark.unlocked")!;
+    const fields = entry.properties.fields!;
+    const original = fields.items;
+    // Exercise a referenced item definition without changing the vendored catalog.
+    Object.assign(fields, { items: { ref: "use_case" } });
+    try {
+      expect(
+        (
+          await post({
+            event: "fleet_benchmark.unlocked",
+            properties: { fields: ["features"] },
+          })
+        ).statusCode,
+      ).toBe(204);
+      sent = [];
+      const result = await post({
+        event: "fleet_benchmark.unlocked",
+        properties: { fields: ["invalid"] },
+      });
+      expect(result.statusCode).toBe(400);
+      expect(result.body).toContain("items must be one of");
+      expect(sent).toHaveLength(0);
+    } finally {
+      fields.items = original;
+    }
+  });
+
   test("an unknown event name gets 400 and sends nothing", async () => {
     const result = await post({ event: "task.created", properties: {} });
     await flush();

package/src/tests/tool-annotations.test.ts

@@ -376,9 +376,10 @@ describe("Tool Annotations & Classification", () => {
     // (this suite forces ALL_CAPABILITIES, including default-disabled ones).
     // Includes 11 skill tools, 7 MCP server tools, reusable script tools, and the
     // native Kapso/WhatsApp tools (register/unregister number + send/reply message),
-    // and the six Chat SDK tools (chat-* + register/unregister-chat-channel).
+    // the six Chat SDK tools (chat-* + register/unregister-chat-channel),
+    // and the seven app row tools plus app-action-run.
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(163);
+    expect(count).toBeLessThanOrEqual(169);
   });
 
   test("core tools are fewer than deferred tools", () => {