@hanzo/dev 3.0.1 → 3.0.2

package/bin/dev.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);
@@ -13,23 +14,15 @@ const __dirname = path.dirname(__filename);
 
 const { platform, arch } = process;
 
-// Important: Never delegate to another system's `dev` binary.
-// 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 os = require("os");
-    const rel = os.release().toLowerCase();
-    if (rel.includes("microsoft")) return true;
-    const fs = require("fs");
-    const txt = fs.readFileSync("/proc/version", "utf8").toLowerCase();
+    const txt = readFileSync("/proc/version", "utf8").toLowerCase();
     return txt.includes("microsoft");
   } catch {
     return false;
   }
-};
+}
 
 let targetTriple = null;
 switch (platform) {
@@ -77,12 +70,11 @@ if (!targetTriple) {
   throw new Error(`Unsupported platform: ${platform} (${arch})`);
 }
 
-// Use 'dev-*' binary names
+// Binary names for Hanzo dev
 let binaryPath = path.join(__dirname, "..", "bin", `dev-${targetTriple}`);
-let legacyBinaryPath = path.join(__dirname, "..", "bin", `dev-${targetTriple}`);
+let legacyBinaryPath = path.join(__dirname, "..", "bin", `code-${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 } from "fs";
+import { existsSync, chmodSync, statSync, openSync, readSync, closeSync, mkdirSync, copyFileSync, readFileSync, unlinkSync, createWriteStream } from "fs";
 
 const validateBinary = (p) => {
   try {
@@ -130,23 +122,22 @@ const getCacheDir = (version) => {
 };
 
 const getCachedBinaryPath = (version) => {
-  const isWin = nodePlatform() === "win32";
-  const ext = isWin ? ".exe" : "";
   const cacheDir = getCacheDir(version);
-  return path.join(cacheDir, `dev-${targetTriple}${ext}`);
+  return path.join(cacheDir, `dev-${targetTriple}`);
 };
 
+let lastBootstrapError = null;
+
 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) {
       return reject(new Error(`HTTP ${status}`));
     }
-    const out = require("fs").createWriteStream(dest);
+    const out = createWriteStream(dest);
     res.pipe(out);
     out.on("finish", () => out.close(resolve));
     out.on("error", (e) => {
@@ -165,29 +156,30 @@ 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 });
 
-    // 2) Fast path: user cache
+    // Fast path: user cache
     const cachePath = getCachedBinaryPath(version);
     if (existsSync(cachePath)) {
       const v = validateBinary(cachePath);
       if (v.ok) {
-        copyFileSync(cachePath, binaryPath);
-        if (platform !== "win32") chmodSync(binaryPath, 0o755);
-        return existsSync(binaryPath);
+        if (platform !== "win32") {
+          copyFileSync(cachePath, binaryPath);
+          try { chmodSync(binaryPath, 0o755); } catch {}
+        }
+        return true;
       }
     }
 
-    // 3) Try platform package (if present)
+    // Try platform package (if present)
     try {
       const req = (await import("module")).createRequire(import.meta.url);
       const name = (() => {
-        if (platform === "win32") return "@just-every/code-win32-x64"; // may be unpublished; falls through
+        if (platform === "win32") return "@hanzo/dev-win32-x64";
         const plt = nodePlatform();
         const cpu = nodeArch();
         if (plt === "darwin" && cpu === "arm64") return "@hanzo/dev-darwin-arm64";
@@ -200,31 +192,41 @@ const tryBootstrapBinary = async () => {
         try {
           const pkgJson = req.resolve(`${name}/package.json`);
           const pkgDir = path.dirname(pkgJson);
-          const src = path.join(pkgDir, "bin", `dev-${targetTriple}${platform === "win32" ? ".exe" : ""}`);
+          const src = path.join(pkgDir, "bin", `dev-${targetTriple}`);
           if (existsSync(src)) {
-            copyFileSync(src, binaryPath);
-            if (platform !== "win32") chmodSync(binaryPath, 0o755);
-            // refresh cache
-            try { copyFileSync(binaryPath, cachePath); } catch {}
-            return existsSync(binaryPath);
+            copyFileSync(src, cachePath);
+            if (platform !== "win32") {
+              copyFileSync(cachePath, binaryPath);
+              try { chmodSync(binaryPath, 0o755); } catch {}
+            }
+            return true;
           }
         } catch { /* ignore and fall back */ }
       }
     } catch { /* ignore */ }
 
-    // 4) Download from GitHub release
+    // Download from GitHub release
     const isWin = platform === "win32";
+    // Use 'code-*' binary names since that's what the release produces
+    const binaryName = `code-${targetTriple}`;
     const archiveName = isWin
-      ? `dev-${targetTriple}.zip`
-      : (() => { try { execSync("zstd --version", { stdio: "ignore", shell: true }); return `dev-${targetTriple}.zst`; } catch { return `dev-${targetTriple}.tar.gz`; } })();
+      ? `${binaryName}.zip`
+      : (() => { try { execSync("zstd --version", { stdio: "ignore", shell: true }); return `${binaryName}.zst`; } catch { return `${binaryName}.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) {
           try {
-            const ps = `powershell -NoProfile -NonInteractive -Command "Expand-Archive -Path '${tmp}' -DestinationPath '${binDir}' -Force"`;
-            execSync(ps, { stdio: "ignore" });
+            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 psCmd = `Expand-Archive -Path '${tmp}' -DestinationPath '${unzipDest}' -Force`;
+            let ok = false;
+            try { execSync(`"${psFull}" -NoProfile -NonInteractive -Command "${psCmd}"`, { stdio: 'ignore' }); ok = true; } catch {}
+            if (!ok) { try { execSync(`powershell -NoProfile -NonInteractive -Command "${psCmd}"`, { stdio: 'ignore' }); ok = true; } catch {} }
+            if (!ok) { try { execSync(`pwsh -NoProfile -NonInteractive -Command "${psCmd}"`, { stdio: 'ignore' }); ok = true; } catch {} }
+            if (!ok) { execSync(`tar -xf "${tmp}" -C "${unzipDest}"`, { stdio: 'ignore', shell: true }); }
           } catch (e) {
             throw new Error(`failed to unzip: ${e.message}`);
           } finally { try { unlinkSync(tmp); } catch {} }
@@ -239,48 +241,75 @@ const tryBootstrapBinary = async () => {
             try { unlinkSync(tmp); } catch {}
           }
         }
-        const v = validateBinary(binaryPath);
+        if (platform !== "win32") {
+          try { copyFileSync(binaryPath, cachePath); } catch {}
+        }
+
+        const v = validateBinary(platform === "win32" ? cachePath : binaryPath);
         if (!v.ok) throw new Error(`invalid binary (${v.reason})`);
-        if (platform !== "win32") chmodSync(binaryPath, 0o755);
-        try { copyFileSync(binaryPath, cachePath); } catch {}
+        if (platform !== "win32") try { chmodSync(binaryPath, 0o755); } catch {}
         return true;
       })
