@hanzo/dev 0.6.73 → 0.6.75

package/scripts/preinstall.js

@@ -2,68 +2,90 @@
 // Windows-friendly preinstall: proactively free file locks from prior installs
 // so npm/yarn/pnpm can stage the new package. No-ops on non-Windows.
 
-import { platform } from 'os';
-import { execSync } from 'child_process';
-import { existsSync, readdirSync, rmSync, readFileSync, statSync } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
+import { platform } from "os";
+import { execSync } from "child_process";
+import { existsSync, readdirSync, rmSync, readFileSync, statSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
 
 function isWSL() {
-  if (platform() !== 'linux') return false;
+  if (platform() !== "linux") return false;
   try {
-    const rel = readFileSync('/proc/version', 'utf8').toLowerCase();
-    return rel.includes('microsoft') || !!process.env.WSL_DISTRO_NAME;
-  } catch { return false; }
+    const rel = readFileSync("/proc/version", "utf8").toLowerCase();
+    return rel.includes("microsoft") || !!process.env.WSL_DISTRO_NAME;
+  } catch {
+    return false;
+  }
 }
 
-const isWin = platform() === 'win32';
+const isWin = platform() === "win32";
 const wsl = isWSL();
 const isWinLike = isWin || wsl;
 
 // Scope: only run for global installs, unless explicitly forced. Allow opt-out.
-const isGlobal = process.env.npm_config_global === 'true';
-const force = process.env.CODE_FORCE_PREINSTALL === '1';
-const skip = process.env.CODE_SKIP_PREINSTALL === '1';
+const isGlobal = process.env.npm_config_global === "true";
+const force = process.env.DEV_FORCE_PREINSTALL === "1";
+const skip = process.env.DEV_SKIP_PREINSTALL === "1";
 if (!isWinLike || skip || (!isGlobal && !force)) process.exit(0);
 
 function tryExec(cmd, opts = {}) {
-  try { execSync(cmd, { stdio: ['ignore', 'ignore', 'ignore'], shell: true, ...opts }); } catch { /* ignore */ }
+  try {
+    execSync(cmd, {
+      stdio: ["ignore", "ignore", "ignore"],
+      shell: true,
+      ...opts,
+    });
+  } catch {
+    /* ignore */
+  }
 }
 
 // 1) Stop our native binary if it is holding locks. Avoid killing unrelated tools.
 // Only available on native Windows; skip entirely on WSL to avoid noise.
 if (isWin) {
-  tryExec('taskkill /IM code-x86_64-pc-windows-msvc.exe /F');
+  tryExec("taskkill /IM dev-x86_64-pc-windows-msvc.exe /F");
 }
 
 // 2) Remove stale staging dirs from previous failed installs under the global
-//    @hanzo scope, which npm will reuse (e.g., .code-XXXXX). Remove only
+//    @hanzo scope, which npm will reuse (e.g., .dev-XXXXX). Remove only
 //    old entries and never the current staging or live package.
 try {
-  let scopeDir = '';
+  let scopeDir = "";
   try {
-    const root = execSync('npm root -g', { stdio: ['ignore', 'pipe', 'ignore'], shell: true }).toString().trim();
-    scopeDir = path.join(root, '@hanzo');
+    const root = execSync("npm root -g", {
+      stdio: ["ignore", "pipe", "ignore"],
+      shell: true,
+    })
+      .toString()
+      .trim();
+    scopeDir = path.join(root, "@hanzo");
   } catch {
     // Fall back to guessing from this script location: <staging>\..\..\
     const here = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
-    scopeDir = path.resolve(here, '..');
+    scopeDir = path.resolve(here, "..");
   }
   if (existsSync(scopeDir)) {
     const now = Date.now();
     const maxAgeMs = 2 * 60 * 60 * 1000; // 2 hours
-    const currentDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+    const currentDir = path.resolve(
+      path.dirname(fileURLToPath(import.meta.url)),
+      "..",
+    );
     for (const name of readdirSync(scopeDir)) {
-      if (!name.startsWith('.code-')) continue;
+      if (!name.startsWith(".dev-")) continue;
       const p = path.join(scopeDir, name);
       if (path.resolve(p) === currentDir) continue; // never remove our current dir
       try {
         const st = statSync(p);
         const age = now - st.mtimeMs;
         if (age > maxAgeMs) rmSync(p, { recursive: true, force: true });
-      } catch { /* ignore */ }
+      } catch {
+        /* ignore */
+      }
     }
   }
-} catch { /* ignore */ }
+} catch {
+  /* ignore */
+}
 
 process.exit(0);

package/scripts/windows-cleanup.ps1

@@ -4,15 +4,15 @@ Closes running processes and removes stale package folders.
 
 Usage (PowerShell):
   Set-ExecutionPolicy -Scope Process Bypass -Force
-  ./codex-cli/scripts/windows-cleanup.ps1
+  ./dev-cli/scripts/windows-cleanup.ps1
 #>
 
 $ErrorActionPreference = 'SilentlyContinue'
 
-Write-Host "Stopping running Code/Coder processes..."
-taskkill /IM code-x86_64-pc-windows-msvc.exe /F 2>$null | Out-Null
-taskkill /IM code.exe /F 2>$null | Out-Null
-taskkill /IM coder.exe /F 2>$null | Out-Null
+Write-Host "Stopping running Hanzo Dev processes..."
+taskkill /IM dev-x86_64-pc-windows-msvc.exe /F 2>$null | Out-Null
+taskkill /IM dev.exe /F 2>$null | Out-Null
+taskkill /IM hanzo.exe /F 2>$null | Out-Null
 
 Write-Host "Removing old global package (if present)..."
 $npmRoot = (& npm root -g).Trim()
@@ -23,10 +23,9 @@ if (Test-Path $pkgPath) {
 
 Write-Host "Removing temp staging directories (if present)..."
 Get-ChildItem -LiteralPath (Join-Path $npmRoot "@hanzo") -Force -ErrorAction SilentlyContinue |
-  Where-Object { $_.Name -like '.code-*' } |
+  Where-Object { $_.Name -like '.dev-*' } |
   ForEach-Object {
     try { Remove-Item -LiteralPath $_.FullName -Recurse -Force -ErrorAction Stop } catch {}
   }
 
 Write-Host "Cleanup complete. You can now run: npm install -g @hanzo/dev@latest"
-

package/bin/codex.js

@@ -1,197 +0,0 @@
-#!/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 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"
-      : "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);
-}