Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
8.3 KB
Raw Blame
import { afterEach, describe, expect, test } from "bun:test";
import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";

import { startServer } from "./server.js";
import { SessionGroupEventStore } from "./session-groups.js";
import type { ServerConfig } from "./types.js";

const stops: Array<() => void | Promise<void>> = [];
const roots: string[] = [];
const previousRuntimeDb = process.env.OMNIRUSH_RUNTIME_DB;

afterEach(async () => {
  while (stops.length) await stops.pop()?.();
  while (roots.length) await rm(roots.pop()!, { recursive: true, force: true });
  if (previousRuntimeDb === undefined) delete process.env.OMNIRUSH_RUNTIME_DB;
  else process.env.OMNIRUSH_RUNTIME_DB = previousRuntimeDb;
});

async function createWorkspaceRoot() {
  const root = await mkdtemp(join(tmpdir(), "omnirush-session-groups-"));
  roots.push(root);
  process.env.OMNIRUSH_RUNTIME_DB = join(root, "runtime.sqlite");
  return root;
}

async function startOmniRushServer(
  workspaceRoot: string,
  options: { authorizedRoots?: string[]; workspace?: ServerConfig["workspaces"][number] } = {},
) {
  const config: ServerConfig = {
    host: "127.0.0.1",
    port: 0,
    token: "owt_test_token",
    hostToken: "owt_host_token",
    approval: { mode: "auto", timeoutMs: 1000 },
    corsOrigins: ["*"],
    workspaces: [
      options.workspace ?? { id: "ws_1", name: "Workspace", path: workspaceRoot, preset: "starter", workspaceType: "local" },
    ],
    authorizedRoots: options.authorizedRoots ?? [workspaceRoot],
    readOnly: false,
    startedAt: Date.now(),
    tokenSource: "cli",
    hostTokenSource: "cli",
    logFormat: "pretty",
    logRequests: false,
  };
  const server = await startServer(config);
  stops.push(() => server.stop());
  return { base: `http://127.0.0.1:${server.port}`, token: config.token };
}