-      .catch((_e) => false);
+      .catch((e) => { lastBootstrapError = e; return false; });
   } catch {
     return false;
   }
 };
 
-// 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;
+// If missing, attempt to bootstrap into place
+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;
+      }
+      if (existsSync(legacyBinaryPath) && !existsSync(binaryPath)) {
+        binaryPath = legacyBinaryPath;
+      }
     }
   }
 }
 
-// Fall back to legacy name if primary is still missing
-if (!existsSync(binaryPath) && existsSync(legacyBinaryPath)) {
-  binaryPath = legacyBinaryPath;
+// Prefer cached binary when available
+try {
+  const pkg = JSON.parse(readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
+  const version = pkg.version;
+  const cached = getCachedBinaryPath(version);
+  const v = existsSync(cached) ? validateBinary(cached) : { ok: false };
+  if (v.ok) {
+    binaryPath = cached;
+  } else if (!existsSync(binaryPath) && existsSync(legacyBinaryPath)) {
+    binaryPath = legacyBinaryPath;
+  }
+} catch {
+  // 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, will be caught below if it's a real problem
+    // Ignore permission errors
   }
 } else {
   console.error(`Binary not found: ${binaryPath}`);
+  if (lastBootstrapError) {
+    const msg = (lastBootstrapError && (lastBootstrapError.message || String(lastBootstrapError))) || 'unknown bootstrap error';
+    console.error(`Bootstrap error: ${msg}`);
+  }
   console.error(`Please try reinstalling the package:`);
   console.error(`  npm uninstall -g @hanzo/dev`);
   console.error(`  npm install -g @hanzo/dev`);
@@ -292,9 +321,6 @@ 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}`);
@@ -313,47 +339,25 @@ if (!validation.ok) {
   process.exit(1);
 }
 
-// If running under npx/npm, emit a concise notice about which binary path is used
+// If running under npx/npm, emit a concise notice
 try {
   const ua = process.env.npm_config_user_agent || "";
   const isNpx = ua.includes("npx");
   if (isNpx && process.stderr && process.stderr.isTTY) {
-    // 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 'dev' exists at ${otherCode}; not delegating.`);
-    } else {
-      console.error(`@hanzo/dev: running bundled binary -> ${binaryPath}`);
-    }
+    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;
+
 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, DEV_MANAGED_BY_NPM: "1", DEV_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}`);
@@ -377,10 +381,6 @@ 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,11 +396,6 @@ 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) {
@@ -412,8 +407,6 @@ 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/package.json

@@ -1,44 +1,32 @@
 {
   "name": "@hanzo/dev",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "license": "Apache-2.0",
-  "description": "Lightweight coding agent that runs in your terminal - Hanzo AI developer tools",
+  "description": "Hanzo AI coding assistant - intelligent CLI for developers",
   "bin": {
-    "dev": "bin/dev.js"
+    "dev": "bin/dev.js",
+    "hanzo": "bin/dev.js"
   },
   "type": "module",
   "engines": {
-    "node": ">=20"
+    "node": ">=16"
   },
   "files": [
     "bin/dev.js",
     "postinstall.js",
+    "scripts/preinstall.js",
+    "scripts/windows-cleanup.ps1",
     "dist"
   ],
   "scripts": {
-    "postinstall": "node postinstall.js"
+    "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...'); }\""
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/hanzoai/dev.git"
   },
-  "keywords": [
-    "ai",
-    "cli",
-    "dev",
-    "developer-tools",
-    "coding-assistant",
-    "hanzo",
-    "llm",
-    "chatgpt",
-    "claude",
-    "code-generation"
-  ],
-  "author": "Hanzo AI",
-  "homepage": "https://github.com/hanzoai/dev#readme",
-  "bugs": {
-    "url": "https://github.com/hanzoai/dev/issues"
-  },
   "publishConfig": {
     "access": "public"
   },
@@ -47,10 +35,10 @@
     "prettier": "^3.3.3"
   },
   "optionalDependencies": {
-    "@hanzo/dev-darwin-arm64": "3.0.1",
-    "@hanzo/dev-darwin-x64": "3.0.1",
-    "@hanzo/dev-linux-x64": "3.0.1",
-    "@hanzo/dev-linux-arm64": "3.0.1",
-    "@hanzo/dev-win32-x64": "3.0.1"
+    "@hanzo/dev-darwin-arm64": "3.0.2",
+    "@hanzo/dev-darwin-x64": "3.0.2",
+    "@hanzo/dev-linux-x64-musl": "3.0.2",
+    "@hanzo/dev-linux-arm64-musl": "3.0.2",
+    "@hanzo/dev-win32-x64": "3.0.2"
   }
 }