@just-every/code 0.2.118 → 0.2.120

package/bin/coder.js

@@ -177,9 +177,12 @@ const tryBootstrapBinary = async () => {
     if (existsSync(cachePath)) {
       const v = validateBinary(cachePath);
       if (v.ok) {
-        copyFileSync(cachePath, binaryPath);
-        if (platform !== "win32") chmodSync(binaryPath, 0o755);
-        return existsSync(binaryPath);
+        // Prefer running directly from cache; mirror into node_modules on Unix
+        if (platform !== "win32") {
+          copyFileSync(cachePath, binaryPath);
+          try { chmodSync(binaryPath, 0o755); } catch {}
+        }
+        return true;
       }
     }
 
@@ -202,11 +205,13 @@ const tryBootstrapBinary = async () => {
           const pkgDir = path.dirname(pkgJson);
           const src = path.join(pkgDir, "bin", `code-${targetTriple}${platform === "win32" ? ".exe" : ""}`);
           if (existsSync(src)) {
-            copyFileSync(src, binaryPath);
-            if (platform !== "win32") chmodSync(binaryPath, 0o755);
-            // refresh cache
-            try { copyFileSync(binaryPath, cachePath); } catch {}
-            return existsSync(binaryPath);
+            // Always ensure cache has the binary; on Unix mirror into node_modules
+            copyFileSync(src, cachePath);
+            if (platform !== "win32") {
+              copyFileSync(cachePath, binaryPath);
+              try { chmodSync(binaryPath, 0o755); } catch {}
+            }
+            return true;
           }
         } catch { /* ignore and fall back */ }
       }
@@ -239,10 +244,19 @@ const tryBootstrapBinary = async () => {
             try { unlinkSync(tmp); } catch {}
           }
         }
-        const v = validateBinary(binaryPath);
+        // On Windows, prefer cache and avoid leaving the executable in node_modules
+        if (platform === "win32") {
+          try {
+            copyFileSync(binaryPath, cachePath);
+          } catch {}
+          try { unlinkSync(binaryPath); } catch {}
+        } else {
+          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);
@@ -262,9 +276,19 @@ if (!existsSync(binaryPath) && !existsSync(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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@just-every/code",
-  "version": "0.2.118",
+  "version": "0.2.120",
   "license": "Apache-2.0",
   "description": "Lightweight coding agent that runs in your terminal - fork of OpenAI Codex",
   "bin": {
@@ -14,9 +14,12 @@
     "bin/coder.js",
     "bin/codex.js",
     "postinstall.js",
+    "scripts/preinstall.js",
+    "scripts/windows-cleanup.ps1",
     "dist"
   ],
   "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 codex-cli. Use codex-cli/scripts/stage_release.sh to stage a release.'); process.exit(1);} else { console.log(inCi ? 'CI publish detected.' : 'Publishing staged package...'); }\""
   },
@@ -32,10 +35,10 @@
     "prettier": "^3.3.3"
   },
   "optionalDependencies": {
-    "@just-every/code-darwin-arm64": "0.2.118",
-    "@just-every/code-darwin-x64": "0.2.118",
-    "@just-every/code-linux-x64-musl": "0.2.118",
-    "@just-every/code-linux-arm64-musl": "0.2.118",
-    "@just-every/code-win32-x64": "0.2.118"
+    "@just-every/code-darwin-arm64": "0.2.120",
+    "@just-every/code-darwin-x64": "0.2.120",
+    "@just-every/code-linux-x64-musl": "0.2.120",
+    "@just-every/code-linux-arm64-musl": "0.2.120",
+    "@just-every/code-win32-x64": "0.2.120"
   }
 }

package/postinstall.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 // Non-functional change to trigger release workflow
 
