@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/tests/workflow-versions.test.ts

@@ -0,0 +1,208 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createWorkflow,
+  getWorkflowVersion,
+  getWorkflowVersions,
+  initDb,
+  updateWorkflow,
+} from "../be/db";
+import type { Workflow } from "../types";
+import { snapshotWorkflow } from "../workflows/version";
+
+const TEST_DB_PATH = "./test-workflow-versions.sqlite";
+
+// ─── Setup ──────────────────────────────────────────────────
+
+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(() => {});
+});
+
+// ─── Helpers ────────────────────────────────────────────────
+
+function makeWorkflow(name?: string): Workflow {
+  return createWorkflow({
+    name: name ?? `test-wf-${crypto.randomUUID().slice(0, 8)}`,
+    definition: {
+      nodes: [
+        {
+          id: "n1",
+          type: "notify",
+          config: { channel: "swarm", template: "v1" },
+        },
+      ],
+    },
+  });
+}
+
+// ─── Tests ──────────────────────────────────────────────────
+
+describe("snapshotWorkflow", () => {
+  test("creates a version snapshot with correct version number", () => {
+    const workflow = makeWorkflow();
+
+    const version = snapshotWorkflow(workflow.id);
+
+    expect(version.workflowId).toBe(workflow.id);
+    expect(version.version).toBe(1);
+    expect(version.snapshot.name).toBe(workflow.name);
+    expect(version.snapshot.definition).toEqual(workflow.definition);
+    expect(version.snapshot.triggers).toEqual([]);
+    expect(version.snapshot.enabled).toBe(true);
+    expect(version.createdAt).toBeDefined();
+  });
+
+  test("version numbers increment on successive snapshots", () => {
+    const workflow = makeWorkflow();
+
+    const v1 = snapshotWorkflow(workflow.id);
+    expect(v1.version).toBe(1);
+
+    // Update workflow between snapshots
+    updateWorkflow(workflow.id, { description: "updated once" });
+
+    const v2 = snapshotWorkflow(workflow.id);
+    expect(v2.version).toBe(2);
+
+    updateWorkflow(workflow.id, { description: "updated twice" });
+
+    const v3 = snapshotWorkflow(workflow.id);
+    expect(v3.version).toBe(3);
+  });
+
+  test("snapshot contains full workflow state at time of capture", () => {
+    const workflow = makeWorkflow();
+
+    // Take snapshot of initial state
+    const v1 = snapshotWorkflow(workflow.id);
+    expect(v1.snapshot.description).toBeUndefined();
+
+    // Update workflow
+    updateWorkflow(workflow.id, {
+      description: "has description now",
+      triggers: [{ type: "webhook", hmacSecret: "secret" }],
+      cooldown: { minutes: 30 },
+    });
+
+    // Take snapshot after update
+    const v2 = snapshotWorkflow(workflow.id);
+    expect(v2.snapshot.description).toBe("has description now");
+    expect(v2.snapshot.triggers).toEqual([{ type: "webhook", hmacSecret: "secret" }]);
+    expect(v2.snapshot.cooldown).toEqual({ minutes: 30 });
+  });
+
+  test("changedByAgentId is recorded when provided", () => {
+    const workflow = makeWorkflow();
+    const agentId = crypto.randomUUID();
+
+    const version = snapshotWorkflow(workflow.id, agentId);
+
+    expect(version.changedByAgentId).toBe(agentId);
+  });
+
+  test("throws when workflow does not exist", () => {
+    expect(() => {
+      snapshotWorkflow("00000000-0000-0000-0000-000000000000");
+    }).toThrow("Workflow 00000000-0000-0000-0000-000000000000 not found");
+  });
+});
+
+describe("getWorkflowVersions", () => {
+  test("returns versions in descending order", () => {
+    const workflow = makeWorkflow();
+
+    snapshotWorkflow(workflow.id);
+    updateWorkflow(workflow.id, { description: "update 1" });
+    snapshotWorkflow(workflow.id);
+    updateWorkflow(workflow.id, { description: "update 2" });
+    snapshotWorkflow(workflow.id);
+
+    const versions = getWorkflowVersions(workflow.id);
+
+    expect(versions.length).toBe(3);
+    expect(versions[0]!.version).toBe(3);
+    expect(versions[1]!.version).toBe(2);
+    expect(versions[2]!.version).toBe(1);
+  });
+
+  test("returns empty array for workflow with no versions", () => {
+    const workflow = makeWorkflow();
+    const versions = getWorkflowVersions(workflow.id);
+    expect(versions).toEqual([]);
+  });
+});
+
+describe("getWorkflowVersion", () => {
+  test("returns specific version by number", () => {
+    const workflow = makeWorkflow();
+
+    snapshotWorkflow(workflow.id);
+    updateWorkflow(workflow.id, { description: "v2 state" });
+    snapshotWorkflow(workflow.id);
+
+    const v1 = getWorkflowVersion(workflow.id, 1);
+    expect(v1).not.toBeNull();
+    expect(v1!.version).toBe(1);
+    expect(v1!.snapshot.description).toBeUndefined();
+
+    const v2 = getWorkflowVersion(workflow.id, 2);
+    expect(v2).not.toBeNull();
+    expect(v2!.version).toBe(2);
+    expect(v2!.snapshot.description).toBe("v2 state");
+  });
+
+  test("returns null for non-existent version", () => {
+    const workflow = makeWorkflow();
+    const result = getWorkflowVersion(workflow.id, 999);
+    expect(result).toBeNull();
+  });
+});
+
+describe("version history workflow (snapshot before update)", () => {
+  test("full update cycle: create -> snapshot -> update -> snapshot -> update -> verify history", () => {
+    const workflow = makeWorkflow("versioned-workflow");
+
+    // Snapshot before first update (captures initial state)
+    snapshotWorkflow(workflow.id);
+    updateWorkflow(workflow.id, {
+      description: "first update",
+      definition: {
+        nodes: [
+          {
+            id: "n1",
+            type: "notify",
+            config: { channel: "swarm", template: "v2" },
+          },
+        ],
+      },
+    });
+
+    // Snapshot before second update
+    snapshotWorkflow(workflow.id);
+    updateWorkflow(workflow.id, {
+      description: "second update",
+    });
+
+    // Verify version history
+    const versions = getWorkflowVersions(workflow.id);
+    expect(versions.length).toBe(2);
+
+    // v1 should have the initial state (no description)
+    const v1 = versions.find((v) => v.version === 1)!;
+    expect(v1.snapshot.description).toBeUndefined();
+    expect(v1.snapshot.definition.nodes[0]!.config.template).toBe("v1");
+
+    // v2 should have the first update state
+    const v2 = versions.find((v) => v.version === 2)!;
+    expect(v2.snapshot.description).toBe("first update");
+    expect(v2.snapshot.definition.nodes[0]!.config.template).toBe("v2");
+  });
+});

