@desplega.ai/agent-swarm 2.7.6 → 2.7.7

package/src/tests/seed-scripts.test.ts

@@ -20,6 +20,10 @@ import opsCatalogAudit, {
   renderPage as renderOpsCatalogAuditPage,
 } from "../be/seed-scripts/catalog/ops-catalog-audit";
 import scheduleHealth from "../be/seed-scripts/catalog/schedule-health";
+import swarmUpdateCheck, {
+  compareVersions,
+  parseVersion,
+} from "../be/seed-scripts/catalog/swarm-update-check";
 import taskContextGathering from "../be/seed-scripts/catalog/task-context-gathering";
 import taskFailureAudit from "../be/seed-scripts/catalog/task-failure-audit";
 import { extractScriptSignature } from "../scripts-runtime/extract-signature";
@@ -62,8 +66,8 @@ afterAll(async () => {
 });
 
 describe("seed-scripts catalog", () => {
-  test("manifest holds 39 unique, well-described scripts", () => {
-    expect(SEED_SCRIPTS.length).toBe(39);
+  test("manifest holds 40 unique, well-described scripts", () => {
+    expect(SEED_SCRIPTS.length).toBe(40);
     const names = SEED_SCRIPTS.map((s) => s.name);
     expect(new Set(names).size).toBe(names.length);
     for (const s of SEED_SCRIPTS) {
@@ -2000,3 +2004,139 @@ describe("dreaming-heartbeat check refuses a worker-chosen draftPath", () => {
     expect(out.reasons.join(" ")).not.toContain("draftPath");
   });
 });
+
+describe("swarm-update-check", () => {
+  const RELEASES = "https://api.github.com/repos/desplega-ai/agent-swarm/releases/latest";
+
+  /** Fake API + GitHub: `/health` answers `running`, the release endpoint `release`. */
+  function fakeCtx(opts: {
+    running?: string | null;
+    release?: { status: number; body?: unknown } | "network-error";
+    agents?: unknown[];
+  }) {
+    const fetches: { url: string; retries?: number }[] = [];
+    const sent: any[] = [];
+    const stdlib = {
+      Redacted: { value: (v: unknown) => v },
+      fetch: async (url: string, init: { retries?: number } = {}) => {
+        fetches.push({ url, retries: init.retries });
+        if (url === "http://api.test/health") {
+          return new Response(
+            JSON.stringify(opts.running === null ? {} : { version: opts.running }),
+          );
+        }
+        if (url === RELEASES) {
+          const release = opts.release ?? { status: 200, body: {} };
+          if (release === "network-error") throw new Error("getaddrinfo ENOTFOUND");
+          return new Response(JSON.stringify(release.body ?? {}), { status: release.status });
+        }
+        return new Response("{}", { status: 404 });
+      },
+    };
+    const swarm = {
+      config: { mcpBaseUrl: "http://api.test/" },
+      async swarm_get() {
+        return {
+          success: true,
+          status: 200,
+          data: {
+            agents: opts.agents ?? [
+              { id: "worker-1", isLead: false },
+              { id: "lead-1", isLead: true },
+            ],
+          },
+        };
+      },
+      async task_send(args: unknown) {
+        sent.push(args);
+        return { success: true, status: 200, data: { success: true, task: { id: "notify-1" } } };
+      },
+    };
+    return { ctx: { stdlib, swarm }, fetches, sent };
+  }
+
+  const release = (tag: string) => ({
+    status: 200,
+    body: {
+      tag_name: tag,
+      html_url: `https://github.com/desplega-ai/agent-swarm/releases/tag/${tag}`,
+    },
+  });
+
+  test("compares versions numerically, never as strings", () => {
+    expect(compareVersions(parseVersion("1.10.0")!, parseVersion("1.9.0")!)).toBeGreaterThan(0);
+    expect(compareVersions(parseVersion("v2.0.0")!, parseVersion("2.0.0")!)).toBe(0);
+    expect(parseVersion("1.2")).toBeNull();
+    expect(parseVersion(undefined)).toBeNull();
+  });
+
+  test("a newer release notifies the lead once, with the versions and release URL", async () => {
+    const { ctx, sent } = fakeCtx({ running: "1.9.0", release: release("v1.10.0") });
+    const result: any = await swarmUpdateCheck({}, ctx);
+    expect(result).toMatchObject({
+      checked: true,
+      status: "update-available",
+      running: "1.9.0",
+      latest: "1.10.0",
+      notified: true,
+      leadTaskId: "notify-1",
+    });
+    expect(sent).toHaveLength(1);
+    expect(sent[0]).toMatchObject({ agentId: "lead-1", routingReason: "skill" });
+    expect(sent[0].task).toContain("running 1.9.0, latest 1.10.0");
+    expect(sent[0].task).toContain(
+      "https://github.com/desplega-ai/agent-swarm/releases/tag/v1.10.0",
+    );
+    expect(sent[0].task).toContain("admin delivery channel");
+  });
+
+  test("control: up to date and older-than-running releases notify nobody", async () => {
+    for (const tag of ["v1.10.0", "v1.9.9"]) {
+      const { ctx, sent } = fakeCtx({ running: "1.10.0", release: release(tag) });
+      const result: any = await swarmUpdateCheck({}, ctx);
+      expect(result).toMatchObject({ checked: true, status: "up-to-date" });
+      expect(sent).toHaveLength(0);
+    }
+  });
+
+  test("a missing running version is unknown, not up to date, and skips GitHub", async () => {
+    const { ctx, sent, fetches } = fakeCtx({ running: null, release: release("v9.0.0") });
+    const result: any = await swarmUpdateCheck({}, ctx);
+    expect(result).toMatchObject({ checked: false, status: "unknown" });
+    expect(result.message).toContain("Unable to determine running version");
+    expect(fetches.map((f) => f.url)).not.toContain(RELEASES);
+    expect(sent).toHaveLength(0);
+  });
+
+  test("a failed GitHub call is reported after one attempt and notifies nobody", async () => {
+    for (const failure of [
+      { status: 403, body: { message: "rate limited" } },
+      "network-error" as const,
+    ]) {
+      const { ctx, sent, fetches } = fakeCtx({ running: "1.0.0", release: failure });
+      const result: any = await swarmUpdateCheck({}, ctx);
+      expect(result).toMatchObject({ checked: false, status: "github-unreachable" });
+      expect(result.message).toContain("Could not reach GitHub releases API");
+      const github = fetches.filter((f) => f.url === RELEASES);
+      expect(github).toHaveLength(1);
+      expect(github[0]?.retries).toBe(1);
+      expect(sent).toHaveLength(0);
+    }
+  });
+
+  test("dryRun reports the update without notifying", async () => {
+    const { ctx, sent } = fakeCtx({ running: "1.0.0", release: release("v1.0.1") });
+    const result: any = await swarmUpdateCheck({ dryRun: true }, ctx);
+    expect(result).toMatchObject({ status: "update-available", notified: false });
+    expect(sent).toHaveLength(0);
+  });
+
+  test("an update with no lead to notify fails the run", async () => {
+    const { ctx } = fakeCtx({
+      running: "1.0.0",
+      release: release("v1.0.1"),
+      agents: [{ id: "worker-1", isLead: false }],
+    });
+    await expect(swarmUpdateCheck({}, ctx)).rejects.toThrow("no lead to notify");
+  });
+});

package/src/tests/swarm-diff.test.ts

@@ -28,6 +28,16 @@ const EXAMPLE_HUNK = {
   ],
 };
 
+/** The rendered diff rows: old-side and new-side gutter numbers plus the row HTML. */
+function diffRows(html: string): { old: string; new: string; html: string }[] {
+  return [...html.matchAll(/<tr\b[^>]*>([\s\S]*?)<\/tr>/g)].map(([, row]) => {
+    const [oldCell = "", newCell = ""] = [
+      ...row!.matchAll(/<td class="swarm-diff-gutter"[^>]*>([^<]*)<\/td>/g),
+    ].map(([, cell]) => cell!);
+    return { old: oldCell, new: newCell, html: row! };
+  });
+}
+
 type StubInstance = {
   innerHTML: string;
   textContent: string;
@@ -55,12 +65,15 @@ function makeRig(
 ): {
   Ctor: new () => StubInstance;
   CursorsCtor: new () => StubInstance;
+  JumpsCtor: new () => StubInstance;
   SdkCtor?: new () => { room: (name?: string, options?: unknown) => Promise<unknown> };
   body: StubInstance;
   setText: (el: StubInstance, attrs: Record<string, string>, text: string) => void;
   fireDocumentEvent: (name: string, event: unknown) => void;
   fireNextFrame: () => void;
   flushMicrotasks: () => Promise<void>;
+  /** Sets what `document.querySelectorAll` returns (the jump list's anchors). */
+  setAnchors: (anchors: unknown[]) => void;
 } {
   const registry = new Map<string, new () => StubInstance>();
   const documentListeners = new Map<string, ((event: unknown) => void)[]>();
@@ -143,12 +156,13 @@ function makeRig(
 
   // Provide `document` stubs the jump-list path uses.
   const body = new StubHTMLElement();
+  let anchors: unknown[] = [];
   const doc = {
     readyState,
     documentElement: { scrollWidth: 1000, scrollHeight: 500, clientWidth: 1000, clientHeight: 500 },
     body,
     createElement: () => new StubHTMLElement(),
-    querySelectorAll: () => [],
+    querySelectorAll: () => anchors,
     addEventListener: (name: string, handler: (event: unknown) => void) => {
       const handlers = documentListeners.get(name) ?? [];
       handlers.push(handler);
@@ -176,7 +190,7 @@ function makeRig(
     "CustomEvent",
     "queueMicrotask",
     "console",
-    `${SWARM_UI_JS}\nreturn { diff: window.customElements.get('swarm-diff'), cursors: window.customElements.get('swarm-cursors'), sdk: window.SwarmSDK };`,
+    `${SWARM_UI_JS}\nreturn { diff: window.customElements.get('swarm-diff'), cursors: window.customElements.get('swarm-cursors'), jumps: window.customElements.get('swarm-diff-jumps'), sdk: window.SwarmSDK };`,
   );
   const constructors = factory(
     win,
@@ -189,16 +203,20 @@ function makeRig(
   ) as {
     diff?: new () => StubInstance;
     cursors?: new () => StubInstance;
+    jumps?: new () => StubInstance;
     sdk?: new () => { room: (name?: string, options?: unknown) => Promise<unknown> };
   };
   const Ctor = constructors.diff;
   if (!Ctor) throw new Error("custom element did not register");
   const CursorsCtor = constructors.cursors;
   if (!CursorsCtor) throw new Error("swarm-cursors custom element did not register");
+  const JumpsCtor = constructors.jumps;
+  if (!JumpsCtor) throw new Error("swarm-diff-jumps custom element did not register");
 
   return {
     Ctor,
     CursorsCtor,
+    JumpsCtor,
     SdkCtor: constructors.sdk,
     body,
     setText(el, attrs, text) {
@@ -220,6 +238,9 @@ function makeRig(
       // Drain the chained async room-open and render callbacks.
       for (let i = 0; i < 5; i++) await Promise.resolve();
     },
+    setAnchors(list) {
+      anchors = list;
+    },
   };
 }
 
@@ -517,6 +538,58 @@ describe("<swarm-diff> render", () => {
     expect(html).toContain("Avoid raw console.log");
   });
 
+  test("shows an annotation once, on its new-side line, not on a context row with that old-side number", async () => {
+    // Three added lines shift the new side: the context row `});` is old 63,
+    // new 66, and the annotation names new line 63.
+    const shifted = {
+      hunks: [
+        {
+          old_start: 60,
+          old_lines: 4,
+          new_start: 60,
+          new_lines: 7,
+          lines: [
+            { type: "context", text: "start();" },
+            { type: "add", text: "one();" },
+            { type: "add", text: "two();" },
+            { type: "add", text: "three();" },
+            { type: "context", text: "four();" },
+            { type: "context", text: "five();" },
+            { type: "context", text: "});" },
+          ],
+          annotations: [{ line: 63, severity: "warn", text: "Note on new line 63" }],
+        },
+      ],
+    };
+    const html = await renderViaStub(JSON.stringify(shifted), { file: "src/a.ts" });
+    const rows = diffRows(html);
+    expect(rows.find((row) => row.html.includes("});"))).toMatchObject({ old: "63", new: "66" });
+    const annotated = rows.filter((row) => row.html.includes("Note on new line 63"));
+    expect(annotated.map((row) => [row.old, row.new])).toEqual([["", "63"]]);
+  });
+
+  test("matches a deleted row's annotation on its old-side number", async () => {
+    const deleted = {
+      hunks: [
+        {
+          old_start: 10,
+          old_lines: 3,
+          new_start: 20,
+          new_lines: 2,
+          lines: [
+            { type: "context", text: "keep();" },
+            { type: "del", text: "drop();" },
+            { type: "context", text: "keepToo();" },
+          ],
+          annotations: [{ line: 11, severity: "error", text: "Why drop this?" }],
+        },
+      ],
+    };
+    const html = await renderViaStub(JSON.stringify(deleted), { file: "src/b.ts" });
+    const annotated = diffRows(html).filter((row) => row.html.includes("Why drop this?"));
+    expect(annotated.map((row) => [row.old, row.new])).toEqual([["11", ""]]);
+  });
+
   test("handles empty/missing JSON body gracefully (no rows, no throw)", async () => {
     const html = await renderViaStub("", { file: "empty.ts" });
     // Should still render an outer container with the file name.
@@ -545,6 +618,52 @@ describe("<swarm-diff> render", () => {
   });
 });
 
+describe("<swarm-diff-jumps> labels", () => {
+  const hunk = (oldStart: number, newStart: number) => ({
+    old_start: oldStart,
+    old_lines: 1,
+    new_start: newStart,
+    new_lines: 1,
+    lines: [{ type: "context", text: "x();" }],
+  });
+
+  test("a file with more than one hunk shows each hunk's new-side start line", async () => {
+    const rig = makeRig();
+    const render = async (file: string, hunks: unknown[]) => {
+      const el = new rig.Ctor();
+      rig.setText(el, { file }, JSON.stringify({ hunks }));
+      el.connectedCallback?.();
+      await rig.flushMicrotasks();
+      return el;
+    };
+    // The anchors the jump list finds in the document, built from the rendered HTML.
+    const anchorsOf = (diff: StubInstance) =>
+      [
+        ...diff.innerHTML.matchAll(
+          /<a id="([^"]*)" class="swarm-diff-anchor" data-hunk="([^"]*)" data-new-start="([^"]*)"><\/a>/g,
+        ),
+      ].map(([, id, slug, newStart]) => {
+        const attrs: Record<string, string> = { "data-hunk": slug!, "data-new-start": newStart! };
+        return { id, getAttribute: (name: string) => attrs[name] ?? null, closest: () => diff };
+      });
+    const x = await render("src/x.ts", [hunk(10, 58), hunk(100, 120)]);
+    const y = await render("src/y.ts", [hunk(5, 5)]);
+    rig.setAnchors([...anchorsOf(x), ...anchorsOf(y)]);
+
+    const jumps = new rig.JumpsCtor();
+    jumps.connectedCallback?.();
+    await rig.flushMicrotasks();
+    const links = [
+      ...jumps.innerHTML.matchAll(/<a href="#([^"]*)" target="_self"[^>]*>([^<]*)<\/a>/g),
+    ].map(([, href, label]) => [href, label]);
+    expect(links).toEqual([
+      ["swarm-diff-src-x-ts-10", "src/x.ts:58"],
+      ["swarm-diff-src-x-ts-100", "src/x.ts:120"],
+      ["swarm-diff-src-y-ts-5", "src/y.ts"],
+    ]);
+  });
+});
+
 describe("<swarm-diff> parse-order regression (Bug #479-1)", () => {
   // Real browsers fire connectedCallback when the parser sees the opening
   // tag, BEFORE the JSON text children are parsed. The element MUST defer

package/src/tests/task-auto-title-config-guard.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { validateConfigValue } from "../be/swarm-config-guard";
+
+describe("task auto-title config validation", () => {
+  test("TASK_AUTO_TITLE_ENABLED accepts boolean literals only", () => {
+    expect(validateConfigValue("TASK_AUTO_TITLE_ENABLED", "true")).toBeNull();
+    expect(validateConfigValue("TASK_AUTO_TITLE_ENABLED", "false")).toBeNull();
+    expect(validateConfigValue("TASK_AUTO_TITLE_ENABLED", "maybe")).toMatch(
+      /TASK_AUTO_TITLE_ENABLED/,
+    );
+  });
+
+  test("TASK_AUTO_TITLE_MODEL accepts provider/model-id for a callable provider, a claude alias, or empty", () => {
+    for (const value of [
+      "openrouter/deepseek/deepseek-v4.1-flash",
+      "anthropic/claude-haiku-5-5",
+      "openai/gpt-5-nano",
+      "openai-codex/gpt-6-luna",
+      "haiku",
+      "",
+      "  anthropic/claude-haiku-5-5  ",
+    ]) {
+      expect(validateConfigValue("TASK_AUTO_TITLE_MODEL", value)).toBeNull();
+    }
+  });
+
+  test("TASK_AUTO_TITLE_MODEL rejects unsupported providers and malformed strings", () => {
+    expect(validateConfigValue("TASK_AUTO_TITLE_MODEL", "google/gemini-2.5-flash-lite")).toMatch(
+      /provider must be/,
+    );
+    expect(validateConfigValue("TASK_AUTO_TITLE_MODEL", "openai/")).toMatch(/provider\/model-id/);
+    expect(validateConfigValue("TASK_AUTO_TITLE_MODEL", "openai/gpt 5")).toMatch(
+      /provider\/model-id/,
+    );
+    expect(validateConfigValue("TASK_AUTO_TITLE_MODEL", 42)).toMatch(/must be a string/);
+  });
+});

package/src/tests/task-auto-title-listener.test.ts

@@ -0,0 +1,165 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getTaskById,
+  initDb,
+  updateTaskTitle,
+} from "../be/db";
+import { setTaskTitleIfUnset } from "../be/db/tasks/write";
+import {
+  isTaskAutoTitleEnabled,
+  startTaskAutoTitleListener,
+  type TaskAutoTitleListener,
+} from "../be/task-auto-title-listener";
+import type { generateTaskTitle } from "../utils/internal-ai/task-title";
+import { workflowEventBus } from "../workflows/event-bus";
+
+const TEST_DB_PATH = "./test-task-auto-title-listener.sqlite";
+
+/**
+ * `createTaskExtended` emits `task.created` from an after-commit hook that
+ * imports the event bus asynchronously, so the event lands after the call
+ * returns. Create the task through this helper to await that emission.
+ */
+async function createTaskAndAwaitEvent(task: string): Promise<string> {
+  const created = new Promise<void>((resolve) => {
+    const handler = () => {
+      workflowEventBus.off("task.created", handler);
+      resolve();
+    };
+    workflowEventBus.on("task.created", handler);
+  });
+  const row = await createTaskExtended(task, { agentId, source: "api" });
+  await created;
+  return row.id;
+}
+const LONG_TASK =
+  "Investigate why the nightly Playwright suite times out on the sessions page after the sidebar redesign and fix the flake.";
+
+let agentId: string;
+let listener: TaskAutoTitleListener | null = null;
+
+type Generate = typeof generateTaskTitle;
+
+/** Generator stub that returns `title` and records every prompt it saw. */
+function generator(title: string | null, seen: string[] = []) {
+  const generate: Generate = async (opts) => {
+    seen.push(opts.task);
+    return title
+      ? { ok: true, title, model: "test/model", kind: "openrouter" }
+      : { ok: false, reason: "all-models-failed" };
+  };
+  return { generate, seen };
+}
+
+beforeAll(async () => {
+  initDb(TEST_DB_PATH);
+  agentId = (await createAgent({ name: "auto-title-worker", isLead: false, status: "idle" })).id;
+});
+
+afterEach(() => {
+  listener?.stop();
+  listener = null;
+});
+
+afterAll(async () => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+
+describe("isTaskAutoTitleEnabled", () => {
+  test("defaults on and honours false-ish values", () => {
+    expect(isTaskAutoTitleEnabled({})).toBe(true);
+    expect(isTaskAutoTitleEnabled({ TASK_AUTO_TITLE_ENABLED: "" })).toBe(true);
+    expect(isTaskAutoTitleEnabled({ TASK_AUTO_TITLE_ENABLED: "false" })).toBe(false);
+    expect(isTaskAutoTitleEnabled({ TASK_AUTO_TITLE_ENABLED: "0" })).toBe(false);
+    expect(isTaskAutoTitleEnabled({ TASK_AUTO_TITLE_ENABLED: "true" })).toBe(true);
+  });
+});
+
+describe("setTaskTitleIfUnset", () => {
+  test("writes once and never replaces an existing title", async () => {
+    const task = await createTaskExtended(LONG_TASK, { agentId, source: "api" });
+    expect(task.title).toBeUndefined();
+
+    const first = await setTaskTitleIfUnset(task.id, "  Generated title  ");
+    expect(first?.title).toBe("Generated title");
+
+    const second = await setTaskTitleIfUnset(task.id, "Another title");
+    expect(second).toBeNull();
+    expect((await getTaskById(task.id))?.title).toBe("Generated title");
+
+    expect(await setTaskTitleIfUnset(task.id, "   ")).toBeNull();
+  });
+});
+
+describe("startTaskAutoTitleListener", () => {
+  test("titles a new task after commit", async () => {
+    const { generate, seen } = generator("Fix sessions page Playwright flake");
+    listener = startTaskAutoTitleListener({ env: {}, generate });
+
+    const taskId = await createTaskAndAwaitEvent(LONG_TASK);
+    await listener.idle();
+
+    expect(seen).toEqual([LONG_TASK]);
+    expect((await getTaskById(taskId))?.title).toBe("Fix sessions page Playwright flake");
+  });
+
+  test("keeps a title a person set while the model was running", async () => {
+    let release: () => void = () => {};
+    const gate = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const generate: Generate = async () => {
+      await gate;
+      return { ok: true, title: "Model title", model: "test/model", kind: "openrouter" };
+    };
+    listener = startTaskAutoTitleListener({ env: {}, generate });
+
+    const taskId = await createTaskAndAwaitEvent(LONG_TASK);
+    await updateTaskTitle(taskId, "Human title");
+    release();
+    await listener.idle();
+
+    expect((await getTaskById(taskId))?.title).toBe("Human title");
+  });
+
+  test("leaves the task untouched when generation fails", async () => {
+    const { generate, seen } = generator(null);
+    listener = startTaskAutoTitleListener({ env: {}, generate });
+
+    const taskId = await createTaskAndAwaitEvent(LONG_TASK);
+    await listener.idle();
+
+    expect(seen.length).toBe(1);
+    expect((await getTaskById(taskId))?.title).toBeUndefined();
+  });
+
+  test("does nothing when TASK_AUTO_TITLE_ENABLED is false", async () => {
+    const { generate, seen } = generator("Should not land");
+    listener = startTaskAutoTitleListener({ env: { TASK_AUTO_TITLE_ENABLED: "false" }, generate });
+
+    const taskId = await createTaskAndAwaitEvent(LONG_TASK);
+    await listener.idle();
+
+    expect(seen).toEqual([]);
+    expect((await getTaskById(taskId))?.title).toBeUndefined();
+  });
+
+  test("stop() detaches from the event bus", async () => {
+    const { generate, seen } = generator("Late title");
+    const handle = startTaskAutoTitleListener({ env: {}, generate });
+    handle.stop();
+
+    await createTaskAndAwaitEvent(LONG_TASK);
+    await handle.idle();
+    expect(seen).toEqual([]);
+  });
+});