@desplega.ai/agent-swarm 1.146.0 → 1.148.0

package/src/tests/fixtures/file-lock-holder.ts

@@ -0,0 +1,13 @@
+// Holds a `withFileLock` lock from a separate process: prints "locked" once it
+// has it, then keeps it for `holdMs` (or until killed).
+import { withFileLock } from "../../utils/file-lock";
+
+const [lockPath, holdMs] = process.argv.slice(2);
+const result = await withFileLock(lockPath as string, async () => {
+  console.log("locked");
+  await Bun.sleep(Number(holdMs));
+});
+if (!result.acquired) {
+  console.log(`not-acquired:${result.reason}`);
+  process.exit(1);
+}

package/src/tests/fixtures/hold-file-lock.ts

@@ -0,0 +1,25 @@
+import { withFileLock } from "../../utils/file-lock";
+
+/**
+ * Hold `lockPath` from this process (a live holder) until the returned release
+ * function is awaited. Resolves once the lock is actually held.
+ */
+export async function holdFileLock(lockPath: string): Promise<() => Promise<void>> {
+  let release!: () => void;
+  const released = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  let held!: () => void;
+  const acquired = new Promise<void>((resolve) => {
+    held = resolve;
+  });
+  const holding = withFileLock(lockPath, async () => {
+    held();
+    await released;
+  });
+  await acquired;
+  return async () => {
+    release();
+    await holding;
+  };
+}

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

