@desplega.ai/agent-swarm 1.157.0 → 1.158.0

package/src/tests/onboard-container-engine.test.ts

@@ -0,0 +1,240 @@
+import { describe, expect, test } from "bun:test";
+import { generateCompose } from "../commands/onboard/compose-generator.ts";
+import {
+  type CommandResult,
+  type CommandRunner,
+  composeCommandText,
+  engineForCommands,
+  isContainerEnginePreference,
+  resolveContainerEngine,
+  resolveContainerEnginePreference,
+} from "../commands/onboard/container-engine.ts";
+import { INITIAL_STATE } from "../commands/onboard/types.ts";
+
+const ok = (stdout: string, stderr = ""): CommandResult => ({ exitCode: 0, stdout, stderr });
+const missing: CommandResult = { exitCode: 127, stdout: "", stderr: "not found" };
+
+/** Mocked runner keyed by the joined argv; unknown commands behave like a missing binary. */
+function mockRunner(responses: Record<string, CommandResult>): CommandRunner & {
+  calls: string[];
+} {
+  const calls: string[] = [];
+  const run = async (argv: string[]) => {
+    const key = argv.join(" ");
+    calls.push(key);
+    return responses[key] ?? missing;
+  };
+  return Object.assign(run, { calls });
+}
+
+const DOCKER = {
+  "docker --version": ok("Docker version 27.3.1, build ce12230\n"),
+  "docker compose version": ok("Docker Compose version v2.29.7\n"),
+};
+const PODMAN = {
+  "podman --version": ok("podman version 5.2.3\n"),
+  "podman compose version": ok(
+    "docker-compose version 2.29.7\n",
+    ">>>> Executing external compose provider ...\n",
+  ),
+};
+const PODMAN_NO_PROVIDER = {
+  "podman --version": ok("podman version 5.2.3\n"),
+  "podman compose version": {
+    exitCode: 125,
+    stdout: "",
+    stderr:
+      'Error: looking up compose provider failed\n7 errors occurred:\n\t* exec: "docker-compose": executable file not found in $PATH\n',
+  },
+};
+
+describe("resolveContainerEngine", () => {
+  test("auto keeps Docker when both engines are installed", async () => {
+    const run = mockRunner({ ...DOCKER, ...PODMAN });
+    const result = await resolveContainerEngine("auto", run);
+    expect(result.ok).toBe(true);
+    expect(result.engine).toBe("docker");
+    expect(run.calls.some((c) => c.startsWith("podman"))).toBe(false);
+  });
+
+  test("auto falls back to Podman when Docker is absent", async () => {
+    const result = await resolveContainerEngine("auto", mockRunner(PODMAN));
+    expect(result.ok).toBe(true);
+    expect(result.engine).toBe("podman");
+    if (result.ok) {
+      expect(result.probe.binary.version).toBe("podman version 5.2.3");
+      expect(result.probe.compose.version).toBe("docker-compose version 2.29.7");
+    }
+  });
+
+  test("auto reports a broken Docker Compose as a Docker failure, without trying Podman", async () => {
+    const run = mockRunner({ "docker --version": DOCKER["docker --version"], ...PODMAN });
+    const result = await resolveContainerEngine("auto", run);
+    expect(result.ok).toBe(false);
+    expect(result.engine).toBe("docker");
+    if (!result.ok) expect(result.error).toBe("Docker Compose v2 not found");
+    expect(run.calls.some((c) => c.startsWith("podman"))).toBe(false);
+  });
+
+  test("auto fails clearly when neither engine exists", async () => {
+    const result = await resolveContainerEngine("auto", mockRunner({}));
+    expect(result.ok).toBe(false);
+    expect(result.engine).toBeNull();
+    if (!result.ok) expect(result.error).toBe("Neither Docker nor Podman was found");
+  });
+
+  test("explicit docker succeeds with Docker and Compose v2", async () => {
+    const result = await resolveContainerEngine("docker", mockRunner(DOCKER));
+    expect(result.ok).toBe(true);
+    expect(result.engine).toBe("docker");
+  });
+
+  test("explicit docker fails when Docker is missing, even if Podman works", async () => {
+    const run = mockRunner(PODMAN);
+    const result = await resolveContainerEngine("docker", run);
+    expect(result.ok).toBe(false);
+    expect(result.engine).toBe("docker");
+    if (!result.ok) {
+      expect(result.error).toBe("Docker not found");
+      expect(result.probe?.binary.hint).toContain("docs.docker.com");
+    }
+    expect(run.calls).toEqual(["docker --version"]);
+  });
+
+  test("explicit podman succeeds with a Compose provider", async () => {
+    const result = await resolveContainerEngine("podman", mockRunner(PODMAN));
+    expect(result.ok).toBe(true);
+    expect(result.engine).toBe("podman");
+  });
+
+  test("explicit podman fails when Podman is missing, even if Docker works", async () => {
+    const run = mockRunner(DOCKER);
+    const result = await resolveContainerEngine("podman", run);
+    expect(result.ok).toBe(false);
+    expect(result.engine).toBe("podman");
+    if (!result.ok) {
+      expect(result.error).toBe("Podman not found");
+      expect(result.probe?.binary.hint).toContain("podman.io");
+    }
+    expect(run.calls).toEqual(["podman --version"]);
+  });
+
+  test("explicit podman without a Compose provider prints a provider diagnostic", async () => {
+    const result = await resolveContainerEngine("podman", mockRunner(PODMAN_NO_PROVIDER));
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toContain("podman compose has no working Compose provider");
+      expect(result.error).toContain("looking up compose provider failed");
+      expect(result.probe?.compose.hint).toContain("podman-compose");
+      expect(result.probe?.compose.hint).toContain("PODMAN_COMPOSE_PROVIDER");
+    }
+  });
+
+  test("a binary that exits non-zero is reported distinctly from a missing one", async () => {
+    const result = await resolveContainerEngine(
+      "podman",
+      mockRunner({ "podman --version": { exitCode: 1, stdout: "", stderr: "boom" } }),
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBe("Podman exited with non-zero status");
+  });
+});
+
+describe("container engine helpers", () => {
+  test("validates preferences", () => {
+    expect(isContainerEnginePreference("auto")).toBe(true);
+    expect(isContainerEnginePreference("docker")).toBe(true);
+    expect(isContainerEnginePreference("podman")).toBe(true);
+    expect(isContainerEnginePreference("nerdctl")).toBe(false);
+    expect(isContainerEnginePreference("")).toBe(false);
+  });
+
+  test("auto renders commands as Docker", () => {
+    expect(engineForCommands("auto")).toBe("docker");
+    expect(composeCommandText(engineForCommands("podman"), "logs -f")).toBe(
+      "podman compose logs -f",
+    );
+  });
+});
+
+describe("resolveContainerEnginePreference", () => {
+  const ENV = "AGENT_SWARM_CONTAINER_ENGINE";
+
+  test("defaults to auto with neither flag nor env var", () => {
+    expect(resolveContainerEnginePreference(undefined, {})).toEqual({ ok: true, value: "auto" });
+  });
+
+  test("an empty env var counts as unset", () => {
+    expect(resolveContainerEnginePreference(undefined, { [ENV]: "" })).toEqual({
+      ok: true,
+      value: "auto",
+    });
+  });
+
+  test("reads the env var when the flag is absent", () => {
+    for (const value of ["auto", "docker", "podman"]) {
+      expect(resolveContainerEnginePreference(undefined, { [ENV]: value })).toEqual({
+        ok: true,
+        value,
+      });
+    }
+  });
+
+  test("the flag wins over the env var", () => {
+    expect(resolveContainerEnginePreference("docker", { [ENV]: "podman" })).toEqual({
+      ok: true,
+      value: "docker",
+    });
+    expect(resolveContainerEnginePreference("auto", { [ENV]: "podman" })).toEqual({
+      ok: true,
+      value: "auto",
+    });
+  });
+
+  test("a valid flag is not blocked by an invalid env var", () => {
+    expect(resolveContainerEnginePreference("podman", { [ENV]: "nerdctl" })).toEqual({
+      ok: true,
+      value: "podman",
+    });
+  });
+
+  test("an invalid env var fails and names the variable", () => {
+    expect(resolveContainerEnginePreference(undefined, { [ENV]: "nerdctl" })).toEqual({
+      ok: false,
+      error: 'Invalid AGENT_SWARM_CONTAINER_ENGINE "nerdctl". Options: auto, docker, podman',
+    });
+  });
+
+  test("an invalid flag fails even when the env var is valid", () => {
+    expect(resolveContainerEnginePreference("", { [ENV]: "podman" })).toEqual({
+      ok: false,
+      error: 'Invalid container engine "". Options: auto, docker, podman',
+    });
+  });
+});
+
+describe("generateCompose engine output", () => {
+  const bedrockState = {
+    ...INITIAL_STATE,
+    services: [{ template: "official/worker", displayName: "Worker", count: 1, role: "worker" }],
+    agentIds: { "worker-worker": "00000000-0000-4000-8000-000000000001" },
+    provider: "bedrock" as const,
+    harness: "pi" as const,
+    awsRegion: "us-east-1",
+    awsProfile: "default",
+  };
+
+  test("Docker output is unchanged: docker usage line, plain :ro AWS mount", () => {
+    const yaml = generateCompose(bedrockState);
+    expect(yaml).toContain("#   docker compose --env-file .env up -d");
+    expect(yaml).toContain("/home/worker/.aws:ro\n");
+    expect(yaml).not.toContain(":ro,z");
+  });
+
+  test("Podman output uses podman compose and a shared SELinux label on the AWS mount", () => {
+    const yaml = generateCompose({ ...bedrockState, containerEngine: "podman" });
+    expect(yaml).toContain("# Podman Compose for Agent Swarm");
+    expect(yaml).toContain("#   podman compose --env-file .env up -d");
+    expect(yaml).toContain("/home/worker/.aws:ro,z\n");
+  });
+});

