@textcortex/zenocode 0.1.2 → 0.1.4

package/scripts/build-branded-opencode.mjs

@@ -1,12 +1,15 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
+import { patchZenocodeBinaryText } from "./branding-patch.mjs";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const currentFilePath = realpathSync(fileURLToPath(import.meta.url));
+const __dirname = path.dirname(currentFilePath);
 const appRoot = path.resolve(__dirname, "..");
 const defaultOutputDir = path.join(appRoot, ".zenocode", "brand-build");
 
@@ -50,6 +53,94 @@ function _command(name) {
   return name;
 }
 
+function _packageParts(packageName) {
+  if (packageName.startsWith("@")) {
+    const [scope, baseName] = packageName.split("/");
+    return { scope, baseName };
+  }
+  return { scope: "", baseName: packageName };
+}
+
+function _runtimeBinaryPrefix(packageName) {
+  const { baseName } = _packageParts(packageName);
+  return baseName.replace(/-ai$/, "");
+}
+
+export function mapBrandedBinaryPackageName(originalPackageName, runtimePackageName = wrapperPackageName) {
+  if (!originalPackageName.startsWith("opencode-")) {
+    throw new Error(`Unsupported OpenCode binary package name: ${originalPackageName}`);
+  }
+  const { scope } = _packageParts(runtimePackageName);
+  const prefix = _runtimeBinaryPrefix(runtimePackageName);
+  const suffix = originalPackageName.slice("opencode".length);
+  const unscopedName = `${prefix}${suffix}`;
+  return scope ? `${scope}/${unscopedName}` : unscopedName;
+}
+
+export function buildWrapperBinMap(packageName, binName) {
+  const { baseName } = _packageParts(packageName);
+  const binMap = {
+    [baseName]: "./bin/opencode",
+    opencode: "./bin/opencode",
+  };
+  if (binName && !(binName in binMap)) {
+    binMap[binName] = "./bin/opencode";
+  }
+  return binMap;
+}
+
+function compareSemver(left, right) {
+  const parse = (value) => {
+    const match = value.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.*)?$/);
+    if (!match) return null;
+    return {
+      major: Number(match[1]),
+      minor: Number(match[2]),
+      patch: Number(match[3]),
+      prerelease: match[4] ?? null,
+    };
+  };
+
+  const lhs = parse(left);
+  const rhs = parse(right);
+  if (!lhs || !rhs) {
+    throw new Error(`Invalid semver comparison: ${left} vs ${right}`);
+  }
+
+  for (const key of ["major", "minor", "patch"]) {
+    if (lhs[key] > rhs[key]) return 1;
+    if (lhs[key] < rhs[key]) return -1;
+  }
+
+  if (lhs.prerelease === rhs.prerelease) return 0;
+  if (lhs.prerelease === null) return 1;
+  if (rhs.prerelease === null) return -1;
+
+  const leftParts = lhs.prerelease.split(".");
+  const rightParts = rhs.prerelease.split(".");
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = leftParts[index];
+    const rightPart = rightParts[index];
+    if (leftPart === undefined) return -1;
+    if (rightPart === undefined) return 1;
+    const leftNumeric = /^\d+$/.test(leftPart);
+    const rightNumeric = /^\d+$/.test(rightPart);
+    if (leftNumeric && rightNumeric) {
+      const leftValue = Number(leftPart);
+      const rightValue = Number(rightPart);
+      if (leftValue > rightValue) return 1;
+      if (leftValue < rightValue) return -1;
+      continue;
+    }
+    if (leftNumeric && !rightNumeric) return -1;
+    if (!leftNumeric && rightNumeric) return 1;
+    if (leftPart > rightPart) return 1;
+    if (leftPart < rightPart) return -1;
+  }
+  return 0;
+}
+
 async function run(command, args, options = {}) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
@@ -68,6 +159,35 @@ async function run(command, args, options = {}) {
   });
 }
 
