@just-every/code 0.2.42 → 0.2.44

package/bin/coder.js

@@ -3,8 +3,6 @@
 
 import path from "path";
 import { fileURLToPath } from "url";
-import { realpathSync, accessSync, constants } from "fs";
-import { spawnSync } from "child_process";
 
 // __dirname equivalent in ESM
 const __filename = fileURLToPath(import.meta.url);
@@ -12,55 +10,9 @@ const __dirname = path.dirname(__filename);
 
 const { platform, arch } = process;
 
-// If invoked as "code" and another "code" exists in PATH that is not
-// this package's launcher, delegate to it (e.g., VS Code's CLI).
-// This avoids hijacking users who already have VS Code installed.
-const maybeDelegateToOtherCode = () => {
-  try {
-    const invoked = process.env._ || "";
-    const invokedBase = path.basename(invoked);
-    if (invokedBase !== "code") return false;
-
-    const ourScriptReal = realpathSync(process.argv[1]);
-
-    const which = spawnSync("bash", ["-lc", "which -a code 2>/dev/null"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    });
-    if (which.status !== 0 || !which.stdout) return false;
-
-    const candidates = which.stdout
-      .split(/\r?\n/)
-      .map((s) => s.trim())
-      .filter(Boolean);
-
-    for (const c of candidates) {
-      // Skip the path that was used to invoke us
-      if (c === invoked) continue;
-      try {
-        const real = realpathSync(c);
-        // Skip if it resolves to our own script (same file inside our package)
-        if (real === ourScriptReal) continue;
-
-        // Ensure it's executable; if so, exec and mirror exit code
-        accessSync(c, constants.X_OK);
-        const run = spawnSync(c, process.argv.slice(2), {
-          stdio: "inherit",
-        });
-        // If it executed (even with non-zero), we consider delegation done.
-        const code = run.status == null ? 1 : run.status;
-        process.exit(code);
-      } catch {
-        // Try next candidate
-      }
-    }
-  } catch {
-    // Fall through to our own binary
-  }
-  return false;
-};
-
-maybeDelegateToOtherCode();
+// Important: Never delegate to another system's `code` binary (e.g., VS Code).
+// When users run via `npx @just-every/code`, we must always execute our
+// packaged native binary by absolute path to avoid PATH collisions.
 
 const isWSL = () => {
   if (platform !== "linux") return false;
@@ -130,6 +82,7 @@ if (!existsSync(binaryPath)) {
 
 // Check if binary exists and try to fix permissions if needed
 import { existsSync, chmodSync, statSync, openSync, readSync, closeSync } from "fs";
+import { spawnSync } from "child_process";
 if (existsSync(binaryPath)) {
   try {
     // Ensure binary is executable on Unix-like systems
@@ -200,6 +153,33 @@ if (!validation.ok) {
   process.exit(1);
 }
 
+// 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) {
+    // 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("@just-every/code")) {
+        otherCode = line;
+      }
+    } catch {}
+    if (otherCode) {
+      console.error(`@just-every/code: running bundled binary -> ${binaryPath}`);
+      console.error(`Note: a different 'code' exists at ${otherCode}; not delegating.`);
+    } else {
+      console.error(`@just-every/code: 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@just-every/code",
-  "version": "0.2.42",
+  "version": "0.2.44",
   "license": "Apache-2.0",
   "description": "Lightweight coding agent that runs in your terminal - fork of OpenAI Codex",
   "bin": {
@@ -35,10 +35,10 @@
     "prettier": "^3.3.3"
   },
   "optionalDependencies": {
-    "@just-every/code-darwin-arm64": "0.2.42",
-    "@just-every/code-darwin-x64": "0.2.42",
-    "@just-every/code-linux-x64-musl": "0.2.42",
-    "@just-every/code-linux-arm64-musl": "0.2.42",
-    "@just-every/code-win32-x64": "0.2.42"
+    "@just-every/code-darwin-arm64": "0.2.44",
+    "@just-every/code-darwin-x64": "0.2.44",
+    "@just-every/code-linux-x64-musl": "0.2.44",
+    "@just-every/code-linux-arm64-musl": "0.2.44",
+    "@just-every/code-win32-x64": "0.2.44"
   }
 }

package/postinstall.js

@@ -30,6 +30,30 @@ function getTargetTriple() {
   return `${rustArch}-${rustPlatform}`;
 }
 
+// Resolve a persistent user cache directory for binaries so that repeated
+// npx installs can reuse a previously downloaded artifact and skip work.
+function getCacheDir(version) {
+  const plt = platform();
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  let base = '';
+  if (plt === 'win32') {
+    base = process.env.LOCALAPPDATA || join(home, 'AppData', 'Local');
+  } else if (plt === 'darwin') {
+    base = join(home, 'Library', 'Caches');
+  } else {
+    base = process.env.XDG_CACHE_HOME || join(home, '.cache');
+  }
+  const dir = join(base, 'just-every', 'code', version);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function getCachedBinaryPath(version, targetTriple, isWindows) {
+  const ext = isWindows ? '.exe' : '';
+  const cacheDir = getCacheDir(version);
+  return join(cacheDir, `code-${targetTriple}${ext}`);
+}
+
 async function downloadBinary(url, dest, maxRedirects = 5, maxRetries = 3) {
   const sleep = (ms) => new Promise(r => setTimeout(r, ms));
 
@@ -151,27 +175,33 @@ function validateDownloadedBinary(p) {
 
 async function main() {
   // Detect potential PATH conflict with an existing `code` command (e.g., VS Code)
-  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];
-    if (resolved) {
-      let contents = '';
-      try {
-        contents = readFileSync(resolved, 'utf8');
-      } catch {
-        contents = '';
-      }
-      const looksLikeOurs = contents.includes('@just-every/code') || contents.includes('bin/coder.js');
-      if (!looksLikeOurs) {
-        console.warn('[notice] Found an existing `code` on PATH at:');
-        console.warn(`         ${resolved}`);
-        console.warn('[notice] We will still install our CLI, also available as `coder`.');
-        console.warn('         If `code` runs another tool, prefer using: coder');
-        console.warn('         Or run our CLI explicitly via: npx -y @just-every/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) {
+    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];
+      if (resolved) {
+        let contents = '';
+        try {
+          contents = readFileSync(resolved, 'utf8');
+        } catch {
+          contents = '';
+        }
+        const looksLikeOurs = contents.includes('@just-every/code') || contents.includes('bin/coder.js');
+        if (!looksLikeOurs) {
+          console.warn('[notice] Found an existing `code` on PATH at:');
+          console.warn(`         ${resolved}`);
+          console.warn('[notice] We will still install our CLI, also available as `coder`.');
+          console.warn('         If `code` runs another tool, prefer using: coder');
+          console.warn('         Or run our CLI explicitly via: npx -y @just-every/code');
+        }
       }
+    } catch {
+      // Ignore detection failures; proceed with install.
     }
-  } catch {
-    // Ignore detection failures; proceed with install.
   }
 
   const targetTriple = getTargetTriple();
@@ -195,6 +225,7 @@ async function main() {
   for (const binary of binaries) {
     const binaryName = `${binary}-${targetTriple}${binaryExt}`;
     const localPath = join(binDir, binaryName);
+    const cachePath = getCachedBinaryPath(version, targetTriple, isWindows);
     
     // Skip if already exists and has correct permissions
     if (existsSync(localPath)) {
@@ -211,6 +242,21 @@ async function main() {
       }
       continue;
     }
+
+    // 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`);
+          continue; // next binary
+        }
+      }
+    } catch {
+      // Ignore cache errors and fall through to normal paths
+    }
     
     // First try platform package via npm optionalDependencies (fast path on npm CDN).
     const require = createRequire(import.meta.url);
