donsetch 4.1.1 → 4.2.0

package/README.md

@@ -23,6 +23,26 @@ Downloads the prebuilt binary for your platform from [GitHub Releases](https://g
 | macOS arm64 | `donsetch-darwin-arm64.tar.gz` |
 | Windows x86_64 | `donsetch-win32-x64.tar.gz` |
 
+## Troubleshooting install
+
+- **pnpm or bun:** approve the `donsetch` build script (`pnpm approve-builds`
+  or the equivalent bun approval), then reinstall. If scripts were blocked,
+  running `npx donsetch` invokes the self-healing shim.
+- **`--ignore-scripts`:** postinstall is intentionally skipped. Run
+  `node node_modules/donsetch/install.js`, or invoke `npx donsetch` to
+  download the binary when network access is available.
+- **Proxy:** set `HTTPS_PROXY` (or `https_proxy`, `HTTP_PROXY`, or
+  `http_proxy`) to an HTTP CONNECT proxy.
+- **Release mirror:** set `DONSETCH_RELEASES_BASE` to a mirror containing
+  `<tag>/<asset>` paths, for example
+  `https://mirror.example/donsetch/releases`.
+- **Windows:** the installer requires `tar`; Windows 10 version 1803 and
+  newer include it.
+- **musl/Alpine:** the published Linux binaries use glibc. Build from source
+  with `cargo build --release` on musl systems.
+- **Windows ARM64:** the x64 build runs under Windows emulation; no native
+  ARM64 asset is required.
+
 ## Two ways to use it
 
 ### MCP Server (for AI agents)

package/bin/donsetch.js

@@ -12,7 +12,7 @@
 // wrapper, we forward it to the native binary so it can clean up
 // (close connections, save ghost state, etc.) before exiting.
 
-const { spawn } = require('child_process');
+const { spawn, execFileSync } = require('child_process');
 const { existsSync } = require('fs');
 const { join } = require('path');
 
@@ -22,8 +22,26 @@ const binDir = join(__dirname, '..', 'binaries');
 const binaryPath = join(binDir, binaryName);
 
 if (!existsSync(binaryPath)) {
-  process.stderr.write('donsetch: binary not found. Run `npm rebuild donsetch` to reinstall.\n');
-  process.exit(1);
+  const installScript = join(__dirname, '..', 'install.js');
+  try {
+    execFileSync(process.execPath, [installScript], {
+      stdio: 'inherit',
+      cwd: join(__dirname, '..'),
+    });
+  } catch (_) {
+    process.stderr.write(
+      `donsetch: native binary missing and download failed. Retry with network access, ` +
+      `or run node ${installScript}; pnpm users: pnpm approve-builds then reinstall.\n`
+    );
+    process.exit(1);
+  }
+  if (!existsSync(binaryPath)) {
+    process.stderr.write(
+      `donsetch: native binary missing and download failed. Retry with network access, ` +
+      `or run node ${installScript}; pnpm users: pnpm approve-builds then reinstall.\n`
+    );
+    process.exit(1);
+  }
 }
 
 // ── spawn native binary ─────────────────────────────────────────

package/install.js

@@ -3,20 +3,10 @@
 
 // donsetch postinstall: download the prebuilt binary for this platform
 // from GitHub Releases, verify SHA256, and extract to ./binaries/.
-//
-// The binary is NOT bundled in the npm package : it's fetched at
-// install time from the GitHub release matching this package version.
-// This keeps the npm registry clean (no 35 MB binary tarballs) and
-// uses the same release artifacts that manual users download.
-//
-// Supported platforms:
-//   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 http = require('http');
 const https = require('https');
+const tls = require('tls');
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
@@ -24,26 +14,26 @@ const { execFileSync } = require('child_process');
 
 const REPO = 'dondai44423/donsetch';
 const VERSION = require('./package.json').version;
-const TAG = `v${VERSION}`;
+const TAG = process.env.DONSETCH_INSTALL_TAG || `v${VERSION}`;
+const REQUEST_TIMEOUT_MS = 30_000;
+const MAX_REDIRECTS = 5;
+const RETRIES = 3;
+const RETRY_BACKOFF_MS = [1_000, 3_000];
 
-// ── platform mapping ────────────────────────────────────────────
 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'     },
+  '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' },
+  'win32-arm64':  { asset: 'donsetch-win32-x64.tar.gz',    binary: 'donsetch.exe', emulated: true },
 };
 
 const platKey = `${process.platform}-${process.arch}`;
 const plat = PLATFORMS[platKey];
 
 if (!plat) {
-  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(`donsetch: unsupported platform ${platKey}`);
   console.error('');
   console.error('Supported platforms:');
   console.error('  linux-x64      Linux x86_64 (glibc)');
@@ -51,222 +41,283 @@ if (!plat) {
   console.error('  darwin-arm64   macOS Apple Silicon');
   console.error('  darwin-x64     macOS Intel');
   console.error('  win32-x64      Windows x86_64');
+  console.error('  win32-arm64    Windows ARM64 (x64 emulation)');
   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.
-//
-// Checking for /lib/ld-musl-*.so.1 existence is a false positive on
-// glibc systems that also have musl installed as a secondary libc
-// (e.g. Arch/Manjaro with the `musl` package). Instead, check what
-// the RUNNING Node process actually uses: read /proc/self/exe's ELF
-// interpreter (.interp section). On glibc it's ld-linux-*.so.2, on
-// musl it's ld-musl-*.so.1. An env var escape hatch is also provided.
-if (process.platform === 'linux') {
-  // Escape hatch: force glibc path even on a musl system (user knows
-  // the binary will run, e.g. via gcompat or a glibc chroot).
-  if (process.env.DONSETCH_FORCE_GLIBC === '1') {
-    // skip musl check
-  } else {
-    let isMusl = false;
-    let detected = false;
-    try {
-      // Read the ELF interpreter of /proc/self/exe (this Node process).
-      // The .interp section starts at offset 0x18 in the ELF header
-      // for the program header table, but the reliable way is to parse
-      // the program headers for PT_INTERP.
-      const exe = '/proc/self/exe';
-      const fd = fs.openSync(exe, 'r');
-      // ELF header: first 64 bytes for 64-bit.
-      const hdr = Buffer.alloc(64);
-      fs.readSync(fd, hdr, 0, 64, 0);
-      // e_phoff at offset 0x20 (64-bit), e_phentsize at 0x36, e_phnum at 0x38.
-      const e_phoff = hdr.readBigUInt64LE(0x20);
-      const e_phentsize = hdr.readUInt16LE(0x36);
-      const e_phnum = hdr.readUInt16LE(0x38);
-      for (let i = 0; i < e_phnum; i++) {
-        const ph = Buffer.alloc(e_phentsize);
-        fs.readSync(fd, ph, 0, e_phentsize, Number(e_phoff) + i * e_phentsize);
-        // PT_INTERP = 3
-        if (ph.readUInt32LE(0) === 3) {
-          // p_offset at 0x08 (64-bit), p_filesz at 0x20.
-          const p_offset = Number(ph.readBigUInt64LE(0x08));
-          const p_filesz = ph.readBigUInt64LE(0x20);
-          const interp = Buffer.alloc(Number(p_filesz));
-          fs.readSync(fd, interp, 0, Number(p_filesz), p_offset);
-          const loaderPath = interp.toString('ascii').replace(/\0/g, '').trim();
-          isMusl = loaderPath.includes('ld-musl');
-          detected = true;
-          break;
-        }
+if (process.env.DONSETCH_SKIP_DOWNLOAD === '1') {
+  console.log('donsetch: download skipped (DONSETCH_SKIP_DOWNLOAD=1)');
+  process.exit(0);
+}
+
+if (plat.emulated) {
+  console.log('donsetch: Windows arm64 uses the win32-x64 build under emulation.');
+}
+
+function detectMusl() {
+  let interpreter;
+  try {
+    const fd = fs.openSync('/proc/self/exe', 'r');
+    const hdr = Buffer.alloc(64);
+    fs.readSync(fd, hdr, 0, 64, 0);
+    const ePhOff = hdr.readBigUInt64LE(0x20);
+    const ePhEntSize = hdr.readUInt16LE(0x36);
+    const ePhNum = hdr.readUInt16LE(0x38);
+    for (let i = 0; i < ePhNum; i++) {
+      const ph = Buffer.alloc(ePhEntSize);
+      fs.readSync(fd, ph, 0, ePhEntSize, Number(ePhOff) + i * ePhEntSize);
+      if (ph.readUInt32LE(0) === 3) {
+        const offset = Number(ph.readBigUInt64LE(0x08));
+        const size = Number(ph.readBigUInt64LE(0x20));
+        const value = Buffer.alloc(size);
+        fs.readSync(fd, value, 0, size, offset);
+        interpreter = value.toString('ascii').replace(/\0/g, '').trim();
+        break;
       }
-      fs.closeSync(fd);
-    } catch (_) {
-      // /proc/self/exe not readable (some containers). Fall back to
-      // the old existence check, but only as a last resort.
-    }
-    // Only fall back to the existence check if we could not read
-    // the ELF interpreter at all. A successful read that found glibc
-    // (isMusl=false, detected=true) must NOT fall back.
-    if (!detected) {
-      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)');
-      console.error('  - set DONSETCH_FORCE_GLIBC=1 if you have a glibc compat layer (gcompat)');
-      process.exit(1);
     }
+    fs.closeSync(fd);
+  } catch (_) {
+    interpreter = undefined;
   }
+  if (interpreter) return interpreter.includes('musl');
+
+  const muslLoader = fs.existsSync('/lib/ld-musl-x86_64.so.1')
+    || fs.existsSync('/lib/ld-musl-aarch64.so.1');
+  const glibcLoader = fs.existsSync('/lib64/ld-linux-x86-64.so.2')
+    || fs.existsSync('/lib/ld-linux-aarch64.so.1');
+  return muslLoader && !glibcLoader;
+}
+
+if (process.platform === 'linux'
+    && process.env.DONSETCH_FORCE_GLIBC !== '1'
+    && detectMusl()) {
+  console.error('donsetch: musl libc detected (Alpine?).');
+  console.error('The prebuilt Linux binaries are glibc-linked and will not run.');
+  console.error('');
+  console.error('Build from source:');
+  console.error(`  git clone https://github.com/${REPO} && cd donsetch && cargo build --release`);
+  console.error('Or use a glibc-based image (Debian, Ubuntu, Fedora).');
+  console.error('Set DONSETCH_FORCE_GLIBC=1 only if a glibc compatibility layer is installed.');
+  process.exit(1);
 }
 
 const binDir = path.join(__dirname, 'binaries');
 const binaryPath = path.join(binDir, plat.binary);
+const stampPath = `${binaryPath}.version`;
 
-// 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)) {
-  let size = 0;
-  try { size = fs.statSync(binaryPath).size; } catch (_) {}
-  if (size > 1024 * 1024) {
-    console.log(`donsetch: binary already present (${plat.binary})`);
+if (fs.existsSync(binaryPath) && fs.existsSync(stampPath)) {
+  let stamp;
+  try { stamp = fs.readFileSync(stampPath, 'utf8').trim(); } catch (_) {}
+  if (stamp === VERSION) {
+    console.log(`donsetch: binary already present (${plat.binary} ${VERSION})`);
     process.exit(0);
   }
-  console.log(`donsetch: leftover ${plat.binary} is ${size} bytes : re-downloading`);
-  try { fs.unlinkSync(binaryPath); } catch (_) {}
+  console.log(`donsetch: binary version stamp mismatch; re-downloading ${VERSION}`);
 }
 
 fs.mkdirSync(binDir, { recursive: true });
 
-const baseUrl = `https://github.com/${REPO}/releases/download/${TAG}`;
-const assetUrl = `${baseUrl}/${plat.asset}`;
-const checksumUrl = `${baseUrl}/${plat.asset}.sha256`;
+const releasesBase = (process.env.DONSETCH_RELEASES_BASE
+  || `https://github.com/${REPO}/releases/download`).replace(/\/+$/, '');
+const assetUrl = `${releasesBase}/${TAG}/${plat.asset}`;
+const checksumUrl = `${assetUrl}.sha256`;
 
-// ── download with redirect following (max 5 hops) ───────────────
-function download(url, dest) {
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function noProxy(host) {
+  const value = process.env.NO_PROXY || process.env.no_proxy || '';
+  return value.split(',').map((part) => part.trim().toLowerCase()).filter(Boolean).some((entry) => {
+    if (entry === '*') return true;
+    const normalized = entry.replace(/^\*\./, '').replace(/^\./, '');
+    return host === normalized || host.endsWith(`.${normalized}`);
+  });
+}
+
+function proxyFor(target) {
+  if (noProxy(target.hostname)) return null;
+  const value = target.protocol === 'https:'
+    ? (process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy)
+    : (process.env.HTTP_PROXY || process.env.http_proxy);
+  return value ? new URL(value) : null;
+}
+
+function requestDirect(target) {
   return new Promise((resolve, reject) => {
-    const MAX_REDIRECTS = 5;
-    function get(u, hops) {
-      if (hops > MAX_REDIRECTS) {
-        reject(new Error(`too many redirects for ${url}`));
+    const transport = target.protocol === 'https:' ? https : http;
+    const req = transport.get(target, {
+      headers: {
+        Accept: 'application/octet-stream',
+        'User-Agent': 'donsetch-npm-installer',
+      },
+    }, resolve);
+    req.setTimeout(REQUEST_TIMEOUT_MS, () => req.destroy(new Error('request timeout')));
+    req.on('error', reject);
+  });
+}
+
+function requestThroughProxy(target, proxy) {
+  return new Promise((resolve, reject) => {
+    const connectTransport = proxy.protocol === 'https:' ? https : http;
+    const proxyReq = connectTransport.request({
+      hostname: proxy.hostname,
+      port: proxy.port || (proxy.protocol === 'https:' ? 443 : 80),
+      method: 'CONNECT',
+      path: `${target.hostname}:${target.port || 443}`,
+      headers: { Host: `${target.hostname}:${target.port || 443}` },
+    });
+    proxyReq.once('connect', (response, socket) => {
+      if (response.statusCode !== 200) {
+        socket.destroy();
+        reject(new Error(`proxy CONNECT returned HTTP ${response.statusCode}`));
         return;
       }
-      const opts = { headers: { 'Accept': 'application/octet-stream', 'User-Agent': 'donsetch-npm-installer' } };
-      https.get(u, opts, (res) => {
-        if ([301, 302, 303, 307, 308].includes(res.statusCode)) {
-          res.resume();
-          const loc = res.headers.location;
-          if (!loc) { reject(new Error(`redirect without Location from ${u}`)); return; }
-          // Stay on https: never follow a downgrade to cleartext.
-          if (loc.startsWith('http://')) {
-            reject(new Error(`refusing http:// downgrade redirect to ${loc}`));
-            return;
-          }
-          get(loc, hops + 1);
-          return;
-        }
-        if (res.statusCode !== 200) {
-          res.resume();
-          reject(new Error(`HTTP ${res.statusCode} for ${u}`));
-          return;
-        }
+      const req = https.request({
+        hostname: target.hostname,
+        port: target.port || 443,
+        path: `${target.pathname}${target.search}`,
+        method: 'GET',
+        headers: {
+          Accept: 'application/octet-stream',
+          'User-Agent': 'donsetch-npm-installer',
+        },
+        agent: false,
+        createConnection: () => tls.connect({
+          socket,
+          servername: target.hostname,
+        }),
+      }, resolve);
+      req.setTimeout(REQUEST_TIMEOUT_MS, () => req.destroy(new Error('request timeout')));
+      req.on('error', reject);
+      req.end();
+    });
+    proxyReq.setTimeout(REQUEST_TIMEOUT_MS, () => {
+      proxyReq.destroy(new Error('proxy CONNECT timeout'));
+    });
+    proxyReq.on('error', reject);
+    proxyReq.end();
+  });
+}
+
+async function requestUrl(url) {
+  const target = new URL(url);
+  if (target.protocol !== 'https:') {
+    throw new Error(`refusing non-HTTPS download URL ${url}`);
+  }
+  const proxy = proxyFor(target);
+  return proxy ? requestThroughProxy(target, proxy) : requestDirect(target);
+}
+
+async function getWithRedirects(url) {
+  let current = url;
+  for (let hops = 0; hops <= MAX_REDIRECTS; hops++) {
+    const response = await requestUrl(current);
+    if (![301, 302, 303, 307, 308].includes(response.statusCode)) {
+      return response;
+    }
+    response.resume();
+    const location = response.headers.location;
+    if (!location) throw new Error(`redirect without Location from ${current}`);
+    const next = new URL(location, current).toString();
+    if (!next.startsWith('https://')) {
+      throw new Error(`refusing HTTP downgrade redirect to ${next}`);
+    }
+    current = next;
+  }
+  throw new Error(`too many redirects for ${url}`);
+}
+
+function drain(response) {
+  return new Promise((resolve) => {
+    response.resume();
+    response.once('end', resolve);
+    response.once('close', resolve);
+  });
+}
+
+function statusError(url, status) {
+  const error = new Error(`HTTP ${status} for ${url}`);
+  error.retryable = status === 429 || status >= 500;
+  return error;
+}
+
+async function download(url, dest) {
+  for (let attempt = 0; attempt < RETRIES; attempt++) {
+    try {
+      const response = await getWithRedirects(url);
+      if (response.statusCode !== 200) {
+        const error = statusError(url, response.statusCode);
+        await drain(response);
+        throw error;
+      }
+      await new Promise((resolve, reject) => {
         const file = fs.createWriteStream(dest);
-        res.pipe(file);
-        file.on('finish', () => { file.close(); resolve(); });
-        file.on('error', (err) => {
-          try { fs.unlinkSync(dest); } catch (_) {}
-          reject(err);
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close(resolve);
         });
-      }).on('error', reject);
+        file.on('error', reject);
+        response.on('error', reject);
+      });
+      return;
+    } catch (error) {
+      try { fs.unlinkSync(dest); } catch (_) {}
+      if (attempt + 1 >= RETRIES || error.retryable === false) throw error;
+      const delay = RETRY_BACKOFF_MS[attempt] || RETRY_BACKOFF_MS[RETRY_BACKOFF_MS.length - 1];
+      console.error(`donsetch: download attempt ${attempt + 1} failed (${error.message}); retrying in ${delay / 1000}s`);
+      await sleep(delay);
     }
-    get(url, 0);
-  });
+  }
 }
 
-// ── main ────────────────────────────────────────────────────────
 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) {
+    try {
+      execFileSync('tar', ['--version'], { stdio: 'ignore' });
+    } catch (_) {
       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);
+      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);
-
-  // 2. Download the SHA256 checksum
   console.log('donsetch: verifying checksum...');
   await download(checksumUrl, checksumFile);
 
-  // 3. Verify SHA256
   const expectedHash = fs.readFileSync(checksumFile, 'utf8').trim().split(/\s+/)[0];
   const actualHash = crypto.createHash('sha256').update(fs.readFileSync(tarball)).digest('hex');
-
-  if (actualHash !== expectedHash) {
+  if (!/^[a-f0-9]{64}$/.test(expectedHash) || actualHash !== expectedHash) {
     try { fs.unlinkSync(tarball); } catch (_) {}
     try { fs.unlinkSync(checksumFile); } catch (_) {}
-    console.error(`donsetch: SHA256 mismatch!`);
-    console.error(`  expected: ${expectedHash}`);
-    console.error(`  actual:   ${actualHash}`);
-    console.error('The download may have been corrupted or tampered with.');
-    process.exit(1);
+    throw new Error(`SHA256 mismatch (expected ${expectedHash}, actual ${actualHash})`);
   }
 
-  // 4. Extract (tar is built into Linux, macOS, and Windows 10+)
   console.log('donsetch: extracting...');
-  // execFileSync: no shell, no string interpolation : the install
-  // path (which can contain quotes/spaces) is passed as argv.
   execFileSync('tar', ['xzf', tarball, '-C', binDir], { stdio: 'inherit' });
-
-  // 5. Cleanup
   try { fs.unlinkSync(tarball); } catch (_) {}
   try { fs.unlinkSync(checksumFile); } catch (_) {}
 
-  // 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}`);
-    console.error('  contents of binaries/:', fs.readdirSync(binDir).join(', '));
-    process.exit(1);
+    throw new Error(`expected ${plat.binary} not found after extraction in ${binDir}`);
   }
-
-  // 7. Make executable (Unix only)
-  if (process.platform !== 'win32') {
-    fs.chmodSync(binaryPath, 0o755);
-  }
-
+  if (process.platform !== 'win32') fs.chmodSync(binaryPath, 0o755);
+  fs.writeFileSync(stampPath, `${VERSION}\n`);
   console.log(`donsetch: installed ${plat.binary} to ${binaryPath}`);
-  console.log(`donsetch: run \`donsetch\` to see available commands.`);
 }
 
-main().catch((err) => {
-  console.error(`donsetch: install failed: ${err.message}`);
+main().catch((error) => {
+  console.error(`donsetch: install failed: ${error.message}`);
   console.error('');
   console.error('You can build from source:');
-  console.error('  git clone https://github.com/' + REPO);
-  console.error('  cd donsetch && cargo build --release');
+  console.error(`  git clone https://github.com/${REPO} && cd donsetch && cargo build --release`);
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "donsetch",
-  "version": "4.1.1",
+  "version": "4.2.0",
   "description": "Web fetch, search and crawl for AI agents. Zero API keys. Chrome-true TLS.",
   "license": "AGPL-3.0-only",
   "author": "Bishesh Bhandari",
@@ -29,10 +29,6 @@
   "pi": {
     "extensions": ["./pi-extension.ts"]
   },
-  "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "typebox": "*"
-  },
   "bin": {
     "donsetch": "bin/donsetch.js"
   },
@@ -43,9 +39,10 @@
     "install.js",
     "bin/donsetch.js",
     "pi-extension.ts",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "engines": {
-    "node": ">=14"
+    "node": ">=18"
   }
 }