@@ -0,0 +1,188 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createServer } from "node:http";
+import {
+  closeDb,
+  createAgent,
+  getAgentById,
+  getDbClient,
+  initDb,
+  updateAgentProfile,
+} from "../be/db";
+import { handleAgentsRest } from "../http/agents";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { HeartbeatExpiryError, validateHeartbeatExpiry } from "../utils/heartbeat-expiry";
+import { listenOnFreePort } from "./test-net";
+
+const section = (...lines: string[]) => `## Tracked Items\n${lines.join("\n")}\n`;
+
+describe("heartbeat expiry validation", () => {
+  test.each(["DELETE 09-30", "delete on 09-30", "DeLeTe ON 09-30"])("accepts %s", (expiry) => {
+    expect(() => validateHeartbeatExpiry("", section(`- New item. ${expiry}`))).not.toThrow();
+  });
+  test("rejects a new undated item and names it", () => {
+    expect(() => validateHeartbeatExpiry("", section("- Check the queue"))).toThrow(
+      "new tracked item requires DELETE <MM-DD> (or DELETE on <MM-DD>): Check the queue",
+    );
+  });
+  test.each([
+    "📌 Permanent rule",
+    "- 📌 Permanent rule",
+    "- [ ] 📌 Permanent rule",
+  ])("exempts pin durables: %s", (line) => {
+    expect(() => validateHeartbeatExpiry("", section(line))).not.toThrow();
+  });
+  test("does not exempt a pin in the middle of an item", () => {
+    expect(() => validateHeartbeatExpiry("", section("- Check 📌 status"))).toThrow(
+      HeartbeatExpiryError,
+    );
+  });
+  test("allows unchanged, shortened, and edited legacy items", () => {
+    const old = section(
+      "- **Queue:** Check the queue every morning and evening",
+      "- Keep this item",
+    );
+    for (const line of [
+      "- **Queue:** Check the queue every morning and evening",
+      "- **Queue:** Check the queue",
+      "- **Queue:** Inspect pending work weekly",
+    ]) {
+      expect(() => validateHeartbeatExpiry(old, section(line, "- Keep this item"))).not.toThrow();
+    }
+    expect(() =>
+      validateHeartbeatExpiry(section("- Check the queue daily"), section("- Check the queue")),
+    ).not.toThrow();
+  });
+  test("allows pure deletion, including the entire section", () => {
+    expect(() => validateHeartbeatExpiry(section("- Old undated item"), section())).not.toThrow();
+    expect(() => validateHeartbeatExpiry(section("- Old undated item"), "")).not.toThrow();
+  });
+  test("uses the last marker and excludes the marker line and later sections", () => {
+    const next =
+      "## Tracked Items\n- Earlier example\n## Tracked Items (current)\n- New. DELETE 09-30\n## Notes\nUndated notes";
+    expect(() => validateHeartbeatExpiry("", next)).not.toThrow();
+    expect(() => validateHeartbeatExpiry("", "Mention ## Tracked Items here\n- Undated")).toThrow();
+    expect(() => validateHeartbeatExpiry("", "## Tracked Items")).not.toThrow();
+    expect(() => validateHeartbeatExpiry("", "## Other\n- Undated")).not.toThrow();
+  });
+  test("does not use a token on the marker or another line", () => {
+    expect(() => validateHeartbeatExpiry("", "## Tracked Items DELETE 09-30\n- Undated")).toThrow();
+    expect(() =>
+      validateHeartbeatExpiry("", section("- Dated DELETE 09-30", "- Undated")),
+    ).toThrow();
+  });
+  test("legacy matches are one-to-one, even for reordered lines", () => {
+    const old = section("- **Old:** Keep", "- **Other:** Keep");
+    expect(() =>
+      validateHeartbeatExpiry(old, section("- **Other:** Keep", "- **Old:** Updated")),
+    ).not.toThrow();
+    expect(() =>
+      validateHeartbeatExpiry(old, section("- **Old:** Keep", "- **Old:** New")),
+    ).toThrow();
+    expect(() => validateHeartbeatExpiry(old, section("- **Unrelated:** New"))).toThrow();
+  });
+  test("condensing the middle of a legacy line passes", () => {
+    expect(() =>
+      validateHeartbeatExpiry(
+        section("- Check the large queue daily"),
+        section("- Check the queue"),
+      ),
+    ).not.toThrow();
+  });
+  test("dating a legacy item cannot authorize a second undated copy", () => {
+    for (const lines of [
+      ["- **Old:** New", "- **Old:** Updated DELETE 09-30"],
+      ["- **Old:** Updated DELETE 09-30", "- **Old:** New"],
+      ["- Legacy text DELETE 09-30", "- Legacy"],
+    ]) {
+      expect(() =>
+        validateHeartbeatExpiry(section("- **Old:** Original", "- Legacy text"), section(...lines)),
+      ).toThrow();
+    }
+  });
+  test("does not grandfather removal of a date or pin", () => {
+    expect(() =>
+      validateHeartbeatExpiry(section("- **Old:** DELETE 09-30"), section("- **Old:** Undated")),
+    ).toThrow();
+    expect(() => validateHeartbeatExpiry(section("📌 Permanent"), section("Permanent"))).toThrow();
+  });
+});
+
+const dbPath = "./test-heartbeat-expiry.sqlite";
+describe("profile persistence heartbeat gate", () => {
+  const agentId = crypto.randomUUID();
+  beforeAll(async () => {
+    initDb(dbPath);
+    await createAgent({ id: agentId, name: "Expiry test", isLead: false, status: "idle" });
+    // Seed pre-gate legacy state directly in this isolated test database.
+    await getDbClient().run("UPDATE agents SET heartbeatMd = ? WHERE id = ?", [
+      section("- **Legacy:** Old text"),
+      agentId,
+    ]);
+  });
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"])
+      await Bun.file(dbPath + suffix)
+        .delete()
+        .catch(() => {});
+  });
+  test("rejects atomically before profile or version writes", async () => {
+    const before = await getAgentById(agentId);
+    const versionsBefore = await getDbClient().query(
+      "SELECT * FROM context_versions WHERE agentId = ?",
+      [agentId],
+    );
+    await expect(
+      updateAgentProfile(agentId, {
+        description: "Must not land",
+        heartbeatMd: section("- **Legacy:** Old text", "- New undated item"),
+      }),
+    ).rejects.toThrow(HeartbeatExpiryError);
+    expect(await getAgentById(agentId)).toEqual(before);
+    expect(
+      await getDbClient().query("SELECT * FROM context_versions WHERE agentId = ?", [agentId]),
+    ).toEqual(versionsBefore);
+  });
+  test("HTTP returns 400 with the offending line", async () => {
+    const server = createServer(async (req, res) => {
+      try {
+        await handleAgentsRest(
+          req,
+          res,
+          getPathSegments(req.url ?? "/"),
+          parseQueryParams(req.url ?? "/"),
+          agentId,
+        );
+      } catch {
+        res.writeHead(500).end();
+      }
+    });
+    const port = await listenOnFreePort(server);
+    try {
+      const response = await fetch(`http://localhost:${port}/api/agents/${agentId}/profile`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ heartbeatMd: section("- New undated HTTP item") }),
+      });
+      expect(response.status).toBe(400);
+      expect((await response.json()).error).toContain("New undated HTTP item");
+    } finally {
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    }
+  });
+  test("persists edits, dated additions, pin durables, and deletions", async () => {
+    const next = section("- **Legacy:** Revised", "- Dated DELETE on 09-30", "📌 Durable");
+    expect((await updateAgentProfile(agentId, { heartbeatMd: next }))?.heartbeatMd).toBe(next);
+    expect((await updateAgentProfile(agentId, { heartbeatMd: "" }))?.heartbeatMd).toBe("");
+  });
+  test("drops a stale heartbeat before validating, preserving other updates", async () => {
+    const result = await updateAgentProfile(
+      agentId,
+      { heartbeatMd: section("- Invalid stale item"), description: "Fresh metadata" },
+      undefined,
+      { expectedHashes: { heartbeatMd: "stale" } },
+    );
+    expect(result?.heartbeatMd).toBe("");
+    expect(result?.description).toBe("Fresh metadata");
+  });
+});

