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

103
script/build-binaries.ts Normal file
View File

@@ -0,0 +1,103 @@
#!/usr/bin/env bun
// script/build-binaries.ts
// Build platform-specific binaries for CLI distribution
import { $ } from "bun";
import { existsSync } from "node:fs";
import { join } from "node:path";
interface PlatformTarget {
dir: string;
target: string;
binary: string;
description: string;
}
const PLATFORMS: PlatformTarget[] = [
{ dir: "darwin-arm64", target: "bun-darwin-arm64", binary: "oh-my-opencode", description: "macOS ARM64" },
{ dir: "darwin-x64", target: "bun-darwin-x64", binary: "oh-my-opencode", description: "macOS x64" },
{ dir: "linux-x64", target: "bun-linux-x64", binary: "oh-my-opencode", description: "Linux x64 (glibc)" },
{ dir: "linux-arm64", target: "bun-linux-arm64", binary: "oh-my-opencode", description: "Linux ARM64 (glibc)" },
{ dir: "linux-x64-musl", target: "bun-linux-x64-musl", binary: "oh-my-opencode", description: "Linux x64 (musl)" },
{ dir: "linux-arm64-musl", target: "bun-linux-arm64-musl", binary: "oh-my-opencode", description: "Linux ARM64 (musl)" },
{ dir: "windows-x64", target: "bun-windows-x64", binary: "oh-my-opencode.exe", description: "Windows x64" },
];
const ENTRY_POINT = "src/cli/index.ts";
async function buildPlatform(platform: PlatformTarget): Promise<boolean> {
const outfile = join("packages", platform.dir, "bin", platform.binary);
console.log(`\n📦 Building ${platform.description}...`);
console.log(` Target: ${platform.target}`);
console.log(` Output: ${outfile}`);
try {
await $`bun build --compile --minify --sourcemap --bytecode --target=${platform.target} ${ENTRY_POINT} --outfile=${outfile}`;
// Verify binary exists
if (!existsSync(outfile)) {
console.error(` ❌ Binary not found after build: ${outfile}`);
return false;
}
// Verify binary with file command (skip on Windows host for non-Windows targets)
if (process.platform !== "win32") {
const fileInfo = await $`file ${outfile}`.text();
console.log(`${fileInfo.trim()}`);
} else {
console.log(` ✓ Binary created successfully`);
}
return true;
} catch (error) {
console.error(` ❌ Build failed: ${error}`);
return false;
}
}
async function main() {
console.log("🔨 Building oh-my-opencode platform binaries");
console.log(` Entry point: ${ENTRY_POINT}`);
console.log(` Platforms: ${PLATFORMS.length}`);
// Verify entry point exists
if (!existsSync(ENTRY_POINT)) {
console.error(`\n❌ Entry point not found: ${ENTRY_POINT}`);
process.exit(1);
}
const results: { platform: string; success: boolean }[] = [];
for (const platform of PLATFORMS) {
const success = await buildPlatform(platform);
results.push({ platform: platform.description, success });
}
// Summary
console.log("\n" + "=".repeat(50));
console.log("Build Summary:");
console.log("=".repeat(50));
const succeeded = results.filter(r => r.success).length;
const failed = results.filter(r => !r.success).length;
for (const result of results) {
const icon = result.success ? "✓" : "✗";
console.log(` ${icon} ${result.platform}`);
}
console.log("=".repeat(50));
console.log(`Total: ${succeeded} succeeded, ${failed} failed`);
if (failed > 0) {
process.exit(1);
}
console.log("\n✅ All platform binaries built successfully!\n");
}
main().catch((error) => {
console.error("Fatal error:", error);
process.exit(1);
});

View File

