feat: Bun single-file executable distribution (#819)

* feat: add Bun single-file executable distribution

- Add 7 platform packages for standalone CLI binaries
- Add bin/platform.js for shared platform detection
- Add bin/oh-my-opencode.js ESM wrapper
- Add postinstall.mjs for binary verification
- Add script/build-binaries.ts for cross-compilation
- Update publish workflow for multi-package publishing
- Add CI guard against @ast-grep/napi in CLI
- Add unit tests for platform detection (12 tests)
- Update README to remove Bun runtime requirement

Platforms supported:
- macOS ARM64 & x64
- Linux x64 & ARM64 (glibc)
- Linux x64 & ARM64 (musl/Alpine)
- Windows x64

Closes #816

* chore: remove unnecessary @ast-grep/napi CI check

* chore: gitignore compiled platform binaries

* fix: use require() instead of top-level await import() for Bun compile compatibility

* refactor: use static ESM import for package.json instead of require()
This commit is contained in:
Kenny
2026-01-15 10:33:07 -05:00
committed by GitHub
parent 72a3975799
commit c67ca8275e
26 changed files with 695 additions and 30 deletions
+80
View File
@@ -0,0 +1,80 @@
#!/usr/bin/env node
// bin/oh-my-opencode.js
// Wrapper script that detects platform and spawns the correct binary
import { spawnSync } from "node:child_process";
import { createRequire } from "node:module";
import { getPlatformPackage, getBinaryPath } from "./platform.js";
const require = createRequire(import.meta.url);
/**
* Detect libc family on Linux
* @returns {string | null} 'glibc', 'musl', or null if detection fails
*/
function getLibcFamily() {
if (process.platform !== "linux") {
return undefined; // Not needed on non-Linux
}
try {
const detectLibc = require("detect-libc");
return detectLibc.familySync();
} catch {
// detect-libc not available
return null;
}
}
function main() {
const { platform, arch } = process;
const libcFamily = getLibcFamily();
// Get platform package name
let pkg;
try {
pkg = getPlatformPackage({ platform, arch, libcFamily });
} catch (error) {
console.error(`\noh-my-opencode: ${error.message}\n`);
process.exit(1);
}
// Resolve binary path
const binRelPath = getBinaryPath(pkg, platform);
let binPath;
try {
binPath = require.resolve(binRelPath);
} catch {
console.error(`\noh-my-opencode: Platform binary not installed.`);
console.error(`\nYour platform: ${platform}-${arch}${libcFamily === "musl" ? "-musl" : ""}`);
console.error(`Expected package: ${pkg}`);
console.error(`\nTo fix, run:`);
console.error(` npm install ${pkg}\n`);
process.exit(1);
}
// Spawn the binary
const result = spawnSync(binPath, process.argv.slice(2), {
stdio: "inherit",
});
// Handle spawn errors
if (result.error) {
console.error(`\noh-my-opencode: Failed to execute binary.`);
console.error(`Error: ${result.error.message}\n`);
process.exit(2);
}
// Handle signals
if (result.signal) {
const signalNum = result.signal === "SIGTERM" ? 15 :
result.signal === "SIGKILL" ? 9 :
result.signal === "SIGINT" ? 2 : 1;
process.exit(128 + signalNum);
}
process.exit(result.status ?? 1);
}
main();
+38
View File
@@ -0,0 +1,38 @@
// bin/platform.js
// Shared platform detection module - used by wrapper and postinstall
/**
* Get the platform-specific package name
* @param {{ platform: string, arch: string, libcFamily?: string | null }} options
* @returns {string} Package name like "oh-my-opencode-darwin-arm64"
* @throws {Error} If libc cannot be detected on Linux
*/
export function getPlatformPackage({ platform, arch, libcFamily }) {
let suffix = "";
if (platform === "linux") {
if (libcFamily === null || libcFamily === undefined) {
throw new Error(
"Could not detect libc on Linux. " +
"Please ensure detect-libc is installed or report this issue."
);
}
if (libcFamily === "musl") {
suffix = "-musl";
}
}
// Map platform names: win32 -> windows (for package name)
const os = platform === "win32" ? "windows" : platform;
return `oh-my-opencode-${os}-${arch}${suffix}`;
}
/**
* Get the path to the binary within a platform package
* @param {string} pkg Package name
* @param {string} platform Process platform
* @returns {string} Relative path like "oh-my-opencode-darwin-arm64/bin/oh-my-opencode"
*/
export function getBinaryPath(pkg, platform) {
const ext = platform === "win32" ? ".exe" : "";
return `${pkg}/bin/oh-my-opencode${ext}`;
}
+148
View File
@@ -0,0 +1,148 @@
// bin/platform.test.ts
import { describe, expect, test } from "bun:test";
import { getPlatformPackage, getBinaryPath } from "./platform.js";
describe("getPlatformPackage", () => {
// #region Darwin platforms
test("returns darwin-arm64 for macOS ARM64", () => {
// #given macOS ARM64 platform
const input = { platform: "darwin", arch: "arm64" };
// #when getting platform package
const result = getPlatformPackage(input);
// #then returns correct package name
expect(result).toBe("oh-my-opencode-darwin-arm64");
});
test("returns darwin-x64 for macOS Intel", () => {
// #given macOS x64 platform
const input = { platform: "darwin", arch: "x64" };
// #when getting platform package
const result = getPlatformPackage(input);
// #then returns correct package name
expect(result).toBe("oh-my-opencode-darwin-x64");
});
// #endregion
// #region Linux glibc platforms
test("returns linux-x64 for Linux x64 with glibc", () => {
// #given Linux x64 with glibc
const input = { platform: "linux", arch: "x64", libcFamily: "glibc" };
// #when getting platform package
const result = getPlatformPackage(input);
// #then returns correct package name
expect(result).toBe("oh-my-opencode-linux-x64");
});
test("returns linux-arm64 for Linux ARM64 with glibc", () => {
// #given Linux ARM64 with glibc
const input = { platform: "linux", arch: "arm64", libcFamily: "glibc" };
// #when getting platform package
const result = getPlatformPackage(input);
// #then returns correct package name
expect(result).toBe("oh-my-opencode-linux-arm64");
});
// #endregion
// #region Linux musl platforms
test("returns linux-x64-musl for Alpine x64", () => {
// #given Linux x64 with musl (Alpine)
const input = { platform: "linux", arch: "x64", libcFamily: "musl" };
// #when getting platform package
const result = getPlatformPackage(input);
// #then returns correct package name with musl suffix
expect(result).toBe("oh-my-opencode-linux-x64-musl");
});
test("returns linux-arm64-musl for Alpine ARM64", () => {
// #given Linux ARM64 with musl (Alpine)
const input = { platform: "linux", arch: "arm64", libcFamily: "musl" };
// #when getting platform package
const result = getPlatformPackage(input);
// #then returns correct package name with musl suffix
expect(result).toBe("oh-my-opencode-linux-arm64-musl");
});
// #endregion
// #region Windows platform
test("returns windows-x64 for Windows", () => {
// #given Windows x64 platform (win32 is Node's platform name)
const input = { platform: "win32", arch: "x64" };
// #when getting platform package
const result = getPlatformPackage(input);
// #then returns correct package name with 'windows' not 'win32'
expect(result).toBe("oh-my-opencode-windows-x64");
});
// #endregion
// #region Error cases
test("throws error for Linux with null libcFamily", () => {
// #given Linux platform with null libc detection
const input = { platform: "linux", arch: "x64", libcFamily: null };
// #when getting platform package
// #then throws descriptive error
expect(() => getPlatformPackage(input)).toThrow("Could not detect libc");
});
test("throws error for Linux with undefined libcFamily", () => {
// #given Linux platform with undefined libc
const input = { platform: "linux", arch: "x64", libcFamily: undefined };
// #when getting platform package
// #then throws descriptive error
expect(() => getPlatformPackage(input)).toThrow("Could not detect libc");
});
// #endregion
});
describe("getBinaryPath", () => {
test("returns path without .exe for Unix platforms", () => {
// #given Unix platform package
const pkg = "oh-my-opencode-darwin-arm64";
const platform = "darwin";
// #when getting binary path
const result = getBinaryPath(pkg, platform);
// #then returns path without extension
expect(result).toBe("oh-my-opencode-darwin-arm64/bin/oh-my-opencode");
});
test("returns path with .exe for Windows", () => {
// #given Windows platform package
const pkg = "oh-my-opencode-windows-x64";
const platform = "win32";
// #when getting binary path
const result = getBinaryPath(pkg, platform);
// #then returns path with .exe extension
expect(result).toBe("oh-my-opencode-windows-x64/bin/oh-my-opencode.exe");
});
test("returns path without .exe for Linux", () => {
// #given Linux platform package
const pkg = "oh-my-opencode-linux-x64";
const platform = "linux";
// #when getting binary path
const result = getBinaryPath(pkg, platform);
// #then returns path without extension
expect(result).toBe("oh-my-opencode-linux-x64/bin/oh-my-opencode");
});
});