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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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 UploadTooimport { 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: stringos: 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.jsonindex 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"}