import { execFileSync } from "node:child_process"; import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { z } from "zod"; import { type AgentRuntimeLock, loadAgentRuntimeLock } from "./agent-runtime-lock"; import { sha256, sha256File } from "./remote-desktop-runtime-release"; export type OpencodeRuntimeTarget = "darwin-arm64" | "darwin-x64" | "linux-x64" | "linux-arm64" | "win32-x64"; const TARGETS = { "darwin-arm64": { package: "@opencode/cli-darwin-arm64", executable: "opencode", platformDirectory: "mac" }, "darwin-x64": { package: "@opencode/cli-darwin-x64", executable: "opencode", platformDirectory: "mac" }, "linux-x64": { package: "@opencode/cli-linux-x64", executable: "opencode", platformDirectory: "linux" }, "linux-arm64": { package: "@opencode/cli-linux-arm64", executable: "opencode", platformDirectory: "linux" }, "win32-x64": { package: "@opencode/cli-windows-x64", executable: "opencode.exe", platformDirectory: "win" }, } as const satisfies Record; const TARGET_IDS: readonly OpencodeRuntimeTarget[] = [ "darwin-arm64", "darwin-x64", "linux-x64", "linux-arm64", "win32-x64", ]; const REGISTRY = "https://registry.npmjs.org"; const CLI_PACKAGE = "@opencode/cli"; const LICENSE_PACKAGE = "opencode-ai"; const REPOSITORY = "https://github.com/anomalyco/opencode"; const DISK_HEADROOM = 1.05; const DISK_GRANULARITY = 10_000_000; const umbrellaSchema = z.object({ version: z.string().regex(/^\d+\.\d+\.\d+$/u), optionalDependencies: z.record(z.string(), z.string()), }); const platformSchema = z.object({ name: z.string(), version: z.string(), dist: z.object({ tarball: z.string().url(), unpackedSize: z.number().int().positive(), }), }); const packageManifestSchema = z.object({ name: z.string(), version: z.string() }); export interface OpencodeRuntimePin { registry: string; repository: string; version: string; license: "MIT"; licensePackage: { name: typeof LICENSE_PACKAGE; version: string }; licenseSha256: string; artifacts: Record; } interface OpencodeArtifactPin { package: string; asset: string; assetSha256: string; binarySha256: string; downloadBytes: number; installedBytes: number; executable: string; platformDirectory: string; } export async function pinOpencodeRuntime( input: { version?: string | undefined; licenseVersion?: string | undefined; fetchImpl?: typeof fetch; runBinary?: boolean; } = {}, ): Promise { const fetchImpl = input.fetchImpl ?? fetch; const umbrella = await fetchParsed( fetchImpl, `${REGISTRY}/${CLI_PACKAGE}/${input.version ?? "latest"}`, umbrellaSchema, ); const version = umbrella.version; const pinTarget = (target: OpencodeRuntimeTarget) => pinArtifact(fetchImpl, target, version, umbrella.optionalDependencies, input.runBinary); const artifacts: Record = { "darwin-arm64": await pinTarget("darwin-arm64"), "darwin-x64": await pinTarget("darwin-x64"), "linux-x64": await pinTarget("linux-x64"), "linux-arm64": await pinTarget("linux-arm64"), "win32-x64": await pinTarget("win32-x64"), }; const licenseVersion = input.licenseVersion ?? (await fetchParsed(fetchImpl, `${REGISTRY}/${LICENSE_PACKAGE}/latest`, packageManifestSchema)).version; const license = await packageLicense(fetchImpl, licenseVersion); return { registry: REGISTRY, repository: REPOSITORY, version, license: "MIT", licensePackage: { name: LICENSE_PACKAGE, version: licenseVersion }, licenseSha256: sha256(license), artifacts, }; } async function pinArtifact( fetchImpl: typeof fetch, target: OpencodeRuntimeTarget, version: string, optionalDependencies: Record, runBinary = true, ): Promise { const descriptor = TARGETS[target]; if (optionalDependencies[descriptor.package] !== version) { throw new Error(`${CLI_PACKAGE} ${version} does not list ${descriptor.package} at the same version.`); } const platform = await fetchParsed(fetchImpl, `${REGISTRY}/${descriptor.package}/${version}`, platformSchema); if (platform.name !== descriptor.package || platform.version !== version) { throw new Error(`The registry served the wrong package for ${target}.`); } const asset = `${descriptor.package.slice(descriptor.package.indexOf("/") + 1)}-${version}.tgz`; if (platform.dist.tarball !== `${REGISTRY}/${descriptor.package}/-/${asset}`) { throw new Error(`Unexpected tarball URL for ${target}: ${platform.dist.tarball}`); } const archiveBytes = await fetchBytes(fetchImpl, platform.dist.tarball); const temporaryRoot = await mkdtemp(join(tmpdir(), "openbot-opencode-pin-")); try { const archive = join(temporaryRoot, asset); const extracted = join(temporaryRoot, "extracted"); await writeFile(archive, archiveBytes, { mode: 0o600 }); validateOpencodeArchive(archive, descriptor.executable); await mkdir(extracted, { recursive: true }); execFileSync("tar", ["-xzf", archive, "-C", extracted, "--no-same-owner"], { stdio: "inherit" }); const packageRoot = join(extracted, "package"); const manifest = packageManifestSchema.parse(JSON.parse(await readFile(join(packageRoot, "package.json"), "utf8"))); if (manifest.name !== descriptor.package || manifest.version !== version) { throw new Error(`The ${target} package manifest does not match the registry metadata.`); } const binary = join(packageRoot, "bin", descriptor.executable); if (runBinary && target === `${process.platform}-${process.arch}`) { await chmod(binary, 0o755); const printed = execFileSync(binary, ["--version"], { encoding: "utf8", windowsHide: true }).trim(); if (printed.replace(/^(?:opencode\s+)?v?/iu, "") !== version) { throw new Error(`The ${target} binary prints "${printed}" and not "${version}".`); } } return { package: descriptor.package, asset, assetSha256: sha256(archiveBytes), binarySha256: await sha256File(binary), downloadBytes: archiveBytes.byteLength, installedBytes: Math.ceil((platform.dist.unpackedSize * DISK_HEADROOM) / DISK_GRANULARITY) * DISK_GRANULARITY, executable: descriptor.executable, platformDirectory: descriptor.platformDirectory, }; } finally { await rm(temporaryRoot, { recursive: true, force: true }); } } async function packageLicense(fetchImpl: typeof fetch, version: string): Promise { const asset = `${LICENSE_PACKAGE}-${version}.tgz`; const archiveBytes = await fetchBytes(fetchImpl, `${REGISTRY}/${LICENSE_PACKAGE}/-/${asset}`); const temporaryRoot = await mkdtemp(join(tmpdir(), "openbot-opencode-pin-")); try { const archive = join(temporaryRoot, asset); await writeFile(archive, archiveBytes, { mode: 0o600 }); execFileSync( "tar", ["-xzf", archive, "-C", temporaryRoot, "--no-same-owner", "package/package.json", "package/LICENSE"], { stdio: "inherit" }, ); const manifest = packageManifestSchema.parse( JSON.parse(await readFile(join(temporaryRoot, "package", "package.json"), "utf8")), ); if (manifest.name !== LICENSE_PACKAGE || manifest.version !== version) { throw new Error(`The ${LICENSE_PACKAGE} ${version} package manifest does not match the registry metadata.`); } return await readFile(join(temporaryRoot, "package", "LICENSE")); } finally { await rm(temporaryRoot, { recursive: true, force: true }); } } export function validateOpencodeArchive(archive: string, executable: string): string[] { const names = execFileSync("tar", ["-tzf", archive], { encoding: "utf8" }).split(/\r?\n/u).filter(Boolean); const details = execFileSync("tar", ["-tvzf", archive], { encoding: "utf8" }).split(/\r?\n/u).filter(Boolean); if (details.some((line) => !["-", "d"].includes(line.trimStart().charAt(0)))) { throw new Error("The OpenCode runtime archive contains a link or a special file."); } for (const name of names) { if (name.includes("\0") || name.includes("\\")) throw new Error(`Unsafe OpenCode archive path: ${name}`); const parts = name.replace(/\/+$/u, "").split("/"); if (parts[0] !== "package" || parts.some((part) => !part || part === "." || part === "..")) { throw new Error(`Unsafe OpenCode archive path: ${name}`); } } for (const required of ["package/package.json", `package/bin/${executable}`]) { if (!names.includes(required)) throw new Error(`The OpenCode runtime archive is missing ${required}.`); } return names; } async function fetchParsed( fetchImpl: typeof fetch, url: string, schema: Schema, ): Promise> { return schema.parse(JSON.parse(Buffer.from(await fetchBytes(fetchImpl, url)).toString("utf8"))); } async function fetchBytes(fetchImpl: typeof fetch, url: string): Promise { const response = await fetchImpl(url, { headers: { "User-Agent": "OpenBot-runtime-pin" }, redirect: "follow", }); if (!response.ok) throw new Error(`${url} answered HTTP ${response.status}.`); return Buffer.from(await response.arrayBuffer()); } export function isPinnedAlready(pin: OpencodeRuntimePin, lock: AgentRuntimeLock): boolean { return JSON.stringify(pin) === JSON.stringify(lock.opencode); } if (import.meta.main) { const pin = await pinOpencodeRuntime({ version: process.argv[2], licenseVersion: process.argv[3] }); const lock = await loadAgentRuntimeLock().catch(() => null); process.stdout.write(`${JSON.stringify({ opencode: pin }, null, 2)}\n`); for (const target of TARGET_IDS) { if (target !== `${process.platform}-${process.arch}`) { process.stdout.write(`This host cannot run the ${target} binary, so its version is not asserted.\n`); } } if (lock && isPinnedAlready(pin, lock)) { process.stdout.write(`native-runtime.lock.json already pins OpenCode ${pin.version}.\n`); } else { process.stdout.write(`Copy the "opencode" block above into native-runtime.lock.json.\n`); } }