@desplega.ai/agent-swarm 2.2.0 → 2.4.0

package/src/tests/realtime-session-join-race.test.ts

@@ -0,0 +1,142 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { createServer, type Server } from "node:http";
+import WebSocket from "ws";
+import { closeDb, createTaskExtended, createUser, initDb } from "../be/db";
+import { setSessionShares } from "../be/session-shares";
+import { mintToken } from "../be/users";
+import { resolveHttpRequestAuth } from "../http/auth";
+import { handleSessions } from "../http/sessions";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { closeRooms, flushRooms, getRoom, sweepRooms } from "../realtime/rooms";
+import { issueRealtimeTicket } from "../realtime/tickets";
+import { attachRealtimeTransport } from "../realtime/transport";
+import { beginRequestAuthScope, setRequestAuth } from "../utils/request-auth-context";
+import { listenOnFreePort } from "./test-net";
+
+type Frame = Record<string, any>;
+type User = Awaited<ReturnType<typeof createUser>>;
+
+let server: Server;
+let detach: () => void;
+let port: number;
+
+beforeAll(async () => {
+  initDb(":memory:");
+  server = createServer(async (req, res) => {
+    beginRequestAuthScope();
+    const auth = await resolveHttpRequestAuth(req, undefined);
+    if (!auth) {
+      res.writeHead(401);
+      res.end();
+      return;
+    }
+    setRequestAuth(req, auth);
+    const url = req.url ?? "/";
+    if (await handleSessions(req, res, getPathSegments(url), parseQueryParams(url), undefined))
+      return;
+    res.writeHead(404);
+    res.end();
+  });
+  detach = attachRealtimeTransport(server);
+  port = await listenOnFreePort(server, "127.0.0.1");
+});
+
+afterAll(async () => {
+  detach();
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  await closeRooms();
+  closeDb();
+});
+
+async function openSocket(user: User) {
+  const { ticket } = issueRealtimeTicket({ kind: "user", userId: user.id, user: user as never });
+  const ws = new WebSocket(`ws://127.0.0.1:${port}/api/realtime?ticket=${ticket}`);
+  const frames: Frame[] = [];
+  ws.on("message", (raw) => {
+    const frame = JSON.parse(raw.toString()) as Frame;
+    frames.push(frame);
+    if (frame.seq) ws.send(JSON.stringify({ ack: frame.seq }));
+  });
+  await new Promise<void>((resolve, reject) => {
+    ws.once("open", () => resolve());
+    ws.once("error", reject);
+  });
+  const next = async (match: (frame: Frame) => boolean) => {
+    for (let i = 0; i < 400; i++) {
+      const index = frames.findIndex(match);
+      if (index >= 0) return frames.splice(index, 1)[0]!;
+      await Bun.sleep(5);
+    }
+    throw new Error(`No matching frame. Buffered: ${JSON.stringify(frames)}`);
+  };
+  return { ws, frames, next, send: (message: Frame) => ws.send(JSON.stringify(message)) };
+}
+
+test("a revoke that lands while a session presence join loads its room rejects the join", async () => {
+  const owner = await createUser({ name: "Race Owner" });
+  const viewer = await createUser({ name: "Race Viewer" });
+  const ownerToken = await mintToken(owner.id, "test", { kind: "system", id: "test" });
+  const root = await createTaskExtended("Private incident", {
+    requestedByUserId: owner.id,
+    source: "ui",
+  });
+  await setSessionShares(
+    { id: root.id, requestedByUserId: owner.id },
+    { everyone: "read", users: [] },
+    owner.id,
+  );
+  const namespace = `presence:session:${root.id}`;
+
+  // Persist the room, then idle-evict it, so the next join reloads it
+  // through the room creation queue.
+  const room = await getRoom(namespace, "default");
+  await flushRooms();
+  room.lastActivity = 0;
+  await sweepRooms(Date.now());
+
+  const state = (globalThis as { __swarmRoomsState?: { creationChain: Promise<void> } })
+    .__swarmRoomsState!;
+  let release!: () => void;
+  state.creationChain = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+
+  const viewerSocket = await openSocket(viewer);
+  const ownerSocket = await openSocket(owner);
+  try {
+    await viewerSocket.next((frame) => frame.type === "hello");
+    await ownerSocket.next((frame) => frame.type === "hello");
+    viewerSocket.send({ id: 1, op: "join", name: "default", namespace, schemaVersion: 1 });
+    const pending = (globalThis as { __swarmRoomsState?: { pending: Map<string, unknown> } })
+      .__swarmRoomsState!.pending;
+    for (let i = 0; i < 400 && pending.size === 0; i++) await Bun.sleep(5);
+    expect(pending.size).toBeGreaterThan(0);
+
+    const revoked = await fetch(`http://127.0.0.1:${port}/api/sessions/${root.id}/shares`, {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${ownerToken.plaintext}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ everyone: "none", users: [] }),
+    });
+    expect(revoked.status).toBe(200);
+    release();
+
+    const joined = await viewerSocket.next((frame) => frame.id === 1);
+    expect(joined.type).toBe("error");
+    expect(joined.error).toContain("access");
+
+    ownerSocket.send({ id: 2, op: "join", name: "default", namespace, schemaVersion: 1 });
+    expect((await ownerSocket.next((frame) => frame.id === 2)).type).toBe("result");
+    viewerSocket.frames.splice(0);
+    ownerSocket.send({ id: 3, op: "presence", namespace, data: { typing: true } });
+    await ownerSocket.next((frame) => frame.type === "result" && frame.id === 3);
+    await Bun.sleep(100);
+    expect(viewerSocket.frames.filter((frame) => frame.type === "presence")).toEqual([]);
+  } finally {
+    release();
+    viewerSocket.ws.close();
+    ownerSocket.ws.close();
+  }
+});

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/script-connections.test.ts

@@ -632,6 +632,8 @@ describe("script connections", () => {
       markMigrationApplied(database, "219_relabel_pi_context_compactions.sql");
       // 220 reads agents and swarm_config, which this migration-112-only fixture does not create.
       markMigrationApplied(database, "220_model_profiles.sql");
+      // 227 alters inbox_item_state, which this migration-112-only fixture does not create.
+      markMigrationApplied(database, "227_inbox_item_state_last_read_at.sql");
 
       const id = crypto.randomUUID();
       const now = new Date().toISOString();