mirror of
https://github.com/nightly-labs/openbot.git
synced 2026-11-23 02:01:26 +08:00
* Remove code comments and add the no-comments rule Remove the comments from first-party code and configuration files: TS/JS, JSX, CSS, SQL migrations, Swift, Kotlin, Gradle, shell, Docker, systemd, Nix, YAML, TOML, JSONC and GritQL. Keep only what a tool reads: license headers, shebangs, compiler and lint directives, JSDoc types in plain .js files, generated file headers, GritQL scope lines, the install-server.sh help text and the openbot-boat-pre-stop marker. Vendored code, fixtures and released schemas keep their comments. Add the rule to AGENTS.md, and change the docs that asked for comments. Add two i18n keys that only comments named to RELEASED_SOURCE_KEYS. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Keep comments that are data in strings The benchmark task files in opencode-free-models-bench.ts tell the model what each function must do. The sample file and HTML page in the two stories are display content. Put their comments back. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Keep released migrations and mobile native inputs unchanged check:migrations compares each released migration with v0.73.0 byte for byte, so restore src/backend/migrations. A change to a native build input of apps/mobile makes a new runtime version, so restore those files and the extra fingerprint sources. List these files and the comment markers that a tool reads in AGENTS.md. Remove the last requests for comments in src/renderer/AGENTS.md. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
191 lines
7.5 KiB
TypeScript
191 lines
7.5 KiB
TypeScript
import { execFileSync } from "node:child_process";
|
|
import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
|
|
import { tmpdir } from "node:os";
|
|
import { join, resolve } from "node:path";
|
|
import { createOpenBotLogger } from "@openbot/logging";
|
|
import { z } from "zod";
|
|
import { type AgentRuntimeLock, loadAgentRuntimeLock } from "./agent-runtime-lock";
|
|
import { rejectNonRegularFiles, sha256 } from "./remote-desktop-runtime-release";
|
|
import {
|
|
download,
|
|
escapeRegExp,
|
|
installValidatedTree,
|
|
isCurrentInstallation,
|
|
safeArchivePathParts,
|
|
} from "./runtime-install";
|
|
|
|
const logger = createOpenBotLogger("install-codex-runtime");
|
|
|
|
export type CodexRuntimeTarget = "darwin-arm64" | "darwin-x64" | "linux-x64" | "linux-arm64" | "win32-x64";
|
|
|
|
const packageManifestSchema = z.object({
|
|
layoutVersion: z.literal(1),
|
|
version: z.string(),
|
|
target: z.enum([
|
|
"aarch64-apple-darwin",
|
|
"x86_64-apple-darwin",
|
|
"x86_64-pc-windows-msvc",
|
|
"x86_64-unknown-linux-musl",
|
|
"aarch64-unknown-linux-musl",
|
|
]),
|
|
variant: z.literal("codex"),
|
|
entrypoint: z.string(),
|
|
resourcesDir: z.literal("codex-resources"),
|
|
pathDir: z.literal("codex-path"),
|
|
});
|
|
|
|
export async function installCodexRuntime(
|
|
input: {
|
|
sourceRoot?: string;
|
|
outputRoot?: string;
|
|
target?: CodexRuntimeTarget;
|
|
fetchImpl?: typeof fetch;
|
|
lock?: AgentRuntimeLock;
|
|
} = {},
|
|
): Promise<"installed" | "current"> {
|
|
const sourceRoot = input.sourceRoot ?? process.cwd();
|
|
const outputRoot = input.outputRoot ?? resolve(sourceRoot, "build/codex");
|
|
const target = input.target ?? codexRuntimeTarget();
|
|
const fetchImpl = input.fetchImpl ?? fetch;
|
|
const lock = input.lock ?? (await loadAgentRuntimeLock(sourceRoot));
|
|
const artifact = lock.codex.artifacts[target];
|
|
const targetRoot = codexRuntimePath(outputRoot, target);
|
|
|
|
if (await isCurrentInstallation(() => verifyCodexRuntime(targetRoot, target, lock))) {
|
|
await writeMetadata(outputRoot, lock, fetchImpl);
|
|
logger.info(`Using verified bundled Codex ${lock.codex.version} for ${target}.`);
|
|
return "current";
|
|
}
|
|
|
|
const archiveBytes = await download(
|
|
fetchImpl,
|
|
`${lock.codex.repository}/releases/download/${encodeURIComponent(lock.codex.tag)}/${artifact.asset}`,
|
|
"Codex runtime",
|
|
);
|
|
if (sha256(archiveBytes) !== artifact.assetSha256) {
|
|
throw new Error(`The ${target} Codex runtime archive checksum is invalid.`);
|
|
}
|
|
|
|
const temporaryRoot = await mkdtemp(join(tmpdir(), "openbot-codex-install-"));
|
|
try {
|
|
const archive = join(temporaryRoot, artifact.asset);
|
|
const extracted = join(temporaryRoot, "extracted");
|
|
await writeFile(archive, archiveBytes, { mode: 0o600 });
|
|
validateCodexArchive(archive);
|
|
await mkdir(extracted, { recursive: true });
|
|
execFileSync("tar", ["-xzf", archive, "-C", extracted, "--no-same-owner"], { stdio: "inherit" });
|
|
await rejectNonRegularFiles(extracted);
|
|
await verifyCodexRuntime(extracted, target, lock);
|
|
await installValidatedTree(extracted, targetRoot);
|
|
await verifyCodexRuntime(targetRoot, target, lock);
|
|
} finally {
|
|
await rm(temporaryRoot, { recursive: true, force: true });
|
|
}
|
|
|
|
await writeMetadata(outputRoot, lock, fetchImpl);
|
|
logger.info(`Installed bundled Codex ${lock.codex.version} for ${target}.`);
|
|
return "installed";
|
|
}
|
|
|
|
const CODEX_MANIFEST_TARGETS = {
|
|
"darwin-arm64": "aarch64-apple-darwin",
|
|
"darwin-x64": "x86_64-apple-darwin",
|
|
"linux-x64": "x86_64-unknown-linux-musl",
|
|
"linux-arm64": "aarch64-unknown-linux-musl",
|
|
"win32-x64": "x86_64-pc-windows-msvc",
|
|
} as const satisfies Record<CodexRuntimeTarget, string>;
|
|
|
|
export function codexRuntimeTarget(
|
|
platform: string = process.platform,
|
|
architecture: string = process.arch,
|
|
): CodexRuntimeTarget {
|
|
const target = `${platform}-${architecture}`;
|
|
if (
|
|
target === "darwin-arm64" ||
|
|
target === "darwin-x64" ||
|
|
target === "linux-x64" ||
|
|
target === "linux-arm64" ||
|
|
target === "win32-x64"
|
|
)
|
|
return target;
|
|
throw new Error(`Unsupported bundled Codex target: ${target}`);
|
|
}
|
|
|
|
export function codexRuntimePath(root: string, target: CodexRuntimeTarget): string {
|
|
if (target === "darwin-arm64") return join(root, "mac", "arm64");
|
|
if (target === "darwin-x64") return join(root, "mac", "x64");
|
|
if (target === "linux-x64") return join(root, "linux", "x64");
|
|
if (target === "linux-arm64") return join(root, "linux", "arm64");
|
|
return join(root, "win", "x64");
|
|
}
|
|
|
|
export async function verifyCodexRuntime(
|
|
root: string,
|
|
target: CodexRuntimeTarget,
|
|
lock: AgentRuntimeLock,
|
|
): Promise<void> {
|
|
const artifact = lock.codex.artifacts[target];
|
|
const manifest = packageManifestSchema.parse(JSON.parse(await readFile(join(root, "codex-package.json"), "utf8")));
|
|
const expectedTarget = CODEX_MANIFEST_TARGETS[target];
|
|
if (
|
|
manifest.version !== lock.codex.version ||
|
|
manifest.target !== expectedTarget ||
|
|
manifest.entrypoint !== artifact.executable
|
|
) {
|
|
throw new Error("The bundled Codex package manifest does not match the runtime lock.");
|
|
}
|
|
const executable = join(root, ...artifact.executable.split("/"));
|
|
const output = execFileSync(executable, ["--version"], { encoding: "utf8", windowsHide: true }).trim();
|
|
if (!new RegExp(`(?:codex-cli\\s+)?${escapeRegExp(lock.codex.version)}(?:\\s|$)`, "u").test(output)) {
|
|
throw new Error(`Unexpected bundled Codex version: ${output}`);
|
|
}
|
|
await readFile(join(root, "bin", target === "win32-x64" ? "codex-code-mode-host.exe" : "codex-code-mode-host"));
|
|
await readFile(join(root, "codex-path", target === "win32-x64" ? "rg.exe" : "rg"));
|
|
}
|
|
|
|
export function validateCodexArchive(archive: 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 Codex runtime archive contains a link or a special file.");
|
|
}
|
|
for (const name of names) validateArchivePath(name);
|
|
if (!names.includes("codex-package.json") || !names.some((name) => /^bin\/codex(?:\.exe)?$/u.test(name))) {
|
|
throw new Error("The Codex runtime archive is incomplete.");
|
|
}
|
|
return names;
|
|
}
|
|
|
|
function validateArchivePath(name: string): void {
|
|
const parts = safeArchivePathParts(name, "Codex");
|
|
if (!["bin", "codex-package.json", "codex-path", "codex-resources"].includes(parts[0] ?? "")) {
|
|
throw new Error(`Unexpected Codex archive path: ${name}`);
|
|
}
|
|
}
|
|
|
|
async function writeMetadata(root: string, lock: AgentRuntimeLock, fetchImpl: typeof fetch): Promise<void> {
|
|
const licenseRoot = join(root, "licenses");
|
|
const licensePath = join(licenseRoot, "Codex-Apache-2.0.txt");
|
|
await mkdir(licenseRoot, { recursive: true });
|
|
let currentLicense: string | null = null;
|
|
try {
|
|
currentLicense = sha256(await readFile(licensePath));
|
|
} catch {}
|
|
if (currentLicense !== lock.codex.licenseSha256) {
|
|
const bytes = await download(
|
|
fetchImpl,
|
|
`${lock.codex.repository}/raw/${encodeURIComponent(lock.codex.tag)}/LICENSE`,
|
|
"Codex license",
|
|
);
|
|
if (sha256(bytes) !== lock.codex.licenseSha256) throw new Error("The Codex license checksum is invalid.");
|
|
await writeFile(licensePath, bytes);
|
|
}
|
|
await writeFile(join(root, "source-manifest.json"), `${JSON.stringify({ name: "codex", ...lock.codex }, null, 2)}\n`);
|
|
}
|
|
|
|
if (import.meta.main) {
|
|
await installCodexRuntime({
|
|
target: codexRuntimeTarget(process.argv[2] ?? process.platform, process.argv[3] ?? process.arch),
|
|
});
|
|
}
|