@desplega.ai/agent-swarm 1.145.0 → 1.147.0

package/src/tests/db-agents.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, expect, spyOn, test } from "bun:test";
+import * as db from "../be/db";
+
+beforeEach(() => db.initDb(":memory:"));
+afterEach(() => db.closeDb());
+
+const worker = { name: "Worker", isLead: false, status: "idle" as const };
+
+test("facade registration installs defaults and records lifecycle logs", async () => {
+  const skill = await db.createSkill({
+    name: "test-default",
+    description: "Default",
+    content: "Instructions",
+    type: "personal",
+    scope: "swarm",
+    systemDefault: true,
+  });
+  const agent = await db.createAgent(worker);
+  expect(
+    await db.getDbClient().get("SELECT skillId FROM agent_skills WHERE agentId = ?", [agent.id]),
+  ).toEqual({ skillId: skill.id });
+  await db.updateAgentStatus(agent.id, "busy");
+  expect(
+    (await db.getLogsByAgentId(agent.id)).map(({ eventType, oldValue, newValue }) => ({
+      eventType,
+      oldValue,
+      newValue,
+    })),
+  ).toEqual(
+    expect.arrayContaining([
+      { eventType: "agent_joined", oldValue: undefined, newValue: "idle" },
+      { eventType: "agent_status_change", oldValue: "idle", newValue: "busy" },
+    ]),
+  );
+  // Logging precedes deletion, including when the existing log FK rejects deletion.
+  await db.getDbClient().run("CREATE TABLE deletion_probe (eventType TEXT, oldValue TEXT)");
+  await db
+    .getDbClient()
+    .run(
+      "CREATE TRIGGER deletion_log AFTER INSERT ON agent_log WHEN NEW.eventType = 'agent_left' BEGIN INSERT INTO deletion_probe VALUES (NEW.eventType, NEW.oldValue); END",
+    );
+  await expect(db.deleteAgent(agent.id)).rejects.toThrow("FOREIGN KEY constraint failed");
+  expect(await db.getDbClient().get("SELECT * FROM deletion_probe")).toEqual({
+    eventType: "agent_left",
+    oldValue: "busy",
+  });
+});
+
+test("skill and log failures retain the original catch boundaries", async () => {
+  await db.getDbClient().run("DROP TABLE skills");
+  await db
+    .getDbClient()
+    .run(
+      "CREATE TRIGGER reject_logs BEFORE INSERT ON agent_log BEGIN SELECT RAISE(FAIL, 'log failure'); END",
+    );
+  const warning = spyOn(console, "warn").mockImplementation(() => {});
+  try {
+    const agent = await db.createAgent(worker);
+    expect(warning).toHaveBeenCalledWith(
+      "[db] Failed to install system-default skills for new agent:",
+      expect.any(String),
+    );
+    expect((await db.updateAgentStatus(agent.id, "busy"))?.status).toBe("busy");
+    expect(await db.deleteAgent(agent.id)).toBe(true);
+  } finally {
+    warning.mockRestore();
+  }
+});
+
+test("unmoved profile and idle-worker callers share agent mapping defaults", async () => {
+  const agent = await db.createAgent(worker);
+  expect(agent).toMatchObject({
+    maxTasks: 1,
+    emptyPollCount: 0,
+    capabilities: [],
+    credentialMissing: null,
+    credStatus: null,
+    harnessProvider: null,
+    avatar: null,
+  });
+  const updated = await db.updateAgentProfile(agent.id, {
+    role: "coder",
+    capabilities: ["typescript"],
+  });
+  expect(updated).toEqual(await db.getAgentById(agent.id));
+  expect(await db.getIdleWorkersWithCapacity()).toEqual([updated!]);
+  await db
+    .getDbClient()
+    .run("UPDATE agents SET avatar = ? WHERE id = ?", ["invalid json", agent.id]);
+  expect((await db.getAgentById(agent.id))?.avatar).toBeNull();
+});

package/src/tests/db-context-versions.test.ts

@@ -0,0 +1,37 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import * as db from "../be/db";
+
+beforeEach(() => db.initDb(":memory:"));
+afterEach(() => db.closeDb());
+
+const worker = { name: "Worker", isLead: false, status: "idle" as const };
+
+test("context history keeps version ordering, limits, hashes and null defaults", async () => {
+  const agent = await db.createAgent(worker);
+  const versions = [];
+  for (const version of [2, 1, 3]) {
+    versions.push(
+      await db.createContextVersion({
+        agentId: agent.id,
+        field: "soulMd",
+        content: `v${version}`,
+        version,
+        changeSource: "system",
+        contentHash: db.computeContentHash(`v${version}`),
+      }),
+    );
+  }
+  expect(
+    (await db.getContextVersionHistory({ agentId: agent.id, field: "soulMd", limit: 2 })).map(
+      (v) => v.version,
+    ),
+  ).toEqual([3, 2]);
+  expect(await db.getLatestContextVersion(agent.id, "soulMd")).toEqual(versions[2]);
+  expect(await db.getContextVersion(versions[0]!.id)).toEqual(versions[0]!);
+  expect(versions[0]).toMatchObject({
+    changedByAgentId: null,
+    changeReason: null,
+    previousVersionId: null,
+  });
+  expect(await db.getLatestContextVersion(agent.id, "toolsMd")).toBeNull();
+});