@@ -1,12 +1,24 @@
#!/usr/bin/env bun
import { $ } from "bun"
import { existsSync } from "node:fs"
import { join } from "node:path"
const PACKAGE_NAME = "oh-my-opencode"
const bump = process.env.BUMP as "major" | "minor" | "patch" | undefined
const versionOverride = process.env.VERSION
console.log("=== Publishing oh-my-opencode ===\n")
const PLATFORM_PACKAGES = [
"darwin-arm64",
"darwin-x64",
"linux-x64",
"linux-arm64",
"linux-x64-musl",
"linux-arm64-musl",
"windows-x64",
]
console.log("=== Publishing oh-my-opencode (multi-package) ===\n")
async function fetchPreviousVersion(): Promise<string> {
try {
@@ -22,7 +34,9 @@ async function fetchPreviousVersion(): Promise<string> {
}
function bumpVersion(version: string, type: "major" | "minor" | "patch"): string {
const [major, minor, patch] = version.split(".").map(Number)
// Handle prerelease versions (e.g., 3.0.0-beta.7)
const baseVersion = version.split("-")[0]
const [major, minor, patch] = baseVersion.split(".").map(Number)
switch (type) {
case "major":
return `${major + 1}.0.0`
@@ -33,14 +47,42 @@ function bumpVersion(version: string, type: "major" | "minor" | "patch"): string
}
}
async function updatePackageVersion(newVersion: string): Promise<void> {
const pkgPath = new URL("../package.json", import.meta.url).pathname
async function updatePackageVersion(pkgPath: string, newVersion: string): Promise<void> {
let pkg = await Bun.file(pkgPath).text()
pkg = pkg.replace(/"version": "[^"]+"/, `"version": "${newVersion}"`)
await Bun.file(pkgPath).write(pkg)
await Bun.write(pkgPath, pkg)
console.log(`Updated: ${pkgPath}`)
}
async function updateAllPackageVersions(newVersion: string): Promise<void> {
console.log("\nSyncing version across all packages...")
// Update main package.json
const mainPkgPath = new URL("../package.json", import.meta.url).pathname
await updatePackageVersion(mainPkgPath, newVersion)
// Update optionalDependencies versions in main package.json
let mainPkg = await Bun.file(mainPkgPath).text()
for (const platform of PLATFORM_PACKAGES) {
const pkgName = `oh-my-opencode-${platform}`
mainPkg = mainPkg.replace(
new RegExp(`"${pkgName}": "[^"]+"`),
`"${pkgName}": "${newVersion}"`
)
}
await Bun.write(mainPkgPath, mainPkg)
// Update each platform package.json
for (const platform of PLATFORM_PACKAGES) {
const pkgPath = new URL(`../packages/${platform}/package.json`, import.meta.url).pathname
if (existsSync(pkgPath)) {
await updatePackageVersion(pkgPath, newVersion)
} else {
console.warn(`Warning: ${pkgPath} not found`)
}
}
}
async function generateChangelog(previous: string): Promise<string[]> {
const notes: string[] = []
@@ -113,28 +155,96 @@ function getDistTag(version: string): string | null {
return tag || "next"
}
async function buildAndPublish(version: string): Promise<void> {
console.log("\nBuilding before publish...")
await $`bun run clean && bun run build`
interface PublishResult {
success: boolean
alreadyPublished?: boolean
error?: string
}
console.log("\nPublishing to npm...")
const distTag = getDistTag(version)
async function publishPackage(cwd: string, distTag: string | null): Promise<PublishResult> {
const tagArgs = distTag ? ["--tag", distTag] : []
const provenanceArgs = process.env.CI ? ["--provenance"] : []
if (process.env.CI) {
await $`npm publish --access public --provenance --ignore-scripts ${tagArgs}`
} else {
await $`npm publish --access public --ignore-scripts ${tagArgs}`
try {
await $`npm publish --access public --ignore-scripts ${provenanceArgs} ${tagArgs}`.cwd(cwd)
return { success: true }
} catch (error: any) {
const stderr = error?.stderr?.toString() || error?.message || ""
// E409 = version already exists (idempotent success)
if (
stderr.includes("EPUBLISHCONFLICT") ||
stderr.includes("E409") ||
stderr.includes("cannot publish over") ||
stderr.includes("already exists")
) {
return { success: true, alreadyPublished: true }
}
return { success: false, error: stderr }
}
}
async function publishAllPackages(version: string): Promise<void> {
const distTag = getDistTag(version)
console.log("\n📦 Publishing platform packages...")
// Publish platform packages first
for (const platform of PLATFORM_PACKAGES) {
const pkgDir = join(process.cwd(), "packages", platform)
const pkgName = `oh-my-opencode-${platform}`
console.log(`\n Publishing ${pkgName}...`)
const result = await publishPackage(pkgDir, distTag)
if (result.success) {
if (result.alreadyPublished) {
console.log(`${pkgName}@${version} (already published)`)
} else {
console.log(`${pkgName}@${version}`)
}
} else {
console.error(`${pkgName} failed: ${result.error}`)
throw new Error(`Failed to publish ${pkgName}`)
}
}
// Publish main package last
console.log(`\n📦 Publishing main package...`)
const mainResult = await publishPackage(process.cwd(), distTag)
if (mainResult.success) {
if (mainResult.alreadyPublished) {
console.log(`${PACKAGE_NAME}@${version} (already published)`)
} else {
console.log(`${PACKAGE_NAME}@${version}`)
}
} else {
console.error(`${PACKAGE_NAME} failed: ${mainResult.error}`)
throw new Error(`Failed to publish ${PACKAGE_NAME}`)
}
}
async function buildPackages(): Promise<void> {
console.log("\nBuilding packages...")
await $`bun run clean && bun run build`
console.log("Building platform binaries...")
await $`bun run build:binaries`
}
async function gitTagAndRelease(newVersion: string, notes: string[]): Promise<void> {
if (!process.env.CI) return
console.log("\nCommitting and tagging...")
await $`git config user.email "github-actions[bot]@users.noreply.github.com"`
await $`git config user.name "github-actions[bot]"`
// Add all package.json files
await $`git add package.json assets/oh-my-opencode.schema.json`
for (const platform of PLATFORM_PACKAGES) {
await $`git add packages/${platform}/package.json`.nothrow()
}
const hasStagedChanges = await $`git diff --cached --quiet`.nothrow()
if (hasStagedChanges.exitCode !== 0) {
@@ -181,15 +291,16 @@ async function main() {
process.exit(0)
}
await updatePackageVersion(newVersion)
await updateAllPackageVersions(newVersion)
const changelog = await generateChangelog(previous)
const contributors = await getContributors(previous)
const notes = [...changelog, ...contributors]
await buildAndPublish(newVersion)
await buildPackages()
await publishAllPackages(newVersion)
await gitTagAndRelease(newVersion, notes)
console.log(`\n=== Successfully published ${PACKAGE_NAME}@${newVersion} ===`)
console.log(`\n=== Successfully published ${PACKAGE_NAME}@${newVersion} (8 packages) ===`)
}
main()