A desktop coding agent with free access to frontier models.
TypeScript
import { afterEach, describe, expect, test } from "bun:test";
import { Database } from "bun:sqlite";
import { existsSync } from "node:fs";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { installCloudPlugin, readInstalledCloudPlugins } from "./cloud-plugins.js";
import { readOmniRushWorkspaceConfig, writeOmniRushWorkspaceConfig } from "./omnirush-workspace-config-store.js";
import { readRuntimeOpencodeConfig, writeRuntimeOpencodeConfig } from "./runtime-opencode-config-store.js";
import { readSessionGroupState, writeSessionGroupState } from "./session-groups.js";
import type { ServerConfig } from "./types.js";
import { createWorkspaceKvStore, isRecord, workspaceKvStoreCacheStatsForTests } from "./workspace-kv-store.js";
const WORKSPACE_ID = "ws_workspace_kv_store";
const roots: string[] = [];
const previousRuntimeDb = process.env.OMNIRUSH_RUNTIME_DB;
afterEach(async () => {
while (roots.length) {
const root = roots.pop();
if (root) await rm(root, { recursive: true, force: true });
}
if (previousRuntimeDb === undefined) delete process.env.OMNIRUSH_RUNTIME_DB;
else process.env.OMNIRUSH_RUNTIME_DB = previousRuntimeDb;
});
function serverConfig(root: string): ServerConfig {
return {
host: "127.0.0.1",
port: 0,
token: "token",
hostToken: "host-token",
configPath: join(root, "server.json"),
approval: { mode: "auto", timeoutMs: 0 },
corsOrigins: [],
workspaces: [{ id: WORKSPACE_ID, name: "Test", path: root, preset: "starter", workspaceType: "local" }],
authorizedRoots: [root],
readOnly: false,
startedAt: Date.now(),
tokenSource: "generated",
hostTokenSource: "generated",
logFormat: "pretty",
logRequests: false,
};
}
async function tempWorkspace(): Promise<{ root: string; dbPath: string; config: ServerConfig }> {
const root = await mkdtemp(join(tmpdir(), "omnirush-workspace-kv-store-"));
roots.push(root);
const dbPath = join(root, "runtime.sqlite");
process.env.OMNIRUSH_RUNTIME_DB = dbPath;
return { root, dbPath, config: serverConfig(root) };
}
function parseRecordJson(json: string): Record<string, unknown> {
try {
const parsed: unknown = JSON.parse(json);
return isRecord(parsed) ? parsed : {};
} catch {
return {};
}
}
function recordStore(tableName: string) {
return createWorkspaceKvStore<Record<string, unknown>>({
tableName,
valueColumn: "config_json",
parse: parseRecordJson,
serialize: (value) => JSON.stringify(value),
});
}
function corruptStoreJson(dbPath: string): void {
const sqlite = new Database(dbPath);
try {
sqlite.query("UPDATE runtime_opencode_configs SET config_json = ? WHERE workspace_id = ?").run("{", WORKSPACE_ID);
sqlite.query("UPDATE omnirush_workspace_configs SET config_json = ? WHERE workspace_id = ?").run("{", WORKSPACE_ID);
sqlite.query("UPDATE cloud_plugin_install_configs SET config_json = ? WHERE workspace_id = ?").run("{", WORKSPACE_ID);
sqlite.query("UPDATE session_group_states SET state_json = ? WHERE workspace_id = ?").run("{", WORKSPACE_ID);
} finally {
sqlite.close();
}
}
function setSessionGroupSchemaVersion(dbPath: string, schemaVersion: number): void {
const sqlite = new Database(dbPath);
try {
sqlite.query("UPDATE session_group_states SET schema_version = ? WHERE workspace_id = ?").run(schemaVersion, WORKSPACE_ID);
} finally {
sqlite.close();
}
}
function sessionGroupSchemaVersion(dbPath: string): number {
const sqlite = new Database(dbPath, { readonly: true, create: false });
try {
const row = sqlite.query("SELECT schema_version AS schemaVersion FROM session_group_states WHERE workspace_id = ?").get(WORKSPACE_ID);
if (!isRecord(row) || typeof row.schemaVersion !== "number") throw new Error("missing schema version");
return row.schemaVersion;
} finally {
sqlite.close();
}
}
describe("workspace kv store", () => {
test("creates, reads, updates, and parses malformed JSON", async () => {
const { config, dbPath } = await tempWorkspace();
const store = recordStore("workspace_kv_factory_round_trip");
expect(await store.get(config, "missing")).toBeUndefined();
await store.set(config, WORKSPACE_ID, { enabled: true });
expect(await store.get(config, WORKSPACE_ID)).toEqual({ enabled: true });
await store.set(config, WORKSPACE_ID, { enabled: false, count: 2 });
expect(await store.get(config, WORKSPACE_ID)).toEqual({ enabled: false, count: 2 });
const sqlite = new Database(dbPath);
try {
sqlite.query("UPDATE workspace_kv_factory_round_trip SET config_json = ? WHERE workspace_id = ?").run("{", WORKSPACE_ID);
} finally {
sqlite.close();
}
expect(await store.get(config, WORKSPACE_ID)).toEqual({});
});
test("reads leave a never-written runtime DB uncreated", async () => {
const { config, dbPath } = await tempWorkspace();
const store = recordStore("workspace_kv_read_never_creates");
expect(await store.get(config, WORKSPACE_ID)).toBeUndefined();
expect(await store.has(config, WORKSPACE_ID)).toBe(false);
expect(await readRuntimeOpencodeConfig(config, WORKSPACE_ID)).toEqual({});
expect(existsSync(dbPath)).toBe(false);
await store.set(config, WORKSPACE_ID, { enabled: true });
expect(existsSync(dbPath)).toBe(true);
expect(await store.get(config, WORKSPACE_ID)).toEqual({ enabled: true });
});
test("returns each migrated store's documented defaults for missing and malformed rows", async () => {
const { root, config, dbPath } = await tempWorkspace();
expect(await readRuntimeOpencodeConfig(config, WORKSPACE_ID)).toEqual({});
expect(await readOmniRushWorkspaceConfig(config, WORKSPACE_ID)).toEqual({});
expect(await readInstalledCloudPlugins(config, WORKSPACE_ID)).toEqual({ skills: {}, providers: {}, marketplaces: {}, plugins: {} });
expect(await readSessionGroupState(config, WORKSPACE_ID)).toEqual({ state: { groups: [], assignments: {} }, updatedAt: null });
await writeRuntimeOpencodeConfig(config, WORKSPACE_ID, () => ({ plugin: ["runtime-plugin"] }));
await writeOmniRushWorkspaceConfig(config, WORKSPACE_ID, () => ({ workspace: { name: "Runtime" } }));
await installCloudPlugin({
serverConfig: config,
workspaceId: WORKSPACE_ID,
workspaceRoot: root,
marketplaceId: null,
resolved: {
plugin: { id: "plugin_kv", name: "KV Plugin", description: null, updatedAt: null },
memberships: [],
},
});
const session = await writeSessionGroupState(config, WORKSPACE_ID, {
groups: [{ id: "grp_kv", label: "KV" }],
assignments: { ses_kv: "grp_kv" },
});
corruptStoreJson(dbPath);
expect(await readRuntimeOpencodeConfig(config, WORKSPACE_ID)).toEqual({});
expect(await readOmniRushWorkspaceConfig(config, WORKSPACE_ID)).toEqual({});
expect(await readInstalledCloudPlugins(config, WORKSPACE_ID)).toEqual({ skills: {}, providers: {}, marketplaces: {}, plugins: {} });
expect(await readSessionGroupState(config, WORKSPACE_ID)).toEqual({ state: { groups: [], assignments: {} }, updatedAt: session.updatedAt });
});
test("keeps session group schema_version at 1 on insert and update", async () => {
const { config, dbPath } = await tempWorkspace();
await writeSessionGroupState(config, WORKSPACE_ID, {
groups: [{ id: "grp_one", label: "One" }],
assignments: {},
});
expect(sessionGroupSchemaVersion(dbPath)).toBe(1);
setSessionGroupSchemaVersion(dbPath, 7);
await writeSessionGroupState(config, WORKSPACE_ID, {
groups: [{ id: "grp_two", label: "Two" }],
assignments: {},
});
expect(sessionGroupSchemaVersion(dbPath)).toBe(1);
});
test("shares one underlying runtime DB connection across stores for the same file", async () => {
const { config, dbPath } = await tempWorkspace();
const first = recordStore("workspace_kv_cache_one");
const second = recordStore("workspace_kv_cache_two");
expect(workspaceKvStoreCacheStatsForTests(dbPath)).toEqual({ connectionEntries: 0, tableEntries: 0 });
await Promise.all([
first.set(config, WORKSPACE_ID, { first: true }),
second.set(config, WORKSPACE_ID, { second: true }),
]);
expect(workspaceKvStoreCacheStatsForTests(dbPath)).toEqual({ connectionEntries: 1, tableEntries: 2 });
});
});