mirror of
https://github.com/hanzoai/dev-desktop.git
synced 2026-11-20 01:07:23 +00:00
126 lines
4.8 KiB
TypeScript
126 lines
4.8 KiB
TypeScript
// TEMPORARY one-time workaround for a Node --build-sea bug on Linux arm64.
|
|
// It breaks kernels with 16 KiB or 64 KiB pages. Revert when Node ships a fix.
|
|
// Node issue: https://github.com/nodejs/node/issues/67048
|
|
// Workaround PR: https://github.com/hanzoai/dev/pull/25825
|
|
import * as NodeModule from "node:module";
|
|
import * as Effect from "effect/Effect";
|
|
import * as FileSystem from "effect/FileSystem";
|
|
import * as Path from "effect/Path";
|
|
import * as Schema from "effect/Schema";
|
|
import { ChildProcess, ChildProcessSpawner } from "effect/process";
|
|
|
|
class LinuxArm64SeaError extends Schema.TaggedError<LinuxArm64SeaError>()("LinuxArm64SeaError", {
|
|
message: Schema.String,
|
|
}) {}
|
|
|
|
const encodeJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
|
|
|
|
const run = Effect.fn("LinuxArm64Sea.run")(function* (args: Array<string>, verbose: boolean) {
|
|
const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
|
|
const child = yield* spawner.spawn(
|
|
ChildProcess.make(process.execPath, args, {
|
|
stdout: verbose ? "inherit" : "ignore",
|
|
stderr: "inherit",
|
|
}),
|
|
);
|
|
const exitCode = yield* child.exitCode;
|
|
if (exitCode !== 0) {
|
|
return yield* new LinuxArm64SeaError({ message: `${args[0]} exited with code ${exitCode}.` });
|
|
}
|
|
});
|
|
|
|
// Builds the SEA blob with this Node and injects it into a copy of this Node with postject.
|
|
export const injectLinuxArm64Sea = Effect.fn("LinuxArm64Sea.inject")(function* (input: {
|
|
bundlePath: string;
|
|
cliAssetPath: string;
|
|
outputPath: string;
|
|
nodeVersion: string;
|
|
verbose: boolean;
|
|
}) {
|
|
// The copied execPath is the shipped runtime; vp pack only checks its own Node.
|
|
if (process.versions.node !== input.nodeVersion) {
|
|
return yield* new LinuxArm64SeaError({
|
|
message: `Linux ARM64 executables must be built with Node ${input.nodeVersion}; running ${process.versions.node}.`,
|
|
});
|
|
}
|
|
const fs = yield* FileSystem.FileSystem;
|
|
const path = yield* Path.Path;
|
|
const temp = yield* fs.makeTempDirectoryScoped({ prefix: "hanzo-sea-" });
|
|
const blobPath = path.join(temp, "sea.blob");
|
|
const configPath = path.join(temp, "sea.json");
|
|
yield* fs.writeFileString(
|
|
configPath,
|
|
yield* encodeJson({
|
|
main: input.bundlePath,
|
|
assets: { "binMain.mjs": input.cliAssetPath },
|
|
output: blobPath,
|
|
mainFormat: "module",
|
|
disableExperimentalSEAWarning: true,
|
|
// Node SEA useCodeCache breaks import(), which the server needs.
|
|
useCodeCache: false,
|
|
// The bootstrap loads the embedded CLI with require(esm).
|
|
execArgv: ["--require-module"],
|
|
}),
|
|
);
|
|
yield* run(["--experimental-sea-config", configPath], input.verbose);
|
|
yield* fs.copyFile(process.execPath, input.outputPath);
|
|
yield* fs.chmod(input.outputPath, 0o755);
|
|
const require = NodeModule.createRequire(import.meta.url);
|
|
yield* run(
|
|
[
|
|
require.resolve("postject/dist/cli.js"),
|
|
input.outputPath,
|
|
"NODE_SEA_BLOB",
|
|
blobPath,
|
|
"--sentinel-fuse",
|
|
"NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2",
|
|
],
|
|
input.verbose,
|
|
);
|
|
}, Effect.scoped);
|
|
|
|
// Kernels map LOAD segments in whole pages. Checking at 64 KiB covers 4, 16, and 64 KiB kernels.
|
|
export function assertLinuxArm64PageCompatibility(bytes: Uint8Array) {
|
|
const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
|
|
if (
|
|
bytes.length < 64 ||
|
|
view.getUint32(0, false) !== 0x7f454c46 ||
|
|
bytes[4] !== 2 ||
|
|
bytes[5] !== 1 ||
|
|
view.getUint16(18, true) !== 183
|
|
) {
|
|
throw new Error("Expected a little-endian ELF64 ARM64 executable.");
|
|
}
|
|
const tableOffset = Number(view.getBigUint64(32, true));
|
|
const entrySize = view.getUint16(54, true);
|
|
const count = view.getUint16(56, true);
|
|
if (
|
|
!Number.isSafeInteger(tableOffset) ||
|
|
entrySize < 56 ||
|
|
count === 0 ||
|
|
tableOffset + entrySize * count > bytes.length
|
|
) {
|
|
throw new Error("Invalid ELF program header table.");
|
|
}
|
|
const pageSize = 0x10000n;
|
|
const ranges: Array<{ start: bigint; end: bigint }> = [];
|
|
for (let index = 0; index < count; index++) {
|
|
const header = tableOffset + index * entrySize;
|
|
if (view.getUint32(header, true) !== 1) continue;
|
|
const offset = view.getBigUint64(header + 8, true);
|
|
const address = view.getBigUint64(header + 16, true);
|
|
const size = view.getBigUint64(header + 40, true);
|
|
if (offset % pageSize !== address % pageSize) {
|
|
throw new Error(`ARM64 LOAD segment ${index} is incompatible with 64 KiB pages.`);
|
|
}
|
|
if (size === 0n) continue;
|
|
const start = address / pageSize;
|
|
const end = (address + size + pageSize - 1n) / pageSize;
|
|
if (ranges.some((range) => start < range.end && range.start < end)) {
|
|
throw new Error(`ARM64 LOAD segments overlap on a 64 KiB page (segment ${index}).`);
|
|
}
|
|
ranges.push({ start, end });
|
|
}
|
|
if (ranges.length === 0) throw new Error("ELF executable has no LOAD segments.");
|
|
}
|