Skip to content

A desktop coding agent with free access to frontier models.

TypeScript

feat: name the engine and harness on every upload

ogsamrat22a7575fc304
diff --git a/apps/server/src/engine-identity.test.ts b/apps/server/src/engine-identity.test.ts
new file mode 100644
index 00000000..080ce916
--- /dev/null
+++ b/apps/server/src/engine-identity.test.ts
@@ -0,0 +1,129 @@
+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";
+
+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-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,
+ });
+ 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 { engineReleaseTag?: string }).engineReleaseTag).toBe(release.tag);
+ expect(constants.opencodeVersion.replace(/^v/, "")).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(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);
+ });
+});
+
+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(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);
+ });
+});
diff --git a/apps/server/src/engine-identity.ts b/apps/server/src/engine-identity.ts
new file mode 100644
index 00000000..9f647571
--- /dev/null
+++ b/apps/server/src/engine-identity.ts
@@ -0,0 +1,54 @@
+import constants from "../../../constants.json" with { type: "json" };
+
+/**
+ * Which engine and harness produced an upload. The same field names and
+ * values as the CLI's uploads, so every delivery can say what ran a session:
+ * `environment.engine_version` ("opencode/1.18.32-r2"), `environment.harness`
+ * and `environment.app_version`.
+ */
+export type HarnessName = "opencode" | "pi";
+export type HarnessEngine = "omnirush-opencode" | "omnirush-core";
+
+export type Harness = {
+ name: HarnessName;
+ engine: HarnessEngine;
+ /** The engine build's version, with its release suffix ("1.18.32-r2"). */
+ version: string;
+ /** The engine release it came from ("engine-1.18.32-r2"). */
+ build_tag: string;
+};
+
+const RELEASE_TAG_PREFIX = "engine-";
+
+/** "engine-1.18.32-r2" -> "1.18.32-r2"; a bare version without the tag. */
+export function engineBuildVersion(buildTag: string, fallbackVersion: string): string {
+ const tag = buildTag.trim();
+ if (tag.startsWith(RELEASE_TAG_PREFIX) && tag.length > RELEASE_TAG_PREFIX.length) return tag.slice(RELEASE_TAG_PREFIX.length);
+ return fallbackVersion.trim().replace(/^v/, "");
+}
+
+/** The desktop's engine: OmniRush.ai's opencode build (apps/desktop/scripts/engine-release.json). */
+export function opencodeHarness(buildTag: string, fallbackVersion: string): Harness {
+ const version = engineBuildVersion(buildTag, fallbackVersion) || "unknown";
+ return {
+ name: "opencode",
+ engine: "omnirush-opencode",
+ version,
+ build_tag: buildTag.trim() || `${RELEASE_TAG_PREFIX}${version}`,
+ };
+}
+
+/** `engine_version` for a harness: "<name>/<version>". */
+export function engineVersionOf(harness: Harness): string {
+ return `${harness.name}/${harness.version}`;
+}
+
+const bundled = constants as { opencodeVersion?: string; engineReleaseTag?: string };
+
+/** The engine this build bundles. */
+export const BUNDLED_HARNESS: Harness = Object.freeze(
+ opencodeHarness(bundled.engineReleaseTag ?? "", bundled.opencodeVersion ?? ""),
+) as Harness;
+
+/** `engine_version` of the bundled engine ("opencode/1.18.32-r2"). */
+export const BUNDLED_ENGINE_VERSION = engineVersionOf(BUNDLED_HARNESS);
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index ddf04987..57e27047 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -203,6 +203,7 @@ import { runtimeStorageDir } from "./runtime-db.js";
import pkg from "../package.json" with { type: "json" };
import constants from "../../../constants.json" with { type: "json" };
import { BestPracticesEngineReloads } from "./best-practices.js";
+import { BUNDLED_ENGINE_VERSION } from "./engine-identity.js";
export {
isSupportedWorkspaceTextFilePath,
@@ -1031,7 +1032,8 @@ export async function startServer(config: ServerConfig): Promise<ServeResult> {
const capture = startCaptureService({
stateDir: runtimeStorageDir(config),
appVersion,
- engineVersion: OPENCODE_VERSION,
+ // "opencode/1.18.32-r2": the bundled engine, as every upload names it (engine-identity.ts).
+ engineVersion: BUNDLED_ENGINE_VERSION,
log: (level, message, attributes) => logger.log(level, message, attributes),
sessionUploader: gatewayBroker.enabled
? {
diff --git a/apps/server/src/session-uploader.test.ts b/apps/server/src/session-uploader.test.ts
index 832d11c0..68210074 100644
--- a/apps/server/src/session-uploader.test.ts
+++ b/apps/server/src/session-uploader.test.ts
@@ -172,12 +172,14 @@ describe("session uploader privacy", () => {
sessionUploader.flushTrace(sessionId);
await sessionUploader.stop();
- const trace = uploads.find((item) => item.snapshot_type === "trace");
- expect(trace).toBeDefined();
- const traceFile = (trace?.files as Array<{ content: string }>)[0];
- const parsed = JSON.parse(traceFile.content) as { trace_truncated: boolean; dropped_event_count: number };
- expect(parsed.trace_truncated).toBe(true);
- expect(parsed.dropped_event_count).toBeGreaterThanOrEqual(1);
+ // The session's leading client.launch event goes out in a batch of its own.
+ const traces = uploads
+ .filter((item) => item.snapshot_type === "trace")
+ .map((item) => JSON.parse((item.files as Array<{ content: string }>)[0]!.content) as { trace_truncated: boolean; dropped_event_count: number; events: Array<{ type: string }> });
+ expect(traces.length).toBeGreaterThan(0);
+ const parsed = traces.find((item) => item.trace_truncated);
+ expect(parsed).toBeDefined();
+ expect(parsed!.dropped_event_count).toBeGreaterThanOrEqual(1);
});
test("persists session segments and message checkpoints across a resume", async () => {
@@ -511,10 +513,10 @@ describe("session uploader envelope v2", () => {
const rejected = attempts[1]!;
const fallback = attempts[2]!;
expect(rejected.files).toEqual([]);
- expect(rejected.trace?.map((event) => event.type)).toEqual(["engine.request"]);
+ expect(rejected.trace?.map((event) => event.type)).toEqual(["client.launch", "engine.request"]);
expect(fallback.files.map((file) => file.path)).toEqual(["__omnirush__/trace.json"]);
expect(fallback.trace?.map((event) => event.type)).toEqual(rejected.trace?.map((event) => event.type));
- expect(JSON.parse(fallback.files[0]!.content).events.map((event: { type: string }) => event.type)).toEqual(["engine.request"]);
+ expect(JSON.parse(fallback.files[0]!.content).events.map((event: { type: string }) => event.type)).toEqual(["client.launch", "engine.request"]);
});
test("summarises a git repository without shipping internals or remote credentials", async () => {
diff --git a/apps/server/src/session-uploader.ts b/apps/server/src/session-uploader.ts
index 897d7c0c..e05b62f3 100644
--- a/apps/server/src/session-uploader.ts
+++ b/apps/server/src/session-uploader.ts
@@ -30,6 +30,8 @@ import { ToolchainCache, type CollectOptions as ToolchainOptions, type UploadToo
import { engine2ImportedFrom } from "./engine2/imported.js";
import { ContextCapture, captureContextEnabled, type ContextOptions } from "./context/index.js";
import bundledBestPractices from "./bundled-best-practices.json" with { type: "json" };
+import serverPackage from "../package.json" with { type: "json" };
+import { BUNDLED_ENGINE_VERSION, BUNDLED_HARNESS, type Harness } from "./engine-identity.js";
const execFileAsync = promisify(execFile);
@@ -223,8 +225,12 @@ export type UploadEnvironment = {
os: string;
os_version: string;
arch: string;
- app_version: string | null;
- engine_version: string | null;
+ /** Never null: the desktop's version, else the server package's. */
+ app_version: string;
+ /** Never null: "opencode/1.18.32-r2" for the bundled engine (engine-identity.ts). */
+ engine_version: string;
+ /** Which engine and harness produced the upload; the same shape the CLI sends. */
+ harness: Harness;
node_version: string;
shell: string | null;
locale: string | null;
@@ -469,6 +475,8 @@ type SessionState = {
/** Watchers still being added for top-level directories the listing did not name. */
watchSetup: Promise<void>;
trace: TraceEvent[];
+ /** The session's trace has this process's `client.launch` event (which engine and harness ran it). */
+ launchRecorded?: boolean;
changeJournal: Map<string, ChangeJournalEntry>;
touchedPaths: Set<string>;
changeJournalBytes: number;
@@ -4038,6 +4046,13 @@ async function gitSkippedField(): Promise<{ git_skipped?: string }> {
return reason ? { git_skipped: reason } : {};
}
+const SERVER_PACKAGE_VERSION: string = serverPackage.version;
+
+/** The desktop's `client.launch` trace data: the CLI's keys, plus the harness. */
+export function clientLaunchData(): { mode: "app"; engine: "opencode"; engine_version: string; harness: Harness } {
+ return { mode: "app", engine: "opencode", engine_version: BUNDLED_ENGINE_VERSION, harness: { ...BUNDLED_HARNESS } };
+}
+
function uploadEnvironment(appVersion: string | undefined, engineVersion: string | undefined, gitVersion: string | null): UploadEnvironment {
let locale: string | null = null;
let timezone: string | null = null;
@@ -4055,8 +4070,9 @@ function uploadEnvironment(appVersion: string | undefined, engineVersion: string
os: process.platform,
os_version: field(osRelease()) ?? "",
arch: process.arch,
- app_version: field(appVersion),
- engine_version: field(engineVersion),
+ app_version: field(appVersion) ?? field(SERVER_PACKAGE_VERSION) ?? "unknown",
+ engine_version: field(engineVersion) ?? BUNDLED_ENGINE_VERSION,
+ harness: { ...BUNDLED_HARNESS },
node_version: field(process.versions.node ?? process.version.replace(/^v/, "")) ?? "",
shell: shellPath?.trim() ? field(basename(shellPath.trim())) : null,
locale: field(locale),
@@ -4277,7 +4293,7 @@ export class SessionUploader {
const capture = new ContextCapture({
client: "gui",
appVersion: this.appVersion ?? null,
- engineVersion: this.engineVersion ?? null,
+ engineVersion: this.engineVersion ?? BUNDLED_ENGINE_VERSION,
cacheDir: stateDir ? join(stateDir, "context") : null,
scrub: {
text: (text) => redactUploadText(text).text,
@@ -5001,6 +5017,13 @@ export class SessionUploader {
}
}
}
+ // A session's first trace event in this process follows the engine and
+ // harness that ran it, like the CLI's `client.launch` (an opaque event
+ // type, kept as sent); it shares the trace's event cap.
+ if (!state.launchRecorded) {
+ state.launchRecorded = true;
+ this.appendTrace(state, "client.launch", clientLaunchData());
+ }
this.appendTrace(state, type, data);
if (type === "turn.messages" && isRecord(data)) this.context?.turnMessages(sessionId, data.messages);
}
diff --git a/constants.json b/constants.json
index da2c0879..647906f6 100644
--- a/constants.json
+++ b/constants.json
@@ -1,4 +1,5 @@
{
"opencodeVersion": "v1.18.32",
- "opencodeV2Version": "0.0.0-beta-19086"
+ "opencodeV2Version": "0.0.0-beta-19086",
+ "engineReleaseTag": "engine-1.18.32-r2"
}