package/src/tests/workflow-workspace.test.ts

@@ -0,0 +1,272 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { EventEmitter } from "node:events";
+import { unlink } from "node:fs/promises";
+import * as db from "../be/db";
+import {
+  closeDb,
+  createAgent,
+  createWorkflow,
+  getWorkflow,
+  initDb,
+  listWorkflows,
+  updateWorkflow,
+} from "../be/db";
+import { WorkflowSchema } from "../types";
+import { startWorkflowExecution } from "../workflows/engine";
+import { createExecutorRegistry } from "../workflows/executors/registry";
+
+const TEST_DB_PATH = "./test-wf-workspace.sqlite";
+
+beforeAll(async () => {
+  try {
+    await unlink(TEST_DB_PATH);
+  } catch {
+    // Ignore
+  }
+  initDb(TEST_DB_PATH);
+
+  // Create a test agent for task assignment
+  createAgent({ name: "test-workspace-agent", isLead: false, status: "idle" });
+});
+
+afterAll(async () => {
+  closeDb();
+  try {
+    await unlink(TEST_DB_PATH);
+    await unlink(`${TEST_DB_PATH}-wal`);
+    await unlink(`${TEST_DB_PATH}-shm`);
+  } catch {
+    // Ignore
+  }
+});
+
+describe("Workflow dir/vcsRepo persistence", () => {
+  test("workflow dir and vcsRepo persist through create/get cycle", () => {
+    const wf = createWorkflow({
+      name: "wf-with-workspace",
+      definition: { nodes: [{ id: "n1", type: "agent-task", config: { template: "test" } }] },
+      dir: "/tmp/test-workspace",
+      vcsRepo: "desplega-ai/landing",
+    });
+
+    expect(wf.dir).toBe("/tmp/test-workspace");
+    expect(wf.vcsRepo).toBe("desplega-ai/landing");
+
+    const fetched = getWorkflow(wf.id);
+    expect(fetched).not.toBeNull();
+    expect(fetched!.dir).toBe("/tmp/test-workspace");
+    expect(fetched!.vcsRepo).toBe("desplega-ai/landing");
+  });
+
+  test("workflow without dir/vcsRepo returns undefined", () => {
+    const wf = createWorkflow({
+      name: "wf-no-workspace",
+      definition: { nodes: [{ id: "n1", type: "agent-task", config: { template: "test" } }] },
+    });
+
+    expect(wf.dir).toBeUndefined();
+    expect(wf.vcsRepo).toBeUndefined();
+  });
+
+  test("updateWorkflow can set dir and vcsRepo", () => {
+    const wf = createWorkflow({
+      name: "wf-update-workspace",
+      definition: { nodes: [{ id: "n1", type: "agent-task", config: { template: "test" } }] },
+    });
+
+    const updated = updateWorkflow(wf.id, {
+      dir: "/tmp/updated-workspace",
+      vcsRepo: "org/repo",
+    });
+
+    expect(updated).not.toBeNull();
+    expect(updated!.dir).toBe("/tmp/updated-workspace");
+    expect(updated!.vcsRepo).toBe("org/repo");
+  });
+
+  test("updateWorkflow can clear dir and vcsRepo with null", () => {
+    const wf = createWorkflow({
+      name: "wf-clear-workspace",
+      definition: { nodes: [{ id: "n1", type: "agent-task", config: { template: "test" } }] },
+      dir: "/tmp/clear-me",
+      vcsRepo: "org/clear-me",
+    });
+
+    const updated = updateWorkflow(wf.id, {
+      dir: null,
+      vcsRepo: null,
+    });
+
+    expect(updated).not.toBeNull();
+    expect(updated!.dir).toBeUndefined();
+    expect(updated!.vcsRepo).toBeUndefined();
+  });
+
+  test("listWorkflows includes dir and vcsRepo", () => {
+    const wf = createWorkflow({
+      name: "wf-list-workspace",
+      definition: { nodes: [{ id: "n1", type: "agent-task", config: { template: "test" } }] },
+      dir: "/tmp/list-test",
+      vcsRepo: "org/list-test",
+    });
+
+    const workflows = listWorkflows();
+    const found = workflows.find((w) => w.id === wf.id);
+    expect(found).not.toBeNull();
+    expect(found!.dir).toBe("/tmp/list-test");
+    expect(found!.vcsRepo).toBe("org/list-test");
+  });
+
+  test("Workflow type validates dir must start with /", () => {
+    const result = WorkflowSchema.shape.dir.safeParse("relative/path");
+    expect(result.success).toBe(false);
+
+    const validResult = WorkflowSchema.shape.dir.safeParse("/absolute/path");
+    expect(validResult.success).toBe(true);
+  });
+});
+
+describe("Agent-task executor workspace inheritance", () => {
+  test("agent-task inherits workflow dir when node config omits it", async () => {
+    const wf = createWorkflow({
+      name: "wf-inherit-dir",
+      definition: {
+        nodes: [
+          {
+            id: "task1",
+            type: "agent-task",
+            config: { template: "Do something" },
+          },
+        ],
+      },
+      dir: "/tmp/inherited-workspace",
+      vcsRepo: "desplega-ai/inherited",
+    });
+
+    const eventBus = new EventEmitter();
+    const registry = createExecutorRegistry({
+      db,
+      eventBus,
+      interpolate: (t) => t,
+    });
+
+    const runId = await startWorkflowExecution(wf, {}, registry);
+
+    // The workflow run should have been created
+    const run = db.getWorkflowRun(runId);
+    expect(run).not.toBeNull();
+    expect(run!.status).toBe("waiting"); // agent-task is async
+
+    // Find the task created by the executor
+    const steps = db.getWorkflowRunStepsByRunId(runId);
+    expect(steps.length).toBe(1);
+
+    const task = db.getTaskByWorkflowRunStepId(steps[0]!.id);
+    expect(task).not.toBeNull();
+    expect(task!.dir).toBe("/tmp/inherited-workspace");
+    expect(task!.vcsRepo).toBe("desplega-ai/inherited");
+  });
+
+  test("node-level dir overrides workflow-level dir", async () => {
+    const wf = createWorkflow({
+      name: "wf-override-dir",
+      definition: {
+        nodes: [
+          {
+            id: "task1",
+            type: "agent-task",
+            config: {
+              template: "Do something",
+              dir: "/tmp/node-specific",
+              vcsRepo: "org/node-specific",
+            },
+          },
+        ],
+      },
+      dir: "/tmp/workflow-level",
+      vcsRepo: "org/workflow-level",
+    });
+
+    const eventBus = new EventEmitter();
+    const registry = createExecutorRegistry({
+      db,
+      eventBus,
+      interpolate: (t) => t,
+    });
+
+    const runId = await startWorkflowExecution(wf, {}, registry);
+    const steps = db.getWorkflowRunStepsByRunId(runId);
+    const task = db.getTaskByWorkflowRunStepId(steps[0]!.id);
+
+    expect(task).not.toBeNull();
+    expect(task!.dir).toBe("/tmp/node-specific");
+    expect(task!.vcsRepo).toBe("org/node-specific");
+  });
+
+  test("workflow without dir/vcsRepo doesn't affect agent-task nodes", async () => {
+    const wf = createWorkflow({
+      name: "wf-no-inherit",
+      definition: {
+        nodes: [
+          {
+            id: "task1",
+            type: "agent-task",
+            config: { template: "Do something" },
+          },
+        ],
+      },
+    });
+
+    const eventBus = new EventEmitter();
+    const registry = createExecutorRegistry({
+      db,
+      eventBus,
+      interpolate: (t) => t,
+    });
+
+    const runId = await startWorkflowExecution(wf, {}, registry);
+    const steps = db.getWorkflowRunStepsByRunId(runId);
+    const task = db.getTaskByWorkflowRunStepId(steps[0]!.id);
+
+    expect(task).not.toBeNull();
+    expect(task!.dir).toBeFalsy();
+    expect(task!.vcsRepo).toBeFalsy();
+  });
+});
+
+describe("Workflow interpolation context", () => {
+  test("{{workflow.dir}} and {{workflow.vcsRepo}} are available in context", async () => {
+    const wf = createWorkflow({
+      name: "wf-interpolation",
+      definition: {
+        nodes: [
+          {
+            id: "task1",
+            type: "agent-task",
+            config: {
+              template: "Work in {{workflow.dir}} on repo {{workflow.vcsRepo}}",
+            },
+          },
+        ],
+      },
+      dir: "/tmp/interp-test",
+      vcsRepo: "org/interp-repo",
+    });
+
+    const eventBus = new EventEmitter();
+    const registry = createExecutorRegistry({
+      db,
+      eventBus,
+      interpolate: (t) => t,
+    });
+
+    const runId = await startWorkflowExecution(wf, {}, registry);
+    const steps = db.getWorkflowRunStepsByRunId(runId);
+    const task = db.getTaskByWorkflowRunStepId(steps[0]!.id);
+
+    expect(task).not.toBeNull();
+    // The template should have been interpolated with workflow context
+    expect(task!.task).toContain("/tmp/interp-test");
+    expect(task!.task).toContain("org/interp-repo");
+  });
+});