package/src/tests/db-extraction-contract.test.ts

@@ -0,0 +1,45 @@
+import { expect, test } from "bun:test";
+import * as db from "../be/db";
+import * as agents from "../be/db/agents";
+import * as context from "../be/db/context-versions";
+import * as taskRead from "../be/db/tasks/read";
+import { CHILD_PROCESS_TEST_BUDGET_MS, expectChildOk, runChild } from "./test-proc";
+
+test("facade exposes repository bindings without internal exports", () => {
+  for (const [name, value] of Object.entries({ ...agents, ...context, ...taskRead })) {
+    if (
+      [
+        "rowToAgent",
+        "configureAgentDependencies",
+        "rowToAgentTask",
+        "rowToAgentTaskSummary",
+        "configureTaskReadDependencies",
+      ].includes(name)
+    ) {
+      expect(name in db).toBe(false);
+    } else {
+      expect((db as Record<string, unknown>)[name]).toBe(value);
+    }
+  }
+});
+
+test(
+  "fresh facade initialization does not access the database",
+  async () => {
+    const runtimePath = JSON.stringify(new URL("../be/db/runtime.ts", import.meta.url).pathname);
+    const facadePath = JSON.stringify(new URL("../be/db.ts", import.meta.url).pathname);
+    expectChildOk(
+      await runChild([process.execPath, "-"], {
+        stdin: `
+      import { spyOn } from "bun:test";
+      const runtime = await import(${runtimePath});
+      const access = spyOn(runtime, "getDbClient");
+      await import(${facadePath});
+      if (access.mock.calls.length) throw new Error("Facade initialization accessed DB client");
+    `,
+      }),
+      "facade initialization",
+    );
+  },
+  CHILD_PROCESS_TEST_BUDGET_MS,
+);

package/src/tests/db-runtime.test.ts

@@ -0,0 +1,70 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import * as facade from "../be/db";
+import * as runtime from "../be/db/runtime";
+
+const runtimeExports = [
+  "__resetSqliteVecExtensionPathCacheForTests",
+  "closeDb",
+  "getDb",
+  "getDbClient",
+  "initDb",
+  "isSqliteVecAvailable",
+  "resolveSqliteVecExtensionPath",
+] as const;
+
+afterEach(() => runtime.closeDb());
+
+describe("database runtime facade", () => {
+  test("re-exports the same seven runtime bindings", () => {
+    expect(Object.keys(runtime).sort()).toEqual([...runtimeExports].sort());
+    expect(facade.__resetSqliteVecExtensionPathCacheForTests).toBe(
+      runtime.__resetSqliteVecExtensionPathCacheForTests,
+    );
+    expect(facade.closeDb).toBe(runtime.closeDb);
+    expect(facade.getDb).toBe(runtime.getDb);
+    expect(facade.getDbClient).toBe(runtime.getDbClient);
+    expect(facade.initDb).toBe(runtime.initDb);
+    expect(facade.isSqliteVecAvailable).toBe(runtime.isSqliteVecAvailable);
+    expect(facade.resolveSqliteVecExtensionPath).toBe(runtime.resolveSqliteVecExtensionPath);
+  });
+
+  test("shares one connection and reuses the async client across close/reopen", async () => {
+    const first = runtime.initDb(":memory:");
+    expect(facade.getDb()).toBe(first);
+    expect(facade.initDb(":memory:")).toBe(first);
+    const client = facade.getDbClient();
+    expect(runtime.getDbClient()).toBe(client);
+    await client.run("CREATE TABLE runtime_probe (value TEXT)");
+    await client.run("INSERT INTO runtime_probe VALUES (?)", ["first"]);
+    expect(await client.get("SELECT value FROM runtime_probe")).toEqual({ value: "first" });
+
+    facade.closeDb();
+    expect(runtime.isSqliteVecAvailable()).toBe(false);
+    runtime.closeDb();
+    const second = facade.initDb(":memory:");
+    expect(second).not.toBe(first);
+    expect(runtime.getDb()).toBe(second);
+    expect(runtime.getDbClient()).toBe(client);
+    expect(
+      await client.get("SELECT name FROM sqlite_master WHERE name = 'runtime_probe'"),
+    ).toBeNull();
+    await client.run("CREATE TABLE runtime_probe (value TEXT)");
+    await client.run("INSERT INTO runtime_probe VALUES (?)", ["second"]);
+    expect(await client.get("SELECT value FROM runtime_probe")).toEqual({ value: "second" });
+  });
+
+  test("cold initialization still seeds templates", () => {
+    const globals = globalThis as typeof globalThis & { __testMigrationTemplate?: Uint8Array };
+    const template = globals.__testMigrationTemplate;
+    runtime.closeDb();
+    globals.__testMigrationTemplate = undefined;
+    try {
+      runtime.initDb(":memory:");
+      const templates = facade.getPromptTemplates({ scope: "global" });
+      expect(templates.length).toBeGreaterThan(0);
+    } finally {
+      runtime.closeDb();
+      globals.__testMigrationTemplate = template;
+    }
+  });
+});