package/src/tests/otel-event-loop-and-logs.test.ts

@@ -0,0 +1,99 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import { type LogRecord, logs, SeverityNumber } from "@opentelemetry/api-logs";
+import { MeterProvider, MetricReader } from "@opentelemetry/sdk-metrics";
+import {
+  installConsoleLogBridge,
+  startEventLoopDelayMetrics,
+  stopEventLoopDelayMetrics,
+  uninstallConsoleLogBridge,
+} from "../otel-impl";
+
+class CollectingReader extends MetricReader {
+  protected async onForceFlush(): Promise<void> {}
+  protected async onShutdown(): Promise<void> {}
+}
+
+async function gaugeValues(reader: CollectingReader): Promise<Record<string, number>> {
+  const { resourceMetrics } = await reader.collect();
+  const values: Record<string, number> = {};
+  for (const scope of resourceMetrics.scopeMetrics) {
+    for (const metric of scope.metrics) {
+      const point = metric.dataPoints[0];
+      if (point && typeof point.value === "number") values[metric.descriptor.name] = point.value;
+    }
+  }
+  return values;
+}
+
+function blockLoop(ms: number): void {
+  const startedAt = performance.now();
+  while (performance.now() - startedAt < ms) {
+    // Busy-wait: the synchronous stall the metric exists to expose.
+  }
+}
+
+describe("event-loop delay metrics", () => {
+  afterEach(() => {
+    stopEventLoopDelayMetrics();
+  });
+
+  test("exports the worst stall since the last collection, then resets", async () => {
+    const reader = new CollectingReader();
+    const provider = new MeterProvider({ readers: [reader] });
+    startEventLoopDelayMetrics(provider.getMeter("test"));
+
+    // Let the histogram take baseline samples, then freeze the loop.
+    await Bun.sleep(50);
+    blockLoop(300);
+    await Bun.sleep(30);
+
+    const first = await gaugeValues(reader);
+    expect(first["nodejs.eventloop.delay.max"]).toBeGreaterThan(0.25);
+    expect(first["nodejs.eventloop.delay.p50"]).toBeLessThan(0.25);
+
+    // The stall was reported once; the next interval starts clean.
+    await Bun.sleep(50);
+    const second = await gaugeValues(reader);
+    expect(second["nodejs.eventloop.delay.max"]).toBeLessThan(0.25);
+
+    await provider.shutdown();
+  });
+});
+
+describe("console log bridge", () => {
+  const emitted: LogRecord[] = [];
+  const emit = mock((record: LogRecord) => {
+    emitted.push(record);
+  });
+
+  afterEach(() => {
+    uninstallConsoleLogBridge();
+    logs.disable();
+    emitted.length = 0;
+    emit.mockClear();
+  });
+
+  test("mirrors console lines as scrubbed log records and still writes to the console", () => {
+    logs.setGlobalLoggerProvider({ getLogger: () => ({ emit }) });
+    const originalWarn = console.warn;
+    const printed: unknown[][] = [];
+    console.warn = (...args: unknown[]) => {
+      printed.push(args);
+    };
+    try {
+      installConsoleLogBridge();
+      const secret = `sk-ant-api03-${"a".repeat(90)}`;
+      console.warn("[db-client] slow statement %dms token=%s", 250, secret);
+
+      expect(printed).toHaveLength(1);
+      expect(emitted).toHaveLength(1);
+      expect(emitted[0]?.severityNumber).toBe(SeverityNumber.WARN);
+      expect(emitted[0]?.severityText).toBe("WARN");
+      expect(String(emitted[0]?.body)).toContain("slow statement 250ms");
+      expect(String(emitted[0]?.body)).not.toContain(secret);
+    } finally {
+      uninstallConsoleLogBridge();
+      console.warn = originalWarn;
+    }
+  });
+});