package/src/tests/x402-client.test.ts

@@ -0,0 +1,117 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { createX402Client } from "../x402/client.ts";
+
+// A valid test private key (DO NOT use in production — this is a well-known throwaway key)
+const TEST_PRIVATE_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+
+describe("createX402Client", () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    delete process.env.EVM_PRIVATE_KEY;
+    delete process.env.X402_MAX_AUTO_APPROVE;
+    delete process.env.X402_DAILY_LIMIT;
+    delete process.env.X402_NETWORK;
+    delete process.env.X402_SIGNER_TYPE;
+    delete process.env.OPENFORT_API_KEY;
+    delete process.env.OPENFORT_WALLET_SECRET;
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  test("creates client with viem signer and config overrides", async () => {
+    process.env.EVM_PRIVATE_KEY = TEST_PRIVATE_KEY;
+
+    const client = await createX402Client({
+      maxAutoApprove: 2.5,
+      dailyLimit: 25.0,
+    });
+
+    expect(client.fetch).toBeFunction();
+    expect(client.x402Client).toBeDefined();
+    expect(client.spendingTracker).toBeDefined();
+    expect(client.getSpendingSummary).toBeFunction();
+    expect(client.walletAddress).toMatch(/^0x[0-9a-fA-F]{40}$/);
+  });
+
+  test("derives a consistent wallet address from private key", async () => {
+    process.env.EVM_PRIVATE_KEY = TEST_PRIVATE_KEY;
+
+    const client1 = await createX402Client();
+    const client2 = await createX402Client();
+
+    expect(client1.walletAddress).toBe(client2.walletAddress);
+  });
+
+  test("safe config excludes secrets", async () => {
+    process.env.EVM_PRIVATE_KEY = TEST_PRIVATE_KEY;
+
+    const client = await createX402Client();
+
+    // config should NOT contain sensitive fields
+    expect(client.config).not.toHaveProperty("evmPrivateKey");
+    expect(client.config).not.toHaveProperty("openfortApiKey");
+    expect(client.config).not.toHaveProperty("openfortWalletSecret");
+    expect(client.config.maxAutoApprove).toBe(1.0);
+    expect(client.config.dailyLimit).toBe(10.0);
+    expect(client.config.network).toBe("eip155:84532");
+    expect(client.config.signerType).toBe("viem");
+  });
+
+  test("spending summary reflects tracker state", async () => {
+    process.env.EVM_PRIVATE_KEY = TEST_PRIVATE_KEY;
+
+    const client = await createX402Client();
+    const summary = client.getSpendingSummary();
+
+    expect(summary.todaySpent).toBe(0);
+    expect(summary.todayCount).toBe(0);
+    expect(summary.maxPerRequest).toBe(1.0);
+    expect(summary.dailyLimit).toBe(10.0);
+    expect(summary.dailyRemaining).toBe(10.0);
+  });
+
+  test("applies config overrides over env defaults", async () => {
+    process.env.EVM_PRIVATE_KEY = TEST_PRIVATE_KEY;
+    process.env.X402_MAX_AUTO_APPROVE = "3.0";
+    process.env.X402_DAILY_LIMIT = "30.0";
+
+    const client = await createX402Client({
+      maxAutoApprove: 7.0,
+      dailyLimit: 70.0,
+    });
+
+    expect(client.config.maxAutoApprove).toBe(7.0);
+    expect(client.config.dailyLimit).toBe(70.0);
+  });
+
+  test("uses Base Sepolia by default (testnet)", async () => {
+    process.env.EVM_PRIVATE_KEY = TEST_PRIVATE_KEY;
+
+    const client = await createX402Client();
+    expect(client.config.network).toBe("eip155:84532");
+  });
+
+  test("throws when no signer credentials are set", async () => {
+    await expect(createX402Client()).rejects.toThrow(
+      "x402 payment requires either Openfort credentials",
+    );
+  });
+
+  test("auto-detects viem signer when EVM_PRIVATE_KEY is set", async () => {
+    process.env.EVM_PRIVATE_KEY = TEST_PRIVATE_KEY;
+
+    const client = await createX402Client();
+    expect(client.config.signerType).toBe("viem");
+  });
+
+  test("respects explicit X402_SIGNER_TYPE=viem", async () => {
+    process.env.EVM_PRIVATE_KEY = TEST_PRIVATE_KEY;
+    process.env.X402_SIGNER_TYPE = "viem";
+
+    const client = await createX402Client();
+    expect(client.config.signerType).toBe("viem");
+  });
+});