+async function runAndCapture(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      ...options,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+        return;
+      }
+      const error = new Error(`${command} ${args.join(" ")} failed with exit code ${String(code ?? 1)}`);
+      error.stdout = stdout;
+      error.stderr = stderr;
+      reject(error);
+    });
+  });
+}
+
 async function requireCommand(command, args = ["--version"]) {
   try {
     await run(command, args, { stdio: "ignore" });
@@ -83,90 +203,375 @@ async function readJson(filePath) {
   return JSON.parse(await fs.readFile(filePath, "utf-8"));
 }
 
-async function buildWrapperPackage({
-  checkoutDir,
-  distDir,
-  artifactDir,
-  packageName,
-  binName,
-}) {
-  const distEntries = await fs.readdir(distDir, { withFileTypes: true });
-  const binaries = {};
-  const versions = new Set();
+async function writeJson(filePath, payload) {
+  await fs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+}
 
-  for (const entry of distEntries) {
-    if (!entry.isDirectory()) continue;
-    const packageJsonPath = path.join(distDir, entry.name, "package.json");
+async function maybePublishedVersion(packageName) {
+  const npmCommand = _command("npm");
+  try {
+    const result = await runAndCapture(
+      npmCommand,
+      ["view", packageName, "version", "--json"],
+      { env: { ...process.env, NODE_AUTH_TOKEN: process.env.NODE_AUTH_TOKEN || process.env.NPM_TOKEN || "" } },
+    );
+    const value = JSON.parse(result.stdout.trim() || "null");
+    if (typeof value === "string" && value) return value;
+    return null;
+  } catch (error) {
+    const stderr = String(error?.stderr || "");
+    if (stderr.includes("E404") || stderr.includes("404")) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function packPackage(packageDir) {
+  const npmCommand = _command("npm");
+  await run(npmCommand, ["pack"], { cwd: packageDir });
+  const tarballs = (await fs.readdir(packageDir)).filter((entry) => entry.endsWith(".tgz")).sort();
+  if (!tarballs.length) {
+    throw new Error(`npm pack did not produce a tarball in ${packageDir}`);
+  }
+  return path.join(packageDir, tarballs[tarballs.length - 1]);
+}
+
+async function publishTarballIfNeeded(packageName, version, tarballPath, cwd) {
+  if (!publishEnabled) return { published: false, skipped: false };
+
+  const publishedVersion = await maybePublishedVersion(packageName);
+  if (publishedVersion) {
+    const comparison = compareSemver(version, publishedVersion);
+    if (comparison < 0) {
+      throw new Error(
+        `Refusing to publish ${packageName}@${version}; npm already has newer version ${publishedVersion}.`,
+      );
+    }
+    if (comparison === 0) {
+      return { published: false, skipped: true };
+    }
+  }
+
+  const npmCommand = _command("npm");
+  await run(
+    npmCommand,
+    ["publish", tarballPath, "--access", "public", "--tag", publishTag, "--provenance"],
+    { cwd },
+  );
+  return { published: true, skipped: false };
+}
+
+function _binaryFilename() {
+  return process.platform === "win32" ? "opencode.exe" : "opencode";
+}
+
+async function patchBinaryAtPath(binaryPath) {
+  const buffer = await fs.readFile(binaryPath);
+  const originalLength = buffer.length;
+  const patch = patchZenocodeBinaryText(buffer.toString("latin1"));
+  if (!patch.patched) {
+    throw new Error(`Branding patch did not match binary ${binaryPath}`);
+  }
+  const nextBuffer = Buffer.from(patch.text, "latin1");
+  if (nextBuffer.length !== originalLength) {
+    throw new Error(`Branding patch changed binary length for ${binaryPath}`);
+  }
+  await fs.writeFile(binaryPath, nextBuffer);
+  if (process.platform !== "win32") {
+    await fs.chmod(binaryPath, 0o755);
+  }
+}
+
+function _buildWrapperExecutable({ runtimePackageName, binName }) {
+  const { scope, baseName } = _packageParts(runtimePackageName);
+  const scopeLiteral = JSON.stringify(scope);
+  const packagePrefixLiteral = JSON.stringify(_runtimeBinaryPrefix(runtimePackageName));
+  const binNameLiteral = JSON.stringify(binName || "");
+  const packageBaseLiteral = JSON.stringify(baseName);
+
+  return `#!/usr/bin/env node
+
+const childProcess = require("child_process")
+const fs = require("fs")
+const path = require("path")
+const os = require("os")
+
+function run(target) {
+  const result = childProcess.spawnSync(target, process.argv.slice(2), {
+    stdio: "inherit",
+  })
+  if (result.error) {
+    console.error(result.error.message)
+    process.exit(1)
+  }
+  const code = typeof result.status === "number" ? result.status : 0
+  process.exit(code)
+}
+
+const envPath = process.env.OPENCODE_BIN_PATH
+if (envPath) {
+  run(envPath)
+}
+
+const scriptPath = fs.realpathSync(__filename)
+const scriptDir = path.dirname(scriptPath)
+const packageScope = ${scopeLiteral}
+const packagePrefix = ${packagePrefixLiteral}
+const packageBaseName = ${packageBaseLiteral}
+const brandedBinName = ${binNameLiteral}
+
+const platformMap = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+}
+const archMap = {
+  x64: "x64",
+  arm64: "arm64",
+  arm: "arm",
+}
+
+let platform = platformMap[os.platform()]
+if (!platform) {
+  platform = os.platform()
+}
+let arch = archMap[os.arch()]
+if (!arch) {
+  arch = os.arch()
+}
+const base = packagePrefix + "-" + platform + "-" + arch
+const binary = platform === "windows" ? "opencode.exe" : "opencode"
+
+function supportsAvx2() {
+  if (arch !== "x64") return false
+
+  if (platform === "linux") {
     try {
-      const pkg = await readJson(packageJsonPath);
-      if (typeof pkg?.name === "string" && typeof pkg?.version === "string") {
-        binaries[pkg.name] = pkg.version;
-        versions.add(pkg.version);
-      }
+      return /(^|\\s)avx2(\\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"))
     } catch {
-      continue;
+      return false
     }
   }
 
-  if (!Object.keys(binaries).length) {
-    throw new Error(`No binary packages found under ${distDir}`);
+  if (platform === "darwin") {
+    try {
+      const result = childProcess.spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], {
+        encoding: "utf8",
+        timeout: 1500,
+      })
+      if (result.status !== 0) return false
+      return (result.stdout || "").trim() === "1"
+    } catch {
+      return false
+    }
   }
 
-  const version = versions.values().next().value;
-  if (!version) {
-    throw new Error("Unable to determine branded package version");
+  if (platform === "windows") {
+    const cmd =
+      '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)'
+
+    for (const exe of ["powershell.exe", "pwsh.exe", "pwsh", "powershell"]) {
+      try {
+        const result = childProcess.spawnSync(exe, ["-NoProfile", "-NonInteractive", "-Command", cmd], {
+          encoding: "utf8",
+          timeout: 3000,
+          windowsHide: true,
+        })
+        if (result.status !== 0) continue
+        const out = (result.stdout || "").trim().toLowerCase()
+        if (out === "true" || out === "1") return true
+        if (out === "false" || out === "0") return false
+      } catch {
+        continue
+      }
+    }
+
+    return false
   }
 
-  const wrapperDir = path.join(artifactDir, "npm-package");
-  await fs.rm(wrapperDir, { recursive: true, force: true });
-  await fs.mkdir(path.join(wrapperDir, "bin"), { recursive: true });
+  return false
+}
 
-  const opencodePkgPath = path.join(checkoutDir, "packages", "opencode", "package.json");
-  const opencodePkg = await readJson(opencodePkgPath);
-  const license = typeof opencodePkg?.license === "string" ? opencodePkg.license : "MIT";
+const names = (() => {
+  const avx2 = supportsAvx2()
+  const baseline = arch === "x64" && !avx2
 
-  const binMap = { opencode: "./bin/opencode" };
-  if (binName && binName !== "opencode") {
-    binMap[binName] = "./bin/opencode";
+  if (platform === "linux") {
+    const musl = (() => {
+      try {
+        if (fs.existsSync("/etc/alpine-release")) return true
+      } catch {
+      }
+
+      try {
+        const result = childProcess.spawnSync("ldd", ["--version"], { encoding: "utf8" })
+        const text = ((result.stdout || "") + (result.stderr || "")).toLowerCase()
+        if (text.includes("musl")) return true
+      } catch {
+      }
+
+      return false
+    })()
+
+    if (musl) {
+      if (arch === "x64") {
+        if (baseline) return [base + "-baseline-musl", base + "-musl", base + "-baseline", base]
+        return [base + "-musl", base + "-baseline-musl", base, base + "-baseline"]
+      }
+      return [base + "-musl", base]
+    }
+
+    if (arch === "x64") {
+      if (baseline) return [base + "-baseline", base, base + "-baseline-musl", base + "-musl"]
+      return [base, base + "-baseline", base + "-musl", base + "-baseline-musl"]
+    }
+    return [base, base + "-musl"]
   }
 
+  if (arch === "x64") {
+    if (baseline) return [base + "-baseline", base]
+    return [base, base + "-baseline"]
+  }
+  return [base]
+})()
+
+function candidatePackageNames(name) {
+  const scopedName = packageScope ? packageScope + "/" + name : name
+  const legacyName = name.replace(new RegExp("^" + packagePrefix), "opencode")
+  return packageScope ? [scopedName, legacyName] : [scopedName]
+}
+
+function resolveFromPackage(packageName) {
+  try {
+    const packageJsonPath = require.resolve(packageName + "/package.json", {
+      paths: [scriptDir],
+    })
+    const packageDir = path.dirname(packageJsonPath)
+    const candidate = path.join(packageDir, "bin", binary)
+    if (fs.existsSync(candidate)) return candidate
+  } catch {
+  }
+}
+
+function findBinary() {
+  for (const name of names) {
+    for (const packageName of candidatePackageNames(name)) {
+      const candidate = resolveFromPackage(packageName)
+      if (candidate) return candidate
+    }
+  }
+}
+
+const resolved = findBinary()
+if (!resolved) {
+  const installTargets = names.flatMap((name) => candidatePackageNames(name))
+  console.error(
+    "It seems that your package manager failed to install the right version of the " +
+      packageBaseName +
+      " CLI for your platform. You can try manually installing " +
+      installTargets.map((name) => "\\""+name+"\\"").join(" or ") +
+      " package",
+  )
+  process.exit(1)
+}
+
+run(resolved)
+`;
+}
+
+async function buildWrapperPackage({
+  artifactDir,
+  licensePath,
+  packageName,
+  binName,
+  version,
+  binaryPackages,
+}) {
+  const wrapperDir = path.join(artifactDir, "npm-package");
+  await fs.rm(wrapperDir, { recursive: true, force: true });
+  await fs.mkdir(path.join(wrapperDir, "bin"), { recursive: true });
+
   const wrapperPkg = {
     name: packageName,
     version,
-    license,
+    license: "MIT",
     type: "commonjs",
-    bin: binMap,
-    scripts: { postinstall: "node ./postinstall.mjs" },
-    optionalDependencies: binaries,
+    bin: buildWrapperBinMap(packageName, binName),
+    optionalDependencies: Object.fromEntries(
+      binaryPackages.map((pkg) => [pkg.brandedName, pkg.version]),
+    ),
+    files: [
+      "bin",
+      "LICENSE",
+    ],
   };
 
-  await fs.copyFile(
-    path.join(checkoutDir, "packages", "opencode", "bin", "opencode"),
+  await fs.copyFile(licensePath, path.join(wrapperDir, "LICENSE"));
+  await fs.writeFile(
     path.join(wrapperDir, "bin", "opencode"),
+    _buildWrapperExecutable({ runtimePackageName: packageName, binName }),
+    { encoding: "utf-8", mode: 0o755 },
   );
-  await fs.copyFile(
-    path.join(checkoutDir, "packages", "opencode", "script", "postinstall.mjs"),
-    path.join(wrapperDir, "postinstall.mjs"),
-  );
-  await fs.copyFile(path.join(checkoutDir, "LICENSE"), path.join(wrapperDir, "LICENSE"));
-  await fs.writeFile(path.join(wrapperDir, "package.json"), `${JSON.stringify(wrapperPkg, null, 2)}\n`, "utf-8");
+  if (process.platform !== "win32") {
+    await fs.chmod(path.join(wrapperDir, "bin", "opencode"), 0o755);
+  }
+  await writeJson(path.join(wrapperDir, "package.json"), wrapperPkg);
 
-  const packCommand = _command("npm");
-  await run(packCommand, ["pack"], { cwd: wrapperDir });
+  const tarballPath = await packPackage(wrapperDir);
+  const publishResult = await publishTarballIfNeeded(packageName, version, tarballPath, wrapperDir);
+  return { tarballPath, publishResult };
+}
 
-  const tarballs = (await fs.readdir(wrapperDir)).filter((entry) => entry.endsWith(".tgz")).sort();
-  if (!tarballs.length) {
-    throw new Error(`npm pack did not produce a tarball in ${wrapperDir}`);
-  }
+async function prepareBinaryPackages({ distDir, artifactDir, runtimePackageName }) {
+  const packageRoot = path.join(artifactDir, "npm-binaries");
+  await fs.rm(packageRoot, { recursive: true, force: true });
+  await fs.mkdir(packageRoot, { recursive: true });
+
+  const entries = await fs.readdir(distDir, { withFileTypes: true });
+  const packages = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const sourceDir = path.join(distDir, entry.name);
+    const packageJsonPath = path.join(sourceDir, "package.json");
+    let pkg;
+    try {
+      pkg = await readJson(packageJsonPath);
+    } catch {
+      continue;
+    }
+    if (typeof pkg?.name !== "string" || typeof pkg?.version !== "string") {
+      continue;
+    }
+    if (!pkg.name.startsWith("opencode-")) {
+      continue;
+    }
 
-  const latestTarball = path.join(wrapperDir, tarballs[tarballs.length - 1]);
-  if (publishEnabled) {
-    await run(packCommand, ["publish", latestTarball, "--access", "public", "--tag", publishTag], {
-      cwd: wrapperDir,
+    const brandedName = mapBrandedBinaryPackageName(pkg.name, runtimePackageName);
+    const targetDir = path.join(packageRoot, brandedName.replace("/", "__"));
+    await fs.cp(sourceDir, targetDir, { recursive: true });
+    pkg.name = brandedName;
+    await writeJson(path.join(targetDir, "package.json"), pkg);
+    await patchBinaryAtPath(path.join(targetDir, "bin", _binaryFilename()));
+
+    const tarballPath = await packPackage(targetDir);
+    const publishResult = await publishTarballIfNeeded(brandedName, pkg.version, tarballPath, targetDir);
+    packages.push({
+      dirName: entry.name,
+      originalName: entry.name,
+      brandedName,
+      version: pkg.version,
+      packageDir: targetDir,
+      tarballPath,
+      publishResult,
     });
   }
 
-  return latestTarball;
+  if (!packages.length) {
+    throw new Error(`No OpenCode binary packages found under ${distDir}`);
+  }
+
+  return packages.sort((left, right) => left.originalName.localeCompare(right.originalName));
 }
 
 function pickCurrentPlatformBinary(distPackages) {
@@ -174,7 +579,8 @@ function pickCurrentPlatformBinary(distPackages) {
   const archMap = { x64: "x64", arm64: "arm64" };
   const expectedPlatform = platformMap[process.platform] || process.platform;
   const expectedArch = archMap[process.arch] || process.arch;
-  const expectedPrefix = `opencode-${expectedPlatform}-${expectedArch}`;
+  const prefix = _runtimeBinaryPrefix(wrapperPackageName);
+  const expectedPrefix = `${prefix}-${expectedPlatform}-${expectedArch}`;
 
   const exact = distPackages.find((name) => name === expectedPrefix);
   if (exact) return exact;
@@ -187,7 +593,7 @@ function pickCurrentPlatformBinary(distPackages) {
 
 async function main() {
   if (cliArgs.includes("-h") || cliArgs.includes("--help")) {
-    console.log("Build a branded Zenocode opencode binary/package from a fork.");
+    console.log("Build branded Zenocode OpenCode runtime packages from upstream.");
     console.log("");
     console.log("Environment variables:");
     console.log(`  ZENOCODE_OPENCODE_FORK_URL    Fork URL (default: ${forkUrl})`);
@@ -196,7 +602,7 @@ async function main() {
     console.log(`  ZENOCODE_BRANDED_PACKAGE      Wrapper package name (default: ${wrapperPackageName})`);
     console.log(`  ZENOCODE_BRANDED_BIN_NAME     Extra bin name in wrapper (default: ${wrapperBinName})`);
     console.log("  ZENOCODE_OPENCODE_BUILD_ARGS  Additional args for upstream build script");
-    console.log("  ZENOCODE_PUBLISH=1            Publish tarball to npm");
+    console.log("  ZENOCODE_PUBLISH=1            Publish packages to npm");
     console.log(`  ZENOCODE_PUBLISH_TAG          npm tag (default: ${publishTag})`);
     console.log("  Legacy CODECORTEX_* env names are still accepted for compatibility.");
     return;
@@ -230,38 +636,64 @@ async function main() {
     );
 
     await fs.mkdir(artifactDir, { recursive: true });
-    const npmTarball = await buildWrapperPackage({
-      checkoutDir,
+    const binaryPackages = await prepareBinaryPackages({
       distDir,
       artifactDir,
-      packageName: wrapperPackageName,
-      binName: wrapperBinName,
+      runtimePackageName: wrapperPackageName,
     });
 
-    const distEntries = await fs.readdir(distDir, { withFileTypes: true });
-    const distPackages = distEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
-    const selectedPackage = pickCurrentPlatformBinary(distPackages);
-    if (!selectedPackage) {
-      throw new Error(`No build artifacts found under ${distDir}`);
+    const version = binaryPackages[0]?.version;
+    if (!version) {
+      throw new Error("Unable to determine branded runtime version");
     }
 
-    const builtBinaryName = process.platform === "win32" ? "opencode.exe" : "opencode";
-    const builtBinaryPath = path.join(distDir, selectedPackage, "bin", builtBinaryName);
+    const wrapperResult = await buildWrapperPackage({
+      artifactDir,
+      licensePath: path.join(checkoutDir, "LICENSE"),
+      packageName: wrapperPackageName,
+      binName: wrapperBinName,
+      version,
+      binaryPackages,
+    });
+
+    const selectedPackage = pickCurrentPlatformBinary(
+      binaryPackages.map((pkg) => pkg.brandedName.split("/").at(-1)),
+    );
+    const localBinaryPackage = binaryPackages.find((pkg) => pkg.brandedName.endsWith(`/${selectedPackage}`))
+      || binaryPackages[0];
     const localBinaryDir = path.join(artifactDir, "bin");
     const localBinaryName = process.platform === "win32" ? "zenocode-opencode.exe" : "zenocode-opencode";
     const localBinaryPath = path.join(localBinaryDir, localBinaryName);
 
     await fs.mkdir(localBinaryDir, { recursive: true });
-    await fs.copyFile(builtBinaryPath, localBinaryPath);
+    await fs.copyFile(
+      path.join(localBinaryPackage.packageDir, "bin", _binaryFilename()),
+      localBinaryPath,
+    );
     if (process.platform !== "win32") {
       await fs.chmod(localBinaryPath, 0o755);
     }
 
     console.log("\nZenocode branded build complete.");
     console.log(`Branded binary: ${localBinaryPath}`);
-    console.log(`Branded package tarball: ${npmTarball}`);
+    console.log(`Wrapper package tarball: ${wrapperResult.tarballPath}`);
+    for (const pkg of binaryPackages) {
+      console.log(`Binary package tarball: ${pkg.tarballPath}`);
+    }
     if (publishEnabled) {
-      console.log(`Published to npm as ${wrapperPackageName} (tag: ${publishTag}).`);
+      const publishedBinaries = binaryPackages.filter((pkg) => pkg.publishResult.published).map((pkg) => pkg.brandedName);
+      const skippedBinaries = binaryPackages.filter((pkg) => pkg.publishResult.skipped).map((pkg) => pkg.brandedName);
+      if (publishedBinaries.length) {
+        console.log(`Published binary packages: ${publishedBinaries.join(", ")}`);
+      }
+      if (skippedBinaries.length) {
+        console.log(`Skipped already-published binary packages: ${skippedBinaries.join(", ")}`);
+      }
+      if (wrapperResult.publishResult.published) {
+        console.log(`Published wrapper package: ${wrapperPackageName} (tag: ${publishTag}).`);
+      } else if (wrapperResult.publishResult.skipped) {
+        console.log(`Skipped already-published wrapper package: ${wrapperPackageName}.`);
+      }
     }
     console.log(`\nRun with local binary:`);
     console.log(`  export ZENOCODE_OPENCODE_BIN_PATH="${localBinaryPath}"`);
@@ -272,7 +704,17 @@ async function main() {
   }
 }
 
-main().catch((error) => {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
-});
+function resolveExecutablePath(value) {
+  try {
+    return realpathSync(value);
+  } catch {
+    return path.resolve(value);
+  }
+}
+
+if (process.argv[1] && resolveExecutablePath(process.argv[1]) === currentFilePath) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}