@hanzo/dev 0.6.92 → 0.6.93

package/bin/coder.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from "url";
 import { platform as nodePlatform, arch as nodeArch } from "os";
 import { execSync } from "child_process";
 import { get as httpsGet } from "https";
+import { runPostinstall } from "../postinstall.js";
 
 // __dirname equivalent in ESM
 const __filename = fileURLToPath(import.meta.url);
@@ -17,7 +18,7 @@ const { platform, arch } = process;
 // When users run via `npx @hanzo/dev`, we must always execute our
 // packaged native binary by absolute path to avoid PATH collisions.
 
-const isWSL = () => {
+function isWSL() {
   if (platform !== "linux") return false;
   try {
     const txt = readFileSync("/proc/version", "utf8").toLowerCase();
@@ -25,7 +26,7 @@ const isWSL = () => {
   } catch {
     return false;
   }
-};
+}
 
 let targetTriple = null;
 switch (platform) {
@@ -270,12 +271,26 @@ const tryBootstrapBinary = async () => {
 };
 
 // If missing, attempt to bootstrap into place (helps when Bun blocks postinstall)
-if (!existsSync(binaryPath) && !existsSync(legacyBinaryPath)) {
-  const ok = await tryBootstrapBinary();
-  if (!ok) {
-    // retry legacy name in case archive provided coder-*
-    if (existsSync(legacyBinaryPath) && !existsSync(binaryPath)) {
-      binaryPath = legacyBinaryPath;
+let binaryReady = existsSync(binaryPath) || existsSync(legacyBinaryPath);
+if (!binaryReady) {
+  let runtimePostinstallError = null;
+  try {
+    await runPostinstall({ invokedByRuntime: true, skipGlobalAlias: true });
+  } catch (err) {
+    runtimePostinstallError = err;
+  }
+
+  binaryReady = existsSync(binaryPath) || existsSync(legacyBinaryPath);
+  if (!binaryReady) {
+    const ok = await tryBootstrapBinary();
+    if (!ok) {
+      if (runtimePostinstallError && !lastBootstrapError) {
+        lastBootstrapError = runtimePostinstallError;
+      }
+      // retry legacy name in case archive provided coder-*
+      if (existsSync(legacyBinaryPath) && !existsSync(binaryPath)) {
+        binaryPath = legacyBinaryPath;
+      }
     }
   }
 }
@@ -379,9 +394,12 @@ try {
 // receives a fatal signal, both processes exit in a predictable manner.
 const { spawn } = await import("child_process");
 
+// Make the resolved native binary path visible to spawned agents/subprocesses.
+process.env.CODE_BINARY_PATH = binaryPath;
+
 const child = spawn(binaryPath, process.argv.slice(2), {
   stdio: "inherit",
-  env: { ...process.env, CODER_MANAGED_BY_NPM: "1", CODEX_MANAGED_BY_NPM: "1" },
+  env: { ...process.env, CODER_MANAGED_BY_NPM: "1", CODEX_MANAGED_BY_NPM: "1", CODE_BINARY_PATH: binaryPath },
 });
 
 child.on("error", (err) => {

package/bin/codex.js

@@ -3,12 +3,24 @@
 
 import { spawn } from "node:child_process";
 import { existsSync } from "fs";
+import { createRequire } from "node:module";
 import path from "path";
 import { fileURLToPath } from "url";
 
 // __dirname equivalent in ESM
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+const require = createRequire(import.meta.url);
+const codexPackageRoot = realpathSync(path.join(__dirname, ".."));
+
+const PLATFORM_PACKAGE_BY_TARGET = {
+  "x86_64-unknown-linux-musl": "@openai/codex-linux-x64",
+  "aarch64-unknown-linux-musl": "@openai/codex-linux-arm64",
+  "x86_64-apple-darwin": "@openai/codex-darwin-x64",
+  "aarch64-apple-darwin": "@openai/codex-darwin-arm64",
+  "x86_64-pc-windows-msvc": "@openai/codex-win32-x64",
+  "aarch64-pc-windows-msvc": "@openai/codex-win32-arm64",
+};
 
 const { platform, arch } = process;
 
@@ -59,9 +71,53 @@ if (!targetTriple) {
   throw new Error(`Unsupported platform: ${platform} (${arch})`);
 }
 
-const vendorRoot = path.join(__dirname, "..", "vendor");
-const archRoot = path.join(vendorRoot, targetTriple);
+const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
+if (!platformPackage) {
+  throw new Error(`Unsupported target triple: ${targetTriple}`);
+}
+
 const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
+const localVendorRoot = path.join(__dirname, "..", "vendor");
+const localBinaryPath = path.join(
+  localVendorRoot,
+  targetTriple,
+  "codex",
+  codexBinaryName,
+);
+
+let vendorRoot;
+try {
+  const packageJsonPath = require.resolve(`${platformPackage}/package.json`);
+  vendorRoot = path.join(path.dirname(packageJsonPath), "vendor");
+} catch {
+  if (existsSync(localBinaryPath)) {
+    vendorRoot = localVendorRoot;
+  } else {
+    const packageManager = detectPackageManager();
+    const updateCommand =
+      packageManager === "bun"
+        ? "bun install -g @openai/codex@latest"
+        : "npm install -g @openai/codex@latest";
+    throw new Error(
+      `Missing optional dependency ${platformPackage}. Reinstall Codex: ${updateCommand}`,
+    );
+  }
+}
+
+if (!vendorRoot) {
+  const packageManager = detectPackageManager();
+  const updateCommand =
+    packageManager === "bun"
+      ? "bun install -g @openai/codex@latest"
+      : packageManager === "pnpm"
+        ? "pnpm add -g @openai/codex@latest"
+        : "npm install -g @openai/codex@latest";
+  throw new Error(
+    `Missing optional dependency ${platformPackage}. Reinstall Codex: ${updateCommand}`,
+  );
+}
+
+const archRoot = path.join(vendorRoot, targetTriple);
 const binaryPath = path.join(archRoot, "codex", codexBinaryName);
 
 // Use an asynchronous spawn instead of spawnSync so that Node is able to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzo/dev",
-  "version": "0.6.92",
+  "version": "0.6.93",
   "license": "Apache-2.0",
   "description": "Local AI coding agent for your terminal, powered by Hanzo AI",
   "bin": {
@@ -35,10 +35,10 @@
     "prettier": "^3.3.3"
   },
   "optionalDependencies": {
-    "@hanzo/dev-darwin-arm64": "0.6.92",
-    "@hanzo/dev-darwin-x64": "0.6.92",
-    "@hanzo/dev-linux-x64-musl": "0.6.92",
-    "@hanzo/dev-linux-arm64-musl": "0.6.92",
-    "@hanzo/dev-win32-x64": "0.6.92"
+    "@hanzo/dev-darwin-arm64": "0.6.93",
+    "@hanzo/dev-darwin-x64": "0.6.93",
+    "@hanzo/dev-linux-x64-musl": "0.6.93",
+    "@hanzo/dev-linux-arm64-musl": "0.6.93",
+    "@hanzo/dev-win32-x64": "0.6.93"
   }
 }

package/postinstall.js

@@ -2,7 +2,7 @@
 // Non-functional change to trigger release workflow
 
 import { existsSync, mkdirSync, createWriteStream, chmodSync, readFileSync, readSync, writeFileSync, unlinkSync, statSync, openSync, closeSync, copyFileSync, fsyncSync, renameSync, realpathSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { get } from 'https';
 import { platform, arch, tmpdir } from 'os';
@@ -289,13 +289,21 @@ function validateDownloadedBinary(p) {
   }
 }
 
-async function main() {
+export async function runPostinstall(options = {}) {
+  const { skipGlobalAlias = false, invokedByRuntime = false } = options;
+  if (process.env.CODE_POSTINSTALL_DRY_RUN === '1') {
+    return { skipped: true };
+  }
+
+  if (invokedByRuntime) {
+    process.env.CODE_RUNTIME_POSTINSTALL = process.env.CODE_RUNTIME_POSTINSTALL || '1';
+  }
   // Detect potential PATH conflict with an existing `code` command (e.g., VS Code)
   // Only relevant for global installs; skip for npx/local installs to keep postinstall fast.
   const ua = process.env.npm_config_user_agent || '';
   const isNpx = ua.includes('npx');
   const isGlobal = process.env.npm_config_global === 'true';
-  if (isGlobal && !isNpx) {
+  if (!skipGlobalAlias && isGlobal && !isNpx) {
     try {
       const whichCmd = process.platform === 'win32' ? 'where code' : 'command -v code || which code || true';
       const resolved = execSync(whichCmd, { stdio: ['ignore', 'pipe', 'ignore'], shell: process.platform !== 'win32' }).toString().split(/\r?\n/).filter(Boolean)[0];
@@ -421,8 +429,15 @@ async function main() {
     // - Windows: .zip
     // - macOS/Linux: prefer .zst if `zstd` CLI is available; otherwise use .tar.gz
     const isWin = isWindows;
+    const detectedWSL = (() => {
+      if (platform() !== 'linux') return false;
+      try {
+        const ver = readFileSync('/proc/version', 'utf8').toLowerCase();
+        return ver.includes('microsoft') || !!process.env.WSL_DISTRO_NAME;
+      } catch { return false; }
+    })();
     const binDirReal = (() => { try { return realpathSync(binDir); } catch { return binDir; } })();
-    const mirrorToLocal = !(isWin || (isWSL() && isPathOnWindowsFs(binDirReal)));
+    const mirrorToLocal = !(isWin || (detectedWSL && isPathOnWindowsFs(binDirReal)));
     let useZst = false;
     if (!isWin) {
       try {
@@ -755,7 +770,19 @@ async function main() {
   }
 }
 
-main().catch(error => {
-  console.error('Installation failed:', error);
-  process.exit(1);
-});
+function isExecutedDirectly() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return resolve(entry) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+}
+
+if (isExecutedDirectly()) {
+  runPostinstall().catch(error => {
+    console.error('Installation failed:', error);
+    process.exit(1);
+  });
+}