-import { existsSync, mkdirSync, createWriteStream, chmodSync, readFileSync, readSync, writeFileSync, unlinkSync, statSync, openSync, closeSync, copyFileSync } from 'fs';
+import { existsSync, mkdirSync, createWriteStream, chmodSync, readFileSync, readSync, writeFileSync, unlinkSync, statSync, openSync, closeSync, copyFileSync, fsyncSync, renameSync, realpathSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { get } from 'https';
-import { platform, arch } from 'os';
+import { platform, arch, tmpdir } from 'os';
 import { execSync } from 'child_process';
 import { createRequire } from 'module';
 
@@ -54,6 +54,56 @@ function getCachedBinaryPath(version, targetTriple, isWindows) {
   return join(cacheDir, `code-${targetTriple}${ext}`);
 }
 
+function isWSL() {
+  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; }
+}
+
+function isPathOnWindowsFs(p) {
+  try {
+    const mounts = readFileSync('/proc/mounts', 'utf8').split(/\n/).filter(Boolean);
+    let best = { mount: '/', type: 'unknown', len: 1 };
+    for (const line of mounts) {
+      const parts = line.split(' ');
+      if (parts.length < 3) continue;
+      const mnt = parts[1];
+      const typ = parts[2];
+      if (p.startsWith(mnt) && mnt.length > best.len) best = { mount: mnt, type: typ, len: mnt.length };
+    }
+    return best.type === 'drvfs' || best.type === 'cifs';
+  } catch { return false; }
+}
+
+async function writeCacheAtomic(srcPath, cachePath) {
+  try {
+    if (existsSync(cachePath)) {
+      const ok = validateDownloadedBinary(cachePath).ok;
+      if (ok) return;
+    }
+  } catch {}
+  const dir = dirname(cachePath);
+  if (!existsSync(dir)) { try { mkdirSync(dir, { recursive: true }); } catch {} }
+  const tmp = cachePath + '.tmp-' + Math.random().toString(36).slice(2, 8);
+  copyFileSync(srcPath, tmp);
+  try { const fd = openSync(tmp, 'r'); try { fsyncSync(fd); } finally { closeSync(fd); } } catch {}
+  // Retry with exponential backoff up to ~1.6s total
+  const delays = [100, 200, 400, 800, 1200, 1600];
+  for (let i = 0; i < delays.length; i++) {
+    try {
+      if (existsSync(cachePath)) { try { unlinkSync(cachePath); } catch {} }
+      renameSync(tmp, cachePath);
+      return;
+    } catch {
+      await new Promise(r => setTimeout(r, delays[i]));
+    }
+  }
+  if (existsSync(cachePath)) { try { unlinkSync(cachePath); } catch {} }
+  renameSync(tmp, cachePath);
+}
+
 async function downloadBinary(url, dest, maxRedirects = 5, maxRetries = 3) {
   const sleep = (ms) => new Promise(r => setTimeout(r, ms));
 
@@ -227,30 +277,26 @@ async function main() {
     const localPath = join(binDir, binaryName);
     const cachePath = getCachedBinaryPath(version, targetTriple, isWindows);
     
-    // Skip if already exists and has correct permissions
-    if (existsSync(localPath)) {
-      // Always try to fix permissions on Unix-like systems
-      if (!isWindows) {
-        try {
-          chmodSync(localPath, 0o755);
-          console.log(`✓ ${binaryName} already exists (permissions fixed)`);
-        } catch (e) {
-          console.log(`✓ ${binaryName} already exists`);
-        }
-      } else {
-        console.log(`✓ ${binaryName} already exists`);
-      }
-      continue;
-    }
+    // On Windows we avoid placing the executable inside node_modules to prevent
+    // EBUSY/EPERM during global upgrades when the binary is in use.
+    // We treat the user cache path as the canonical home of the native binary.
+    // For macOS/Linux we keep previous behavior and also place a copy in binDir
+    // for convenience.
 
     // Fast path: if a valid cached binary exists for this version+triple, reuse it.
     try {
       if (existsSync(cachePath)) {
         const valid = validateDownloadedBinary(cachePath);
         if (valid.ok) {
-          copyFileSync(cachePath, localPath);
-          if (!isWindows) chmodSync(localPath, 0o755);
-          console.log(`✓ Installed ${binaryName} from user cache`);
+          // Avoid mirroring into node_modules on Windows or WSL-on-NTFS.
+          const wsl = isWSL();
+          const binDirReal = (() => { try { return realpathSync(binDir); } catch { return binDir; } })();
+          const mirrorToLocal = !(isWindows || (wsl && isPathOnWindowsFs(binDirReal)));
+          if (mirrorToLocal) {
+            copyFileSync(cachePath, localPath);
+            try { chmodSync(localPath, 0o755); } catch {}
+          }
+          console.log(`✓ ${binaryName} ready from user cache`);
           continue; // next binary
         }
       }
@@ -288,15 +334,17 @@ async function main() {
         if (!existsSync(src)) {
           throw new Error(`platform package missing binary: ${platformPkg.name}`);
         }
-        copyFileSync(src, localPath);
-        if (!isWindows) chmodSync(localPath, 0o755);
-        console.log(`✓ Installed ${binaryName} from ${platformPkg.name}`);
-        // Populate cache for future npx runs
-        try {
-          if (!existsSync(cachePath)) {
-            copyFileSync(localPath, cachePath);
-          }
-        } catch {}
+        // Populate cache first (canonical location) atomically
+        await writeCacheAtomic(src, cachePath);
+        // Mirror into local bin only on Unix-like filesystems (not Windows/WSL-on-NTFS)
+        const wsl = isWSL();
+        const binDirReal = (() => { try { return realpathSync(binDir); } catch { return binDir; } })();
+        const mirrorToLocal = !(isWindows || (wsl && isPathOnWindowsFs(binDirReal)));
+        if (mirrorToLocal) {
+          copyFileSync(cachePath, localPath);
+          try { chmodSync(localPath, 0o755); } catch {}
+        }
+        console.log(`✓ Installed ${binaryName} from ${platformPkg.name} (cached)`);
         continue; // next binary
       } catch (e) {
         console.warn(`⚠ Failed platform package install (${e.message}), falling back to GitHub download`);
@@ -307,6 +355,15 @@ async function main() {
     // - Windows: .zip
     // - macOS/Linux: prefer .zst if `zstd` CLI is available; otherwise use .tar.gz
     const isWin = isWindows;
+    const isWSL = (() => {
+      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)));
     let useZst = false;
     if (!isWin) {
       try {
@@ -321,24 +378,57 @@ async function main() {
 
     console.log(`Downloading ${archiveName}...`);
     try {
-      const tmpPath = join(binDir, `.${archiveName}.part`);
+      const needsIsolation = isWin || (!isWin && !mirrorToLocal); // Windows or WSL-on-NTFS
+      let safeTempDir = needsIsolation ? join(tmpdir(), 'just-every', 'code', version) : binDir;
+      // Ensure staging dir exists; if tmp fails (permissions/space), fall back to user cache.
+      if (needsIsolation) {
+        try {
+          if (!existsSync(safeTempDir)) mkdirSync(safeTempDir, { recursive: true });
+        } catch {
+          try {
+            safeTempDir = getCacheDir(version);
+            if (!existsSync(safeTempDir)) mkdirSync(safeTempDir, { recursive: true });
+          } catch {}
+        }
+      }
+      const tmpPath = join(needsIsolation ? safeTempDir : binDir, `.${archiveName}.part`);
       await downloadBinary(downloadUrl, tmpPath);
 
       if (isWin) {
-        // Unzip the single-file archive using PowerShell (built-in)
+        // Unzip to a temp directory, then move into the per-user cache.
+        const unzipDest = safeTempDir;
         try {
-          const psCmd = `powershell -NoProfile -NonInteractive -Command "Expand-Archive -Path '${tmpPath}' -DestinationPath '${binDir}' -Force"`;
-          execSync(psCmd, { stdio: 'ignore' });
+          const sysRoot = process.env.SystemRoot || process.env.windir || 'C:\\Windows';
+          const psFull = join(sysRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+          const psCmd = `Expand-Archive -Path '${tmpPath}' -DestinationPath '${unzipDest}' -Force`;
+          let ok = false;
+          // Attempt full-path powershell.exe
+          try { execSync(`"${psFull}" -NoProfile -NonInteractive -Command "${psCmd}"`, { stdio: 'ignore' }); ok = true; } catch {}
+          // Fallback to powershell in PATH
+          if (!ok) { try { execSync(`powershell -NoProfile -NonInteractive -Command "${psCmd}"`, { stdio: 'ignore' }); ok = true; } catch {} }
+          // Fallback to pwsh (PowerShell 7)
+          if (!ok) { try { execSync(`pwsh -NoProfile -NonInteractive -Command "${psCmd}"`, { stdio: 'ignore' }); ok = true; } catch {} }
+          // Final fallback: bsdtar can extract .zip
+          if (!ok) { execSync(`tar -xf "${tmpPath}" -C "${unzipDest}"`, { stdio: 'ignore', shell: true }); }
         } catch (e) {
           throw new Error(`failed to unzip archive: ${e.message}`);
         } finally {
           try { unlinkSync(tmpPath); } catch {}
         }
+        // Move the extracted file from temp to cache; do not leave a copy in node_modules
+        try {
+          const extractedPath = join(unzipDest, binaryName);
+          await writeCacheAtomic(extractedPath, cachePath);
+          try { unlinkSync(extractedPath); } catch {}
+        } catch (e) {
+          throw new Error(`failed to move binary to cache: ${e.message}`);
+        }
       } else {
         if (useZst) {
           // Decompress .zst via system zstd
           try {
-            execSync(`zstd -d '${tmpPath}' -o '${localPath}'`, { stdio: 'ignore', shell: true });
+            const outPath = mirrorToLocal ? localPath : join(safeTempDir, binaryName);
+            execSync(`zstd -d '${tmpPath}' -o '${outPath}'`, { stdio: 'ignore', shell: true });
           } catch (e) {
             try { unlinkSync(tmpPath); } catch {}
             throw new Error(`failed to decompress .zst (need zstd CLI): ${e.message}`);
@@ -347,32 +437,43 @@ async function main() {
         } else {
           // Extract .tar.gz using system tar
           try {
-            execSync(`tar -xzf '${tmpPath}' -C '${binDir}'`, { stdio: 'ignore', shell: true });
+            const dest = mirrorToLocal ? binDir : safeTempDir;
+            execSync(`tar -xzf '${tmpPath}' -C '${dest}'`, { stdio: 'ignore', shell: true });
           } catch (e) {
             try { unlinkSync(tmpPath); } catch {}
             throw new Error(`failed to extract .tar.gz: ${e.message}`);
           }
           try { unlinkSync(tmpPath); } catch {}
         }
+        if (!mirrorToLocal) {
+          try {
+            const extractedPath = join(safeTempDir, binaryName);
+            await writeCacheAtomic(extractedPath, cachePath);
+            try { unlinkSync(extractedPath); } catch {}
+          } catch (e) {
+            throw new Error(`failed to move binary to cache: ${e.message}`);
+          }
+        }
       }
 
       // Validate header to avoid corrupt binaries causing spawn EFTYPE/ENOEXEC
-      const valid = validateDownloadedBinary(localPath);
+
+      const valid = validateDownloadedBinary(isWin ? cachePath : (mirrorToLocal ? localPath : cachePath));
       if (!valid.ok) {
-        try { unlinkSync(localPath); } catch {}
+        try { (isWin || !mirrorToLocal) ? unlinkSync(cachePath) : unlinkSync(localPath); } catch {}
         throw new Error(`invalid binary (${valid.reason})`);
       }
 
       // Make executable on Unix-like systems
-      if (!isWindows) {
+      if (!isWin && mirrorToLocal) {
         chmodSync(localPath, 0o755);
       }
       
-      console.log(`✓ Installed ${binaryName}`);
-      // Save into persistent cache for future fast installs
-      try {
-        copyFileSync(localPath, cachePath);
-      } catch {}
+      console.log(`✓ Installed ${binaryName}${(isWin || !mirrorToLocal) ? ' (cached)' : ''}`);
+      // Ensure persistent cache holds the binary (already true for Windows path)
+      if (!isWin && mirrorToLocal) {
+        try { await writeCacheAtomic(localPath, cachePath); } catch {}
+      }
     } catch (error) {
       console.error(`✗ Failed to install ${binaryName}: ${error.message}`);
       console.error(`  Downloaded from: ${downloadUrl}`);
@@ -384,13 +485,12 @@ async function main() {
   const mainBinary = `code-${targetTriple}${binaryExt}`;
   const mainBinaryPath = join(binDir, mainBinary);
   
-  if (existsSync(mainBinaryPath)) {
+  if (existsSync(mainBinaryPath) || existsSync(getCachedBinaryPath(version, targetTriple, platform() === 'win32'))) {
     try {
-      const stats = statSync(mainBinaryPath);
-      if (!stats.size) {
-        throw new Error('binary is empty (download likely failed)');
-      }
-      const valid = validateDownloadedBinary(mainBinaryPath);
+      const probePath = existsSync(mainBinaryPath) ? mainBinaryPath : getCachedBinaryPath(version, targetTriple, platform() === 'win32');
+      const stats = statSync(probePath);
+      if (!stats.size) throw new Error('binary is empty (download likely failed)');
+      const valid = validateDownloadedBinary(probePath);
       if (!valid.ok) {
         console.warn(`⚠ Main code binary appears invalid: ${valid.reason}`);
         console.warn('  Try reinstalling or check your network/proxy settings.');

package/scripts/preinstall.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+// 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';
+
+function isWSL() {
+  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 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';
+if (!isWinLike || skip || (!isGlobal && !force)) process.exit(0);
+
+function tryExec(cmd, opts = {}) {
+  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');
+}
+
+// 2) Remove stale staging dirs from previous failed installs under the global
+//    @just-every scope, which npm will reuse (e.g., .code-XXXXX). Remove only
+//    old entries and never the current staging or live package.
+try {
+  let scopeDir = '';
+  try {
+    const root = execSync('npm root -g', { stdio: ['ignore', 'pipe', 'ignore'], shell: true }).toString().trim();
+    scopeDir = path.join(root, '@just-every');
+  } catch {
+    // Fall back to guessing from this script location: <staging>\..\..\
+    const here = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
+    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)), '..');
+    for (const name of readdirSync(scopeDir)) {
+      if (!name.startsWith('.code-')) 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 */ }
+
+process.exit(0);

package/scripts/windows-cleanup.ps1

@@ -0,0 +1,32 @@
+<#
+Helper to recover from EBUSY/EPERM during global npm upgrades on Windows.
+Closes running processes and removes stale package folders.
+
+Usage (PowerShell):
+  Set-ExecutionPolicy -Scope Process Bypass -Force
+  ./codex-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 "Removing old global package (if present)..."
+$npmRoot = (& npm root -g).Trim()
+$pkgPath = Join-Path $npmRoot "@just-every\code"
+if (Test-Path $pkgPath) {
+  try { Remove-Item -LiteralPath $pkgPath -Recurse -Force -ErrorAction Stop } catch {}
+}
+
+Write-Host "Removing temp staging directories (if present)..."
+Get-ChildItem -LiteralPath (Join-Path $npmRoot "@just-every") -Force -ErrorAction SilentlyContinue |
+  Where-Object { $_.Name -like '.code-*' } |
+  ForEach-Object {
+    try { Remove-Item -LiteralPath $_.FullName -Recurse -Force -ErrorAction Stop } catch {}
+  }
+
+Write-Host "Cleanup complete. You can now run: npm install -g @just-every/code@latest"
+