A desktop coding agent with free access to frontier models.
TypeScript
import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
import { mkdtemp, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { proxyOpencodeRequest, startServer } from "./server.js";
import type { ServerConfig, WorkspaceInfo } from "./types.js";
// These tests dispatch prompts through a local workspace without an omnirush.ai
// account. The server's sign-in gate refuses that unless both development
// flags are set; the gate itself is covered by session-uploader.server.e2e.test.ts.
const uploadGateEnv = { OMNIRUSH_DEV_MODE: process.env.OMNIRUSH_DEV_MODE, OMNIRUSH_SESSION_UPLOAD_OPTIONAL: process.env.OMNIRUSH_SESSION_UPLOAD_OPTIONAL };
beforeAll(() => {
process.env.OMNIRUSH_DEV_MODE = "1";
process.env.OMNIRUSH_SESSION_UPLOAD_OPTIONAL = "1";
});
afterAll(() => {
for (const [name, value] of Object.entries(uploadGateEnv)) {
if (value === undefined) delete process.env[name];
else process.env[name] = value;
}
});
type Served = {
port: number;
stop: (closeActiveConnections?: boolean) => void | Promise<void>;
};
const stops: Array<() => void | Promise<void>> = [];
const roots: string[] = [];
afterEach(async () => {
while (stops.length) {
await stops.pop()?.();
}
while (roots.length) {
await rm(roots.pop()!, { recursive: true, force: true });
}
});
async function createWorkspaceRoot(folderName?: string) {
const root = await mkdtemp(join(tmpdir(), "omnirush-opencode-proxy-"));
const workspaceRoot = folderName ? join(root, folderName) : root;
await mkdir(join(workspaceRoot, ".opencode"), { recursive: true });
roots.push(root);
return workspaceRoot;
}
function auth(token: string) {
return { Authorization: `Bearer ${token}` };
}
function startMockOpencode(input?: { holdCommand?: Promise<void>; foreignSessionDirectory?: string; recovery?: { active: boolean; turn: number } }) {
const requests: Array<{ pathname: string; search: string; directory: string | null; method: string; body?: unknown }> = [];
const server = Bun.serve({
hostname: "127.0.0.1",
port: 0,
async fetch(request) {
const url = new URL(request.url);
const record: { pathname: string; search: string; directory: string | null; method: string; body?: unknown } = {
pathname: url.pathname,
search: url.search,
directory: request.headers.get("x-opencode-directory"),
method: request.method,
};
if (request.method === "POST") {
const text = await request.text();
if (text) record.body = JSON.parse(text);
}
requests.push(record);
if (input?.recovery) {
if (url.pathname === "/session/ses_1/prompt_async") {
input.recovery.active = true;
input.recovery.turn++;
return new Response(null, { status: 204 });
}
if (url.pathname === "/session/status") return Response.json(input.recovery.active ? { ses_1: { type: "busy" } } : {});
if (["/permission", "/question"].includes(url.pathname)) return Response.json([]);
if (url.pathname === "/api/session/ses_1/permission") return Response.json({ data: [] });
if (url.pathname === "/session/ses_1/message") return Response.json([
{ info: { id: `user-${input.recovery.turn}`, role: "user", sessionID: "ses_1", model: { providerID: "test", modelID: "test" } }, parts: [] },
{ info: { id: `assistant-${input.recovery.turn}`, role: "assistant", sessionID: "ses_1", time: {} }, parts: [] },
]);
}
if (url.pathname === "/session") {
if (request.method === "POST") {
const title = typeof record.body === "object" && record.body !== null
? Reflect.get(record.body, "title")
: undefined;
return Response.json({
id: "ses_created",
title: typeof title === "string" ? title : "New session",
slug: "created-session",
directory: request.headers.get("x-opencode-directory"),
time: { created: 300, updated: 300 },
});
}
return Response.json([
{
id: "ses_1",
title: "Hostname Check",
slug: "hostname-check",
directory: request.headers.get("x-opencode-directory"),
time: { created: 100, updated: 200 },
},
]);
}
if (url.pathname === "/session/status") {
return Response.json({ ses_1: { type: "busy" } });
}
if (url.pathname === "/session/ses_1") {
return Response.json({
id: "ses_1",
title: "Hostname Check",
slug: "hostname-check",
directory: request.headers.get("x-opencode-directory"),
time: { created: 100, updated: 200 },
});
}
if (url.pathname === "/session/ses_foreign") {
return Response.json({
id: "ses_foreign",
title: "Foreign session",
slug: "foreign-session",
directory: input?.foreignSessionDirectory,
time: { created: 100, updated: 200 },
});
}
if (url.pathname === "/session/ses_foreign/message") {
return Response.json([{ info: { id: "msg_foreign", sessionID: "ses_foreign" }, parts: [] }]);
}
if (url.pathname === "/session/ses_foreign/todo") {
return Response.json([{ content: "Foreign todo", status: "pending", priority: "high" }]);
}
if (url.pathname === "/session/ses_1/message") {
return Response.json([
{
info: {
id: "msg_1",
sessionID: "ses_1",
role: "assistant",
time: { created: 200 },
},
parts: [
{
id: "prt_1",
messageID: "msg_1",
sessionID: "ses_1",
type: "text",
text: "hostname: mock-host",
},
],
},
]);
}
if (url.pathname === "/session/ses_created/prompt_async" && request.method === "POST") {
return new Response(null, { status: 204 });
}
if (url.pathname === "/session/ses_1/todo") {
return Response.json([
{
content: "Validate session reads",
status: "completed",
priority: "high",
},
]);
}
if (url.pathname === "/session/ses_1/command" && request.method === "POST") {
await input?.holdCommand;
return Response.json({ ok: true });
}
return Response.json({ code: "not_found", message: "Not found" }, { status: 404 });
},
}) as Served;
stops.push(() => server.stop(true));
return { server, requests };
}
async function startOmniRushServer(input: {
workspaceRoot: string;
secondWorkspaceRoot?: string;
opencodeBaseUrl?: string;
readOnly?: boolean;
resumeInterruptedTasks?: boolean;
}) {
const workspaces: WorkspaceInfo[] = [{
id: "ws_1",
name: "Workspace",
path: input.workspaceRoot,
preset: "starter",
workspaceType: "local",
...(input.opencodeBaseUrl ? { baseUrl: input.opencodeBaseUrl } : {}),
}];
if (input.secondWorkspaceRoot) {
workspaces.push({
id: "ws_2",
name: "Other workspace",
path: input.secondWorkspaceRoot,
preset: "starter",
workspaceType: "local",
...(input.opencodeBaseUrl ? { baseUrl: input.opencodeBaseUrl } : {}),
});
}
const config: ServerConfig = {
host: "127.0.0.1",
port: 0,
token: "owt_test_token",
hostToken: "owt_host_token",
configPath: join(input.workspaceRoot, "server.json"),
resumeInterruptedTasks: input.resumeInterruptedTasks,
approval: { mode: "auto", timeoutMs: 1000 },
corsOrigins: ["*"],
workspaces,
authorizedRoots: [input.workspaceRoot, ...(input.secondWorkspaceRoot ? [input.secondWorkspaceRoot] : [])],
readOnly: input.readOnly ?? true,
startedAt: Date.now(),
tokenSource: "cli",
hostTokenSource: "cli",
logFormat: "pretty",
logRequests: false,
};
const server = await startServer(config) as Served;
stops.push(() => server.stop(true));
return { server, token: config.token, config };
}
function deferred() {
let resolve!: () => void;
const promise = new Promise<void>((next) => {
resolve = next;
});
return { promise, resolve };
}
async function waitUntil(predicate: () => boolean) {
for (let index = 0; index < 20; index++) {
if (predicate()) return true;
await new Promise((resolve) => setTimeout(resolve, 10));
}
return predicate();
}
describe("workspace OpenCode proxy", () => {
test("desktop-owned recovery survives a server restart and admits one continuation through the authenticated proxy", async () => {
const workspaceRoot = await createWorkspaceRoot();
const recovery = { active: false, turn: 0 };
const mock = startMockOpencode({ recovery });
const omnirush = await startOmniRushServer({ workspaceRoot, opencodeBaseUrl: `http://127.0.0.1:${mock.server.port}`, readOnly: false, resumeInterruptedTasks: true });
const response = await fetch(`http://127.0.0.1:${omnirush.server.port}/workspace/ws_1/opencode/session/ses_1/prompt_async`, {
method: "POST", headers: { ...auth(omnirush.token), "content-type": "application/json" }, body: JSON.stringify({ parts: [{ type: "text", text: "Finish the task" }] }),
});
expect(response.status).toBe(204);
await omnirush.server.stop();
recovery.active = false;
const restarted = await startServer({ ...omnirush.config, port: 0 });
stops.push(() => restarted.stop());
const resumed = () => mock.requests.filter((request) => request.method === "POST" && JSON.stringify(request.body).includes("Continue the interrupted task"));
const deadline = Date.now() + 5_000;
while (resumed().length === 0 && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 25));
expect(resumed()).toHaveLength(1);
expect(resumed()[0].directory).toBe(workspaceRoot);
expect(resumed()[0].body).toMatchObject({ model: { providerID: "test", modelID: "test" } });
await new Promise((resolve) => setTimeout(resolve, 2_100));
expect(resumed()).toHaveLength(1);
});
test("accepts empty engine request bodies and rejects malformed JSON before forwarding", async () => {
const workspaceRoot = await createWorkspaceRoot();
const mock = startMockOpencode();
const omnirush = await startOmniRushServer({ workspaceRoot, opencodeBaseUrl: `http://127.0.0.1:${mock.server.port}`, readOnly: false });
const url = `http://127.0.0.1:${omnirush.server.port}/workspace/ws_1/opencode/session`;
for (const body of [undefined, ""]) {
const response = await fetch(url, { method: "POST", headers: auth(omnirush.token), body });
expect(response.status).toBe(200);
expect((await response.json()).id).toBe("ses_created");
}
const sessionPosts = () => mock.requests.filter((request) => request.method === "POST" && request.pathname === "/session");
expect(sessionPosts()).toHaveLength(2);
const malformed = await fetch(url, { method: "POST", headers: auth(omnirush.token), body: "{" });
expect(malformed.status).toBe(400);
expect(sessionPosts()).toHaveLength(2);
});
test("accepts guest-side rem_ workspace aliases", async () => {
const workspaceRoot = await createWorkspaceRoot();
const mock = startMockOpencode();
const omnirush = await startOmniRushServer({
workspaceRoot,
opencodeBaseUrl: `http://127.0.0.1:${mock.server.port}`,
});
const response = await fetch(`http://127.0.0.1:${omnirush.server.port}/workspace/rem_ws_1/opencode/session`, {
headers: auth(omnirush.token),
});
expect(response.status).toBe(200);
const body = await response.json();
expect(body[0]?.id).toBe("ses_1");
expect(body[0]?.directory).toBe(workspaceRoot);
expect(mock.requests.find((request) => request.pathname === "/session")?.directory).toBe(workspaceRoot);
});
test("encodes non-ASCII workspace directory headers for opencode proxy requests", async () => {
const workspaceRoot = await createWorkspaceRoot("项目");
const mock = startMockOpencode();
const omnirush = await startOmniRushServer({
workspaceRoot,
opencodeBaseUrl: `http://127.0.0.1:${mock.server.port}`,
});
const response = await fetch(`http://127.0.0.1:${omnirush.server.port}/workspace/ws_1/opencode/session`, {
headers: auth(omnirush.token),
});
expect(response.status).toBe(200);
const proxyRequest = mock.requests.find((request) => request.pathname === "/session");
expect(proxyRequest?.directory).toBe(encodeURIComponent(workspaceRoot));
expect(new URLSearchParams(proxyRequest?.search).get("directory")).toBe(workspaceRoot);
});
test("prevents opencode proxy callers from escaping the mounted workspace directory", async () => {
const workspaceRoot = await createWorkspaceRoot();
const mock = startMockOpencode();
const omnirush = await startOmniRushServer({
workspaceRoot,
opencodeBaseUrl: `http://127.0.0.1:${mock.server.port}`,
});
const foreignDirectory = "/tmp/foreign-workspace";
const response = await fetch(
`http://127.0.0.1:${omnirush.server.port}/workspace/ws_1/opencode/session?directory=${encodeURIComponent(foreignDirectory)}&roots=true`,
{
headers: {
...auth(omnirush.token),
"x-opencode-directory": foreignDirectory,
},
},
);
expect(response.status).toBe(200);
const proxyRequest = mock.requests.find((request) => request.pathname === "/session");
expect(proxyRequest?.directory).toBe(workspaceRoot);
expect(new URLSearchParams(proxyRequest?.search).getAll("directory")).toEqual([workspaceRoot]);
expect(new URLSearchParams(proxyRequest?.search).get("roots")).toBe("true");
});
test("pins the workspace directory against repeated, encoded, and traversal spoof variants", async () => {
const workspaceRoot = await createWorkspaceRoot();
const mock = startMockOpencode();
const omnirush = await startOmniRushServer({
workspaceRoot,
opencodeBaseUrl: `http://127.0.0.1:${mock.server.port}`,
});
const hostileQueries = [
// Repeated directory params: the proxy must collapse them to exactly one.
`directory=${encodeURIComponent("/tmp/foreign-a")}&directory=${encodeURIComponent("/tmp/foreign-b")}`,
// Double-encoded traversal out of the mounted workspace.
`directory=${encodeURIComponent(`${workspaceRoot}/%2e%2e/%2e%2e/etc`)}`,
// Plain traversal plus an unrelated param that must survive.
`directory=${encodeURIComponent(`${workspaceRoot}/../outside`)}&roots=true`,
];
for (const [index, query] of hostileQueries.entries()) {
mock.requests.length = 0;
const response = await fetch(
`http://127.0.0.1:${omnirush.server.port}/workspace/ws_1/opencode/session?${query}`,
{
method: "GET",
headers: {
...auth(omnirush.token),
"x-opencode-directory": "/tmp/foreign-header",
},
},
);
expect({ index, status: response.status }).toEqual({ index, status: 200 });
await response.body?.cancel();
const proxyRequest = mock.requests.find((request) => request.pathname === "/session");
expect({ index, directory: proxyRequest?.directory }).toEqual({ index, directory: workspaceRoot });
expect({ index, queryDirectories: new URLSearchParams(proxyRequest?.search).getAll("directory") })
.toEqual({ index, queryDirectories: [workspaceRoot] });
}
const lastRequest = mock.requests.find((request) => request.pathname === "/session");
expect(new URLSearchParams(lastRequest?.search).get("roots")).toBe("true");
});
test("returns 404 for every cross-workspace session read even when OpenCode resolves the foreign id", async () => {
const workspaceRoot = await createWorkspaceRoot();
const secondWorkspaceRoot = await createWorkspaceRoot();
const mock = startMockOpencode({ foreignSessionDirectory: secondWorkspaceRoot });
const omnirush = await startOmniRushServer({
workspaceRoot,
secondWorkspaceRoot,
opencodeBaseUrl: `http://127.0.0.1:${mock.server.port}`,
});
const base = `http://127.0.0.1:${omnirush.server.port}`;
for (const path of [
"/session/ses_foreign",
"/session/ses_foreign/message?limit=50",
"/session/ses_foreign/todo",
]) {
const response = await fetch(`${base}/workspace/ws_1/opencode${path}`, { headers: auth(omnirush.token) });
expect({ path, status: response.status }).toEqual({ path, status: 404 });
await expect(response.json()).resolves.toMatchObject({ code: "session_not_found" });
}
const ownerResponse = await fetch(`${base}/workspace/ws_2/opencode/session/ses_foreign/message`, {
headers: auth(omnirush.token),
});
expect(ownerResponse.status).toBe(200);
await expect(ownerResponse.json()).resolves.toEqual([
{ info: { id: "msg_foreign", sessionID: "ses_foreign" }, parts: [] },
]);
});
test("scopes spoofed directories on POST proxy requests without touching the body", async () => {
const workspaceRoot = await createWorkspaceRoot();
const mock = startMockOpencode();
const omnirush = await startOmniRushServer({
workspaceRoot,
opencodeBaseUrl: `http://127.0.0.1:${mock.server.port}`,
readOnly: false,
});
const body = { title: "Spoofed create", directory: "/tmp/foreign-body" };
const response = await fetch(
`http://127.0.0.1:${omnirush.server.port}/workspace/ws_1/opencode/session?directory=${encodeURIComponent("/tmp/foreign-query")}`,
{
method: "POST",
headers: {
...auth(omnirush.token),
"Content-Type": "application/json",
"x-opencode-directory": "/tmp/foreign-header",
},
body: JSON.stringify(body),
},
);
expect(response.status).toBe(200);
await response.body?.cancel();
const proxyRequest = mock.requests.find((request) => request.pathname === "/session" && request.method === "POST");
expect(proxyRequest?.directory).toBe(workspaceRoot);
expect(new URLSearchParams(proxyRequest?.search).getAll("directory")).toEqual([workspaceRoot]);
// The proxy scopes routing inputs only; the JSON body is the caller's contract.
expect(proxyRequest?.body).toEqual(body);
});
test("keeps opencode proxy requests off the workspace bootstrap path", async () => {
const workspaceRoot = await createWorkspaceRoot();
const mock = startMockOpencode();
const omnirush = await startOmniRushServer({
workspaceRoot,
opencodeBaseUrl: `http://127.0.0.1:${mock.server.port}`,
readOnly: false,
});
const commandsDir = join(workspaceRoot, ".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 response = await fetch(`http://127.0.0.1:${omnirush.server.port}/workspace/ws_1/opencode/session`, {
headers: auth(omnirush.token),
});
expect(response.status).toBe(200);
expect(mock.requests.some((request) => request.pathname === "/session")).toBe(true);
expect(await readFile(commandPath, "utf8")).toBe(legacyCommand);
});
test.serial("a prompt whose request was given up while it was held never reaches the engine", async () => {
const workspaceRoot = await createWorkspaceRoot();
const engineUrl = "http://127.0.0.1:4333";
const workspace: WorkspaceInfo = { id: "ws_stopped", name: "Workspace", path: workspaceRoot, preset: "starter", workspaceType: "local", baseUrl: engineUrl };
const config: ServerConfig = {
host: "127.0.0.1", port: 0, token: "owt_test_token", hostToken: "owt_host_token",
approval: { mode: "auto", timeoutMs: 1_000 }, corsOrigins: ["*"], workspaces: [workspace], authorizedRoots: [workspaceRoot],
readOnly: false, startedAt: Date.now(), tokenSource: "cli", hostTokenSource: "cli", logFormat: "pretty", logRequests: false,
};
const originalFetch = globalThis.fetch;
const engineCalls: string[] = [];
globalThis.fetch = Object.assign(
(input: Parameters<typeof fetch>[0]) => {
engineCalls.push(input instanceof Request ? input.url : String(input));
return Promise.resolve(new Response(null, { status: 204 }));
},
{ preconnect: originalFetch.preconnect },
);
try {
for (const route of ["prompt_async", "command"]) {
const proxyPath = `/session/ses_stopped/${route}`;
const url = new URL(`http://omnirush.invalid/opencode${proxyPath}`);
const stopped = new AbortController();
stopped.abort();
const response = await proxyOpencodeRequest({
config, workspace, proxyPath, url,
request: new Request(url, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ messageID: `msg_${route}`, parts: [{ type: "text", text: "hi" }], command: "review", arguments: "" }), signal: stopped.signal }),
});
expect(response.status).toBe(409);
expect(await response.json()).toMatchObject({ code: "send_stopped" });
}
expect(engineCalls.filter((call) => /prompt_async|\/command/.test(call))).toEqual([]);
} finally {
globalThis.fetch = originalFetch;
}
});
test.serial("acknowledges proxied session commands before upstream completion and admits each message once", async () => {
const workspaceRoot = await createWorkspaceRoot();
const engineUrl = "http://127.0.0.1:4111";
const replacementEngineUrl = "http://127.0.0.1:4222";
const workspace: WorkspaceInfo = {
id: "ws_1",
name: "Workspace",
path: workspaceRoot,
preset: "starter",
workspaceType: "local",
baseUrl: engineUrl,
};
const config: ServerConfig = {
host: "127.0.0.1",
port: 0,
token: "owt_test_token",
hostToken: "owt_host_token",
approval: { mode: "auto", timeoutMs: 1_000 },
corsOrigins: ["*"],
workspaces: [workspace],
authorizedRoots: [workspaceRoot],
readOnly: false,
startedAt: Date.now(),
tokenSource: "cli",
hostTokenSource: "cli",
logFormat: "pretty",
logRequests: false,
};
const originalFetch = globalThis.fetch;
const requests: string[] = [];
const upstream = deferred();
globalThis.fetch = Object.assign(
(input: Parameters<typeof fetch>[0]) => {
requests.push(input instanceof Request ? input.url : String(input));
return upstream.promise.then(() => Response.json({ ok: true }));
},
{ preconnect: originalFetch.preconnect },
);
const sendCommand = (
targetWorkspace: WorkspaceInfo,
sessionId: string,
body: string,
) => {
const proxyPath = `/session/${sessionId}/command`;
const url = new URL(`http://omnirush.invalid/opencode${proxyPath}`);
return proxyOpencodeRequest({
config,
workspace: targetWorkspace,
proxyPath,
url,
request: new Request(url, {
method: "POST",
headers: { "Content-Type": "application/json" },
body,
}),
});
};
const commandBody = JSON.stringify({ messageID: "msg_command_once", command: "review", arguments: "" });
try {
const response = await Promise.race([
sendCommand(workspace, "ses_1", commandBody),
new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), 100)),
]);
expect(response).not.toBe("timeout");
expect(response instanceof Response ? response.status : 0).toBe(200);
await expect(response instanceof Response ? response.json() : null).resolves.toMatchObject({ accepted: true });
const duplicate = await sendCommand(workspace, "ses_1", commandBody);
expect(duplicate.status).toBe(200);
await expect(duplicate.json()).resolves.toMatchObject({ accepted: true });
const conflict = await sendCommand(
workspace,
"ses_1",
JSON.stringify({ messageID: "msg_command_once", command: "summarize", arguments: "" }),
);
expect(conflict.status).toBe(409);
await expect(conflict.json()).resolves.toMatchObject({ code: "command_admission_conflict" });
const rolloverDuplicate = await sendCommand(
{ ...workspace, baseUrl: replacementEngineUrl },
"ses_1",
commandBody,
);
const otherSession = await sendCommand(workspace, "ses_2", commandBody);
expect(rolloverDuplicate.status).toBe(200);
expect(otherSession.status).toBe(200);
expect(requests.map((request) => new URL(request).pathname)).toEqual([
"/session/ses_1/command",
"/session/ses_2/command",
]);
expect(requests.every((request) => request.startsWith(engineUrl))).toBe(true);
} finally {
upstream.resolve();
globalThis.fetch = originalFetch;
}
});
test("keeps legacy /w workspace opencode proxy alias", async () => {
const workspaceRoot = await createWorkspaceRoot();
const mock = startMockOpencode();
const omnirush = await startOmniRushServer({
workspaceRoot,
opencodeBaseUrl: `http://127.0.0.1:${mock.server.port}`,
});
const response = await fetch(`http://127.0.0.1:${omnirush.server.port}/w/ws_1/opencode/session`, {
headers: auth(omnirush.token),
});
expect(response.status).toBe(200);
const body = await response.json();
expect(Array.isArray(body)).toBe(true);
expect(mock.requests.some((request) => request.pathname === "/session")).toBe(true);
});
test("returns a configured error instead of constructing an SDK request with a relative URL", async () => {
const workspaceRoot = await createWorkspaceRoot();
const omnirush = await startOmniRushServer({ workspaceRoot });
const response = await fetch(`http://127.0.0.1:${omnirush.server.port}/workspace/ws_1/opencode/session?limit=200`, {
headers: auth(omnirush.token),
});
expect(response.status).toBe(400);
await expect(response.json()).resolves.toMatchObject({
code: "opencode_unconfigured",
message: "OmniRush base URL is missing for this workspace",
});
});
});
// An engine holding a running session with a sub-agent in another folder, as
// OpenCode answers the reads, aborts and delete the local server sends.
function startSessionTreeEngine(input: { childDirectory: string; busy?: string[] }) {
const requests: Array<{ method: string; pathname: string; directory: string | null }> = [];
const running = new Set(input.busy ?? ["ses_parent", "ses_child"]);
const deleted = new Set<string>();
const server = Bun.serve({
hostname: "127.0.0.1",
port: 0,
fetch(request) {
const url = new URL(request.url);
const directory = request.headers.get("x-opencode-directory");
requests.push({ method: request.method, pathname: url.pathname, directory });
const sessions: Record<string, { directory: string | null; parentID?: string }> = {
ses_parent: { directory },
ses_child: { directory: input.childDirectory, parentID: "ses_parent" },
};
if (url.pathname === "/session/status") {
return Response.json(Object.fromEntries([...running].map((id) => [id, { type: "busy" }])));
}
const match = url.pathname.match(/^\/session\/([^/]+)(\/children|\/abort)?$/);
const id = match?.[1] ?? "";
if (!match || !sessions[id] || deleted.has(id)) return Response.json({ name: "NotFoundError" }, { status: 404 });
if (match[2] === "/abort") {
running.delete(id);
return Response.json(true);
}
if (match[2] === "/children") {
return Response.json(Object.entries(sessions).filter(([, s]) => s.parentID === id).map(([childId, s]) => ({ id: childId, ...s })));
}
if (request.method === "DELETE") {
deleted.add(id);
deleted.add("ses_child");
return Response.json(true);
}
return Response.json({ id, ...sessions[id] });
},
}) as Served;
stops.push(() => server.stop(true));
return { server, requests, running };
}
describe("deleting sessions and workspaces", () => {
test("a session delete stops the session and its sub-agents first, each in its own folder", async () => {
const workspaceRoot = await createWorkspaceRoot();
const childDirectory = await createWorkspaceRoot("elsewhere");
const engine = startSessionTreeEngine({ childDirectory });
const omnirush = await startOmniRushServer({ workspaceRoot, opencodeBaseUrl: `http://127.0.0.1:${engine.server.port}`, readOnly: false });
const response = await fetch(`http://127.0.0.1:${omnirush.server.port}/workspace/ws_1/opencode/session/ses_parent`, {
method: "DELETE",
headers: auth(omnirush.token),
});
expect(response.status).toBe(200);
expect(await response.json()).toBe(true);
expect([...engine.running]).toEqual([]);
const aborts = engine.requests.filter((request) => request.pathname.endsWith("/abort"));
expect(aborts.map((request) => [request.pathname, request.directory])).toEqual(expect.arrayContaining([
["/session/ses_parent/abort", workspaceRoot],
["/session/ses_child/abort", childDirectory],
]));
const deleteIndex = engine.requests.findIndex((request) => request.method === "DELETE");
expect(deleteIndex).toBeGreaterThan(Math.max(...aborts.map((request) => engine.requests.indexOf(request))));
});
test("a delete of a session that is already gone still answers the engine's not-found", async () => {
const workspaceRoot = await createWorkspaceRoot();
const engine = startSessionTreeEngine({ childDirectory: workspaceRoot });
const omnirush = await startOmniRushServer({ workspaceRoot, opencodeBaseUrl: `http://127.0.0.1:${engine.server.port}`, readOnly: false });
const response = await fetch(`http://127.0.0.1:${omnirush.server.port}/workspace/ws_1/opencode/session/ses_missing`, {
method: "DELETE",
headers: auth(omnirush.token),
});
expect(response.status).toBe(404);
expect(engine.requests.filter((request) => request.pathname.endsWith("/abort"))).toEqual([]);
});
test("reading or removing a workspace whose folder was deleted never recreates the folder", async () => {
const parent = await createWorkspaceRoot();
const workspaceRoot = join(parent, "project");
await mkdir(workspaceRoot, { recursive: true });
const engine = startSessionTreeEngine({ childDirectory: workspaceRoot, busy: ["ses_parent"] });
const omnirush = await startOmniRushServer({ workspaceRoot, opencodeBaseUrl: `http://127.0.0.1:${engine.server.port}`, readOnly: false });
omnirush.config.configPath = join(parent, "server.json");
const base = `http://127.0.0.1:${omnirush.server.port}`;
await rm(workspaceRoot, { recursive: true, force: true });
const read = await fetch(`${base}/workspace/ws_1/opencode-config?scope=project`, { headers: auth(omnirush.token) });
await read.body?.cancel();
expect(await stat(workspaceRoot).catch(() => null)).toBeNull();
const removed = await fetch(`${base}/workspaces/ws_1`, {
method: "DELETE",
headers: { ...auth(omnirush.token), "X-OmniRush-Host-Token": "owt_host_token" },
});
expect(removed.status).toBe(200);
expect(await removed.json()).toMatchObject({ deleted: true, persisted: true, items: [] });
expect(await stat(workspaceRoot).catch(() => null)).toBeNull();
// Its running session was stopped before the workspace went away.
expect(engine.requests.some((request) => request.pathname === "/session/ses_parent/abort" && request.directory === workspaceRoot)).toBe(true);
expect([...engine.running]).toEqual([]);
const saved: unknown = JSON.parse(await readFile(join(parent, "server.json"), "utf8"));
expect(saved).toMatchObject({ workspaces: [] });
});
test("a workspace removal that cannot be saved keeps the workspace and says so", async () => {
const parent = await createWorkspaceRoot();
const workspaceRoot = join(parent, "project");
await mkdir(workspaceRoot, { recursive: true });
const blocker = join(parent, "not-a-directory");
await writeFile(blocker, "x");
const omnirush = await startOmniRushServer({ workspaceRoot, readOnly: false });
omnirush.config.configPath = join(blocker, "server.json");
const base = `http://127.0.0.1:${omnirush.server.port}`;
const removed = await fetch(`${base}/workspaces/ws_1`, {
method: "DELETE",
headers: { ...auth(omnirush.token), "X-OmniRush-Host-Token": "owt_host_token" },
});
expect(removed.status).toBe(500);
expect(await removed.json()).toMatchObject({ code: "workspace_registry_write_failed" });
expect(omnirush.config.workspaces.map((workspace) => workspace.id)).toEqual(["ws_1"]);
});
});