@desplega.ai/agent-swarm 1.164.1 → 1.166.0

package/src/tests/heartbeat-checklist.test.ts

@@ -242,6 +242,28 @@ describe("Heartbeat Checklist", () => {
       expect(tasks.length).toBe(1);
     });
 
+    test("dedup: superseded heartbeat-checklist does not block a new task", async () => {
+      const lead = await createAgent({ name: "lead", isLead: true, status: "idle" });
+      await updateAgentProfile(lead.id, { heartbeatMd: "- Check tasks\n" });
+      await checkHeartbeatChecklist();
+      const previous = await getDbClient().get<{ id: string }>(
+        "SELECT id FROM agent_tasks WHERE taskType = 'heartbeat-checklist'",
+      );
+      expect(previous).toBeDefined();
+      await getDbClient().run("UPDATE agent_tasks SET status = 'superseded' WHERE id = ?", [
+        previous!.id,
+      ]);
+
+      await checkHeartbeatChecklist();
+
+      const tasks = await getDbClient().query<{ id: string; status: string }>(
+        "SELECT id, status FROM agent_tasks WHERE taskType = 'heartbeat-checklist'",
+      );
+      expect(tasks).toHaveLength(2);
+      expect(tasks.find((task) => task.id === previous!.id)?.status).toBe("superseded");
+      expect(tasks.find((task) => task.id !== previous!.id)?.status).toBe("pending");
+    });
+
     test("created task includes system status with [auto-generated] labels", async () => {
       const lead = await createAgent({ name: "lead", isLead: true, status: "idle" });
       await updateAgentProfile(lead.id, {
@@ -427,6 +449,28 @@ describe("Heartbeat Checklist", () => {
       expect(tasks.length).toBe(1);
     });
 
+    test("dedup: superseded boot-triage does not block a new task", async () => {
+      const lead = await createAgent({ name: "lead", isLead: true, status: "idle" });
+      await updateAgentProfile(lead.id, { heartbeatMd: "- Check tasks\n" });
+      await createBootTriageTask();
+      const previous = await getDbClient().get<{ id: string }>(
+        "SELECT id FROM agent_tasks WHERE taskType = 'boot-triage'",
+      );
+      expect(previous).toBeDefined();
+      await getDbClient().run("UPDATE agent_tasks SET status = 'superseded' WHERE id = ?", [
+        previous!.id,
+      ]);
+
+      await createBootTriageTask();
+
+      const tasks = await getDbClient().query<{ id: string; status: string }>(
+        "SELECT id, status FROM agent_tasks WHERE taskType = 'boot-triage'",
+      );
+      expect(tasks).toHaveLength(2);
+      expect(tasks.find((task) => task.id === previous!.id)?.status).toBe("superseded");
+      expect(tasks.find((task) => task.id !== previous!.id)?.status).toBe("pending");
+    });
+
     test("boot-triage has correct tags", async () => {
       await createAgent({ name: "lead", isLead: true, status: "idle" });
 

package/src/tests/integration-disable-flags.test.ts

@@ -0,0 +1,156 @@
+/**
+ * Integration `*_DISABLE` flags parse identically via the shared env-flag
+ * parser (issue #1939).
+ *
+ * GITHUB_DISABLE, JIRA_DISABLE, LINEAR_DISABLE, AGENTMAIL_DISABLE and
+ * SLACK_DISABLE used to hand-roll `value === "true" || value === "1"`,
+ * silently ignoring "TRUE", "True" or " 1 " — while the config validator
+ * and `isEnvFlagEnabled` (already used by GITLAB_DISABLE /
+ * AZURE_DEVOPS_DISABLE) accept any case. Every read now goes through
+ * `isEnvFlagEnabled`, so these tests pin the shared-parser behavior at
+ * each integration's entry point.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { initAgentMail, isAgentMailEnabled, resetAgentMail } from "../agentmail/app";
+import { initGitHub, isGitHubEnabled, resetGitHub } from "../github/app";
+import { isJiraEnabled, resetJira } from "../jira/app";
+import { isLinearEnabled, resetLinear } from "../linear/app";
+import { getSlackConfiguration } from "../slack/config";
+
+const ENV_KEYS = [
+  "GITHUB_DISABLE",
+  "GITHUB_WEBHOOK_SECRET",
+  "JIRA_DISABLE",
+  "JIRA_CLIENT_ID",
+  "LINEAR_DISABLE",
+  "LINEAR_CLIENT_ID",
+  "AGENTMAIL_DISABLE",
+  "AGENTMAIL_WEBHOOK_SECRET",
+] as const;
+const originalEnv = new Map(ENV_KEYS.map((key) => [key, process.env[key]]));
+
+// Spellings the hand-rolled `=== "true" || === "1"` checks used to ignore.
+const TRUTHY_SPELLINGS = ["true", "TRUE", "True", "1", " 1 ", " True "];
+// Everything that must NOT disable the integration.
+const NON_DISABLING = ["false", "FALSE", "0", " 0 ", "", undefined];
+
+beforeEach(() => {
+  for (const key of ENV_KEYS) delete process.env[key];
+});
+
+afterEach(() => {
+  resetGitHub();
+  resetAgentMail();
+  resetJira();
+  resetLinear();
+  for (const key of ENV_KEYS) {
+    const value = originalEnv.get(key);
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+});
+
+describe("GitHub GITHUB_DISABLE", () => {
+  test("every truthy spelling disables the integration", () => {
+    process.env.GITHUB_WEBHOOK_SECRET = "secret";
+    for (const spelling of TRUTHY_SPELLINGS) {
+      process.env.GITHUB_DISABLE = spelling;
+      expect(isGitHubEnabled()).toBe(false);
+    }
+  });
+
+  test("non-disabling values keep the integration enabled", () => {
+    process.env.GITHUB_WEBHOOK_SECRET = "secret";
+    for (const value of NON_DISABLING) {
+      if (value === undefined) delete process.env.GITHUB_DISABLE;
+      else process.env.GITHUB_DISABLE = value;
+      expect(isGitHubEnabled()).toBe(true);
+    }
+  });
+
+  test("initGitHub honors TRUE even with credentials configured", () => {
+    process.env.GITHUB_WEBHOOK_SECRET = "secret";
+    process.env.GITHUB_DISABLE = "TRUE";
+    resetGitHub();
+    expect(initGitHub()).toBe(false);
+  });
+});
+
+describe("Jira JIRA_DISABLE", () => {
+  test("every truthy spelling disables the integration", () => {
+    process.env.JIRA_CLIENT_ID = "client-id";
+    for (const spelling of TRUTHY_SPELLINGS) {
+      process.env.JIRA_DISABLE = spelling;
+      expect(isJiraEnabled()).toBe(false);
+    }
+  });
+
+  test("non-disabling values keep the integration enabled", () => {
+    process.env.JIRA_CLIENT_ID = "client-id";
+    for (const value of NON_DISABLING) {
+      if (value === undefined) delete process.env.JIRA_DISABLE;
+      else process.env.JIRA_DISABLE = value;
+      expect(isJiraEnabled()).toBe(true);
+    }
+  });
+});
+
+describe("Linear LINEAR_DISABLE", () => {
+  test("every truthy spelling disables the integration", () => {
+    process.env.LINEAR_CLIENT_ID = "client-id";
+    for (const spelling of TRUTHY_SPELLINGS) {
+      process.env.LINEAR_DISABLE = spelling;
+      expect(isLinearEnabled()).toBe(false);
+    }
+  });
+
+  test("non-disabling values keep the integration enabled", () => {
+    process.env.LINEAR_CLIENT_ID = "client-id";
+    for (const value of NON_DISABLING) {
+      if (value === undefined) delete process.env.LINEAR_DISABLE;
+      else process.env.LINEAR_DISABLE = value;
+      expect(isLinearEnabled()).toBe(true);
+    }
+  });
+});
+
+describe("AgentMail AGENTMAIL_DISABLE", () => {
+  test("every truthy spelling disables the integration", () => {
+    process.env.AGENTMAIL_WEBHOOK_SECRET = "secret";
+    for (const spelling of TRUTHY_SPELLINGS) {
+      process.env.AGENTMAIL_DISABLE = spelling;
+      expect(isAgentMailEnabled()).toBe(false);
+    }
+  });
+
+  test("non-disabling values keep the integration enabled", () => {
+    process.env.AGENTMAIL_WEBHOOK_SECRET = "secret";
+    for (const value of NON_DISABLING) {
+      if (value === undefined) delete process.env.AGENTMAIL_DISABLE;
+      else process.env.AGENTMAIL_DISABLE = value;
+      expect(isAgentMailEnabled()).toBe(true);
+    }
+  });
+
+  test("initAgentMail honors TRUE even with credentials configured", () => {
+    process.env.AGENTMAIL_WEBHOOK_SECRET = "secret";
+    process.env.AGENTMAIL_DISABLE = "TRUE";
+    resetAgentMail();
+    expect(initAgentMail()).toBe(false);
+  });
+});
+
+describe("Slack SLACK_DISABLE", () => {
+  test("every truthy spelling reports disabled", () => {
+    for (const spelling of TRUTHY_SPELLINGS) {
+      expect(getSlackConfiguration({ SLACK_DISABLE: spelling }).disabled).toBe(true);
+    }
+  });
+
+  test("non-disabling values report enabled", () => {
+    for (const value of NON_DISABLING) {
+      const env = value === undefined ? {} : { SLACK_DISABLE: value };
+      expect(getSlackConfiguration(env).disabled).toBe(false);
+    }
+  });
+});

package/src/tests/kv-http.test.ts

@@ -246,6 +246,40 @@ describe("/api/kv REST — explicit namespace shape", () => {
     expect((await get.json()).value).toBe("hi");
   });
 
+  test("GET with path/offset/limit returns a view of a JSON string value", async () => {
+    const ns = "swarm:test:view";
+    const stored = JSON.stringify({ outcome: { data: { rows: [10, 11, 12, 13, 14] } } });
+    const put = await authedFetch(`/api/kv/_/${encodeURIComponent(ns)}/spill`, {
+      method: "PUT",
+      body: JSON.stringify({ value: stored, valueType: "string" }),
+      agentId,
+    });
+    expect(put.status).toBe(200);
+    const base = `/api/kv/_/${encodeURIComponent(ns)}/spill`;
+
+    const page = await authedFetch(`${base}?path=outcome.data.rows&offset=1&limit=2`, { agentId });
+    expect(page.status).toBe(200);
+    const body = await page.json();
+    expect(body.value).toEqual([11, 12]);
+    expect(body.view).toEqual({
+      path: "outcome.data.rows",
+      type: "array",
+      total: 5,
+      offset: 1,
+      returned: 2,
+      nextOffset: 3,
+    });
+
+    const whole = await authedFetch(base, { agentId });
+    const wholeBody = await whole.json();
+    expect(wholeBody.value).toBe(stored);
+    expect(wholeBody).not.toHaveProperty("view");
+
+    const missing = await authedFetch(`${base}?path=outcome.nope`, { agentId });
+    expect(missing.status).toBe(400);
+    expect((await missing.json()).error).toContain('no key "nope"');
+  });
+
   test("list with explicit namespace", async () => {
     const ns = "swarm:test:explicit-list";
     await authedFetch(`/api/kv/_/${encodeURIComponent(ns)}/k`, {

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

@@ -15,6 +15,7 @@ import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:tes
 import { unlink } from "node:fs/promises";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { closeDb, createAgent, getDbClient, initDb } from "../be/db";
+import { summarizeKvShape } from "../kv-view";
 import {
   registerKvDeleteTool,
   registerKvGetTool,
@@ -22,7 +23,12 @@ import {
   registerKvListTool,
   registerKvSetTool,
 } from "../tools/kv";
-import { finalizeSwarmToolResult, mcpOverflowNamespace } from "../tools/utils";
+import {
+  finalizeSwarmToolResult,
+  MCP_RESULT_WIRE_LIMIT_BYTES,
+  mcpOverflowNamespace,
+  wireChannelBytes,
+} from "../tools/utils";
 
 const TEST_DB_PATH = "./test-kv-tool.sqlite";
 
@@ -172,6 +178,273 @@ describe("kv MCP tools", () => {
     expect(intruderList.structuredContent.entries).toBeUndefined();
   });
 
+  type ViewResult = {
+    content: Array<{ type: string; text: string }>;
+    structuredContent: {
+      success: boolean;
+      message: string;
+      details?: string;
+      entry?: { value?: unknown; key?: string };
+      view?: {
+        path: string;
+        type: string;
+        total?: number;
+        offset?: number;
+        returned?: number;
+        nextOffset?: number | null;
+      };
+    };
+  };
+
+  test("kv-get path/offset/limit follows the spill hint to a bounded, pageable slice", async () => {
+    const tools = buildServer();
+    const rows = Array.from({ length: 400 }, (_, id) => ({ id, note: "r".repeat(100) }));
+    const spill = await finalizeSwarmToolResult(
+      "script-run",
+      {
+        ok: true,
+        message: "Script run completed.",
+        details: `result:\n${JSON.stringify({ rows }, null, 2)}`,
+        data: { status: 200, data: { result: { rows } } },
+      },
+      { agentId: agentA },
+    );
+    const truncation = (
+      spill.structuredContent as {
+        truncation: { retrieval: string; shape: Array<{ path: string; items?: number }> };
+      }
+    ).truncation;
+    expect(truncation.shape).toContainEqual(
+      expect.objectContaining({ path: "outcome.data.data.result.rows", type: "array", items: 400 }),
+    );
+    // The hint is a literal, copy-pasteable call.
+    const hinted = JSON.parse(
+      truncation.retrieval.slice("kv-get(".length, truncation.retrieval.indexOf(") returns")),
+    ) as { namespace: string; key: string; path: string; offset: number };
+    expect(hinted.path).toBe("outcome.data.data.result.rows");
+
+    const first = (await tools.get.handler(hinted, meta(agentA))) as ViewResult;
+    const view = first.structuredContent.view!;
+    expect(first.structuredContent.success).toBe(true);
+    expect(view).toMatchObject({
+      path: "outcome.data.data.result.rows",
+      type: "array",
+      total: 400,
+    });
+    expect(view.returned).toBeGreaterThan(0);
+    expect(view.returned).toBeLessThan(400);
+    expect(view.nextOffset).toBe(view.returned);
+    expect(JSON.parse(first.structuredContent.details!)).toEqual(rows.slice(0, view.returned));
+    expect(first.structuredContent.entry).not.toHaveProperty("value");
+    expect(first.structuredContent.message).toContain("continue at view.nextOffset");
+    expect(wireChannelBytes(first)).toBeLessThanOrEqual(MCP_RESULT_WIRE_LIMIT_BYTES);
+
+    const next = (await tools.get.handler(
+      { ...hinted, offset: view.nextOffset!, limit: 5 },
+      meta(agentA),
+    )) as ViewResult;
+    expect(next.structuredContent.view).toMatchObject({ offset: view.nextOffset, returned: 5 });
+    expect(JSON.parse(next.structuredContent.details!)).toEqual(
+      rows.slice(view.nextOffset!, view.nextOffset! + 5),
+    );
+
+    const pastEnd = (await tools.get.handler(
+      { ...hinted, offset: 10_000 },
+      meta(agentA),
+    )) as ViewResult;
+    expect(pastEnd.structuredContent.success).toBe(true);
+    expect(pastEnd.structuredContent.view).toMatchObject({
+      total: 400,
+      returned: 0,
+      nextOffset: null,
+    });
+    expect(pastEnd.structuredContent.details).toBe("[]");
+
+    const missing = (await tools.get.handler(
+      { ...hinted, path: "outcome.data.nope" },
+      meta(agentA),
+    )) as ViewResult;
+    expect(missing.structuredContent.success).toBe(false);
+    expect(missing.structuredContent.message).toContain('no key "nope" under "outcome.data"');
+
+    const badIndex = (await tools.get.handler(
+      { ...hinted, path: "outcome.data.data.result.rows.400" },
+      meta(agentA),
+    )) as ViewResult;
+    expect(badIndex.structuredContent.success).toBe(false);
+    expect(badIndex.structuredContent.message).toContain("array of 400");
+
+    const oneRow = (await tools.get.handler(
+      { ...hinted, path: "outcome.data.data.result.rows.7" },
+      meta(agentA),
+    )) as ViewResult;
+    expect(JSON.parse(oneRow.structuredContent.details!)).toEqual(rows[7]);
+  });
+
+  test("a wide-object spill hint pages the parent of its scalar leaves", async () => {
+    const tools = buildServer();
+    const wide = Object.fromEntries(
+      Array.from({ length: 2_000 }, (_, i) => [`k${i}`, 1_000_000_000.5 + i]),
+    );
+    const spill = await finalizeSwarmToolResult(
+      "wide-tool",
+      { ok: true, message: "Done.", data: wide },
+      { agentId: agentA },
+    );
+    const { retrieval, shape } = (
+      spill.structuredContent as {
+        truncation: { retrieval: string; shape: Array<{ path: string; type: string }> };
+      }
+    ).truncation;
+    expect(shape[0]).toMatchObject({ type: "number" });
+    const hinted = JSON.parse(retrieval.slice("kv-get(".length, retrieval.indexOf(") returns")));
+    expect(hinted).toMatchObject({ path: "outcome.data", offset: 0 });
+
+    const page = (await tools.get.handler(hinted, meta(agentA))) as ViewResult;
+    expect(page.structuredContent.success).toBe(true);
+    expect(page.structuredContent.view).toMatchObject({ type: "object", total: 2_000 });
+    expect(page.structuredContent.view!.returned).toBeGreaterThan(0);
+  });
+
+  test("kv-get view on a plain string pages characters and rejects a JSON path", async () => {
+    const tools = buildServer();
+    await tools.set.handler(
+      { key: "plain", value: "hello world, not json", valueType: "string" },
+      meta(agentA),
+    );
+    const chars = (await tools.get.handler(
+      { key: "plain", offset: 6, limit: 5 },
+      meta(agentA),
+    )) as ViewResult;
+    expect(chars.structuredContent.success).toBe(true);
+    expect(chars.structuredContent.details).toBe('"world"');
+    expect(chars.structuredContent.view).toMatchObject({
+      type: "string",
+      total: 21,
+      returned: 5,
+      nextOffset: 11,
+    });
+
+    await tools.set.handler(
+      { key: "spaced", value: "a  \n  b", valueType: "string" },
+      meta(agentA),
+    );
+    for (const [offset, slice] of [
+      [1, "  \n  "],
+      [0, "a  "],
+    ] as const) {
+      const exact = (await tools.get.handler(
+        { key: "spaced", offset, limit: slice.length },
+        meta(agentA),
+      )) as ViewResult;
+      expect(JSON.parse(exact.structuredContent.details!)).toBe(slice);
+      expect(JSON.parse(exact.content[0]!.text.split("\n\n").at(-1)!)).toBe(slice);
+    }
+
+    const pathed = (await tools.get.handler(
+      { key: "plain", path: "a" },
+      meta(agentA),
+    )) as ViewResult;
+    expect(pathed.structuredContent.success).toBe(false);
+    expect(pathed.structuredContent.message).toContain("plain string");
+
+    await tools.set.handler({ key: "num", value: 42 }, meta(agentA));
+    const scalar = (await tools.get.handler({ key: "num", offset: 1 }, meta(agentA))) as ViewResult;
+    expect(scalar.structuredContent.success).toBe(false);
+    expect(scalar.structuredContent.message).toContain("is a number");
+  });
+
+  test("kv-get view names a narrower path when one item alone exceeds the cap", async () => {
+    const tools = buildServer();
+    await tools.set.handler(
+      { key: "fat-items", value: { items: [{ blob: "f".repeat(20_000) }, { id: 2 }] } },
+      meta(agentA),
+    );
+    const res = (await tools.get.handler(
+      { key: "fat-items", path: "items" },
+      meta(agentA),
+    )) as ViewResult;
+    expect(res.structuredContent.success).toBe(true);
+    expect(res.structuredContent.view).toMatchObject({ returned: 0, nextOffset: 0, total: 2 });
+    expect(res.structuredContent.message).toContain('narrow the path to "items.0"');
+    expect(wireChannelBytes(res)).toBeLessThanOrEqual(MCP_RESULT_WIRE_LIMIT_BYTES);
+
+    const narrowed = (await tools.get.handler(
+      { key: "fat-items", path: "items.0.blob", limit: 100 },
+      meta(agentA),
+    )) as ViewResult;
+    expect(JSON.parse(narrowed.structuredContent.details!)).toBe("f".repeat(100));
+  });
+
+  test("a shrunk kv-get page counts its note, so both channels stay within the cap", async () => {
+    const tools = buildServer();
+    const channelBytes = (res: ViewResult) => ({
+      text: Buffer.byteLength(res.content.map((part) => part.text).join(""), "utf8"),
+      structured: Buffer.byteLength(JSON.stringify(res.structuredContent), "utf8"),
+    });
+    const longKey = "k".repeat(900);
+    await tools.set.handler(
+      {
+        key: "near-cap",
+        value: {
+          text: "a".repeat(20_000),
+          rows: Array.from({ length: 400 }, (_, id) => ({ id, note: "r".repeat(100) })),
+          [longKey]: [{ blob: "f".repeat(20_000) }],
+        },
+      },
+      meta(agentA),
+    );
+    await tools.set.handler(
+      { key: "dense", value: "x".repeat(20_000), valueType: "string" },
+      meta(agentA),
+    );
+    const cases = [
+      { key: "dense", args: { offset: 0 }, note: "Page shrunk" },
+      { args: { path: "text" }, note: "Page shrunk" },
+      { args: { path: "text", offset: 3 }, note: "Page shrunk" },
+      { args: { path: "rows" }, note: "Page shrunk" },
+      { args: { path: longKey }, note: `narrow the path to "${longKey}.0"` },
+    ];
+    for (const { key = "near-cap", args, note } of cases) {
+      const res = (await tools.get.handler({ key, ...args }, meta(agentA))) as ViewResult;
+      expect(res.structuredContent.success).toBe(true);
+      expect(res.structuredContent.message).toContain(note);
+      const bytes = channelBytes(res);
+      expect(bytes.text).toBeLessThanOrEqual(MCP_RESULT_WIRE_LIMIT_BYTES);
+      expect(bytes.structured).toBeLessThanOrEqual(MCP_RESULT_WIRE_LIMIT_BYTES);
+    }
+  });
+
+  test("every spill shape path, long or empty-keyed, works as a kv-get path", async () => {
+    const tools = buildServer();
+    const rows = (n: number) =>
+      Array.from({ length: n }, (_, id) => ({ id, note: "r".repeat(60) }));
+    const longKey = "L".repeat(200);
+    const values = {
+      long: { [longKey]: rows(80), small: 1 },
+      emptyRoot: { "": rows(80), small: 1 },
+      emptyNested: { outer: { "": rows(80), side: rows(40) }, small: 1 },
+      overMax: { ["X".repeat(1_100)]: rows(80), small: 1 },
+    };
+    for (const [key, value] of Object.entries(values)) {
+      await tools.set.handler({ key, value: JSON.stringify(value) }, meta(agentA));
+      const shape = summarizeKvShape(value);
+      expect(shape.length).toBeGreaterThan(0);
+      for (const entry of shape) {
+        const res = (await tools.get.handler(
+          { key, path: entry.path, ...(entry.items === undefined ? {} : { offset: 0 }) },
+          meta(agentA),
+        )) as ViewResult;
+        expect(res.structuredContent.success).toBe(true);
+        expect(res.structuredContent.view).toMatchObject({ path: entry.path, type: entry.type });
+        if (entry.items !== undefined) {
+          expect(res.structuredContent.view!.total).toBe(entry.items);
+        }
+      }
+      if (key === "long") expect(shape[0]!.path).toBe(longKey);
+    }
+  });
+
   test("kv-incr creates + increments + reports value", async () => {
     const tools = buildServer();
     const r1 = (await tools.incr.handler({ key: "ctr", by: 5 }, meta(agentA))) as StructuredResult<{