donsetch 2.4.1 → 3.0.0

package/bin/donsetch.js

@@ -57,7 +57,10 @@ child.on('exit', (code, signal) => {
   if (signal) {
     // Re-raise the signal so the parent's exit reflects it
     try { process.kill(process.pid, signal); } catch (_) {}
-    process.exit(128 + 15); // 128 + SIGTERM
+    // Fallback: exit code for the signal we actually received
+    // (SIGINT=2, SIGTERM=15, SIGHUP=1), not always SIGTERM's 143.
+    const sigNum = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGTERM: 15 }[signal] || 15;
+    process.exit(128 + sigNum);
   } else {
     process.exit(code || 0);
   }

package/install.js

@@ -10,9 +10,10 @@
 // uses the same release artifacts that manual users download.
 //
 // Supported platforms:
-//   linux-x64      Linux x86_64
-//   linux-arm64    Linux ARM64 (aarch64)
+//   linux-x64      Linux x86_64 (glibc)
+//   linux-arm64    Linux ARM64 (glibc)
 //   darwin-arm64   macOS Apple Silicon
+//   darwin-x64     macOS Intel
 //   win32-x64      Windows x86_64
 
 const https = require('https');
@@ -30,6 +31,7 @@ const PLATFORMS = {
   'linux-x64':    { asset: 'donsetch-linux-x64.tar.gz',    binary: 'donsetch'     },
   'linux-arm64':  { asset: 'donsetch-linux-arm64.tar.gz',  binary: 'donsetch'     },
   'darwin-arm64': { asset: 'donsetch-darwin-arm64.tar.gz', binary: 'donsetch'     },
+  'darwin-x64':   { asset: 'donsetch-darwin-x64.tar.gz',   binary: 'donsetch'     },
   'win32-x64':    { asset: 'donsetch-win32-x64.tar.gz',    binary: 'donsetch.exe' },
 };
 
@@ -37,25 +39,56 @@ const platKey = `${process.platform}-${process.arch}`;
 const plat = PLATFORMS[platKey];
 
 if (!plat) {
-  console.error(`donsetch: unsupported platform ${platKey}`);
+  const known = {
+    'darwin-x64': 'prebuilt binaries exist — update donsetch to a version that ships one',
+    'win32-arm64': 'no prebuilt binary yet — build from source (see below)',
+  }[platKey];
+  console.error(`donsetch: unsupported platform ${platKey}${known ? ` (${known})` : ''}`);
   console.error('');
   console.error('Supported platforms:');
-  console.error('  linux-x64      Linux x86_64');
-  console.error('  linux-arm64    Linux ARM64 (aarch64)');
+  console.error('  linux-x64      Linux x86_64 (glibc)');
+  console.error('  linux-arm64    Linux ARM64 (glibc)');
   console.error('  darwin-arm64   macOS Apple Silicon');
+  console.error('  darwin-x64     macOS Intel');
   console.error('  win32-x64      Windows x86_64');
   console.error('');
   console.error('Build from source: https://github.com/' + REPO);
   process.exit(1);
 }
 
+// ── musl detection (Alpine etc.) ────────────────────────────────
+// The Linux binaries are glibc-linked. On musl systems they install
+// fine but can never exec (missing ld-linux loader) — fail HERE with
+// the actual cause instead of a cryptic spawn error on first run.
+if (process.platform === 'linux') {
+  const isMusl = fs.existsSync('/lib/ld-musl-x86_64.so.1')
+    || fs.existsSync('/lib/ld-musl-aarch64.so.1');
+  if (isMusl) {
+    console.error('donsetch: musl libc detected (Alpine?).');
+    console.error('The prebuilt Linux binaries are glibc-linked and will not run.');
+    console.error('');
+    console.error('Options:');
+    console.error('  - build from source: git clone https://github.com/' + REPO + ' && cargo build --release');
+    console.error('  - use a glibc-based image/dist (debian, ubuntu, fedora)');
+    process.exit(1);
+  }
+}
+
 const binDir = path.join(__dirname, 'binaries');
 const binaryPath = path.join(binDir, plat.binary);
 
-// Skip if already installed (npm cache reuse, reinstall, etc.)
+// Skip if already installed (npm cache reuse, reinstall, etc.).
+// A plausibility check first: a stale 0-byte or truncated leftover
+// (killed install, crashed download) must not shadow a fresh one.
 if (fs.existsSync(binaryPath)) {
-  console.log(`donsetch: binary already present (${plat.binary})`);
-  process.exit(0);
+  let size = 0;
+  try { size = fs.statSync(binaryPath).size; } catch (_) {}
+  if (size > 1024 * 1024) {
+    console.log(`donsetch: binary already present (${plat.binary})`);
+    process.exit(0);
+  }
+  console.log(`donsetch: leftover ${plat.binary} is ${size} bytes — re-downloading`);
+  try { fs.unlinkSync(binaryPath); } catch (_) {}
 }
 
 fs.mkdirSync(binDir, { recursive: true });
@@ -110,6 +143,19 @@ async function main() {
   const tarball = path.join(binDir, plat.asset);
   const checksumFile = path.join(binDir, 'checksum.sha256');
 
+  // 0. Windows: tar ships with Windows 10 1803+; older boxes lack it.
+  //    Detect BEFORE downloading so the error names the real problem.
+  if (process.platform === 'win32') {
+    let hasTar = false;
+    try { execFileSync('tar', ['--version'], { stdio: 'ignore' }); hasTar = true; } catch (_) {}
+    if (!hasTar) {
+      console.error('donsetch: `tar` not found on this Windows system.');
+      console.error('tar ships with Windows 10 1803+. Update Windows, or extract manually');
+      console.error('after downloading ' + assetUrl);
+      process.exit(1);
+    }
+  }
+
   // 1. Download the binary tarball
   console.log(`donsetch: downloading ${plat.asset} from ${TAG}...`);
   await download(assetUrl, tarball);
@@ -142,12 +188,8 @@ async function main() {
   try { fs.unlinkSync(tarball); } catch (_) {}
   try { fs.unlinkSync(checksumFile); } catch (_) {}
 
-  // 6. Make executable (Unix only)
-  if (process.platform !== 'win32') {
-    fs.chmodSync(binaryPath, 0o755);
-  }
-
-  // 7. Verify the binary exists after extraction
+  // 6. Verify the binary exists after extraction (BEFORE chmod —
+  //    chmod on a missing file throws an opaque error).
   if (!fs.existsSync(binaryPath)) {
     console.error(`donsetch: expected ${plat.binary} not found after extraction`);
     console.error(`  looked at: ${binaryPath}`);
@@ -155,6 +197,11 @@ async function main() {
     process.exit(1);
   }
 
+  // 7. Make executable (Unix only)
+  if (process.platform !== 'win32') {
+    fs.chmodSync(binaryPath, 0o755);
+  }
+
   console.log(`donsetch: installed ${plat.binary} to ${binaryPath}`);
   console.log(`donsetch: run \`donsetch\` to see available commands.`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "donsetch",
-  "version": "2.4.1",
+  "version": "3.0.0",
   "description": "Web fetch, search and crawl for AI agents. Zero API keys. Chrome-true TLS.",
   "license": "AGPL-3.0-only",
   "author": "Bishesh Bhandari",

package/pi-extension.ts

@@ -118,7 +118,11 @@ function startServer(): Promise<void> {
     }
 
     try {
-      proc = spawn(binaryPath, ["mcp"], {
+      // --supervised: crash-only daemon. If the MCP server is SIGKILLed
+      // (OOM, crash), the supervisor respawns it and replays in-flight
+      // requests — pi users never see a dead tool until the process
+      // itself dies.
+      proc = spawn(binaryPath, ["mcp", "--supervised"], {
         stdio: ["pipe", "pipe", "pipe"],
         env: { ...process.env },
         windowsHide: true,
@@ -196,20 +200,58 @@ function startServer(): Promise<void> {
   });
 }
 
-function sendRequest(method: string, params: any, timeoutMs = CALL_TIMEOUT_MS): Promise<any> {
+function sendRequest(
+  method: string,
+  params: any,
+  timeoutMs = CALL_TIMEOUT_MS,
+  signal?: AbortSignal
+): Promise<any> {
   return new Promise((resolve, reject) => {
     if (!proc?.stdin?.writable) {
       reject(new Error("donsetch MCP server not running"));
       return;
     }
     const id = nextId++;
+    let settled = false;
+    const finish = (fn: (v: any) => void, v: any) => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener("abort", onAbort);
+      fn(v);
+    };
     const timer = setTimeout(() => {
-      if (pending.has(id)) {
-        pending.delete(id);
-        reject(new Error(`MCP request timeout (${timeoutMs}ms): ${method}`));
+      if (pending.delete(id)) {
+        finish(reject, new Error(`MCP request timeout (${timeoutMs}ms): ${method}`));
       }
     }, timeoutMs);
-    pending.set(id, { resolve, reject, timer });
+    // v3 real MCP cancellation: forward pi's abort to the server so the
+    // in-flight fetch/crawl actually stops server-side, then settle
+    // locally. The caller maps this to a graceful "Cancelled" result.
+    const onAbort = () => {
+      if (pending.delete(id)) {
+        clearTimeout(timer);
+        sendNotification("notifications/cancelled", { id, reason: "client aborted" });
+        finish(reject, new Error("cancelled"));
+      }
+    };
+    if (signal) {
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    pending.set(id, {
+      resolve: (v: any) => {
+        clearTimeout(timer);
+        finish(resolve, v);
+      },
+      reject: (e: any) => {
+        clearTimeout(timer);
+        finish(reject, e);
+      },
+      timer,
+    });
     const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params });
     proc.stdin.write(msg + "\n");
   });
@@ -221,8 +263,8 @@ function sendNotification(method: string, params: any): void {
   proc.stdin.write(msg + "\n");
 }
 
-async function callMcpTool(name: string, args: any): Promise<any> {
-  return sendRequest("tools/call", { name, arguments: args ?? {} });
+async function callMcpTool(name: string, args: any, signal?: AbortSignal): Promise<any> {
+  return sendRequest("tools/call", { name, arguments: args ?? {} }, CALL_TIMEOUT_MS, signal);
 }
 
 function killServer(): void {
@@ -384,7 +426,7 @@ export default function (pi: ExtensionAPI) {
           }
 
           try {
-            const result = await callMcpTool(toolName, params);
+            const result = await callMcpTool(toolName, params, _signal);
             // Join all content text blocks, skipping [meta] blocks.
             // [meta] blocks contain compact metadata for clients
             // (Claude Code, VSCode) that drop text when
@@ -411,13 +453,15 @@ export default function (pi: ExtensionAPI) {
             } else if (toolName === "web_fetch") {
               details.source = getFetchSource(sc);
               details.status = getFetchStatus(sc);
+              if (sc?.stitched) details.stitched = sc.stitched;
             } else if (toolName === "web_crawl") {
               details.pages = countCrawlPages(text);
             }
 
-            // For errors, extract error text
+            // For errors, extract error text + v3 stable error code
             if (isErr) {
               details.error = getPreview(text, 60);
+              if (sc?.code) details.code = sc.code;
             } else {
               details.preview = getPreview(text);
             }
@@ -428,6 +472,15 @@ export default function (pi: ExtensionAPI) {
               isError: isErr,
             };
           } catch (err: any) {
+            // User pressed Esc in pi: we already told the server to stop
+            // (notifications/cancelled). Graceful non-error result, per
+            // pi's extension contract for aborted calls.
+            if (err.message === "cancelled") {
+              return {
+                content: [{ type: "text", text: "Cancelled" }],
+                details: { mcpTool: toolName, cancelled: true },
+              };
+            }
             return {
               content: [{ type: "text", text: `donsetch MCP call failed: ${err.message}` }],
               details: { mcpTool: toolName, isError: true, error: err.message },
@@ -469,6 +522,7 @@ export default function (pi: ExtensionAPI) {
             else if (d.source === "ghost") parts.push("via ghost");
             if (d.status === "blocked") parts.push("blocked");
             else if (d.status === "thin") parts.push("thin");
+            if (d.stitched) parts.push(`stitched \u00D7${d.stitched}`);
             meta = parts.join(" \u00B7 ");
           } else if (toolName === "web_search") {
             const count = d.results ?? 0;
@@ -481,8 +535,10 @@ export default function (pi: ExtensionAPI) {
 
           // Build line 2: preview or error
           let line2 = "";
-          if (isErr) {
-            line2 = d.error || "failed";
+          if (d.cancelled) {
+            line2 = "cancelled";
+          } else if (isErr) {
+            line2 = d.code ? `[${d.code}] ${d.error || "failed"}` : d.error || "failed";
           } else if (toolName === "web_search" && d.topResult) {
             line2 = truncate(d.topResult, 70);
           } else if (d.preview) {