@desplega.ai/agent-swarm 1.20.0 → 1.49.0

package/src/tests/context-versioning.test.ts

@@ -0,0 +1,425 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createContextVersion,
+  getContextVersion,
+  getContextVersionHistory,
+  getLatestContextVersion,
+  initDb,
+  updateAgentProfile,
+} from "../be/db";
+
+const TEST_DB_PATH = "./test-context-versioning.sqlite";
+
+function sha256(content: string): string {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(content);
+  return hasher.digest("hex");
+}
+
+describe("Context Versioning", () => {
+  const leadId = "aaaa0000-0000-4000-8000-000000000001";
+  const workerId = "bbbb0000-0000-4000-8000-000000000002";
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {
+        // File doesn't exist
+      }
+    }
+
+    initDb(TEST_DB_PATH);
+
+    createAgent({ id: leadId, name: "Test Lead", isLead: true, status: "idle" });
+    createAgent({ id: workerId, name: "Test Worker", isLead: false, status: "idle" });
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {
+        // File doesn't exist
+      }
+    }
+  });
+
+  // ============================================================================
+  // createContextVersion + getContextVersion
+  // ============================================================================
+
+  describe("createContextVersion", () => {
+    test("creates a version and returns it with all fields", () => {
+      const version = createContextVersion({
+        agentId: workerId,
+        field: "soulMd",
+        content: "# Soul v1\nI am a test agent.",
+        version: 1,
+        changeSource: "system",
+        contentHash: sha256("# Soul v1\nI am a test agent."),
+      });
+
+      expect(version.id).toBeTruthy();
+      expect(version.agentId).toBe(workerId);
+      expect(version.field).toBe("soulMd");
+      expect(version.content).toBe("# Soul v1\nI am a test agent.");
+      expect(version.version).toBe(1);
+      expect(version.changeSource).toBe("system");
+      expect(version.changedByAgentId).toBeNull();
+      expect(version.changeReason).toBeNull();
+      expect(version.contentHash).toBe(sha256("# Soul v1\nI am a test agent."));
+      expect(version.previousVersionId).toBeNull();
+      expect(version.createdAt).toBeTruthy();
+    });
+
+    test("creates a version with optional fields populated", () => {
+      const version = createContextVersion({
+        agentId: workerId,
+        field: "identityMd",
+        content: "# Identity v1",
+        version: 1,
+        changeSource: "lead_coaching",
+        changedByAgentId: leadId,
+        changeReason: "Initial coaching",
+        contentHash: sha256("# Identity v1"),
+      });
+
+      expect(version.changedByAgentId).toBe(leadId);
+      expect(version.changeReason).toBe("Initial coaching");
+    });
+
+    test("chains versions with previousVersionId", () => {
+      const v1 = createContextVersion({
+        agentId: workerId,
+        field: "toolsMd",
+        content: "tools v1",
+        version: 1,
+        changeSource: "system",
+        contentHash: sha256("tools v1"),
+      });
+
+      const v2 = createContextVersion({
+        agentId: workerId,
+        field: "toolsMd",
+        content: "tools v2",
+        version: 2,
+        changeSource: "self_edit",
+        contentHash: sha256("tools v2"),
+        previousVersionId: v1.id,
+      });
+
+      expect(v2.previousVersionId).toBe(v1.id);
+      expect(v2.version).toBe(2);
+    });
+  });
+
+  // ============================================================================
+  // getContextVersion
+  // ============================================================================
+
+  describe("getContextVersion", () => {
+    test("returns a version by ID", () => {
+      const created = createContextVersion({
+        agentId: workerId,
+        field: "claudeMd",
+        content: "claude md content",
+        version: 1,
+        changeSource: "api",
+        contentHash: sha256("claude md content"),
+      });
+
+      const fetched = getContextVersion(created.id);
+      expect(fetched).not.toBeNull();
+      expect(fetched!.id).toBe(created.id);
+      expect(fetched!.content).toBe("claude md content");
+    });
+
+    test("returns null for non-existent ID", () => {
+      const result = getContextVersion("00000000-0000-4000-8000-999999999999");
+      expect(result).toBeNull();
+    });
+  });
+
+  // ============================================================================
+  // getLatestContextVersion
+  // ============================================================================
+
+  describe("getLatestContextVersion", () => {
+    test("returns the latest version for an agent+field", () => {
+      const content1 = `setup script v1 ${crypto.randomUUID()}`;
+      const content2 = `setup script v2 ${crypto.randomUUID()}`;
+
+      createContextVersion({
+        agentId: leadId,
+        field: "setupScript",
+        content: content1,
+        version: 1,
+        changeSource: "system",
+        contentHash: sha256(content1),
+      });
+
+      createContextVersion({
+        agentId: leadId,
+        field: "setupScript",
+        content: content2,
+        version: 2,
+        changeSource: "self_edit",
+        contentHash: sha256(content2),
+      });
+
+      const latest = getLatestContextVersion(leadId, "setupScript");
+      expect(latest).not.toBeNull();
+      expect(latest!.version).toBe(2);
+      expect(latest!.content).toBe(content2);
+    });
+
+    test("returns null when no versions exist for agent+field", () => {
+      const result = getLatestContextVersion("00000000-0000-4000-8000-999999999999", "soulMd");
+      expect(result).toBeNull();
+    });
+  });
+
+  // ============================================================================
+  // getContextVersionHistory
+  // ============================================================================
+
+  describe("getContextVersionHistory", () => {
+    const historyAgentId = "cccc0000-0000-4000-8000-000000000003";
+
+    beforeAll(() => {
+      createAgent({ id: historyAgentId, name: "History Agent", isLead: false, status: "idle" });
+
+      // Create 5 versions for soulMd
+      for (let i = 1; i <= 5; i++) {
+        const content = `soul version ${i}`;
+        createContextVersion({
+          agentId: historyAgentId,
+          field: "soulMd",
+          content,
+          version: i,
+          changeSource: i === 1 ? "system" : "self_edit",
+          contentHash: sha256(content),
+        });
+      }
+
+      // Create 2 versions for identityMd
+      for (let i = 1; i <= 2; i++) {
+        const content = `identity version ${i}`;
+        createContextVersion({
+          agentId: historyAgentId,
+          field: "identityMd",
+          content,
+          version: i,
+          changeSource: "api",
+          contentHash: sha256(content),
+        });
+      }
+    });
+
+    test("returns all versions for an agent (no field filter)", () => {
+      const history = getContextVersionHistory({ agentId: historyAgentId, limit: 50 });
+      expect(history.length).toBe(7); // 5 soulMd + 2 identityMd
+    });
+
+    test("filters by field", () => {
+      const history = getContextVersionHistory({
+        agentId: historyAgentId,
+        field: "soulMd",
+        limit: 50,
+      });
+      expect(history.length).toBe(5);
+      for (const v of history) {
+        expect(v.field).toBe("soulMd");
+      }
+    });
+
+    test("respects limit parameter", () => {
+      const history = getContextVersionHistory({
+        agentId: historyAgentId,
+        field: "soulMd",
+        limit: 3,
+      });
+      expect(history.length).toBe(3);
+      // Should be latest first (DESC order)
+      expect(history[0]!.version).toBe(5);
+      expect(history[1]!.version).toBe(4);
+      expect(history[2]!.version).toBe(3);
+    });
+
+    test("defaults limit to 10", () => {
+      const history = getContextVersionHistory({ agentId: historyAgentId });
+      expect(history.length).toBe(7); // Only 7 versions exist, so all returned
+    });
+
+    test("returns empty array for agent with no versions", () => {
+      const history = getContextVersionHistory({
+        agentId: "00000000-0000-4000-8000-999999999999",
+      });
+      expect(history).toEqual([]);
+    });
+  });
+
+  // ============================================================================
+  // updateAgentProfile — SHA-256 content hash dedup
+  // ============================================================================
+
+  describe("updateAgentProfile with versioning", () => {
+    const dedupAgentId = "dddd0000-0000-4000-8000-000000000004";
+
+    beforeAll(() => {
+      createAgent({ id: dedupAgentId, name: "Dedup Agent", isLead: false, status: "idle" });
+    });
+
+    test("creates a version when content changes", () => {
+      updateAgentProfile(dedupAgentId, { soulMd: "soul content A" }, { changeSource: "api" });
+
+      const latest = getLatestContextVersion(dedupAgentId, "soulMd");
+      expect(latest).not.toBeNull();
+      expect(latest!.content).toBe("soul content A");
+      expect(latest!.version).toBe(1);
+      expect(latest!.changeSource).toBe("api");
+    });
+
+    test("creates a new version when content changes again", () => {
+      updateAgentProfile(
+        dedupAgentId,
+        { soulMd: "soul content B" },
+        { changeSource: "self_edit", changedByAgentId: dedupAgentId },
+      );
+
+      const latest = getLatestContextVersion(dedupAgentId, "soulMd");
+      expect(latest).not.toBeNull();
+      expect(latest!.content).toBe("soul content B");
+      expect(latest!.version).toBe(2);
+      expect(latest!.changeSource).toBe("self_edit");
+      expect(latest!.changedByAgentId).toBe(dedupAgentId);
+    });
+
+    test("skips version creation when content is unchanged (dedup)", () => {
+      // Update with the same content
+      updateAgentProfile(
+        dedupAgentId,
+        { soulMd: "soul content B" },
+        { changeSource: "session_sync" },
+      );
+
+      const latest = getLatestContextVersion(dedupAgentId, "soulMd");
+      expect(latest).not.toBeNull();
+      // Version should still be 2 — no new version created
+      expect(latest!.version).toBe(2);
+      expect(latest!.changeSource).toBe("self_edit"); // unchanged from before
+    });
+
+    test("creates versions for multiple fields in one update", () => {
+      updateAgentProfile(
+        dedupAgentId,
+        {
+          identityMd: "identity content",
+          toolsMd: "tools content",
+        },
+        { changeSource: "api" },
+      );
+
+      const identityLatest = getLatestContextVersion(dedupAgentId, "identityMd");
+      const toolsLatest = getLatestContextVersion(dedupAgentId, "toolsMd");
+
+      expect(identityLatest).not.toBeNull();
+      expect(identityLatest!.content).toBe("identity content");
+      expect(identityLatest!.version).toBe(1);
+
+      expect(toolsLatest).not.toBeNull();
+      expect(toolsLatest!.content).toBe("tools content");
+      expect(toolsLatest!.version).toBe(1);
+    });
+
+    test("defaults changeSource to 'api' when no meta provided", () => {
+      updateAgentProfile(dedupAgentId, { claudeMd: "claude content" });
+
+      const latest = getLatestContextVersion(dedupAgentId, "claudeMd");
+      expect(latest).not.toBeNull();
+      expect(latest!.changeSource).toBe("api");
+    });
+
+    test("chains previousVersionId correctly", () => {
+      // soulMd already has v1 and v2, create v3
+      updateAgentProfile(dedupAgentId, { soulMd: "soul content C" }, { changeSource: "self_edit" });
+
+      const v3 = getLatestContextVersion(dedupAgentId, "soulMd");
+      expect(v3).not.toBeNull();
+      expect(v3!.version).toBe(3);
+      expect(v3!.previousVersionId).not.toBeNull();
+
+      // The previous version should be v2
+      const v2 = getContextVersion(v3!.previousVersionId!);
+      expect(v2).not.toBeNull();
+      expect(v2!.version).toBe(2);
+    });
+
+    test("returns updated agent even with versioning", () => {
+      const agent = updateAgentProfile(
+        dedupAgentId,
+        { soulMd: "soul content D" },
+        { changeSource: "api" },
+      );
+
+      expect(agent).not.toBeNull();
+      expect(agent!.soulMd).toBe("soul content D");
+      expect(agent!.id).toBe(dedupAgentId);
+    });
+  });
+
+  // ============================================================================
+  // Backfill / seed logic
+  // ============================================================================
+
+  describe("seedContextVersions (via initDb)", () => {
+    // seedContextVersions runs automatically during initDb.
+    // The worker and lead agents created in beforeAll had no soulMd/identityMd,
+    // so no versions should have been seeded for them.
+    // Test by creating an agent with content and re-running initDb (which re-seeds).
+
+    test("agents without content fields get no seeded versions", () => {
+      // workerId was created without any soulMd/identityMd content
+      // So no auto-seeded versions should exist for fields that were null
+      const history = getContextVersionHistory({
+        agentId: leadId,
+        field: "soulMd",
+        limit: 50,
+      });
+      // Lead agent had no soulMd at creation time, so no seeded version
+      // (any versions would be from explicit test calls)
+      // We can't test seeding directly since it ran at initDb time with empty agents
+      // But we verify the function doesn't crash on agents with null fields
+      expect(history).toBeInstanceOf(Array);
+    });
+  });
+
+  // ============================================================================
+  // Content hash consistency
+  // ============================================================================
+
+  describe("content hash consistency", () => {
+    test("same content produces same hash", () => {
+      const hash1 = sha256("hello world");
+      const hash2 = sha256("hello world");
+      expect(hash1).toBe(hash2);
+    });
+
+    test("different content produces different hash", () => {
+      const hash1 = sha256("hello world");
+      const hash2 = sha256("hello world!");
+      expect(hash1).not.toBe(hash2);
+    });
+
+    test("empty string has a valid hash", () => {
+      const hash = sha256("");
+      expect(hash).toBeTruthy();
+      expect(hash.length).toBe(64); // SHA-256 hex = 64 chars
+    });
+  });
+});

