@hanzo/dev 0.6.91 → 0.6.93

package/bin/{dev.js → coder.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// Unified entry point for the Hanzo Dev CLI.
+// Unified entry point for the Code CLI.
 
 import path from "path";
 import { fileURLToPath } from "url";
@@ -14,6 +14,10 @@ const __dirname = path.dirname(__filename);
 
 const { platform, arch } = process;
 
+// Important: Never delegate to another system's `code` binary (e.g., VS Code).
+// When users run via `npx @hanzo/dev`, we must always execute our
+// packaged native binary by absolute path to avoid PATH collisions.
+
 function isWSL() {
   if (platform !== "linux") return false;
   try {
@@ -70,10 +74,11 @@ if (!targetTriple) {
   throw new Error(`Unsupported platform: ${platform} (${arch})`);
 }
 
-// Binary names for Hanzo dev
+// Prefer new 'dev-*' binary names; fall back to legacy 'coder-*' if missing.
 let binaryPath = path.join(__dirname, "..", "bin", `dev-${targetTriple}`);
-let legacyBinaryPath = path.join(__dirname, "..", "bin", `dev-${targetTriple}`);
+let legacyBinaryPath = path.join(__dirname, "..", "bin", `coder-${targetTriple}`);
 
+// --- Bootstrap helper (runs if the binary is missing, e.g. Bun blocked postinstall) ---
 import { existsSync, chmodSync, statSync, openSync, readSync, closeSync, mkdirSync, copyFileSync, readFileSync, unlinkSync, createWriteStream } from "fs";
 
 const validateBinary = (p) => {
@@ -116,12 +121,14 @@ const getCacheDir = (version) => {
   } else {
     base = process.env.XDG_CACHE_HOME || path.join(home, ".cache");
   }
-  const dir = path.join(base, "hanzo", "dev", version);
+  const dir = path.join(base, "hanzoai", "dev", version);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   return dir;
 };
 
 const getCachedBinaryPath = (version) => {
+  // targetTriple already includes the proper extension on Windows ("...msvc.exe").
+  // Do not append another suffix; just use the exact targetTriple-derived name.
   const cacheDir = getCacheDir(version);
   return path.join(cacheDir, `dev-${targetTriple}`);
 };
@@ -132,6 +139,7 @@ const httpsDownload = (url, dest) => new Promise((resolve, reject) => {
   const req = httpsGet(url, (res) => {
     const status = res.statusCode || 0;
     if (status >= 300 && status < 400 && res.headers.location) {
+      // follow one redirect recursively
       return resolve(httpsDownload(res.headers.location, dest));
     }
     if (status !== 200) {
@@ -156,17 +164,19 @@ const httpsDownload = (url, dest) => new Promise((resolve, reject) => {
 
 const tryBootstrapBinary = async () => {
   try {
+    // 1) Read our published version
     const pkg = JSON.parse(readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
     const version = pkg.version;
 
     const binDir = path.join(__dirname, "..", "bin");
     if (!existsSync(binDir)) mkdirSync(binDir, { recursive: true });
 
-    // Fast path: user cache
+    // 2) Fast path: user cache
     const cachePath = getCachedBinaryPath(version);
     if (existsSync(cachePath)) {
       const v = validateBinary(cachePath);
       if (v.ok) {
+        // Prefer running directly from cache; mirror into node_modules on Unix
         if (platform !== "win32") {
           copyFileSync(cachePath, binaryPath);
           try { chmodSync(binaryPath, 0o755); } catch {}
@@ -175,11 +185,11 @@ const tryBootstrapBinary = async () => {
       }
     }
 
-    // Try platform package (if present)
+    // 3) Try platform package (if present)
     try {
       const req = (await import("module")).createRequire(import.meta.url);
       const name = (() => {
-        if (platform === "win32") return "@hanzo/dev-win32-x64";
+        if (platform === "win32") return "@hanzo/dev-win32-x64"; // may be unpublished; falls through
         const plt = nodePlatform();
         const cpu = nodeArch();
         if (plt === "darwin" && cpu === "arm64") return "@hanzo/dev-darwin-arm64";
@@ -194,6 +204,7 @@ const tryBootstrapBinary = async () => {
           const pkgDir = path.dirname(pkgJson);
           const src = path.join(pkgDir, "bin", `dev-${targetTriple}`);
           if (existsSync(src)) {
+            // Always ensure cache has the binary; on Unix mirror into node_modules
             copyFileSync(src, cachePath);
             if (platform !== "win32") {
               copyFileSync(cachePath, binaryPath);
@@ -205,22 +216,21 @@ const tryBootstrapBinary = async () => {
       }
     } catch { /* ignore */ }
 
-    // Download from GitHub release
+    // 4) Download from GitHub release
     const isWin = platform === "win32";
-    // Use 'dev-*' binary names matching the release artifacts
-    const binaryName = `dev-${targetTriple}`;
     const archiveName = isWin
-      ? `${binaryName}.zip`
-      : (() => { try { execSync("zstd --version", { stdio: "ignore", shell: true }); return `${binaryName}.zst`; } catch { return `${binaryName}.tar.gz`; } })();
+      ? `dev-${targetTriple}.zip`
+      : (() => { try { execSync("zstd --version", { stdio: "ignore", shell: true }); return `dev-${targetTriple}.zst`; } catch { return `dev-${targetTriple}.tar.gz`; } })();
     const url = `https://github.com/hanzoai/dev/releases/download/v${version}/${archiveName}`;
     const tmp = path.join(binDir, `.${archiveName}.part`);
     return httpsDownload(url, tmp)
       .then(() => {
         if (isWin) {
+          // Extract zip with robust fallbacks and use a safe temp dir, then move to cache
           try {
-            const sysRoot = process.env.SystemRoot || process.env.windir || 'C:\\Windows';
+            const sysRoot = process.env.SystemRoot || process.env.windir || 'C:\\\Windows';
             const psFull = path.join(sysRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
-            const unzipDest = getCacheDir(version);
+            const unzipDest = getCacheDir(version); // extract directly to cache location
             const psCmd = `Expand-Archive -Path '${tmp}' -DestinationPath '${unzipDest}' -Force`;
             let ok = false;
             try { execSync(`"${psFull}" -NoProfile -NonInteractive -Command "${psCmd}"`, { stdio: 'ignore' }); ok = true; } catch {}
@@ -241,7 +251,11 @@ const tryBootstrapBinary = async () => {
             try { unlinkSync(tmp); } catch {}
           }
         }
-        if (platform !== "win32") {
+        // On Windows, the file was extracted directly into the cache dir
+        if (platform === "win32") {
+          // Ensure the expected filename exists in cache; Expand-Archive extracts exact name
+          // No action required here; validation occurs below against cachePath
+        } else {
           try { copyFileSync(binaryPath, cachePath); } catch {}
         }
 
@@ -256,7 +270,7 @@ const tryBootstrapBinary = async () => {
   }
 };
 
-// If missing, attempt to bootstrap into place
+// If missing, attempt to bootstrap into place (helps when Bun blocks postinstall)
 let binaryReady = existsSync(binaryPath) || existsSync(legacyBinaryPath);
 if (!binaryReady) {
   let runtimePostinstallError = null;
@@ -273,6 +287,7 @@ if (!binaryReady) {
       if (runtimePostinstallError && !lastBootstrapError) {
         lastBootstrapError = runtimePostinstallError;
       }
+      // retry legacy name in case archive provided coder-*
       if (existsSync(legacyBinaryPath) && !existsSync(binaryPath)) {
         binaryPath = legacyBinaryPath;
       }
@@ -295,14 +310,17 @@ try {
   // ignore
 }
 
+// Check if binary exists and try to fix permissions if needed
+// fs imports are above; keep for readability if tree-shaken by bundlers
 import { spawnSync } from "child_process";
 if (existsSync(binaryPath)) {
   try {
+    // Ensure binary is executable on Unix-like systems
     if (platform !== "win32") {
       chmodSync(binaryPath, 0o755);
     }
   } catch (e) {
-    // Ignore permission errors
+    // Ignore permission errors, will be caught below if it's a real problem
   }
 } else {
   console.error(`Binary not found: ${binaryPath}`);
@@ -321,6 +339,9 @@ if (existsSync(binaryPath)) {
   process.exit(1);
 }
 
+// Lightweight header validation to provide clearer errors before spawn
+// Reuse the validateBinary helper defined above in the bootstrap section.
+
 const validation = validateBinary(binaryPath);
 if (!validation.ok) {
   console.error(`The native binary at ${binaryPath} appears invalid: ${validation.reason}`);
@@ -339,25 +360,50 @@ if (!validation.ok) {
   process.exit(1);
 }
 
-// If running under npx/npm, emit a concise notice
+// If running under npx/npm, emit a concise notice about which binary path is used
 try {
   const ua = process.env.npm_config_user_agent || "";
   const isNpx = ua.includes("npx");
   if (isNpx && process.stderr && process.stderr.isTTY) {
-    console.error(`@hanzo/dev: running bundled binary -> ${binaryPath}`);
+    // Best-effort discovery of another 'code' on PATH for user clarity
+    let otherCode = "";
+    try {
+      const cmd = process.platform === "win32" ? "where code" : "command -v code || which code || true";
+      const out = spawnSync(process.platform === "win32" ? "cmd" : "bash", [
+        process.platform === "win32" ? "/c" : "-lc",
+        cmd,
+      ], { encoding: "utf8" });
+      const line = (out.stdout || "").split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
+      if (line && !line.includes("@hanzo/dev")) {
+        otherCode = line;
+      }
+    } catch {}
+    if (otherCode) {
+      console.error(`@hanzo/dev: running bundled binary -> ${binaryPath}`);
+      console.error(`Note: a different 'code' exists at ${otherCode}; not delegating.`);
+    } else {
+      console.error(`@hanzo/dev: running bundled binary -> ${binaryPath}`);
+    }
   }
 } catch {}
 
+// Use an asynchronous spawn instead of spawnSync so that Node is able to
+// respond to signals (e.g. Ctrl-C / SIGINT) while the native binary is
+// executing. This allows us to forward those signals to the child process
+// and guarantees that when either the child terminates or the parent
+// receives a fatal signal, both processes exit in a predictable manner.
 const { spawn } = await import("child_process");
 
-process.env.DEV_BINARY_PATH = binaryPath;
+// 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, DEV_MANAGED_BY_NPM: "1", DEV_BINARY_PATH: binaryPath },
+  env: { ...process.env, CODER_MANAGED_BY_NPM: "1", CODEX_MANAGED_BY_NPM: "1", CODE_BINARY_PATH: binaryPath },
 });
 
 child.on("error", (err) => {
+  // Typically triggered when the binary is missing or not executable.
   const code = err && err.code;
   if (code === 'EACCES') {
     console.error(`Permission denied: ${binaryPath}`);
@@ -381,6 +427,10 @@ child.on("error", (err) => {
   process.exit(1);
 });
 
+// Forward common termination signals to the child so that it shuts down
+// gracefully. In the handler we temporarily disable the default behavior of
+// exiting immediately; once the child has been signaled we simply wait for
+// its exit event which will in turn terminate the parent (see below).
 const forwardSignal = (signal) => {
   if (child.killed) {
     return;
@@ -396,6 +446,11 @@ const forwardSignal = (signal) => {
   process.on(sig, () => forwardSignal(sig));
 });
 
+// When the child exits, mirror its termination reason in the parent so that
+// shell scripts and other tooling observe the correct exit status.
+// Wrap the lifetime of the child process in a Promise so that we can await
+// its termination in a structured way. The Promise resolves with an object
+// describing how the child exited: either via exit code or due to a signal.
 const childResult = await new Promise((resolve) => {
   child.on("exit", (code, signal) => {
     if (signal) {
@@ -407,6 +462,8 @@ const childResult = await new Promise((resolve) => {
 });
 
 if (childResult.type === "signal") {
+  // Re-emit the same signal so that the parent terminates with the expected
+  // semantics (this also sets the correct exit code of 128 + n).
   process.kill(process.pid, childResult.signal);
 } else {
   process.exit(childResult.exitCode);

package/bin/codex.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+// Unified entry point for the Codex CLI.
+
+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;
+
+let targetTriple = null;
+switch (platform) {
+  case "linux":
+  case "android":
+    switch (arch) {
+      case "x64":
+        targetTriple = "x86_64-unknown-linux-musl";
+        break;
+      case "arm64":
+        targetTriple = "aarch64-unknown-linux-musl";
+        break;
+      default:
+        break;
+    }
+    break;
+  case "darwin":
+    switch (arch) {
+      case "x64":
+        targetTriple = "x86_64-apple-darwin";
+        break;
+      case "arm64":
+        targetTriple = "aarch64-apple-darwin";
+        break;
+      default:
+        break;
+    }
+    break;
+  case "win32":
+    switch (arch) {
+      case "x64":
+        targetTriple = "x86_64-pc-windows-msvc";
+        break;
+      case "arm64":
+        targetTriple = "aarch64-pc-windows-msvc";
+        break;
+      default:
+        break;
+    }
+    break;
+  default:
+    break;
+}
+
+if (!targetTriple) {
+  throw new Error(`Unsupported platform: ${platform} (${arch})`);
+}
+
+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
+// respond to signals (e.g. Ctrl-C / SIGINT) while the native binary is
+// executing. This allows us to forward those signals to the child process
+// and guarantees that when either the child terminates or the parent
+// receives a fatal signal, both processes exit in a predictable manner.
+
+function getUpdatedPath(newDirs) {
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  const existingPath = process.env.PATH || "";
+  const updatedPath = [
+    ...newDirs,
+    ...existingPath.split(pathSep).filter(Boolean),
+  ].join(pathSep);
+  return updatedPath;
+}
+
+const additionalDirs = [];
+const pathDir = path.join(archRoot, "path");
+if (existsSync(pathDir)) {
+  additionalDirs.push(pathDir);
+}
+const updatedPath = getUpdatedPath(additionalDirs);
+
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: "inherit",
+  env: { ...process.env, PATH: updatedPath, CODEX_MANAGED_BY_NPM: "1" },
+});
+
+child.on("error", (err) => {
+  // Typically triggered when the binary is missing or not executable.
+  // Re-throwing here will terminate the parent with a non-zero exit code
+  // while still printing a helpful stack trace.
+  // eslint-disable-next-line no-console
+  console.error(err);
+  process.exit(1);
+});
+
+// Forward common termination signals to the child so that it shuts down
+// gracefully. In the handler we temporarily disable the default behavior of
+// exiting immediately; once the child has been signaled we simply wait for
+// its exit event which will in turn terminate the parent (see below).
+const forwardSignal = (signal) => {
+  if (child.killed) {
+    return;
+  }
+  try {
+    child.kill(signal);
+  } catch {
+    /* ignore */
+  }
+};
+
+["SIGINT", "SIGTERM", "SIGHUP"].forEach((sig) => {
+  process.on(sig, () => forwardSignal(sig));
+});
+
+// When the child exits, mirror its termination reason in the parent so that
+// shell scripts and other tooling observe the correct exit status.
+// Wrap the lifetime of the child process in a Promise so that we can await
+// its termination in a structured way. The Promise resolves with an object
+// describing how the child exited: either via exit code or due to a signal.
+const childResult = await new Promise((resolve) => {
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      resolve({ type: "signal", signal });
+    } else {
+      resolve({ type: "code", exitCode: code ?? 1 });
+    }
+  });
+});
+
+if (childResult.type === "signal") {
+  // Re-emit the same signal so that the parent terminates with the expected
+  // semantics (this also sets the correct exit code of 128 + n).
+  process.kill(process.pid, childResult.signal);
+} else {
+  process.exit(childResult.exitCode);
+}

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@hanzo/dev",
-  "version": "0.6.91",
+  "version": "0.6.93",
   "license": "Apache-2.0",
-  "description": "Hanzo AI coding assistant - intelligent CLI for developers",
+  "description": "Local AI coding agent for your terminal, powered by Hanzo AI",
   "bin": {
-    "dev": "bin/dev.js",
-    "hanzo": "bin/dev.js"
+    "dev": "bin/coder.js"
   },
   "type": "module",
   "engines": {
     "node": ">=16"
   },
   "files": [
-    "bin/dev.js",
+    "bin/coder.js",
+    "bin/codex.js",
     "postinstall.js",
     "scripts/preinstall.js",
     "scripts/windows-cleanup.ps1",
@@ -21,7 +21,7 @@
   "scripts": {
     "preinstall": "node scripts/preinstall.js",
     "postinstall": "node postinstall.js",
-    "prepublishOnly": "node -e \"const fs=require('fs'),path=require('path'); const repoGit=path.join(__dirname,'..','.git'); const inCi=process.env.GITHUB_ACTIONS==='true'||process.env.CI==='true'; if(fs.existsSync(repoGit) && !inCi){ console.error('Refusing to publish from dev-cli. Publishing happens via release.yml.'); process.exit(1);} else { console.log(inCi ? 'CI publish detected.' : 'Publishing staged package...'); }\""
+    "prepublishOnly": "node -e \"const fs=require('fs'),path=require('path'); const repoGit=path.join(__dirname,'..','.git'); const inCi=process.env.GITHUB_ACTIONS==='true'||process.env.CI==='true'; if(fs.existsSync(repoGit) && !inCi){ console.error('Refusing to publish from codex-cli. Publishing happens via release.yml.'); process.exit(1);} else { console.log(inCi ? 'CI publish detected.' : 'Publishing staged package...'); }\""
   },
   "repository": {
     "type": "git",
@@ -35,10 +35,10 @@
     "prettier": "^3.3.3"
   },
   "optionalDependencies": {
-    "@hanzo/dev-darwin-arm64": "0.6.91",
-    "@hanzo/dev-darwin-x64": "0.6.91",
-    "@hanzo/dev-linux-x64-musl": "0.6.91",
-    "@hanzo/dev-linux-arm64-musl": "0.6.91",
-    "@hanzo/dev-win32-x64": "0.6.91"
+    "@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"
   }
 }