package/src/tests/http-api-integration.test.ts

@@ -5,7 +5,7 @@
  * and tests every API endpoint for correct behavior.
  */
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { rm, unlink } from "node:fs/promises";
 import type { Subprocess } from "bun";
 import { Webhook } from "svix";
@@ -388,6 +388,83 @@ describe("Agents", () => {
     expect(unrelated.body.events).toHaveLength(0);
   });
 
+  test("PUT /api/agents/:id/profile — expectedHashes drops a stale field, keeps the rest", async () => {
+    const sha = (v: string) => createHash("sha256").update(v).digest("hex");
+    const base = "# CLAUDE.md\n\nbase the session materialized";
+    const seeded = await put(`/api/agents/${ids.workerAgent}/profile`, {
+      body: { claudeMd: base, changeSource: "self_edit" },
+      agentId: ids.workerAgent,
+    });
+    expect(seeded.status).toBe(200);
+
+    const reconciledClaudeMd = async () =>
+      (
+        await get(
+          `/api/events?${new URLSearchParams({
+            event: "system.profile_sync_reconciled",
+            agentId: ids.workerAgent,
+            dataField: "claudeMd",
+            limit: "100",
+          })}`,
+          { agentId: ids.workerAgent },
+        )
+      ).body.events.length as number;
+    const before = await reconciledClaudeMd();
+
+    // A copy based on something the DB already moved past: dropped, 200, and
+    // the other field of the same sync still lands.
+    const stale = await put(`/api/agents/${ids.workerAgent}/profile`, {
+      body: {
+        claudeMd: "stale copy",
+        toolsMd: "fresh tools",
+        changeSource: "session_sync",
+        expectedHashes: { claudeMd: sha("an older materialization") },
+      },
+      agentId: ids.workerAgent,
+    });
+    expect(stale.status).toBe(200);
+    expect(stale.body.claudeMd).toBe(base);
+    expect(stale.body.toolsMd).toBe("fresh tools");
+    expect(await reconciledClaudeMd()).toBe(before); // not written → not reconciled
+    const conflictEvents = await get(
+      `/api/events?${new URLSearchParams({
+        event: "system.profile_sync_conflict",
+        agentId: ids.workerAgent,
+        dataField: "claudeMd",
+        limit: "1",
+      })}`,
+      { agentId: ids.workerAgent },
+    );
+    expect(conflictEvents.body.events[0]).toMatchObject({
+      event: "system.profile_sync_conflict",
+      status: "skipped",
+      data: {
+        field: "claudeMd",
+        expectedHash: sha("an older materialization"),
+        currentHash: sha(base),
+        changeSource: "session_sync",
+      },
+    });
+
+    // An edit on top of the current value applies.
+    const edited = await put(`/api/agents/${ids.workerAgent}/profile`, {
+      body: {
+        claudeMd: "edited in session",
+        changeSource: "session_sync",
+        expectedHashes: { claudeMd: sha(base) },
+      },
+      agentId: ids.workerAgent,
+    });
+    expect(edited.status).toBe(200);
+    expect(edited.body.claudeMd).toBe("edited in session");
+
+    const malformed = await put(`/api/agents/${ids.workerAgent}/profile`, {
+      body: { claudeMd: "x", expectedHashes: { claudeMd: "not-a-sha256" } },
+      agentId: ids.workerAgent,
+    });
+    expect(malformed.status).toBe(400);
+  });
+
   test("PUT /api/agents/:id/profile — non-existent returns 404", async () => {
     const { status } = await put(`/api/agents/${randomUUID()}/profile`, {
       body: { role: "ghost" },