@just-every/code 0.2.3 → 0.2.5

package/bin/coder.js

@@ -10,6 +10,20 @@ const __dirname = path.dirname(__filename);
 
 const { platform, arch } = process;
 
+const 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();
+    return txt.includes("microsoft");
+  } catch {
+    return false;
+  }
+};
+
 let targetTriple = null;
 switch (platform) {
   case "linux":
@@ -63,7 +77,7 @@ if (!existsSync(binaryPath)) {
 }
 
 // Check if binary exists and try to fix permissions if needed
-import { existsSync, chmodSync } from "fs";
+import { existsSync, chmodSync, statSync, openSync, readSync, closeSync } from "fs";
 if (existsSync(binaryPath)) {
   try {
     // Ensure binary is executable on Unix-like systems
@@ -78,6 +92,59 @@ if (existsSync(binaryPath)) {
   console.error(`Please try reinstalling the package:`);
   console.error(`  npm uninstall -g @just-every/code`);
   console.error(`  npm install -g @just-every/code`);
+  if (isWSL()) {
+    console.error("Detected WSL. Install inside WSL (Ubuntu) separately:");
+    console.error("  npx -y @just-every/code@latest  (run inside WSL)");
+    console.error("If installed globally on Windows, those binaries are not usable from WSL.");
+  }
+  process.exit(1);
+}
+
+// Lightweight header validation to provide clearer errors before spawn
+const validateBinary = (p) => {
+  try {
+    const st = statSync(p);
+    if (!st.isFile() || st.size === 0) {
+      return { ok: false, reason: "empty or not a regular file" };
+    }
+    const fd = openSync(p, "r");
+    try {
+      const buf = Buffer.alloc(4);
+      const n = readSync(fd, buf, 0, 4, 0);
+      if (n < 2) return { ok: false, reason: "too short" };
+      if (platform === "win32") {
+        if (!(buf[0] === 0x4d && buf[1] === 0x5a)) return { ok: false, reason: "invalid PE header (missing MZ)" };
+      } else if (platform === "linux" || platform === "android") {
+        if (!(buf[0] === 0x7f && buf[1] === 0x45 && buf[2] === 0x4c && buf[3] === 0x46)) return { ok: false, reason: "invalid ELF header" };
+      } else if (platform === "darwin") {
+        const isMachO = (buf[0] === 0xcf && buf[1] === 0xfa && buf[2] === 0xed && buf[3] === 0xfe) ||
+                        (buf[0] === 0xca && buf[1] === 0xfe && buf[2] === 0xba && buf[3] === 0xbe);
+        if (!isMachO) return { ok: false, reason: "invalid Mach-O header" };
+      }
+    } finally {
+      closeSync(fd);
+    }
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, reason: e.message };
+  }
+};
+
+const validation = validateBinary(binaryPath);
+if (!validation.ok) {
+  console.error(`The native binary at ${binaryPath} appears invalid: ${validation.reason}`);
+  console.error("This can happen if the download failed or was modified by antivirus/proxy.");
+  console.error("Please try reinstalling:");
+  console.error("  npm uninstall -g @just-every/code");
+  console.error("  npm install -g @just-every/code");
+  if (platform === "win32") {
+    console.error("If the issue persists, clear npm cache and disable antivirus temporarily:");
+    console.error("  npm cache clean --force");
+  }
+  if (isWSL()) {
+    console.error("Detected WSL. Ensure you install/run inside WSL, not Windows:");
+    console.error("  npx -y @just-every/code@latest  (inside WSL)");
+  }
   process.exit(1);
 }
 
@@ -95,10 +162,23 @@ const child = spawn(binaryPath, process.argv.slice(2), {
 
 child.on("error", (err) => {
   // Typically triggered when the binary is missing or not executable.
-  if (err.code === 'EACCES') {
+  const code = err && err.code;
+  if (code === 'EACCES') {
     console.error(`Permission denied: ${binaryPath}`);
     console.error(`Try running: chmod +x "${binaryPath}"`);
     console.error(`Or reinstall the package with: npm install -g @just-every/code`);
+  } else if (code === 'EFTYPE' || code === 'ENOEXEC') {
+    console.error(`Failed to execute native binary: ${binaryPath}`);
+    console.error("The file may be corrupt or of the wrong type. Reinstall usually fixes this:");
+    console.error("  npm uninstall -g @just-every/code && npm install -g @just-every/code");
+    if (platform === 'win32') {
+      console.error("On Windows, ensure the .exe downloaded correctly (proxy/AV can interfere).");
+      console.error("Try clearing cache: npm cache clean --force");
+    }
+    if (isWSL()) {
+      console.error("Detected WSL. Windows binaries cannot be executed from WSL.");
+      console.error("Install inside WSL and run there: npx -y @just-every/code@latest");
+    }
   } else {
     console.error(err);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@just-every/code",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "license": "Apache-2.0",
   "description": "Lightweight coding agent that runs in your terminal - fork of OpenAI Codex",
   "bin": {

package/postinstall.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // Non-functional change to trigger release workflow
 
-import { existsSync, mkdirSync, createWriteStream, chmodSync, readFileSync, readSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, createWriteStream, chmodSync, readFileSync, readSync, writeFileSync, unlinkSync, statSync, openSync, closeSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { get } from 'https';
@@ -29,31 +29,123 @@ function getTargetTriple() {
   return `${rustArch}-${rustPlatform}`;
 }
 
-async function downloadBinary(url, dest) {
-  return new Promise((resolve, reject) => {
-    const file = createWriteStream(dest);
-    
-    get(url, (response) => {
-      if (response.statusCode === 302 || response.statusCode === 301) {
-        // Follow redirect
-        get(response.headers.location, (redirectResponse) => {
-          redirectResponse.pipe(file);
+async function downloadBinary(url, dest, maxRedirects = 5, maxRetries = 3) {
+  const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+  const doAttempt = () => new Promise((resolve, reject) => {
+    const attempt = (currentUrl, redirectsLeft) => {
+      const req = get(currentUrl, (response) => {
+        const status = response.statusCode || 0;
+        const location = response.headers.location;
+
+        if ((status === 301 || status === 302 || status === 303 || status === 307 || status === 308) && location) {
+          if (redirectsLeft <= 0) {
+            reject(new Error(`Too many redirects while downloading ${currentUrl}`));
+            return;
+          }
+          attempt(location, redirectsLeft - 1);
+          return;
+        }
+
+        if (status === 200) {
+          const expected = parseInt(response.headers['content-length'] || '0', 10) || 0;
+          let bytes = 0;
+          let timer;
+          const timeoutMs = 30000; // 30s inactivity timeout
+
+          const resetTimer = () => {
+            if (timer) clearTimeout(timer);
+            timer = setTimeout(() => {
+              req.destroy(new Error('download stalled'));
+            }, timeoutMs);
+          };
+
+          resetTimer();
+          response.on('data', (chunk) => {
+            bytes += chunk.length;
+            resetTimer();
+          });
+
+          const file = createWriteStream(dest);
+          response.pipe(file);
           file.on('finish', () => {
+            if (timer) clearTimeout(timer);
             file.close();
-            resolve();
+            if (expected && bytes !== expected) {
+              try { unlinkSync(dest); } catch {}
+              reject(new Error(`incomplete download: got ${bytes} of ${expected} bytes`));
+            } else if (bytes === 0) {
+              try { unlinkSync(dest); } catch {}
+              reject(new Error('empty download'));
+            } else {
+              resolve();
+            }
           });
-        }).on('error', reject);
-      } else if (response.statusCode === 200) {
-        response.pipe(file);
-        file.on('finish', () => {
-          file.close();
-          resolve();
-        });
-      } else {
-        reject(new Error(`Failed to download: ${response.statusCode}`));
-      }
-    }).on('error', reject);
+          file.on('error', (err) => {
+            if (timer) clearTimeout(timer);
+            try { unlinkSync(dest); } catch {}
+            reject(err);
+          });
+        } else {
+          reject(new Error(`Failed to download: HTTP ${status}`));
+        }
+      });
+
+      req.on('error', (err) => {
+        try { unlinkSync(dest); } catch {}
+        reject(err);
+      });
+
+      // Absolute request timeout to avoid hanging forever
+      req.setTimeout(120000, () => {
+        req.destroy(new Error('download timed out'));
+      });
+    };
+
+    attempt(url, maxRedirects);
   });
+
+  let attemptNum = 0;
+  while (true) {
+    try {
+      return await doAttempt();
+    } catch (e) {
+      attemptNum += 1;
+      if (attemptNum > maxRetries) throw e;
+      const backoff = Math.min(2000, 200 * attemptNum);
+      await sleep(backoff);
+    }
+  }
+}
+
+function validateDownloadedBinary(p) {
+  try {
+    const st = statSync(p);
+    if (!st.isFile() || st.size === 0) {
+      return { ok: false, reason: 'empty or not a regular file' };
+    }
+    const fd = openSync(p, 'r');
+    try {
+      const buf = Buffer.alloc(4);
+      const n = readSync(fd, buf, 0, 4, 0);
+      if (n < 2) return { ok: false, reason: 'too short' };
+      const plt = platform();
+      if (plt === 'win32') {
+        if (!(buf[0] === 0x4d && buf[1] === 0x5a)) return { ok: false, reason: 'invalid PE header (missing MZ)' };
+      } else if (plt === 'linux' || plt === 'android') {
+        if (!(buf[0] === 0x7f && buf[1] === 0x45 && buf[2] === 0x4c && buf[3] === 0x46)) return { ok: false, reason: 'invalid ELF header' };
+      } else if (plt === 'darwin') {
+        const isMachO = (buf[0] === 0xcf && buf[1] === 0xfa && buf[2] === 0xed && buf[3] === 0xfe) ||
+                        (buf[0] === 0xca && buf[1] === 0xfe && buf[2] === 0xba && buf[3] === 0xbe);
+        if (!isMachO) return { ok: false, reason: 'invalid Mach-O header' };
+      }
+      return { ok: true };
+    } finally {
+      closeSync(fd);
+    }
+  } catch (e) {
+    return { ok: false, reason: e.message };
+  }
 }
 
 async function main() {
@@ -124,7 +216,14 @@ async function main() {
     console.log(`Downloading ${binaryName}...`);
     try {
       await downloadBinary(downloadUrl, localPath);
-      
+
+      // Validate header to avoid corrupt binaries causing spawn EFTYPE/ENOEXEC
+      const valid = validateDownloadedBinary(localPath);
+      if (!valid.ok) {
+        try { unlinkSync(localPath); } catch {}
+        throw new Error(`invalid binary (${valid.reason})`);
+      }
+
       // Make executable on Unix-like systems
       if (!isWindows) {
         chmodSync(localPath, 0o755);
@@ -143,6 +242,20 @@ async function main() {
   const mainBinaryPath = join(binDir, mainBinary);
   
   if (existsSync(mainBinaryPath)) {
+    try {
+      const stats = statSync(mainBinaryPath);
+      if (!stats.size) {
+        throw new Error('binary is empty (download likely failed)');
+      }
+      const valid = validateDownloadedBinary(mainBinaryPath);
+      if (!valid.ok) {
+        console.warn(`⚠ Main code binary appears invalid: ${valid.reason}`);
+        console.warn('  Try reinstalling or check your network/proxy settings.');
+      }
+    } catch (e) {
+      console.warn(`⚠ Main code binary appears invalid: ${e.message}`);
+      console.warn('  Try reinstalling or check your network/proxy settings.');
+    }
     console.log('Setting up main code binary...');
     
     // On Windows, we can't use symlinks easily, so update the JS wrapper