@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/tests/slack-external-channel.test.ts

@@ -0,0 +1,370 @@
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+import { unlinkSync } from "node:fs";
+import type { WebClient } from "@slack/web-api";
+import { closeDb, getDbClient, getKv, initDb, upsertKv } from "../be/db";
+import {
+  EXTERNAL_ALERT_KV_NAMESPACE,
+  getChannelBlockReason,
+  getChannelExternality,
+  invalidateChannelExternality,
+  leaveExternalChannel,
+  resetExternalChannelStateForTesting,
+  scanExternalChannelsOnBoot,
+  shouldBlockChannel,
+} from "../slack/external-channel";
+
+const originalFlag = process.env.SLACK_BLOCK_EXTERNAL_CHANNELS;
+const originalAlerts = process.env.SLACK_ALERTS_CHANNEL;
+const TEST_DB_PATH = "./test-slack-external-channel.sqlite";
+
+function removeDbFiles(): void {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      unlinkSync(`${TEST_DB_PATH}${suffix}`);
+    } catch {
+      // ignore
+    }
+  }
+}
+
+beforeAll(() => {
+  removeDbFiles();
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(() => {
+  closeDb();
+  removeDbFiles();
+});
+
+function makePlatformError(code: string, extra: Record<string, unknown> = {}): Error {
+  const err = new Error(`An API error occurred: ${code}`);
+  (err as unknown as { data: Record<string, unknown> }).data = { ok: false, error: code, ...extra };
+  return err;
+}
+
+function makeClient(opts: {
+  channel?: Record<string, unknown>;
+  info?: () => Promise<unknown>;
+  leave?: () => Promise<unknown>;
+  channels?: Array<Record<string, unknown>>;
+}) {
+  const info = mock(opts.info ?? (() => Promise.resolve({ channel: opts.channel ?? {} })));
+  const leave = mock(opts.leave ?? (() => Promise.resolve({ ok: true })));
+  const postMessage = mock(() => Promise.resolve({ ok: true }));
+  const usersConversations = mock(() =>
+    Promise.resolve({ channels: opts.channels ?? [], response_metadata: { next_cursor: "" } }),
+  );
+  const client = {
+    conversations: { info, leave },
+    chat: { postMessage },
+    users: { conversations: usersConversations },
+  } as unknown as WebClient;
+  return { client, info, leave, postMessage, usersConversations };
+}
+
+function postedText(postMessage: ReturnType<typeof mock>): string {
+  return (postMessage.mock.calls[0]?.[0] as { text: string }).text;
+}
+
+beforeEach(async () => {
+  resetExternalChannelStateForTesting();
+  await getDbClient().run("DELETE FROM kv_entries WHERE namespace = ?", [
+    EXTERNAL_ALERT_KV_NAMESPACE,
+  ]);
+  process.env.SLACK_BLOCK_EXTERNAL_CHANNELS = "true";
+  process.env.SLACK_ALERTS_CHANNEL = "C_ALERTS";
+});
+
+afterEach(() => {
+  if (originalFlag === undefined) delete process.env.SLACK_BLOCK_EXTERNAL_CHANNELS;
+  else process.env.SLACK_BLOCK_EXTERNAL_CHANNELS = originalFlag;
+  if (originalAlerts === undefined) delete process.env.SLACK_ALERTS_CHANNEL;
+  else process.env.SLACK_ALERTS_CHANNEL = originalAlerts;
+});
+
+describe("getChannelExternality", () => {
+  test("is_ext_shared is external", async () => {
+    const { client } = makeClient({ channel: { is_ext_shared: true } });
+    expect(await getChannelExternality(client, "C1")).toBe("external");
+  });
+
+  test("is_ext_shared with a foreign conversation_host_id is external", async () => {
+    const { client } = makeClient({
+      channel: { is_ext_shared: true, conversation_host_id: "T0FOREIGN1" },
+    });
+    expect(await getChannelExternality(client, "C1")).toBe("external");
+  });
+
+  test("is_pending_ext_shared is external", async () => {
+    const { client } = makeClient({ channel: { is_pending_ext_shared: true } });
+    expect(await getChannelExternality(client, "C1")).toBe("external");
+  });
+
+  test("is_org_shared with both ext flags false is internal", async () => {
+    const { client } = makeClient({
+      channel: {
+        is_shared: true,
+        is_org_shared: true,
+        is_ext_shared: false,
+        is_pending_ext_shared: false,
+      },
+    });
+    expect(await getChannelExternality(client, "C1")).toBe("internal");
+  });
+
+  test("conversations.info error is unknown and not cached", async () => {
+    const { client, info } = makeClient({ info: () => Promise.reject(new Error("boom")) });
+    expect(await getChannelExternality(client, "C1")).toBe("unknown");
+    expect(await getChannelExternality(client, "C1")).toBe("unknown");
+    expect(info).toHaveBeenCalledTimes(2);
+  });
+
+  test("2 lookups inside the TTL make 1 API call; invalidate forces a fresh call", async () => {
+    const { client, info } = makeClient({ channel: { is_ext_shared: false } });
+    await getChannelExternality(client, "C1");
+    await getChannelExternality(client, "C1");
+    expect(info).toHaveBeenCalledTimes(1);
+    invalidateChannelExternality("C1");
+    await getChannelExternality(client, "C1");
+    expect(info).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe("shouldBlockChannel", () => {
+  test("flag off never blocks and makes no API call", async () => {
+    process.env.SLACK_BLOCK_EXTERNAL_CHANNELS = "false";
+    const { client, info } = makeClient({ channel: { is_ext_shared: true } });
+    expect(await shouldBlockChannel(client, "C1", true)).toBe(false);
+    expect(info).not.toHaveBeenCalled();
+  });
+
+  test("envelope flag blocks without an API call", async () => {
+    const { client, info } = makeClient({});
+    expect(await shouldBlockChannel(client, "C1", true)).toBe(true);
+    expect(info).not.toHaveBeenCalled();
+  });
+
+  test("unknown blocks as unverified (fail closed)", async () => {
+    const { client } = makeClient({ info: () => Promise.reject(new Error("boom")) });
+    expect(await shouldBlockChannel(client, "C1")).toBe(true);
+    expect(await getChannelBlockReason(client, "C1")).toBe("unverified");
+  });
+
+  test("a verified internal channel is not blocked", async () => {
+    const { client } = makeClient({ channel: { is_ext_shared: false } });
+    expect(await getChannelBlockReason(client, "C1")).toBeNull();
+  });
+
+  test("envelope evidence replaces a cached internal value", async () => {
+    let channel: Record<string, unknown> = { is_ext_shared: false };
+    const { client, info } = makeClient({ info: () => Promise.resolve({ channel }) });
+    expect(await getChannelExternality(client, "C1")).toBe("internal");
+    channel = { is_ext_shared: true };
+    expect(await shouldBlockChannel(client, "C1", true)).toBe(true);
+    // Reviewer repro: the next outbound check without an envelope must block too.
+    expect(await shouldBlockChannel(client, "C1")).toBe(true);
+    expect(info).toHaveBeenCalledTimes(1);
+  });
+
+  test("an in-flight internal lookup does not overwrite envelope evidence", async () => {
+    let resolveInfo: (value: unknown) => void = () => {};
+    const { client } = makeClient({
+      info: () =>
+        new Promise((resolve) => {
+          resolveInfo = resolve;
+        }),
+    });
+    const inFlight = getChannelExternality(client, "C1");
+    expect(await shouldBlockChannel(client, "C1", true)).toBe(true);
+    resolveInfo({ channel: { is_ext_shared: false } });
+    expect(await inFlight).toBe("external");
+    expect(await shouldBlockChannel(client, "C1")).toBe(true);
+  });
+
+  test("an in-flight lookup after invalidation is not cached", async () => {
+    let resolveInfo: (value: unknown) => void = () => {};
+    const { client, info } = makeClient({
+      info: () =>
+        new Promise((resolve) => {
+          resolveInfo = resolve;
+        }),
+    });
+    const inFlight = getChannelExternality(client, "C1");
+    invalidateChannelExternality("C1");
+    resolveInfo({ channel: { is_ext_shared: false } });
+    expect(await inFlight).toBe("unknown");
+    const next = getChannelExternality(client, "C1");
+    resolveInfo({ channel: { is_ext_shared: false } });
+    expect(await next).toBe("internal");
+    expect(info).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe("leaveExternalChannel", () => {
+  test("success: 1 leave and 1 alert with Leave: left", async () => {
+    const { client, leave, postMessage } = makeClient({});
+    await leaveExternalChannel(client, "C1", "joined");
+    expect(leave).toHaveBeenCalledTimes(1);
+    expect(postMessage).toHaveBeenCalledTimes(1);
+    expect((postMessage.mock.calls[0]?.[0] as { channel: string }).channel).toBe("C_ALERTS");
+    expect(postedText(postMessage)).toContain("Trigger: joined");
+    expect(postedText(postMessage)).toContain("Leave: left");
+  });
+
+  test("missing_scope: failed line and scope hint", async () => {
+    const { client, postMessage } = makeClient({
+      leave: () =>
+        Promise.reject(makePlatformError("missing_scope", { needed: "channels:manage" })),
+    });
+    await leaveExternalChannel(client, "C1", "joined");
+    expect(postedText(postMessage)).toContain("Leave: failed (missing_scope)");
+    expect(postedText(postMessage)).toContain("Slack requires the `channels:manage` scope");
+  });
+
+  test.each([
+    "cant_leave_general",
+    "last_member",
+    "method_not_supported_for_channel_type",
+  ])("%s maps to failed (<code>)", async (code) => {
+    const { client, postMessage } = makeClient({
+      leave: () => Promise.reject(makePlatformError(code)),
+    });
+    await leaveExternalChannel(client, "C1", "shared");
+    expect(postedText(postMessage)).toContain(`Leave: failed (${code})`);
+  });
+
+  test("not_in_channel response counts as left", async () => {
+    const { client, postMessage } = makeClient({
+      leave: () => Promise.reject(makePlatformError("not_in_channel", { not_in_channel: true })),
+    });
+    await leaveExternalChannel(client, "C1", "joined");
+    expect(postedText(postMessage)).toContain("Leave: left");
+  });
+
+  test("second call within 1 hour posts no second alert", async () => {
+    const { client, leave, postMessage } = makeClient({});
+    await leaveExternalChannel(client, "C1", "joined");
+    await leaveExternalChannel(client, "C1", "joined");
+    expect(leave).toHaveBeenCalledTimes(2);
+    expect(postMessage).toHaveBeenCalledTimes(1);
+  });
+
+  test("alert dedupe survives a restart", async () => {
+    const first = makeClient({});
+    await leaveExternalChannel(first.client, "C1", "joined");
+    expect(first.postMessage).toHaveBeenCalledTimes(1);
+
+    // Restart: all process memory is gone; only kv_entries survives. (The test
+    // DB restores from an in-memory template, so it cannot be reopened here.)
+    resetExternalChannelStateForTesting();
+
+    const second = makeClient({});
+    await leaveExternalChannel(second.client, "C1", "joined");
+    expect(second.postMessage).not.toHaveBeenCalled();
+    const entry = await getKv(EXTERNAL_ALERT_KV_NAMESPACE, "C1:joined");
+    expect(entry?.value).toBe("sent");
+    expect(entry?.expiresAt).toBeGreaterThan(Date.now() + 59 * 60 * 1000);
+  });
+
+  test("a failed alert post releases the key so the next attempt sends", async () => {
+    const error = spyOn(console, "error").mockImplementation(() => {});
+    try {
+      const { client, postMessage } = makeClient({});
+      postMessage.mockImplementationOnce(() => Promise.reject(new Error("slack down")));
+      await leaveExternalChannel(client, "C1", "joined");
+      expect(await getKv(EXTERNAL_ALERT_KV_NAMESPACE, "C1:joined")).toBeNull();
+      await leaveExternalChannel(client, "C1", "joined");
+      expect(postMessage).toHaveBeenCalledTimes(2);
+      await leaveExternalChannel(client, "C1", "joined");
+      expect(postMessage).toHaveBeenCalledTimes(2);
+    } finally {
+      error.mockRestore();
+    }
+  });
+
+  test("a stale sending reservation (crash mid-post) does not suppress the alert", async () => {
+    await upsertKv({
+      namespace: EXTERNAL_ALERT_KV_NAMESPACE,
+      key: "C1:joined",
+      value: "sending",
+      valueType: "string",
+      expiresAt: Date.now() - 1,
+    });
+    const { client, postMessage } = makeClient({});
+    await leaveExternalChannel(client, "C1", "joined");
+    expect(postMessage).toHaveBeenCalledTimes(1);
+  });
+
+  test("an in-flight sending reservation suppresses a concurrent duplicate", async () => {
+    const { client, postMessage } = makeClient({});
+    await Promise.all([
+      leaveExternalChannel(client, "C1", "joined"),
+      leaveExternalChannel(client, "C1", "joined"),
+    ]);
+    expect(postMessage).toHaveBeenCalledTimes(1);
+  });
+
+  test("unset SLACK_ALERTS_CHANNEL: 0 posts and 1 warning", async () => {
+    delete process.env.SLACK_ALERTS_CHANNEL;
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const { client, postMessage } = makeClient({});
+      await leaveExternalChannel(client, "C1", "joined");
+      expect(postMessage).not.toHaveBeenCalled();
+      expect(warn).toHaveBeenCalledTimes(1);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+});
+
+describe("scanExternalChannelsOnBoot", () => {
+  test("boot scan sweeps expired alert keys", async () => {
+    await upsertKv({
+      namespace: EXTERNAL_ALERT_KV_NAMESPACE,
+      key: "C_OLD:boot-scan",
+      value: "sent",
+      valueType: "string",
+      expiresAt: Date.now() - 1,
+    });
+    const { client } = makeClient({});
+    await scanExternalChannelsOnBoot(client);
+    const rows = await getDbClient().query<{ key: string }>(
+      "SELECT key FROM kv_entries WHERE namespace = ?",
+      [EXTERNAL_ALERT_KV_NAMESPACE],
+    );
+    expect(rows).toEqual([]);
+  });
+
+  test("1 external + 1 internal: 1 report-only alert, 0 leaves", async () => {
+    const { client, leave, postMessage } = makeClient({
+      channels: [
+        { id: "C_EXT", is_ext_shared: true },
+        { id: "C_INT", is_ext_shared: false, is_pending_ext_shared: false },
+      ],
+    });
+    await scanExternalChannelsOnBoot(client);
+    expect(leave).not.toHaveBeenCalled();
+    expect(postMessage).toHaveBeenCalledTimes(1);
+    expect(postedText(postMessage)).toContain("C_EXT");
+    expect(postedText(postMessage)).toContain("Leave: not attempted (report only)");
+  });
+
+  test("flag off: no Slack calls", async () => {
+    process.env.SLACK_BLOCK_EXTERNAL_CHANNELS = "false";
+    const { client, usersConversations } = makeClient({});
+    await scanExternalChannelsOnBoot(client);
+    expect(usersConversations).not.toHaveBeenCalled();
+  });
+});

package/src/tests/slack-render-v2.test.ts

@@ -556,6 +556,40 @@ describe("Slack renderer v2", () => {
     });
   }
 
+  for (const delegationEnabled of [false, true]) {
+    for (const status of ["completed", "failed"] as const) {
+      test(`worker deferred ${status} wake posts no outcome with delegation=${delegationEnabled}`, async () => {
+        process.env.SLACK_RENDER_V2_DELEGATION = String(delegationEnabled);
+        if (delegationEnabled) await ensureSlackDelegationActivation();
+        const worker = await createAgent({ name: "Fast Coder", isLead: false, status: "idle" });
+        const { channelId, threadTs } = uniqueSlackAddress("C_WORKER_WAKE");
+        const wake = await createTaskExtended("Check PR #2136 CI at the expected head", {
+          agentId: worker.id,
+          source: "schedule",
+          taskType: "deferred",
+          slackChannelId: channelId,
+          slackThreadTs: threadTs,
+          contextKey: slackContextKey({ channelId, threadTs }),
+        });
+        await startTask(wake.id);
+        await ensureSlackThreadTree([wake.id]);
+        await processSlackRenderV2();
+        if (status === "failed") {
+          await failTask(wake.id, "CI is failing at expected head");
+        } else {
+          await completeTask(wake.id, "CI is green at expected head");
+        }
+        calls.length = 0;
+
+        await processSlackRenderV2();
+        await processSlackRenderV2();
+
+        expect(await getSlackOutcomeMessage(wake.id)).toBeNull();
+        expect(calls.filter((call) => call.method === "chat.startStream")).toHaveLength(0);
+      });
+    }
+  }
+
   test("does not relay an ordinary scheduled task without Slack context", async () => {
     const schedule = await createScheduledTask({
       name: "ordinary-maintenance",
@@ -2474,7 +2508,7 @@ describe("Slack renderer v2", () => {
     expect(calls).toContainEqual(doneReaction);
   });
 
-  test("a wake-up that deferred again posts the next ⏳ card, and the old card points at it", async () => {
+  test("re-defers retain one ⏳ card through multiple wakes and the final result", async () => {
     const lead = await createAgent({ name: "Chained Lead", isLead: true, status: "idle" });
     const { channelId, threadTs } = uniqueSlackAddress("C_DEFER_CHAIN");
     const ask = await createTaskExtended("answer when the build is done", {
@@ -2513,18 +2547,60 @@ describe("Slack renderer v2", () => {
     calls.length = 0;
     await processSlackRenderV2();
 
-    // The chain continues on a new ⏳ card, which the next wake-up resolves.
-    const next = calls.find((call) => call.method === "chat.startStream");
-    expect(next?.payload.markdown_text).toBe("⏳ Checking back later");
-    const nextCard = await getSlackOutcomeMessage(wake.id);
-    expect(nextCard?.permalink).toBeTruthy();
-    // The old card hands over to it rather than repeating the new ETA.
+    expect(calls.filter((call) => call.method === "chat.startStream")).toHaveLength(0);
+    expect(await getSlackOutcomeMessage(wake.id)).toBeNull();
     const rewrite = calls.find(
       (call) => call.method === "chat.update" && call.payload.ts === card?.ts,
     );
-    expect(rewrite?.payload.text).toBe(
-      `↪️ Resumed by ${lead.name} and deferred again — <${nextCard?.permalink}|next update>`,
-    );
+    expect(rewrite?.payload.text).toBe("⏳ Checking back later");
+    expect((await getSlackOutcomeMessage(ask.id))?.deferralResolvedAt).toBeUndefined();
+
+    const nextSchedule = await createScheduledTask({
+      ...schedule,
+      name: "deferred-chain-next",
+      parentTaskId: wake.id,
+    });
+    const nextWake = await createStandaloneScheduleTask(nextSchedule);
+    await startTask(nextWake.id);
+    await completeTask(nextWake.id, "Waiting on Builder — or today at 21:00 at the latest", {
+      addTags: ["deferred"],
+      deferredAt: new Date().toISOString(),
+    });
+    calls.length = 0;
+    await processSlackRenderV2();
+    expect(calls.filter((call) => call.method === "chat.startStream")).toHaveLength(0);
+    expect(
+      calls.find((call) => call.method === "chat.update" && call.payload.ts === card?.ts)?.payload
+        .text,
+    ).toBe("⏳ Waiting on Builder");
+
+    calls.length = 0;
+    await processSlackRenderV2();
+    expect(
+      calls.filter((call) => call.method === "chat.update" && call.payload.ts === card?.ts),
+    ).toHaveLength(0);
+
+    const finalSchedule = await createScheduledTask({
+      ...schedule,
+      name: "deferred-chain-final",
+      parentTaskId: nextWake.id,
+    });
+    const finalWake = await createStandaloneScheduleTask(finalSchedule);
+    await startTask(finalWake.id);
+    await completeTask(finalWake.id, "The build passed.");
+    calls.length = 0;
+    await processSlackRenderV2();
+    expect(calls.filter((call) => call.method === "chat.startStream")).toHaveLength(0);
+    expect(
+      calls.find((call) => call.method === "chat.update" && call.payload.ts === card?.ts)?.payload
+        .text,
+    ).toContain("The build passed.");
+    expect((await getSlackOutcomeMessage(ask.id))?.deferralResolvedAt).toBeTruthy();
+    calls.length = 0;
+    await processSlackRenderV2();
+    expect(
+      calls.filter((call) => call.method === "chat.update" && call.payload.ts === card?.ts),
+    ).toHaveLength(0);
   });
 
   test("a wake-up that failed closes the deferral card as failed, not as done", async () => {

package/src/tests/sonnet-5-5-registry.test.ts

@@ -23,10 +23,11 @@ describe("Sonnet 5.5 registry", () => {
             .filter((row) => row.provider === provider && row.model === model)
             .map((row) => [row.tokenClass, row.pricePerMillionUsd]),
         );
+        // Sonnet 5.5 cache hits cost 0.05x input, not the usual 0.1x.
         expect(rates).toEqual({
           input: 2,
           output: 10,
-          cached_input: 0.2,
+          cached_input: 0.1,
           cache_write: 2.5,
           cache_write_1h: 4,
         });
@@ -41,4 +42,11 @@ describe("Sonnet 5.5 registry", () => {
       ).toBe(2);
     }
   });
+
+  test("the shortname fallback seeds the same cache-read rate when the snapshot lacks the model", () => {
+    const row = buildModelsDevSeedRows({ anthropic: { models: {} } }).find(
+      (r) => r.provider === "claude" && r.model === "sonnet" && r.tokenClass === "cached_input",
+    );
+    expect(row?.pricePerMillionUsd).toBe(0.1);
+  });
 });

package/src/tests/spec-base-url.test.ts

@@ -246,12 +246,27 @@ describe("migration 117 consolidated connections-redesign schema", () => {
           new Date().toISOString(),
           new Bun.CryptoHasher("sha256").update(migration117).digest("hex"),
         );
+      // 213 rebuilds script_connections with post-117 columns, so it must wait for 117 too.
+      const migration213 = readFileSync(
+        "src/be/migrations/213_script_connections_sql.sql",
+        "utf-8",
+      );
+      database
+        .prepare(
+          "INSERT INTO _migrations (version, name, applied_at, checksum) VALUES (?, ?, ?, ?)",
+        )
+        .run(
+          213,
+          "213_script_connections_sql",
+          new Date().toISOString(),
+          new Bun.CryptoHasher("sha256").update(migration213).digest("hex"),
+        );
       runMigrations(database);
       database.run(
         `INSERT INTO script_connections (id, slug, kind, base_url)
          VALUES ('existing', 'existing', 'raw', 'https://api.vendor.test')`,
       );
-      database.run("DELETE FROM _migrations WHERE version = 117");
+      database.run("DELETE FROM _migrations WHERE version IN (117, 213)");
       runMigrations(database);
       expect(
         database