package/src/tests/db-queries-oauth.test.ts

@@ -0,0 +1,197 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, initDb } from "../be/db";
+import {
+  deleteOAuthTokens,
+  getOAuthApp,
+  getOAuthTokens,
+  isTokenExpiringSoon,
+  storeOAuthTokens,
+  upsertOAuthApp,
+} from "../be/db-queries/oauth";
+
+const TEST_DB_PATH = "./test-db-queries-oauth.sqlite";
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  await unlink(TEST_DB_PATH).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+});
+
+describe("OAuth Apps CRUD", () => {
+  test("getOAuthApp returns null for unknown provider", () => {
+    const result = getOAuthApp("nonexistent");
+    expect(result).toBeNull();
+  });
+
+  test("upsertOAuthApp creates a new app", () => {
+    upsertOAuthApp("test-provider", {
+      clientId: "client-123",
+      clientSecret: "secret-456",
+      authorizeUrl: "https://example.com/authorize",
+      tokenUrl: "https://example.com/token",
+      redirectUri: "https://example.com/callback",
+      scopes: "read,write",
+    });
+
+    const app = getOAuthApp("test-provider");
+    expect(app).not.toBeNull();
+    expect(app!.provider).toBe("test-provider");
+    expect(app!.clientId).toBe("client-123");
+    expect(app!.clientSecret).toBe("secret-456");
+    expect(app!.authorizeUrl).toBe("https://example.com/authorize");
+    expect(app!.tokenUrl).toBe("https://example.com/token");
+    expect(app!.redirectUri).toBe("https://example.com/callback");
+    expect(app!.scopes).toBe("read,write");
+    expect(app!.metadata).toBe("{}");
+  });
+
+  test("upsertOAuthApp updates existing app on conflict", () => {
+    upsertOAuthApp("test-provider", {
+      clientId: "client-updated",
+      clientSecret: "secret-updated",
+      authorizeUrl: "https://example.com/authorize-v2",
+      tokenUrl: "https://example.com/token-v2",
+      redirectUri: "https://example.com/callback-v2",
+      scopes: "read,write,admin",
+      metadata: '{"key": "value"}',
+    });
+
+    const app = getOAuthApp("test-provider");
+    expect(app).not.toBeNull();
+    expect(app!.clientId).toBe("client-updated");
+    expect(app!.scopes).toBe("read,write,admin");
+    expect(app!.metadata).toBe('{"key": "value"}');
+  });
+
+  test("multiple providers can coexist", () => {
+    upsertOAuthApp("provider-a", {
+      clientId: "a-client",
+      clientSecret: "a-secret",
+      authorizeUrl: "https://a.com/authorize",
+      tokenUrl: "https://a.com/token",
+      redirectUri: "https://a.com/callback",
+      scopes: "read",
+    });
+    upsertOAuthApp("provider-b", {
+      clientId: "b-client",
+      clientSecret: "b-secret",
+      authorizeUrl: "https://b.com/authorize",
+      tokenUrl: "https://b.com/token",
+      redirectUri: "https://b.com/callback",
+      scopes: "write",
+    });
+
+    const a = getOAuthApp("provider-a");
+    const b = getOAuthApp("provider-b");
+    expect(a!.clientId).toBe("a-client");
+    expect(b!.clientId).toBe("b-client");
+  });
+});
+
+describe("OAuth Tokens CRUD", () => {
+  test("getOAuthTokens returns null for unknown provider", () => {
+    const result = getOAuthTokens("nonexistent-tokens");
+    expect(result).toBeNull();
+  });
+
+  test("storeOAuthTokens creates tokens", () => {
+    // Need an oauth_app first (FK constraint)
+    upsertOAuthApp("token-test", {
+      clientId: "c",
+      clientSecret: "s",
+      authorizeUrl: "https://x.com/auth",
+      tokenUrl: "https://x.com/token",
+      redirectUri: "https://x.com/cb",
+      scopes: "read",
+    });
+
+    const futureDate = new Date(Date.now() + 3600000).toISOString();
+    storeOAuthTokens("token-test", {
+      accessToken: "access-abc",
+      refreshToken: "refresh-xyz",
+      expiresAt: futureDate,
+      scope: "read,write",
+    });
+
+    const tokens = getOAuthTokens("token-test");
+    expect(tokens).not.toBeNull();
+    expect(tokens!.provider).toBe("token-test");
+    expect(tokens!.accessToken).toBe("access-abc");
+    expect(tokens!.refreshToken).toBe("refresh-xyz");
+    expect(tokens!.scope).toBe("read,write");
+  });
+
+  test("storeOAuthTokens updates existing tokens (upsert)", () => {
+    const futureDate = new Date(Date.now() + 7200000).toISOString();
+    storeOAuthTokens("token-test", {
+      accessToken: "access-updated",
+      expiresAt: futureDate,
+    });
+
+    const tokens = getOAuthTokens("token-test");
+    expect(tokens!.accessToken).toBe("access-updated");
+    // refreshToken should be preserved (COALESCE)
+    expect(tokens!.refreshToken).toBe("refresh-xyz");
+  });
+
+  test("deleteOAuthTokens removes tokens", () => {
+    deleteOAuthTokens("token-test");
+    const tokens = getOAuthTokens("token-test");
+    expect(tokens).toBeNull();
+  });
+});
+
+describe("isTokenExpiringSoon", () => {
+  test("returns true when no tokens exist", () => {
+    expect(isTokenExpiringSoon("nonexistent")).toBe(true);
+  });
+
+  test("returns false for tokens expiring far in the future", () => {
+    upsertOAuthApp("expiry-test", {
+      clientId: "c",
+      clientSecret: "s",
+      authorizeUrl: "https://x.com/auth",
+      tokenUrl: "https://x.com/token",
+      redirectUri: "https://x.com/cb",
+      scopes: "read",
+    });
+
+    const farFuture = new Date(Date.now() + 24 * 3600000).toISOString();
+    storeOAuthTokens("expiry-test", {
+      accessToken: "a",
+      expiresAt: farFuture,
+    });
+
+    expect(isTokenExpiringSoon("expiry-test")).toBe(false);
+  });
+
+  test("returns true for tokens expiring within buffer", () => {
+    const almostExpired = new Date(Date.now() + 60000).toISOString(); // 1 minute from now
+    storeOAuthTokens("expiry-test", {
+      accessToken: "a",
+      expiresAt: almostExpired,
+    });
+
+    // Default buffer is 5 minutes, token expires in 1 minute → expiring soon
+    expect(isTokenExpiringSoon("expiry-test")).toBe(true);
+  });
+
+  test("respects custom buffer", () => {
+    const twoMinutes = new Date(Date.now() + 120000).toISOString();
+    storeOAuthTokens("expiry-test", {
+      accessToken: "a",
+      expiresAt: twoMinutes,
+    });
+
+    // With 1-minute buffer, 2-minute token is fine
+    expect(isTokenExpiringSoon("expiry-test", 60000)).toBe(false);
+    // With 3-minute buffer, 2-minute token is expiring soon
+    expect(isTokenExpiringSoon("expiry-test", 180000)).toBe(true);
+  });
+});