@@ -245,6 +291,12 @@ async function main() {
         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 {}
         continue; // next binary
       } catch (e) {
         console.warn(`⚠ Failed platform package install (${e.message}), falling back to GitHub download`);
@@ -317,6 +369,10 @@ async function main() {
       }
       
       console.log(`✓ Installed ${binaryName}`);
+      // Save into persistent cache for future fast installs
+      try {
+        copyFileSync(localPath, cachePath);
+      } catch {}
     } catch (error) {
       console.error(`✗ Failed to install ${binaryName}: ${error.message}`);
       console.error(`  Downloaded from: ${downloadUrl}`);
@@ -353,108 +409,142 @@ async function main() {
   }
 
   // With bin name = 'code', handle collisions (e.g., VS Code) and add legacy wrappers
-  try {
+  // Only do this for global installs; skip under npx/local to avoid extra work and collisions.
+  if (isGlobal && !isNpx) try {
     const isTTY = process.stdout && process.stdout.isTTY;
     const isWindows = platform() === 'win32';
+    const ua = process.env.npm_config_user_agent || '';
+    const isBun = ua.includes('bun') || !!process.env.BUN_INSTALL;
 
-    let globalBin = '';
-    try {
-      globalBin = execSync('npm bin -g', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
-    } catch {}
-
-    const ourShim = join(globalBin || '', isWindows ? 'code.cmd' : 'code');
+    const installedCmds = new Set(['coder']); // global install always exposes coder via package manager
+    const skippedCmds = [];
 
-    // Resolve which 'code' is currently on PATH
-    const resolveOnPath = (cmd) => {
+    // Helper to resolve all 'code' on PATH
+    const resolveAllOnPath = () => {
       try {
         if (isWindows) {
-          const out = execSync(`where ${cmd}`, { stdio: ['ignore', 'pipe', 'ignore'] }).toString().split(/\r?\n/)[0]?.trim();
-          return out || '';
-        } else {
-          return execSync(`command -v ${cmd}`, { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+          const out = execSync('where code', { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+          return out.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
         }
-      } catch { return ''; }
+        let out = '';
+        try {
+          out = execSync('bash -lc "which -a code 2>/dev/null"', { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+        } catch {
+          try {
+            out = execSync('command -v code || true', { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+          } catch { out = ''; }
+        }
+        return out.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+      } catch {
+        return [];
+      }
     };
 
-    const codeResolved = resolveOnPath('code');
-    const collision = codeResolved && ourShim && codeResolved !== ourShim;
-
-    const ensureWrapper = (name, args) => {
-      if (!globalBin) return;
+    if (isBun) {
+      // Bun creates shims for every bin; if another 'code' exists elsewhere on PATH, remove Bun's shim
+      let bunBin = '';
       try {
-        const wrapperPath = join(globalBin, isWindows ? `${name}.cmd` : name);
-        if (isWindows) {
-          const content = `@echo off\r\n"%~dp0${collision ? 'coder' : 'code'}" ${args} %*\r\n`;
-          writeFileSync(wrapperPath, content);
-        } else {
-          const content = `#!/bin/sh\nexec "$(dirname \"$0\")/${collision ? 'coder' : 'code'}" ${args} "$@"\n`;
-          writeFileSync(wrapperPath, content);
-          chmodSync(wrapperPath, 0o755);
+        const home = process.env.HOME || process.env.USERPROFILE || '';
+        const bunBase = process.env.BUN_INSTALL || join(home, '.bun');
+        bunBin = join(bunBase, 'bin');
+      } catch {}
+
+      const bunShim = join(bunBin || '', isWindows ? 'code.cmd' : 'code');
+      const candidates = resolveAllOnPath();
+      const other = candidates.find(p => p && (!bunBin || !p.startsWith(bunBin)));
+      if (other && existsSync(bunShim)) {
+        try {
+          unlinkSync(bunShim);
+          console.log(`✓ Skipped global 'code' shim under Bun (existing: ${other})`);
+          skippedCmds.push({ name: 'code', reason: `existing: ${other}` });
+        } catch (e) {
+          console.log(`⚠ Could not remove Bun shim '${bunShim}': ${e.message}`);
         }
-        console.log(`✓ Created wrapper '${name}' -> ${collision ? 'coder' : 'code'} ${args}`);
-      } catch (e) {
-        console.log(`⚠ Failed to create '${name}' wrapper: ${e.message}`);
+      } else if (existsSync(bunShim)) {
+        installedCmds.add('code');
       }
-    };
 
-    // Always create legacy wrappers so existing scripts keep working
-    ensureWrapper('code-tui', '');
-    ensureWrapper('code-exec', 'exec');
+      // Print summary for Bun
+      const list = Array.from(installedCmds).sort().join(', ');
+      console.log(`Commands installed (bun): ${list}`);
+      if (skippedCmds.length) {
+        for (const s of skippedCmds) console.log(`Commands skipped: ${s.name} (${s.reason})`);
+        console.log('→ Use `coder` to run this tool.');
+      }
+      // Final friendly usage hint
+      if (installedCmds.has('code')) {
+        console.log("Use 'code' to launch Code.");
+      } else {
+        console.log("Use 'coder' to launch Code.");
+      }
+    } else {
+      // npm/pnpm/yarn path
+      let globalBin = '';
+      try {
+        globalBin = execSync('npm bin -g', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+      } catch {}
+
+      const ourShim = join(globalBin || '', isWindows ? 'code.cmd' : 'code');
+      const candidates = resolveAllOnPath();
+      const others = candidates.filter(p => p && ourShim && p !== ourShim);
+      const collision = others.length > 0;
 
-    if (collision) {
-      console.log('⚠ Detected an existing `code` command on your PATH (likely VS Code).');
-      if (globalBin) {
-        // Create a 'coder' shim that forwards to our installed 'code' in the same dir
+      const ensureWrapper = (name, args) => {
+        if (!globalBin) return;
         try {
-          const coderShim = join(globalBin, isWindows ? 'coder.cmd' : 'coder');
+          const wrapperPath = join(globalBin, isWindows ? `${name}.cmd` : name);
           if (isWindows) {
-            const content = `@echo off\r\n"%~dp0code" %*\r\n`;
-            writeFileSync(coderShim, content);
+            const content = `@echo off\r\n"%~dp0${collision ? 'coder' : 'code'}" ${args} %*\r\n`;
+            writeFileSync(wrapperPath, content);
           } else {
-            const content = `#!/bin/sh\nexec "$(dirname \"$0\")/code" "$@"\n`;
-            writeFileSync(coderShim, content);
-            chmodSync(coderShim, 0o755);
+            const content = `#!/bin/sh\nexec "$(dirname \"$0\")/${collision ? 'coder' : 'code'}" ${args} "$@"\n`;
+            writeFileSync(wrapperPath, content);
+            chmodSync(wrapperPath, 0o755);
           }
-          console.log(`✓ Created fallback command \`coder\` -> our \`code\``);
+          console.log(`✓ Created wrapper '${name}' -> ${collision ? 'coder' : 'code'} ${args}`);
+          installedCmds.add(name);
         } catch (e) {
-          console.log(`⚠ Failed to create 'coder' fallback: ${e.message}`);
+          console.log(`⚠ Failed to create '${name}' wrapper: ${e.message}`);
         }
+      };
 
-        // Offer to create a 'vscode' alias that points to the existing system VS Code
-        if (isTTY && codeResolved) {
-          const prompt = (msg) => {
-            process.stdout.write(msg);
-            try {
-              const buf = Buffer.alloc(1024);
-              const bytes = readSync(0, buf, 0, 1024, null);
-              const ans = buf.slice(0, bytes).toString('utf8').trim().toLowerCase();
-              return ans;
-            } catch { return 'n'; }
-          };
-          const ans = prompt('Create a `vscode` alias for your existing editor? [y/N] ');
-          if (ans === 'y' || ans === 'yes') {
-            try {
-              const vscodeShim = join(globalBin, isWindows ? 'vscode.cmd' : 'vscode');
-              if (isWindows) {
-                const content = `@echo off\r\n"${codeResolved}" %*\r\n`;
-                writeFileSync(vscodeShim, content);
-              } else {
-                const content = `#!/bin/sh\nexec "${codeResolved}" "$@"\n`;
-                writeFileSync(vscodeShim, content);
-                chmodSync(vscodeShim, 0o755);
-              }
-              console.log('✓ Created `vscode` alias for your editor');
-            } catch (e) {
-              console.log(`⚠ Failed to create 'vscode' alias: ${e.message}`);
+      // Always create legacy wrappers so existing scripts keep working
+      ensureWrapper('code-tui', '');
+      ensureWrapper('code-exec', 'exec');
+
+      if (collision) {
+        console.log('⚠ Detected existing `code` on PATH:');
+        for (const p of others) console.log(`   - ${p}`);
+        if (globalBin) {
+          try {
+            if (existsSync(ourShim)) {
+              unlinkSync(ourShim);
+              console.log(`✓ Skipped global 'code' shim (removed ${ourShim})`);
+              skippedCmds.push({ name: 'code', reason: `existing: ${others[0]}` });
             }
-          } else {
-            console.log('Skipping creation of `vscode` alias.');
+          } catch (e) {
+            console.log(`⚠ Could not remove npm shim '${ourShim}': ${e.message}`);
           }
+          console.log('→ Use `coder` to run this tool.');
+        } else {
+          console.log('Note: could not determine npm global bin; skipping alias creation.');
         }
+      } else {
+        // No collision; npm created a 'code' shim for us.
+        if (globalBin && existsSync(ourShim)) installedCmds.add('code');
+      }
 
-        console.log('→ Use `coder` to run this tool, and `vscode` (if created) for your editor.');
+      // Print summary for npm/pnpm/yarn
+      const list = Array.from(installedCmds).sort().join(', ');
+      console.log(`Commands installed: ${list}`);
+      if (skippedCmds.length) {
+        for (const s of skippedCmds) console.log(`Commands skipped: ${s.name} (${s.reason})`);
+      }
+      // Final friendly usage hint
+      if (installedCmds.has('code')) {
+        console.log("Use 'code' to launch Code.");
       } else {
-        console.log('Note: could not determine npm global bin; skipping alias creation.');
+        console.log("Use 'coder' to launch Code.");
       }
     }
   } catch {