@liwenkai/deepcode 0.4.8 → 0.4.10

package/bin/deepcode

@@ -9,15 +9,25 @@
 // instead of leaving a command pointing at nothing.
 'use strict';
 
-const { spawnSync } = require('node:child_process');
+const { spawn } = require('node:child_process');
 const { existsSync } = require('node:fs');
-const { join } = require('node:path');
+const { basename, join } = require('node:path');
+const os = require('node:os');
 
 const binary = join(
   __dirname,
   process.platform === 'win32' ? 'deepcode.exe' : 'deepcode-bin',
 );
 
+// The binary prints its own name in `--help`, `--version`, every usage line and
+// every "Try `… --help`" error, and it reads that name from argv[0]. Spawned
+// from here, argv[0] is `deepcode-bin` — the deliberately distinct download
+// name, which is on nobody's PATH — so the first lines a new user reads told
+// them to run a command that does not exist. This launcher is the only thing
+// that knows the name npm actually linked, so it hands it over. `argv[1]` is
+// this script's own path, which IS that name.
+const invokedAs = basename(process.argv[1] || 'deepcode');
+
 if (!existsSync(binary)) {
   console.error('deepcode: native binary not found.');
   console.error('Reinstall without --ignore-scripts, or grab a prebuilt binary from');
@@ -25,12 +35,48 @@ if (!existsSync(binary)) {
   process.exit(1);
 }
 
-const result = spawnSync(binary, process.argv.slice(2), { stdio: 'inherit' });
+// `spawn`, not `spawnSync`: a supervisor (or `timeout`, or a closed shell) that
+// sends SIGTERM/SIGHUP to THIS launcher would, with spawnSync, kill only Node —
+// the native binary is reparented to init and keeps running, orphaning its job
+// process groups (dev servers, watchers). Async spawn lets us forward those
+// signals so the binary runs its own graceful shutdown. (SIGINT/Ctrl-C already
+// reaches the whole foreground group; forwarding it too is harmless — the binary
+// guards against a double interrupt — and covers a supervisor that signals only
+// this pid.)
+const child = spawn(binary, process.argv.slice(2), {
+  stdio: 'inherit',
+  env: { ...process.env, DEEP_CODE_PROGRAM_NAME: invokedAs },
+});
 
-if (result.error) {
-  console.error(`deepcode: failed to launch binary: ${result.error.message}`);
-  process.exit(1);
+const forward = (signal) => {
+  try {
+    child.kill(signal);
+  } catch {
+    /* child already gone — nothing to forward to */
+  }
+};
+// SIGINT is deliberately NOT forwarded on Windows: the child receives its own
+// CTRL_C_EVENT from the console directly, and Node's `child.kill('SIGINT')`
+// there is a forced TerminateProcess — it would win the race and abort the
+// binary before its graceful Ctrl-C cancel (drain, JSON report, session tail)
+// could run. On unix SIGINT already reaches the whole foreground group; the
+// forward only additionally covers a supervisor signalling this pid alone.
+const forwarded =
+  process.platform === 'win32' ? ['SIGTERM', 'SIGHUP'] : ['SIGINT', 'SIGTERM', 'SIGHUP'];
+for (const signal of forwarded) {
+  process.on(signal, () => forward(signal));
 }
 
-// Mirror the child's exit; a signal-terminated child reports null status.
-process.exit(result.status === null ? 1 : result.status);
+child.on('error', (error) => {
+  console.error(`deepcode: failed to launch binary: ${error.message}`);
+  process.exit(1);
+});
+
+child.on('exit', (code, signal) => {
+  // Mirror the child's fate. A signal exit becomes the shell convention 128+n so
+  // the parent sees the real cause; a normal exit passes its code through.
+  if (signal) {
+    process.exit(128 + (os.constants.signals[signal] || 0));
+  }
+  process.exit(code === null ? 1 : code);
+});

package/install.mjs

@@ -237,8 +237,24 @@ async function checksumMatches(assetName, binPath) {
     const expected = parseChecksum(fs.readFileSync(sumsPath, 'utf8'), assetName);
     if (!expected) return !checksumRequired();
     return (await sha256OfFile(binPath)) === expected;
-  } catch {
-    return !checksumRequired();
+  } catch (error) {
+    // Distinguish "the server answered no" from "could not reach the server".
+    // A 404 / HTTP status means this VERSION's manifest or asset is genuinely
+    // absent (a wrong version left on disk), so fall through to re-download as
+    // before. But a connection failure/timeout is transient — offline
+    // `npm rebuild`, a blocked request — and the binary on disk was already
+    // verified at install time (download → verifyChecksum → rename), so deleting
+    // it and then failing the offline re-download is worse than keeping it.
+    const message = String(error?.message ?? error);
+    const serverRejected = message.includes('Binary not found') || message.startsWith('HTTP ');
+    if (serverRejected) {
+      return !checksumRequired();
+    }
+    console.warn(
+      '⚠️  deepcode: could not reach SHA256SUMS to re-verify the installed binary ' +
+      '(offline?); keeping the existing, install-time-verified binary.',
+    );
+    return true;
   } finally {
     fs.rmSync(sumsPath, { force: true });
   }
@@ -266,7 +282,32 @@ function sha256OfFile(file) {
 }
 
 // ── 辅助函数 ──
-function downloadFile(url, dest) {
+// GitHub release assets always 302 to a signed URL, so the redirect branch runs
+// on every install. Two things it must not do: follow forever, and throw
+// synchronously out of the response callback (an `https.get` handler is not
+// inside the promise executor, so a throw there is an uncaught exception, not a
+// rejection — the install dies with an unrelated stack).
+//
+// `MAX_DOWNLOAD_REDIRECTS` bounds the chain: each hop opens its own socket and
+// arms its own 5-minute timeout, so an unbounded chain is an unbounded hang, not
+// merely a slow one.
+const MAX_DOWNLOAD_REDIRECTS = 5;
+
+// `fs.rmSync(..., { force: true })`, never `unlinkSync`: the write stream opens
+// the file asynchronously, so on a fast response the path may not exist yet
+// (`ENOENT`), and on Windows a file with a live handle refuses to unlink
+// (`EBUSY`/`EPERM`). Both threw from inside the response callback. `force`
+// swallows the missing-file case; the try/catch covers the locked-file one.
+function discardPartial(file, dest) {
+  file.close();
+  try {
+    fs.rmSync(dest, { force: true });
+  } catch {
+    /* a locked or already-gone temp file must not mask the real error */
+  }
+}
+
+function downloadFile(url, dest, redirectsLeft = MAX_DOWNLOAD_REDIRECTS) {
   return new Promise((resolve, reject) => {
     const file = fs.createWriteStream(dest, { mode: 0o755 });
 
@@ -275,18 +316,24 @@ function downloadFile(url, dest) {
       if ([301, 302, 303, 307, 308].includes(response.statusCode)) {
         const redirectUrl = response.headers.location;
         if (!redirectUrl) {
+          discardPartial(file, dest);
           reject(new Error(`Redirect with no location from ${url}`));
           return;
         }
-        file.close();
-        fs.unlinkSync(dest);
-        downloadFile(redirectUrl, dest).then(resolve).catch(reject);
+        if (redirectsLeft <= 0) {
+          discardPartial(file, dest);
+          reject(new Error(
+            `Too many redirects (more than ${MAX_DOWNLOAD_REDIRECTS}) starting at ${url}.`
+          ));
+          return;
+        }
+        discardPartial(file, dest);
+        downloadFile(redirectUrl, dest, redirectsLeft - 1).then(resolve).catch(reject);
         return;
       }
 
       if (response.statusCode === 404) {
-        file.close();
-        fs.unlinkSync(dest);
+        discardPartial(file, dest);
         reject(new Error(
           `Binary not found for ${platform()}-${arch()} (v${VERSION}). ` +
           `Check https://github.com/${REPO}/releases for available versions.`
@@ -295,8 +342,7 @@ function downloadFile(url, dest) {
       }
 
       if (response.statusCode !== 200) {
-        file.close();
-        fs.unlinkSync(dest);
+        discardPartial(file, dest);
         reject(new Error(`HTTP ${response.statusCode} from ${url}`));
         return;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liwenkai/deepcode",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "AI coding assistant in your terminal — powered by DeepSeek",
   "bin": {
     "deepcode": "bin/deepcode"