function auth(token: string) {
  return { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
}

async function json(response: Response) {
  expect(response.status).toBe(200);
  return response.json();
}

describe("session group API", () => {
  test("persists groups, assignments, and update events in the runtime db", async () => {
    const root = await createWorkspaceRoot();
    const { base, token } = await startOmniRushServer(root);

    const empty = await json(await fetch(`${base}/workspace/ws_1/session-groups`, { headers: auth(token) }));
    expect(empty).toMatchObject({ state: { groups: [], assignments: {} } });

    const imported = await json(await fetch(`${base}/workspace/ws_1/session-groups`, {
      method: "PUT",
      headers: auth(token),
      body: JSON.stringify({
        state: {
          groups: [{ id: "grp_imported", label: "Imported" }],
          assignments: { ses_1: "grp_imported" },
        },
      }),
    }));
    expect(imported).toMatchObject({
      state: {
        groups: [{ id: "grp_imported", label: "Imported" }],
        assignments: { ses_1: "grp_imported" },
      },
    });

    const created = await json(await fetch(`${base}/workspace/ws_1/session-groups`, {
      method: "POST",
      headers: auth(token),
      body: JSON.stringify({ id: "grp_next", label: "Next" }),
    }));
    expect(created).toMatchObject({
      state: {
        groups: [
          { id: "grp_imported", label: "Imported" },
          { id: "grp_next", label: "Next" },
        ],
      },
    });

    const assigned = await json(await fetch(`${base}/workspace/ws_1/session-groups/assignments/ses_2`, {
      method: "PATCH",
      headers: auth(token),
      body: JSON.stringify({ groupId: "grp_next" }),
    }));
    expect(assigned).toMatchObject({ state: { assignments: { ses_1: "grp_imported", ses_2: "grp_next" } } });

    const events = await json(await fetch(`${base}/workspace/ws_1/session-groups/events`, { headers: auth(token) }));
    expect(events.items.map((event: { action: string }) => event.action)).toEqual(["imported", "created", "assigned"]);

    const persisted = await json(await fetch(`${base}/workspace/ws_1/session-groups`, { headers: auth(token) }));
    expect(persisted).toMatchObject(assigned);
  });

  test("serializes concurrent read-modify-write group updates", async () => {
    const root = await createWorkspaceRoot();
    const { base, token } = await startOmniRushServer(root);

    const responses = await Promise.all([
      fetch(`${base}/workspace/ws_1/session-groups`, {
        method: "POST",
        headers: auth(token),
        body: JSON.stringify({ id: "grp_first", label: "First" }),
      }),
      fetch(`${base}/workspace/ws_1/session-groups`, {
        method: "POST",
        headers: auth(token),
        body: JSON.stringify({ id: "grp_second", label: "Second" }),
      }),
    ]);
    for (const response of responses) {
      expect(response.status).toBe(200);
    }

    const persisted = await json(await fetch(`${base}/workspace/ws_1/session-groups`, { headers: auth(token) }));
    expect(persisted.state.groups.map((group: { id: string }) => group.id).sort()).toEqual([
      "grp_first",
      "grp_second",
    ]);
  });

  test("read-only session group endpoints do not repair legacy command files", async () => {
    const root = await createWorkspaceRoot();
    const { base, token } = await startOmniRushServer(root);
    const commandsDir = join(root, ".opencode", "commands");
    const commandPath = join(commandsDir, "legacy.md");
    const legacyCommand = "---\nname: legacy\ndescription: Legacy\nmodel: null\n---\nRun legacy command\n";

    await mkdir(commandsDir, { recursive: true });
    await writeFile(commandPath, legacyCommand, "utf8");

    const stateResponse = await fetch(`${base}/workspace/ws_1/session-groups`, { headers: auth(token) });
    expect(stateResponse.status).toBe(200);
    const eventsResponse = await fetch(`${base}/workspace/ws_1/session-groups/events`, { headers: auth(token) });
    expect(eventsResponse.status).toBe(200);
    expect(await readFile(commandPath, "utf8")).toBe(legacyCommand);
  });

  test("read-only session group endpoints preserve remote workspace authorization", async () => {
    const root = await createWorkspaceRoot();
    const remoteRoot = await mkdtemp(join(tmpdir(), "omnirush-session-groups-remote-"));
    roots.push(remoteRoot);
    const { base, token } = await startOmniRushServer(root, {
      authorizedRoots: [root],
      workspace: { id: "ws_remote", name: "Remote", path: remoteRoot, preset: "remote", workspaceType: "remote" },
    });

    const response = await fetch(`${base}/workspace/ws_remote/session-groups`, { headers: auth(token) });
    expect(response.status).toBe(403);
  });

  test("moves assigned sessions when deleting a group with a destination", async () => {
    const root = await createWorkspaceRoot();
    const { base, token } = await startOmniRushServer(root);

    await json(await fetch(`${base}/workspace/ws_1/session-groups`, {
      method: "PUT",
      headers: auth(token),
      body: JSON.stringify({
        state: {
          groups: [
            { id: "grp_source", label: "Source" },
            { id: "grp_destination", label: "Destination" },
          ],
          assignments: {
            ses_1: "grp_source",
            ses_2: "grp_source",
            ses_3: "grp_destination",
          },
        },
      }),
    }));

    const deleted = await json(await fetch(
      `${base}/workspace/ws_1/session-groups/grp_source?destinationGroupId=grp_destination`,
      { method: "DELETE", headers: auth(token) },
    ));

    expect(deleted).toMatchObject({
      state: {
        groups: [{ id: "grp_destination", label: "Destination" }],
        assignments: {
          ses_1: "grp_destination",
          ses_2: "grp_destination",
          ses_3: "grp_destination",
        },
      },
    });
  });

  test("keeps session group events buffered per workspace", () => {
    const store = new SessionGroupEventStore(2);
    const first = store.record("quiet", "created", { groupId: "grp_quiet" });
    store.record("busy", "created", { groupId: "grp_1" });
    store.record("busy", "created", { groupId: "grp_2" });
    store.record("busy", "created", { groupId: "grp_3" });

    expect(store.list("quiet", first.seq - 1).map((event) => event.groupId)).toEqual(["grp_quiet"]);
    expect(store.list("busy").map((event) => event.groupId)).toEqual(["grp_2", "grp_3"]);
    expect(store.cursor("quiet")).toBe(1);
    expect(store.cursor("busy")).toBe(3);
  });
});