@desplega.ai/agent-swarm 2.3.0 → 2.4.1

package/src/tests/realtime-tickets.test.ts

@@ -8,6 +8,7 @@ import {
   redeemRealtimeTicket,
   sweepRealtimeTickets,
 } from "../realtime/tickets";
+import { type HttpRequestAuth, setRequestAuth } from "../utils/request-auth-context";
 
 const auth = { kind: "operator", fingerprint: "test-operator" } as const;
 
@@ -46,26 +47,32 @@ describe("realtime tickets", () => {
     expect(redeemRealtimeTicket(newest.ticket, 4_001)).toEqual(auth);
   });
 
-  test("the ticket route answers 404 while Comb is off", async () => {
+  test("the ticket route refuses agents and serves the dashboard with Comb off", async () => {
     const previous = process.env.COMB_ENABLED;
     process.env.COMB_ENABLED = "false";
     try {
-      let status = 0;
-      const res = {
-        writeHead: (code: number) => {
-          status = code;
-        },
-        end: () => {},
-      } as unknown as ServerResponse;
-      const req = { method: "POST", headers: {} } as IncomingMessage;
-      const handled = await handleRealtimeTicket(
-        req,
-        res,
-        ["api", "realtime", "ticket"],
-        new URLSearchParams(),
-      );
-      expect(handled).toBe(true);
-      expect(status).toBe(404);
+      const ticketStatus = async (requestAuth: HttpRequestAuth | null) => {
+        let status = 0;
+        const res = {
+          writeHead: (code: number) => {
+            status = code;
+          },
+          end: () => {},
+        } as unknown as ServerResponse;
+        const req = { method: "POST", headers: {} } as IncomingMessage;
+        if (requestAuth) setRequestAuth(req, requestAuth);
+        const handled = await handleRealtimeTicket(
+          req,
+          res,
+          ["api", "realtime", "ticket"],
+          new URLSearchParams(),
+        );
+        expect(handled).toBe(true);
+        return status;
+      };
+      // Session presence uses the ticket too, so Comb being off no longer hides the route.
+      expect(await ticketStatus(auth)).toBe(200);
+      expect(await ticketStatus(null)).toBe(403);
     } finally {
       if (previous === undefined) delete process.env.COMB_ENABLED;
       else process.env.COMB_ENABLED = previous;

package/src/tests/realtime-transport.test.ts

@@ -655,6 +655,97 @@ describe("realtime transport", () => {
     }
   });
 
+  test("session presence: the first joiner creates the room, and a viewer needs read access", async () => {
+    const owner = await createUserToken("Session Owner");
+    const viewer = await createUserToken("Session Viewer");
+    const created = await api("POST", "/api/tasks", {
+      body: { task: "Fix flaky deploy", requestedByUserId: owner.id, source: "ui" },
+    });
+    expect(created.status).toBe(201);
+    const rootId = ((await created.json()) as { id: string }).id;
+    const namespace = `presence:session:${rootId}`;
+    const ownerSocket = await openSocket(
+      {},
+      `${socketUrl}?ticket=${(await issueTicket(owner.token)).ticket}`,
+    );
+    const viewerSocket = await openSocket(
+      {},
+      `${socketUrl}?ticket=${(await issueTicket(viewer.token)).ticket}`,
+    );
+    try {
+      await ownerSocket.next((frame) => frame.type === "hello");
+      await viewerSocket.next((frame) => frame.type === "hello");
+      // Nobody is in the room yet: this join creates it.
+      const ownerJoined = await join(ownerSocket, 1, "default", namespace);
+      expect(ownerJoined.type).toBe("result");
+
+      viewerSocket.send({ id: 2, op: "join", name: "default", namespace, schemaVersion: 1 });
+      const denied = await viewerSocket.next((frame) => frame.type === "error" && frame.id === 2);
+      expect(denied.error).toContain("access");
+
+      const shared = await api("PUT", `/api/sessions/${rootId}/shares`, {
+        headers: { Authorization: `Bearer ${owner.token}` },
+        body: { everyone: "read", users: [] },
+      });
+      expect(shared.status).toBe(200);
+      expect((await join(viewerSocket, 3, "default", namespace)).type).toBe("result");
+    } finally {
+      await closeSocket(ownerSocket);
+      await closeSocket(viewerSocket);
+    }
+  });
+
+  test("session presence: revoking read access evicts the viewer from the room", async () => {
+    const owner = await createUserToken("Revoking Owner");
+    const viewer = await createUserToken("Revoked Viewer");
+    const created = await api("POST", "/api/tasks", {
+      body: { task: "Private incident", requestedByUserId: owner.id, source: "ui" },
+    });
+    expect(created.status).toBe(201);
+    const rootId = ((await created.json()) as { id: string }).id;
+    const namespace = `presence:session:${rootId}`;
+    const share = async (everyone: "read" | "none") => {
+      const response = await api("PUT", `/api/sessions/${rootId}/shares`, {
+        headers: { Authorization: `Bearer ${owner.token}` },
+        body: { everyone, users: [] },
+      });
+      expect(response.status).toBe(200);
+    };
+    const ownerSocket = await openSocket(
+      {},
+      `${socketUrl}?ticket=${(await issueTicket(owner.token)).ticket}`,
+    );
+    const viewerSocket = await openSocket(
+      {},
+      `${socketUrl}?ticket=${(await issueTicket(viewer.token)).ticket}`,
+    );
+    try {
+      await ownerSocket.next((frame) => frame.type === "hello");
+      await viewerSocket.next((frame) => frame.type === "hello");
+      await share("read");
+      expect((await join(ownerSocket, 1, "default", namespace)).type).toBe("result");
+      expect((await join(viewerSocket, 2, "default", namespace)).type).toBe("result");
+      viewerSocket.frames.splice(0);
+
+      await share("none");
+      const evicted = await viewerSocket.next(
+        (frame) => frame.type === "error" && frame.namespace === namespace,
+      );
+      expect(evicted.error).toContain("access");
+
+      ownerSocket.send({ id: 3, op: "presence", namespace, data: { typing: true } });
+      await ownerSocket.next((frame) => frame.type === "result" && frame.id === 3);
+      await Bun.sleep(100);
+      const leaked = viewerSocket.frames.filter(
+        (frame) => frame.type === "presence" && JSON.stringify(frame.peers).includes("typing"),
+      );
+      expect(leaked).toEqual([]);
+    } finally {
+      await closeSocket(ownerSocket);
+      await closeSocket(viewerSocket);
+    }
+  });
+
   test("refuses agent access to Comb presence namespaces", async () => {
     const agentId = await registerAgent();
     const client = await openSocket({

package/src/tests/reasoning-effort.test.ts

@@ -212,6 +212,13 @@ describe("applyReasoningEffort — pi-session shape", () => {
       sessionOptions: { thinkingLevel: "medium" },
     });
   });
+
+  test("max passes through for an opencode-go model that declares it", () => {
+    expect(applyReasoningEffort("pi", "opencode-go/deepseek-v4-flash", "max")).toEqual({
+      kind: "pi-session",
+      sessionOptions: { thinkingLevel: "max" },
+    });
+  });
 });
 
 describe("applyReasoningEffort — opencode-options shape", () => {
@@ -245,6 +252,30 @@ describe("applyReasoningEffort — opencode-options shape", () => {
       kind: "noop",
     });
   });
+
+  test("opencode-go passes max through on its OpenAI-compatible transport", () => {
+    // `opencode-go/deepseek-v4-flash` declares low|high|max in the snapshot.
+    expect(reasoningCapability("opencode", "opencode-go/deepseek-v4-flash").levels).toEqual([
+      "low",
+      "high",
+      "max",
+    ]);
+    expect(applyReasoningEffort("opencode", "opencode-go/deepseek-v4-flash", "max")).toEqual({
+      kind: "opencode-options",
+      providerId: "opencode-go",
+      modelId: "deepseek-v4-flash",
+      options: { reasoningEffort: "max" },
+    });
+  });
+
+  test("anthropic max uses the effort key opencode's Anthropic transport reads", () => {
+    expect(applyReasoningEffort("opencode", "anthropic/claude-opus-5-5", "max")).toEqual({
+      kind: "opencode-options",
+      providerId: "anthropic",
+      modelId: "claude-opus-5-5",
+      options: { effort: "max" },
+    });
+  });
 });
 
 // The offered levels, the API's validation and the harness application all read the same
@@ -266,16 +297,21 @@ describe("harness × model → effort matrix", () => {
     },
     { harness: "codex", model: "gpt-6-astra", levels: ["low", "medium", "high", "xhigh", "max"] },
     { harness: "codex", model: "gpt-5.1-codex", levels: ["low", "medium", "high"] },
-    { harness: "pi", model: "openrouter/deepseek/deepseek-v4.1-flash", levels: ["low", "high"] },
+    {
+      harness: "pi",
+      model: "openrouter/deepseek/deepseek-v4.1-flash",
+      levels: ["low", "high", "max"],
+    },
     {
       harness: "pi",
       model: "openrouter/anthropic/claude-opus-5.5",
-      levels: ["low", "medium", "high", "xhigh"],
+      levels: ["low", "medium", "high", "xhigh", "max"],
     },
     {
       harness: "opencode",
       model: "openrouter/deepseek/deepseek-v4.1-flash",
-      levels: ["low", "high"],
+      // The facts declare max, and opencode passes it through.
+      levels: ["low", "high", "max"],
     },
     { harness: "pi", model: "openrouter/qwen/qwen3-coder-flash", levels: [] },
     { harness: "claude", model: "totally-custom-model-xyz", levels: [] },

package/src/tests/runner-harness-telemetry-env.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { join } from "node:path";
-import { withHarnessTelemetryEnv } from "../commands/runner";
+import { applyResolvedEnvToProcessEnv, withHarnessTelemetryEnv } from "../commands/runner";
+import { _resetTelemetryStateForTests, initTelemetry, track } from "../telemetry";
 import { CHILD_PROCESS_TEST_BUDGET_MS, runChild } from "./test-proc";
 
 const TELEMETRY_PATH = join(import.meta.dir, "..", "telemetry.ts");
@@ -86,6 +87,60 @@ describe("withHarnessTelemetryEnv", () => {
   });
 });
 
+test("worker telemetry receives and clears company profile through resolved config", async () => {
+  const profile = {
+    SWARM_ORG_WEBSITE: "acme.com",
+    SWARM_ORG_TEAM_SIZE: "2-10",
+    SWARM_ORG_USE_CASE: "ops",
+    SWARM_ORG_ACQUISITION_SOURCE: "github",
+  };
+  const saved = Object.fromEntries(
+    [...Object.keys(profile), "ANONYMIZED_TELEMETRY"].map((key) => [key, process.env[key]]),
+  );
+  const originalFetch = globalThis.fetch;
+  const sent: Array<{ context: Record<string, unknown> }> = [];
+  try {
+    process.env.ANONYMIZED_TELEMETRY = "true";
+    _resetTelemetryStateForTests();
+    globalThis.fetch = (async (_url: string, init?: { body?: string }) => {
+      sent.push(JSON.parse(init?.body ?? "{}"));
+      return new Response(null, { status: 204 });
+    }) as typeof fetch;
+    applyResolvedEnvToProcessEnv(profile);
+    const config: Record<string, string> = {
+      telemetry_installation_id: "install_worker_profile",
+      telemetry_org_id: "org_0123456789abcdef",
+      telemetry_org_domain: "acme.com",
+    };
+    await initTelemetry(
+      "worker",
+      (key) => config[key],
+      () => {},
+    );
+    track({ event: "session.started", properties: { agentId: crypto.randomUUID() } });
+    expect(sent[0]?.context).toMatchObject({
+      org_website: "acme.com",
+      org_domain: "acme.com",
+      team_size: "2-10",
+      use_case: "ops",
+      acquisition_source: "github",
+    });
+    applyResolvedEnvToProcessEnv(Object.fromEntries(Object.keys(profile).map((key) => [key, ""])));
+    track({ event: "session.started", properties: { agentId: crypto.randomUUID() } });
+    expect(sent[1]?.context).not.toHaveProperty("org_website");
+    expect(sent[1]?.context).not.toHaveProperty("team_size");
+    expect(sent[1]?.context).not.toHaveProperty("use_case");
+    expect(sent[1]?.context.acquisition_source).toBeNull();
+  } finally {
+    for (const [key, value] of Object.entries(saved)) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+    globalThis.fetch = originalFetch;
+    _resetTelemetryStateForTests();
+  }
+});
+
 describe("API boot telemetry environment", () => {
   test(
     "an unprefixed API boot from an agent session emits test",