Skip to content

A desktop coding agent with free access to frontier models.

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

import { buildOmniRushRuntimeConfig } from "./omnirush-runtime-config.js";
import { readGlobalRuntimeOpencodeConfig, readRuntimeOpencodeConfig } from "./runtime-opencode-config-store.js";
import { startServer } from "./server.js";
import type { ReloadEvent, ServerConfig } from "./types.js";

import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";
import { applyProviderLockAnswer, resetProviderLock } from "./provider-lock.js";

// These cover the app while the server leaves model providers unlocked
// (providers.locked false); provider-lock.test.ts covers the lock.
beforeAllUnlocked(() => { applyProviderLockAnswer({ providers: { locked: false } }); });
afterAllUnlocked(() => resetProviderLock());

const stops: Array<() => void | Promise<void>> = [];
const roots: string[] = [];

afterEach(async () => {
  while (stops.length) await stops.pop()?.();
  while (roots.length) {
    const root = roots.pop();
    if (root) {
      await rm(root, { recursive: true, force: true });
    }
  }
});

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null && !Array.isArray(value);
}

function isReloadEvent(value: unknown): value is ReloadEvent {
  return isRecord(value) && typeof value.reason === "string";
}

function auth(token: string) {
  return { authorization: `Bearer ${token}`, "content-type": "application/json" };
}

async function createWorkspaceRoot() {
  const root = await mkdtemp(join(tmpdir(), "omnirush-runtime-patch-reload-"));
  roots.push(root);
  return root;
}

async function startOmniRushServer(workspaceRoot: string) {
  const config: ServerConfig = {
    host: "127.0.0.1",
    port: 0,
    configPath: join(workspaceRoot, "server.json"),
    token: "owt_test_token",
    hostToken: "owt_host_token",
    approval: { mode: "auto", timeoutMs: 1000 },
    corsOrigins: ["*"],
    workspaces: [{ id: "ws_1", name: "Workspace", path: workspaceRoot, preset: "starter", workspaceType: "local" }],
    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, config };
}

async function patchConfig(base: string, token: string, payload: Record<string, unknown>): Promise<void> {
  const response = await fetch(`${base}/workspace/ws_1/config`, {
    method: "PATCH",
    headers: auth(token),
    body: JSON.stringify(payload),
  });
  expect(response.status).toBe(200);
}

async function readEvents(base: string, token: string): Promise<ReloadEvent[]> {
  const response = await fetch(`${base}/workspace/ws_1/events`, { headers: auth(token) });
  expect(response.status).toBe(200);
  const body: unknown = await response.json();
  if (!isRecord(body) || !Array.isArray(body.items)) {
    throw new Error("Expected reload event response");
  }
  return body.items.filter(isReloadEvent);
}

async function sleep(ms: number): Promise<void> {
  await new Promise((resolve) => setTimeout(resolve, ms));
}

describe("workspace config patch reload events", () => {
  test("identical runtime provider patches do not emit another config reload event", async () => {
    const root = await createWorkspaceRoot();
    const { base, token } = await startOmniRushServer(root);
    const payload = {
      opencode: {
        provider: {
          p1: {
            id: "openrouter",
            name: "OpenRouter",
            env: ["OPENROUTER_API_KEY"],
            models: {
              "model-a": { id: "model-a", name: "Model A" },
            },
          },
        },
      },
    };

    await patchConfig(base, token, payload);
    const firstEvents = await readEvents(base, token);
    expect(firstEvents).toHaveLength(1);
    expect(firstEvents[0]?.reason).toBe("config");

    await sleep(800);
    await patchConfig(base, token, payload);

    const secondEvents = await readEvents(base, token);
    expect(secondEvents).toHaveLength(1);
  });

  test("workspace provider patches land in the global row and the injected engine file", async () => {
    const root = await createWorkspaceRoot();
    const { base, token, config } = await startOmniRushServer(root);
    await patchConfig(base, token, {
      opencode: {
        provider: {
          "user-lmstudio": {
            npm: "@ai-sdk/openai-compatible",
            options: { baseURL: "https://lmstudio.example/v1" },
            models: { "model-a": { id: "model-a", name: "Model A" } },
          },
        },
      },
    });

    // The provider must reach the ENGINE_GLOBAL row — a workspace-row write
    // would never reach the engine because the injected file is global-only.
    const globalRuntime = await readGlobalRuntimeOpencodeConfig(config);
    expect(globalRuntime.provider?.["user-lmstudio"]).toMatchObject({ npm: "@ai-sdk/openai-compatible" });
    expect((await readRuntimeOpencodeConfig(config, "ws_1")).provider).toBeUndefined();

    const injected = JSON.parse(await buildOmniRushRuntimeConfig(config)) as Record<string, unknown>;
    const providers = injected.provider as Record<string, unknown>;
    expect(providers["user-lmstudio"]).toMatchObject({ npm: "@ai-sdk/openai-compatible" });

    // The UI-facing effective config read keeps seeing the provider.
    const read = await fetch(`${base}/workspace/ws_1/config`, { headers: auth(token) });
    expect(read.status).toBe(200);
    const body = await read.json() as { opencode?: { provider?: Record<string, unknown> } };
    expect(body.opencode?.provider?.["user-lmstudio"]).toBeDefined();

    // Explicit null deletes from the global row.
    await patchConfig(base, token, { opencode: { provider: { "user-lmstudio": null } } });
    expect((await readGlobalRuntimeOpencodeConfig(config)).provider?.["user-lmstudio"]).toBeUndefined();
  });
});