package/src/tests/pricing-routes.test.ts

@@ -252,6 +252,20 @@ describe("Phase 6 — /api/pricing REST surface", () => {
       expect(res.status).toBe(400);
     });
 
+    // `dsh` is a registered ProviderNameSchema harness provider
+    // (src/types.ts) but PricingProviderSchema forgot it, so an operator
+    // could not record a dsh price row (#1636). `acp` sets the precedent
+    // for accepting a provider here even without seeded rate rows.
+    test("POST /api/pricing/dsh/{model}/input accepts the dsh provider", async () => {
+      const res = await authedFetch(`/api/pricing/dsh/dsh-model/input`, {
+        method: "POST",
+        body: JSON.stringify({ pricePerMillionUsd: 2.5 }),
+      });
+      expect(res.status).toBe(201);
+      const row = await res.json();
+      expect(row.provider).toBe("dsh");
+    });
+
     test("POST 400 on invalid token class", async () => {
       const res = await authedFetch(`/api/pricing/codex/gpt-5.3-codex/wrong-class`, {
         method: "POST",

package/src/tests/profile-sync-warning.test.ts

@@ -78,11 +78,15 @@ describe("profile sync rejection session warning", () => {
       fetchImpl,
     );
 
-    expect(requests[0]?.url).toContain("event=system.profile_sync_rejected");
-    expect(requests[0]?.url).toContain("agentId=agent-1");
-    expect(requests[0]?.url).toContain("limit=1");
-    expect(requests[0]?.url).toContain("dataField=soulMd");
+    // This mock predates latestPerDataField: the batched request is not
+    // confirmed, so the per-field lookups follow it.
+    expect(requests[0]?.url).toContain("latestPerDataField=true");
     expect(requests[0]?.headers.get("X-Agent-ID")).toBe("agent-1");
+    expect(requests[1]?.url).toContain("event=system.profile_sync_rejected");
+    expect(requests[1]?.url).toContain("agentId=agent-1");
+    expect(requests[1]?.url).toContain("limit=1");
+    expect(requests[1]?.url).toContain("dataField=soulMd");
+    expect(requests[1]?.headers.get("X-Agent-ID")).toBe("agent-1");
     expect(requests.at(-1)?.url).toBe("https://api.example.test/me");
     expect(result.injected).toBeTrue();
     expect(result.prompt).toContain("PERSISTED PROFILE SYNC REJECTION");

package/src/tests/promote-draft-task-route.test.ts

@@ -90,6 +90,25 @@ afterAll(async () => {
 });
 
 describe("POST /api/tasks draft:true + /promote-draft (#1240)", () => {
+  test("a new UI session root (panel or /sessions) is source ui and assigned to the Lead", async () => {
+    // Shape the dashboard sends from both the /sessions composer and the
+    // contextual session panel: no agentId, source ui, a per-session key.
+    const created = await api("POST", "/api/tasks", {
+      task: "the chart legend is wrong",
+      source: "ui",
+      contextKey: "task:ui:workflow:w1:0b7c6e1a-5f38-4b47-9d42-1d7e7c6f0a11",
+    });
+
+    expect(created.status).toBe(201);
+    expect(created.body.source).toBe("ui");
+    expect(created.body.agentId).toBe(leadAgentId);
+    expect(created.body.status).toBe("pending");
+    expect(created.body.parentTaskId).toBeUndefined();
+    expect(created.body.contextKey).toBe(
+      "task:ui:workflow:w1:0b7c6e1a-5f38-4b47-9d42-1d7e7c6f0a11",
+    );
+  });
+
   test("a UI follow-up lands on the Lead without being stamped Lead-only", async () => {
     const worker = await createAgent({
       name: "session-parent-worker",