A desktop coding agent with free access to frontier models.
TypeScript
import { spawnSync } from "child_process";
import { createHash } from "crypto";
import {
chmodSync,
closeSync,
copyFileSync,
existsSync,
mkdirSync,
openSync,
readFileSync,
readSync,
readdirSync,
statSync,
unlinkSync,
writeFileSync,
} from "fs";
import { basename, dirname, join, resolve } from "path";
import { homedir, tmpdir } from "os";
import { fileURLToPath } from "url";
const __dirname = dirname(fileURLToPath(import.meta.url));
const readArg = (name) => {
const raw = process.argv.slice(2);
const direct = raw.find((arg) => arg.startsWith(`${name}=`));
if (direct) return direct.split("=")[1];
const index = raw.indexOf(name);
if (index >= 0 && raw[index + 1]) return raw[index + 1];
return null;
};
const sidecarOverride = process.env.OMNIRUSH_SIDECAR_DIR?.trim() || readArg("--outdir");
// `--engine v2`: the OpenCode 2.x engine (engine-v2-release.json) beside the 1.x one, as `opencode2-<triple>`.
const engineV2 = readArg("--engine") === "v2";
const sidecarDir = sidecarOverride ? resolve(sidecarOverride) : join(__dirname, "..", "resources", "sidecars");
const constantsPath = resolve(__dirname, "..", "..", "..", "constants.json");
const opencodeVersion = (() => {
try {
const raw = readFileSync(constantsPath, "utf8");
const parsed = JSON.parse(raw);
const pinned = engineV2 ? parsed.opencodeV2Version : parsed.opencodeVersion;
return typeof pinned === "string" ? pinned.trim() || null : null;
} catch {
return null;
}
})();
const normalizeVersion = (value) => {
const raw = String(value ?? "").trim();
if (!raw) return null;
if (raw.toLowerCase() === "latest") return null;
return raw.startsWith("v") ? raw.slice(1) : raw;
};
// The engine is OmniRush.ai's build of opencode 1.18.32 (the one the CLI
// bundles): per-platform tarballs on a public pre-release of this repo (never
// marked latest), sha256-pinned in engine-release.json. No token is needed.
// Each tarball holds one executable, `opencode[.exe]`, at its root.
const engineReleasePath = resolve(__dirname, engineV2 ? "engine-v2-release.json" : "engine-release.json");
const engineRelease = JSON.parse(readFileSync(engineReleasePath, "utf8"));
// Target triple for native platform binaries
const resolvedTargetTriple = (() => {
const envTarget =
process.env.TAURI_ENV_TARGET_TRIPLE ??
process.env.CARGO_CFG_TARGET_TRIPLE ??
process.env.TARGET;
if (envTarget) return envTarget;
if (process.platform === "darwin") {
return process.arch === "arm64" ? "aarch64-apple-darwin" : "x86_64-apple-darwin";
}
if (process.platform === "linux") {
return process.arch === "arm64" ? "aarch64-unknown-linux-gnu" : "x86_64-unknown-linux-gnu";
}
if (process.platform === "win32") {
return process.arch === "arm64" ? "aarch64-pc-windows-msvc" : "x86_64-pc-windows-msvc";
}
return null;
})();
const isWindowsTarget = process.platform === "win32" || resolvedTargetTriple?.includes("windows") === true;
const engineBase = engineV2 ? "opencode2" : "opencode";
const opencodeBaseName = isWindowsTarget ? `${engineBase}.exe` : engineBase;
const opencodePath = join(sidecarDir, opencodeBaseName);
const opencodeTargetName = resolvedTargetTriple
? `${engineBase}-${resolvedTargetTriple}${isWindowsTarget ? ".exe" : ""}`
: null;
const opencodeTargetPath = opencodeTargetName ? join(sidecarDir, opencodeTargetName) : null;
const opencodeCandidatePath = opencodeTargetPath ?? opencodePath;
let existingOpencodeVersion = null;
// omnirush-server paths
const omnirushServerDir = resolve(__dirname, "..", "..", "server");
const readHeader = (filePath, length = 256) => {
const fd = openSync(filePath, "r");
try {
const buffer = Buffer.alloc(length);
const bytesRead = readSync(fd, buffer, 0, length, 0);
return buffer.subarray(0, bytesRead).toString("utf8");
} finally {
closeSync(fd);
}
};
const isStubBinary = (filePath) => {
try {
const stat = statSync(filePath);
if (!stat.isFile()) return true;
if (stat.size < 1024) return true;
const header = readHeader(filePath);
if (header.startsWith("#!")) return true;
if (header.includes("Sidecar missing") || header.includes("Bun is required")) return true;
} catch {
return true;
}
return false;
};
const readDirectory = (dir) => {
let entries = [];
try {
entries = readdirSync(dir, { withFileTypes: true });
} catch {
return [];
}
return entries.flatMap((entry) => {
const next = join(dir, entry.name);
if (entry.isDirectory()) {
return readDirectory(next);
}
if (entry.isFile()) {
return [next];
}
return [];
});
};
const findOpencodeBinary = (dir) => {
const candidates = readDirectory(dir);
return (
candidates.find((file) => file.endsWith(`/${opencodeBaseName}`) || file.endsWith(`\\${opencodeBaseName}`)) ??
candidates.find((file) => file.endsWith("/opencode.exe") || file.endsWith("\\opencode.exe")) ??
candidates.find((file) => file.endsWith("/opencode") || file.endsWith("\\opencode")) ??
null
);
};
const readBinaryVersion = (filePath) => {
try {
const result = spawnSync(filePath, ["--version"], { encoding: "utf8" });
if (result.status === 0 && result.stdout) {
// The engine prints the bare version ("1.18.32").
const match = result.stdout.trim().match(/(\d+\.\d+\.\d+(?:[-+][\w.-]+)?)\s*$/);
return match ? match[1] : result.stdout.trim();
}
} catch {
// ignore
}
return null;
};
const sha256File = (filePath) => {
const hash = createHash("sha256");
hash.update(readFileSync(filePath));
return hash.digest("hex");
};
const adHocSignDarwin = (filePath) => {
if (process.platform !== "darwin" || !filePath || !existsSync(filePath)) return;
const remove = spawnSync("codesign", ["--remove-signature", filePath], {
encoding: "utf8",
});
if (remove.error && remove.error.code === "ENOENT") {
throw new Error("codesign is required to prepare runnable macOS sidecars");
}
const sign = spawnSync("codesign", ["--force", "--sign", "-", filePath], {
encoding: "utf8",
});
if (sign.error) {
if (sign.error.code === "ENOENT") {
throw new Error("codesign is required to prepare runnable macOS sidecars");
}
throw sign.error;
}
if (sign.status !== 0) {
const stderr = sign.stderr?.trim();
throw new Error(`Failed to codesign ${filePath}${stderr ? `: ${stderr}` : ""}`);
}
};
const adHocSignDarwinSidecars = (paths) => {
if (process.platform !== "darwin") return;
for (const filePath of [...new Set(paths.filter(Boolean))]) {
adHocSignDarwin(filePath);
}
};
// omnirush-server is no longer compiled as a sidecar binary — it runs
// in-process inside Electron via a direct import of the server library.
// Server binary copy/sign skipped — runs in-process.
if (!existingOpencodeVersion && opencodeCandidatePath) {
existingOpencodeVersion =
existsSync(opencodeCandidatePath) && !isStubBinary(opencodeCandidatePath)
? readBinaryVersion(opencodeCandidatePath)
: null;
}
const normalizedOpencodeVersion = normalizeVersion(opencodeVersion);
if (!normalizedOpencodeVersion) {
console.error(
`OpenCode version could not be resolved from ${constantsPath}.`
);
process.exit(1);
}
if (normalizedOpencodeVersion !== engineRelease.version) {
console.error(
`constants.json pins OpenCode ${normalizedOpencodeVersion}, but ${engineReleasePath} pins the engine release ${engineRelease.tag} (${engineRelease.version}).`
);
process.exit(1);
}
const engineAsset = resolvedTargetTriple ? engineRelease.assets?.[resolvedTargetTriple] ?? null : null;
/** What the sidecar directory holds: the engine release and archive it was taken from. */
const readRecordedEngine = () => {
const names = [resolvedTargetTriple ? `versions.json-${resolvedTargetTriple}${isWindowsTarget ? ".exe" : ""}` : null, "versions.json"];
for (const name of names.filter(Boolean)) {
try {
const parsed = JSON.parse(readFileSync(join(sidecarDir, name), "utf8"));
if (parsed?.[engineBase]) return parsed[engineBase];
} catch {
// not recorded
}
}
return null;
};
const recordedEngine = readRecordedEngine();
const shouldDownloadOpencode =
!opencodeCandidatePath ||
!existsSync(opencodeCandidatePath) ||
isStubBinary(opencodeCandidatePath) ||
!existingOpencodeVersion ||
existingOpencodeVersion !== normalizedOpencodeVersion ||
!engineAsset ||
recordedEngine?.archiveSha256 !== engineAsset.sha256 ||
(opencodeCandidatePath && recordedEngine?.sha256 !== sha256File(opencodeCandidatePath));
if (!shouldDownloadOpencode) {
console.log(`OpenCode sidecar already present (${existingOpencodeVersion}, ${engineRelease.tag}).`);
}
/** A public release asset's bytes, with a few tries (GitHub's download hosts answer 5xx now and then). */
const download = async (url) => {
let last = null;
for (let attempt = 1; attempt <= 4; attempt++) {
try {
const response = await fetch(url, { headers: { "user-agent": "omnirush-desktop-prepare-sidecar" }, redirect: "follow" });
if (response.ok) return Buffer.from(await response.arrayBuffer());
last = new Error(`GitHub answered ${response.status} for ${url}`);
if (response.status < 500 && response.status !== 429) break;
} catch (error) {
last = error;
}
await new Promise((done) => setTimeout(done, 2_000 * attempt));
}
throw last ?? new Error(`Download of ${url} failed`);
};
/** The pinned archive's bytes: a local copy (OMNIRUSH_ENGINE_ARCHIVE), the cache, or the public release. */
const readEngineArchive = async () => {
const verify = (bytes, source) => {
const actual = createHash("sha256").update(bytes).digest("hex");
if (actual !== engineAsset.sha256) {
throw new Error(`Checksum mismatch for ${engineAsset.name} from ${source}: expected ${engineAsset.sha256}, got ${actual}`);
}
return bytes;
};
const local = engineV2 ? null : process.env.OMNIRUSH_ENGINE_ARCHIVE?.trim();
if (local) return verify(readFileSync(resolve(local)), local);
// A folder of release archives not uploaded yet (either engine; only its own asset name is read).
const localDir = process.env.OMNIRUSH_ENGINE_ARCHIVE_DIR?.trim();
if (localDir && existsSync(join(resolve(localDir), engineAsset.name))) {
const file = join(resolve(localDir), engineAsset.name);
return verify(readFileSync(file), file);
}
const cacheDir = process.env.OMNIRUSH_ENGINE_CACHE?.trim()
? resolve(process.env.OMNIRUSH_ENGINE_CACHE.trim())
: join(homedir(), ".cache", "omnirush-desktop", "engine");
const cached = join(cacheDir, engineRelease.tag, engineAsset.name);
if (existsSync(cached)) {
try {
return verify(readFileSync(cached), cached);
} catch (error) {
console.warn(`${error instanceof Error ? error.message : String(error)}; downloading it again.`);
}
}
const url = `https://github.com/${engineRelease.repo}/releases/download/${engineRelease.tag}/${engineAsset.name}`;
const bytes = verify(await download(url), url);
try {
mkdirSync(dirname(cached), { recursive: true });
writeFileSync(cached, bytes);
} catch {
// the cache is optional
}
return bytes;
};
if (shouldDownloadOpencode) {
if (!engineAsset) {
console.error(`No engine archive is pinned for target ${resolvedTargetTriple ?? "unknown"} in ${engineReleasePath}.`);
process.exit(1);
}
mkdirSync(sidecarDir, { recursive: true });
const stamp = Date.now();
const archivePath = join(tmpdir(), `opencode-${stamp}-${engineAsset.name}`);
const extractDir = join(tmpdir(), `opencode-${stamp}`);
mkdirSync(extractDir, { recursive: true });
try {
writeFileSync(archivePath, await readEngineArchive());
} catch (error) {
console.error(error instanceof Error ? error.message : String(error));
process.exit(1);
}
// bsdtar (Windows 10+ tar.exe) and GNU tar both read gzip tarballs. Paths
// are relative to the temp dir: Git Bash's GNU tar on Windows reads
// "C:\..." as a remote host ("Cannot connect to C: resolve failed").
const tarResult = spawnSync(
"tar",
["-xzf", basename(archivePath), "-C", basename(extractDir)],
{ stdio: "inherit", cwd: tmpdir() },
);
if (tarResult.status !== 0) {
process.exit(tarResult.status ?? 1);
}
const extractedBinary = findOpencodeBinary(extractDir);
if (!extractedBinary) {
console.error("OpenCode binary not found after extraction.");
process.exit(1);
}
const opencodeTargets = [opencodeTargetPath, opencodePath].filter(Boolean);
for (const target of opencodeTargets) {
try {
if (existsSync(target)) {
unlinkSync(target);
}
} catch {
// ignore
}
copyFileSync(extractedBinary, target);
try {
chmodSync(target, 0o755);
} catch {
// ignore
}
}
try {
unlinkSync(archivePath);
} catch {
// ignore
}
console.log(`OpenCode sidecar updated to ${normalizedOpencodeVersion} (${engineRelease.tag}).`);
}
adHocSignDarwinSidecars([
opencodePath,
opencodeTargetPath,
// omnirush-server runs in-process — no binary to sign.
]);
const omnirushServerVersion = (() => {
try {
const raw = readFileSync(resolve(omnirushServerDir, "package.json"), "utf8");
return String(JSON.parse(raw).version ?? "").trim();
} catch {
return null;
}
})();
// One versions.json for both engines: each run updates its own entry.
const previousVersions = (() => {
try {
return JSON.parse(readFileSync(join(sidecarDir, "versions.json"), "utf8"));
} catch {
return {};
}
})();
const versions = {
...(engineV2 ? previousVersions : previousVersions.opencode2 ? { opencode2: previousVersions.opencode2 } : {}),
[engineBase]: {
version: normalizedOpencodeVersion,
sha256: opencodeCandidatePath && existsSync(opencodeCandidatePath) ? sha256File(opencodeCandidatePath) : null,
release: engineRelease.tag,
archiveSha256: engineAsset?.sha256 ?? null,
},
"omnirush-server": {
version: omnirushServerVersion,
sha256: "in-process",
},
};
const missing = Object.entries(versions)
.filter(([, info]) => !info.version || !info.sha256)
.map(([name]) => name);
if (missing.length) {
console.error(`Sidecar version metadata incomplete for: ${missing.join(", ")}`);
process.exit(1);
}
const versionsPath = join(sidecarDir, "versions.json");
try {
mkdirSync(sidecarDir, { recursive: true });
const content = JSON.stringify(versions, null, 2) + "\n";
writeFileSync(versionsPath, content, "utf8");
if (resolvedTargetTriple) {
const targetSuffix = isWindowsTarget ? ".exe" : "";
const targetVersionsPath = join(sidecarDir, `versions.json-${resolvedTargetTriple}${targetSuffix}`);
writeFileSync(targetVersionsPath, content, "utf8");
}
} catch (error) {
console.error(`Failed to write versions.json: ${error}`);
process.exit(1);
}
// The Linux sandbox's helpers (boxsh, boxd) beside the engine: optional, never fatal.
try {
if (!engineV2) await import("./prepare-box-helpers.mjs");
} catch (error) {
console.warn(`Sandbox helpers not prepared: ${error instanceof Error ? error.message : String(error)}`);
}