@just-every/code 0.2.43 → 0.2.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@just-every/code",
-  "version": "0.2.43",
+  "version": "0.2.45",
   "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.43",
-    "@just-every/code-darwin-x64": "0.2.43",
-    "@just-every/code-linux-x64-musl": "0.2.43",
-    "@just-every/code-linux-arm64-musl": "0.2.43",
-    "@just-every/code-win32-x64": "0.2.43"
+    "@just-every/code-darwin-arm64": "0.2.45",
+    "@just-every/code-darwin-x64": "0.2.45",
+    "@just-every/code-linux-x64-musl": "0.2.45",
+    "@just-every/code-linux-arm64-musl": "0.2.45",
+    "@just-every/code-win32-x64": "0.2.45"
   }
 }

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,26 +409,23 @@ 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 all 'code' candidates on PATH (so we detect collisions even if
-    // our npm global bin currently appears first).
+    // Helper to resolve all 'code' on PATH
     const resolveAllOnPath = () => {
       try {
         if (isWindows) {
           const out = execSync('where code', { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
           return out.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
         }
-        // Prefer 'which -a' if available; fall back to 'command -v'
         let out = '';
         try {
           out = execSync('bash -lc "which -a code 2>/dev/null"', { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
@@ -387,81 +440,111 @@ async function main() {
       }
     };
 
-    const candidates = resolveAllOnPath();
-    const others = candidates.filter(p => p && ourShim && p !== ourShim);
-    const collision = others.length > 0;
-
-    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 {}
 
-    if (collision) {
-      console.log('⚠ Detected existing `code` on PATH:');
-      for (const p of others) console.log(`   - ${p}`);
-      if (globalBin) {
-        // Remove our global `code` shim to avoid shadowing editors like VS Code
+      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;
+
+      const ensureWrapper = (name, args) => {
+        if (!globalBin) return;
         try {
-          if (existsSync(ourShim)) {
-            unlinkSync(ourShim);
-            console.log(`✓ Skipped global 'code' shim (removed ${ourShim})`);
+          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);
           }
+          console.log(`✓ Created wrapper '${name}' -> ${collision ? 'coder' : 'code'} ${args}`);
+          installedCmds.add(name);
         } catch (e) {
-          console.log(`⚠ Could not remove npm shim '${ourShim}': ${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
-        const primaryOther = others[0];
-        if (isTTY && primaryOther) {
-          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"${primaryOther}" %*\r\n`;
-                writeFileSync(vscodeShim, content);
-              } else {
-                const content = `#!/bin/sh\nexec "${primaryOther}" "$@"\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.');
         }
-        console.log('→ Use `coder` to run this tool, and `vscode` (if created) for your editor.');
       } else {
-        console.log('Note: could not determine npm global bin; skipping alias creation.');
+        // No collision; npm created a 'code' shim for us.
+        if (globalBin && existsSync(ourShim)) installedCmds.add('code');
+      }
+
+      // 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("Use 'coder' to launch Code.");
       }
     }
   } catch {