A desktop coding agent with free access to frontier models.
TypeScript
import { afterEach, describe, expect, test } from "bun:test";
import { readFile, mkdtemp, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join, resolve } from "node:path";
import { zstdDecompressSync } from "node:zlib";
import constants from "../../../constants.json" with { type: "json" };
import { BUNDLED_ENGINE_VERSION, BUNDLED_HARNESS, engineBuildVersion, engineVersionOf, opencodeHarness } from "./engine-identity.js";
import { SessionUploader, clientLaunchData } from "./session-uploader.js";
/** Schema 1/2 trace uploads carry their events only in files[0] (__omnirush__/trace.json): read them back as `trace`. */
function withTraceEvents<T>(envelope: T): T {
const record = envelope as Record<string, unknown>;
if (record.trace !== undefined || !Array.isArray(record.files)) return envelope;
const file = (record.files as Array<{ path?: string; content?: string }>).find((item) => item.path === "__omnirush__/trace.json");
if (!file?.content) return envelope;
return { ...record, trace: (JSON.parse(file.content) as { events?: unknown[] }).events ?? [] } as T;
}
type Envelope = {
snapshot_type: string;
environment: Record<string, unknown>;
trace?: Array<{ type: string; data?: Record<string, unknown> }>;
};
const roots: string[] = [];
afterEach(async () => {
for (const root of roots.splice(0)) await rm(root, { recursive: true, force: true });
});
async function engineRelease(): Promise<{ tag: string; version: string }> {
const path = resolve(import.meta.dir, "../../desktop/scripts/engine-v2-release.json");
return JSON.parse(await readFile(path, "utf8")) as { tag: string; version: string };
}
function expectHarness(value: unknown): void {
expect(value).toEqual({
name: "opencode",
engine: "omnirush-opencode",
version: BUNDLED_HARNESS.version,
build_tag: BUNDLED_HARNESS.build_tag,
engine_schema: "opencode-v2",
});
const harness = value as Record<string, unknown>;
for (const key of ["name", "engine", "version", "build_tag"]) {
expect(typeof harness[key]).toBe("string");
expect((harness[key] as string).length).toBeGreaterThan(0);
}
}
describe("engine identity", () => {
test("names the engine release the build bundles", async () => {
const release = await engineRelease();
// constants.json and engine-release.json name the same engine build.
expect((constants as { engineV2ReleaseTag?: string }).engineV2ReleaseTag).toBe(release.tag);
expect(constants.opencodeV2Version).toBe(release.version);
expect(BUNDLED_HARNESS.build_tag).toBe(release.tag);
expect(BUNDLED_HARNESS.version.startsWith(release.version)).toBe(true);
expect(BUNDLED_HARNESS.version).toBe(release.tag.replace(/^engine-/, ""));
expect(BUNDLED_ENGINE_VERSION).toBe(`opencode/${BUNDLED_HARNESS.version}`);
});
test("derives version and engine_version from a release tag", () => {
expect(engineBuildVersion("engine-1.18.32-r2", "v1.18.32")).toBe("1.18.32-r2");
expect(engineBuildVersion("", "v1.18.32")).toBe("1.18.32");
const harness = opencodeHarness("engine-1.18.32-r2", "v1.18.32");
expect(harness).toEqual({ name: "opencode", engine: "omnirush-opencode", version: "1.18.32-r2", build_tag: "engine-1.18.32-r2" });
expect(opencodeHarness("engine-2.0.32-r2", "2.0.32")).toEqual({ name: "opencode", engine: "omnirush-opencode", version: "2.0.32-r2", build_tag: "engine-2.0.32-r2", engine_schema: "opencode-v2" });
expect(engineVersionOf(harness)).toBe("opencode/1.18.32-r2");
// Never empty, even without a tag or version.
const bare = opencodeHarness("", "");
expect(bare.version.length).toBeGreaterThan(0);
expect(bare.build_tag.length).toBeGreaterThan(0);
});
test("the client.launch data names the harness", () => {
const data = clientLaunchData();
expect(data.mode).toBe("app");
expect(data.engine).toBe("opencode");
expect(data.engine_version).toBe(BUNDLED_ENGINE_VERSION);
expectHarness(data.harness);
expect("engine_migrated_from" in data).toBe(false);
expect(clientLaunchData("1.18.32").engine_migrated_from).toBe("1.18.32");
});
});
describe("every upload names its engine", () => {
async function run(options: { appVersion?: string; engineVersion?: string }): Promise<Envelope[]> {
const root = await mkdtemp(join(tmpdir(), "omnirush-engine-identity-"));
roots.push(root);
await writeFile(join(root, "app.ts"), "export const answer = 42;\n");
const uploads: Envelope[] = [];
const sessionUploader = new SessionUploader({
upload: async (_sessionId, compressed) => {
uploads.push(withTraceEvents(JSON.parse(zstdDecompressSync(compressed).toString("utf8"))) as Envelope);
return Response.json({ ok: true }, { status: 201 });
},
fallbackScanMs: 60_000,
...options,
});
const sessionId = "session-engine-identity-1";
sessionUploader.startSession(sessionId, "workspace-engine", root);
await sessionUploader.idle(sessionId);
sessionUploader.recordTrace(sessionId, "engine.request", { path: "app.ts" });
sessionUploader.recordTrace(sessionId, "session.idle", {});
sessionUploader.flushTrace(sessionId);
await sessionUploader.idle(sessionId);
await sessionUploader.stop();
return uploads;
}
test("start, trace and end uploads carry engine_version, harness and app_version", async () => {
const uploads = await run({ appVersion: "3.4.0", engineVersion: BUNDLED_ENGINE_VERSION });
expect(uploads.map((item) => item.snapshot_type)).toEqual(["start", "trace", "end"]);
for (const envelope of uploads) {
expect(envelope.environment.engine_version).toBe(BUNDLED_ENGINE_VERSION);
expect(envelope.environment.app_version).toBe("3.4.0");
expectHarness(envelope.environment.harness);
}
});
test("the fields are never null, even when the host passes no versions", async () => {
const uploads = await run({});
expect(uploads.length).toBeGreaterThan(0);
for (const envelope of uploads) {
expect(envelope.environment.engine_version).toBe(BUNDLED_ENGINE_VERSION);
expect(typeof envelope.environment.app_version).toBe("string");
expect((envelope.environment.app_version as string).length).toBeGreaterThan(0);
expectHarness(envelope.environment.harness);
}
});
test("the session's trace starts with one client.launch event", async () => {
const uploads = await run({ appVersion: "3.4.0", engineVersion: BUNDLED_ENGINE_VERSION });
const events = uploads.filter((item) => item.snapshot_type === "trace").flatMap((item) => item.trace ?? []);
expect(events.map((event) => event.type)).toEqual(["client.launch", "engine.request", "session.idle"]);
const launch = events[0]!.data!;
expect(launch.engine).toBe("opencode");
expect(launch.engine_version).toBe(BUNDLED_ENGINE_VERSION);
expectHarness(launch.harness);
});
});