bingocode 1.0.31 → 1.0.33

package/config/bingo-defaults/settings.json

@@ -1,6 +1,7 @@
 {
   "env": {
     "ANTHROPIC_AUTH_TOKEN": "pending-provider-setup",
-    "ANTHROPIC_BASE_URL": "http://127.0.0.1:3456"
+    "ANTHROPIC_BASE_URL": "http://127.0.0.1:3456",
+    "BINGO_SKIP_TRUST_DIALOG": "1"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "type": "module",
   "bin": {
     "claude": "bin/claude-win.cjs",
@@ -9,6 +9,8 @@
     "bingo": "bin/bingo-win.cjs"
   },
   "scripts": {
+    "preinstall": "node scripts/preinstall-stop.cjs",
+    "postinstall": "node scripts/postinstall-ripgrep.cjs",
     "start": "bun run ./bin/bingo-win.cjs",
     "bingo": "bun run ./bin/bingo-win.cjs",
     "bingocode": "bun run ./bin/bingocode-win.cjs",

package/scripts/postinstall-ripgrep.cjs

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+
+/**
+ * npm postinstall hook: download ripgrep binary for the current platform.
+ *
+ * The runtime code (src/utils/ripgrep.ts) expects the binary at:
+ *   src/vendor/ripgrep/{arch}-{platform}/rg[.exe]
+ *
+ * When installed via npm (non-bundled mode), there is no embedded ripgrep,
+ * and if the system `rg` is not on PATH, all Grep/file-search operations
+ * will hang. This script ensures a working ripgrep binary is always available.
+ *
+ * Must be CJS (.cjs) because npm executes lifecycle scripts with node,
+ * and package.json has "type": "module".
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const http = require('http');
+
+// ── Configuration ──────────────────────────────────────────────────────────
+
+const RG_VERSION = '14.1.1';
+
+// Map Node.js platform/arch to ripgrep release asset names
+const PLATFORM_MAP = {
+  'x64-win32': {
+    asset: `ripgrep-${RG_VERSION}-x86_64-pc-windows-msvc.zip`,
+    binary: 'rg.exe',
+    archiveType: 'zip',
+  },
+  'x64-linux': {
+    asset: `ripgrep-${RG_VERSION}-x86_64-unknown-linux-musl.tar.gz`,
+    binary: 'rg',
+    archiveType: 'tar.gz',
+  },
+  'arm64-darwin': {
+    asset: `ripgrep-${RG_VERSION}-aarch64-apple-darwin.tar.gz`,
+    binary: 'rg',
+    archiveType: 'tar.gz',
+  },
+  'x64-darwin': {
+    asset: `ripgrep-${RG_VERSION}-x86_64-apple-darwin.tar.gz`,
+    binary: 'rg',
+    archiveType: 'tar.gz',
+  },
+  'arm64-linux': {
+    asset: `ripgrep-${RG_VERSION}-aarch64-unknown-linux-gnu.tar.gz`,
+    binary: 'rg',
+    archiveType: 'tar.gz',
+  },
+};
+
+// ── Path resolution ────────────────────────────────────────────────────────
+// Must match src/utils/ripgrep.ts path resolution:
+//   __dirname = src/  (one level up from src/utils/)
+//   rgRoot = src/vendor/ripgrep/
+//   binary = src/vendor/ripgrep/{arch}-{platform}/rg[.exe]
+
+const packageRoot = path.resolve(__dirname, '..');
+const rgRoot = path.join(packageRoot, 'src', 'vendor', 'ripgrep');
+
+const platformKey = `${process.arch}-${process.platform}`;
+const platformInfo = PLATFORM_MAP[platformKey];
+
+if (!platformInfo) {
+  console.log(
+    `[bingocode] postinstall: 当前平台 ${platformKey} 不在 ripgrep 预构建列表中，跳过下载。`
+  );
+  console.log(
+    '[bingocode] 请确保系统已安装 ripgrep (rg) 并在 PATH 中可用。'
+  );
+  process.exit(0);
+}
+
+const targetDir = path.join(rgRoot, platformKey);
+const targetBinary = path.join(targetDir, platformInfo.binary);
+
+// ── Skip if already present ────────────────────────────────────────────────
+
+if (fs.existsSync(targetBinary)) {
+  console.log(`[bingocode] postinstall: ripgrep 已存在 (${targetBinary})，跳过下载。`);
+  process.exit(0);
+}
+
+// ── Download helpers ───────────────────────────────────────────────────────
+
+const DOWNLOAD_BASE = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}`;
+const downloadUrl = `${DOWNLOAD_BASE}/${platformInfo.asset}`;
+
+/**
+ * Download a URL to a local file, following redirects (GitHub releases redirect
+ * to CDN). Returns a Promise that resolves when the file is fully written.
+ */
+function downloadFile(url, destPath, maxRedirects = 5) {
+  return new Promise((resolve, reject) => {
+    if (maxRedirects <= 0) {
+      return reject(new Error('Too many redirects'));
+    }
+
+    const protocol = url.startsWith('https') ? https : http;
+
+    protocol
+      .get(url, { headers: { 'User-Agent': 'bingocode-postinstall' } }, (res) => {
+        // Handle redirects (301, 302, 303, 307, 308)
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          res.resume(); // Drain the response
+          return downloadFile(res.headers.location, destPath, maxRedirects - 1)
+            .then(resolve)
+            .catch(reject);
+        }
+
+        if (res.statusCode !== 200) {
+          res.resume();
+          return reject(
+            new Error(`Download failed: HTTP ${res.statusCode} for ${url}`)
+          );
+        }
+
+        const fileStream = fs.createWriteStream(destPath);
+        res.pipe(fileStream);
+        fileStream.on('finish', () => {
+          fileStream.close(resolve);
+        });
+        fileStream.on('error', reject);
+      })
+      .on('error', reject);
+  });
+}
+
+// ── Extract helpers ────────────────────────────────────────────────────────
+
+/**
+ * Extract the rg binary from a .tar.gz archive.
+ * The archive structure is: ripgrep-{version}-{target}/rg
+ */
+function extractTarGz(archivePath, binaryName, destDir) {
+  // Use tar to list, find the rg binary, then extract just that file
+  const stripComponents = 1; // strip the top-level directory
+  fs.mkdirSync(destDir, { recursive: true });
+
+  try {
+    execSync(
+      `tar -xzf "${archivePath}" --strip-components=${stripComponents} -C "${destDir}" --wildcards "*/${binaryName}"`,
+      { stdio: 'pipe' }
+    );
+  } catch {
+    // Some tar implementations (e.g., macOS BSD tar) don't support --wildcards
+    // Fall back to extracting everything and moving the binary
+    const tmpExtract = path.join(os.tmpdir(), `rg-extract-${Date.now()}`);
+    fs.mkdirSync(tmpExtract, { recursive: true });
+
+    try {
+      execSync(`tar -xzf "${archivePath}" -C "${tmpExtract}"`, { stdio: 'pipe' });
+
+      // Find the rg binary in the extracted contents
+      const entries = fs.readdirSync(tmpExtract);
+      let found = false;
+      for (const entry of entries) {
+        const candidate = path.join(tmpExtract, entry, binaryName);
+        if (fs.existsSync(candidate)) {
+          fs.copyFileSync(candidate, path.join(destDir, binaryName));
+          found = true;
+          break;
+        }
+      }
+
+      if (!found) {
+        // Maybe the binary is directly in the tmp dir
+        const directCandidate = path.join(tmpExtract, binaryName);
+        if (fs.existsSync(directCandidate)) {
+          fs.copyFileSync(directCandidate, path.join(destDir, binaryName));
+        } else {
+          throw new Error(`Could not find ${binaryName} in extracted archive`);
+        }
+      }
+    } finally {
+      // Cleanup temp dir
+      try {
+        fs.rmSync(tmpExtract, { recursive: true, force: true });
+      } catch {
+        // Best effort
+      }
+    }
+  }
+}
+
+/**
+ * Extract the rg.exe binary from a .zip archive (Windows).
+ * Uses PowerShell's Expand-Archive on Windows.
+ */
+function extractZip(archivePath, binaryName, destDir) {
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const tmpExtract = path.join(os.tmpdir(), `rg-extract-${Date.now()}`);
+  fs.mkdirSync(tmpExtract, { recursive: true });
+
+  try {
+    if (process.platform === 'win32') {
+      // Use PowerShell to extract
+      execSync(
+        `powershell -NoProfile -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${tmpExtract}' -Force"`,
+        { stdio: 'pipe' }
+      );
+    } else {
+      // Use unzip on non-Windows (unlikely but defensive)
+      execSync(`unzip -o "${archivePath}" -d "${tmpExtract}"`, { stdio: 'pipe' });
+    }
+
+    // Find the binary in extracted contents
+    const entries = fs.readdirSync(tmpExtract);
+    let found = false;
+    for (const entry of entries) {
+      const entryPath = path.join(tmpExtract, entry);
+      const stat = fs.statSync(entryPath);
+
+      if (stat.isDirectory()) {
+        const candidate = path.join(entryPath, binaryName);
+        if (fs.existsSync(candidate)) {
+          fs.copyFileSync(candidate, path.join(destDir, binaryName));
+          found = true;
+          break;
+        }
+      } else if (entry === binaryName) {
+        fs.copyFileSync(entryPath, path.join(destDir, binaryName));
+        found = true;
+        break;
+      }
+    }
+
+    if (!found) {
+      throw new Error(`Could not find ${binaryName} in extracted zip archive`);
+    }
+  } finally {
+    try {
+      fs.rmSync(tmpExtract, { recursive: true, force: true });
+    } catch {
+      // Best effort
+    }
+  }
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+async function main() {
+  console.log(`[bingocode] postinstall: 正在下载 ripgrep v${RG_VERSION} (${platformKey})...`);
+  console.log(`[bingocode] URL: ${downloadUrl}`);
+
+  const tmpArchive = path.join(
+    os.tmpdir(),
+    `ripgrep-${RG_VERSION}-${Date.now()}${platformInfo.archiveType === 'zip' ? '.zip' : '.tar.gz'}`
+  );
+
+  try {
+    // 1. Download
+    await downloadFile(downloadUrl, tmpArchive);
+    console.log('[bingocode] postinstall: 下载完成，正在解压...');
+
+    // 2. Extract
+    if (platformInfo.archiveType === 'tar.gz') {
+      extractTarGz(tmpArchive, platformInfo.binary, targetDir);
+    } else {
+      extractZip(tmpArchive, platformInfo.binary, targetDir);
+    }
+
+    // 3. Set executable permission on non-Windows
+    if (process.platform !== 'win32') {
+      fs.chmodSync(targetBinary, 0o755);
+    }
+
+    // 4. Verify
+    if (fs.existsSync(targetBinary)) {
+      const stat = fs.statSync(targetBinary);
+      console.log(
+        `[bingocode] postinstall: ripgrep 安装成功！(${targetBinary}, ${(stat.size / 1024 / 1024).toFixed(1)} MB)`
+      );
+    } else {
+      throw new Error('Binary not found after extraction');
+    }
+  } catch (err) {
+    console.warn(`[bingocode] postinstall: ripgrep 下载/安装失败: ${err.message}`);
+    console.warn('[bingocode] 请手动安装 ripgrep: https://github.com/BurntSushi/ripgrep#installation');
+    console.warn('[bingocode] 或确保系统 PATH 中有 rg 命令可用。');
+    // Don't fail the install — ripgrep is a best-effort enhancement.
+    // The runtime will fall back to system rg if available.
+  } finally {
+    // Cleanup temp archive
+    try {
+      fs.rmSync(tmpArchive, { force: true });
+    } catch {
+      // Best effort
+    }
+  }
+}
+
+main();

package/scripts/preinstall-stop.cjs

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+
+/**
+ * npm preinstall hook: gracefully stop running bingo/bingocode processes
+ * so that npm can overwrite files without EBUSY/EPERM on Windows.
+ *
+ * On Windows, running processes hold mandatory file locks on their loaded .js
+ * files and dependencies. When `npm install -g bingocode` tries to overwrite
+ * these files, it fails with EBUSY or EPERM. This script discovers all running
+ * bingo/bingocode processes via their PID files and stops them before npm
+ * writes any files.
+ *
+ * PID file locations (matching the runtime code):
+ *   - Singleton server: ~/.claude-cli/runtime/server.lock.json  { pid, port, ... }
+ *   - Active sessions:  ~/.claude/sessions/<pid>.json            { pid, sessionId, ... }
+ *
+ * Must be CJS (.cjs) because npm executes lifecycle scripts with node,
+ * and package.json has "type": "module".
+ */
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// ── Paths (mirroring the runtime code) ──────────────────────────────────────
+
+const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+const runtimeDir = path.join(os.homedir(), '.claude-cli', 'runtime');
+const serverLockPath = path.join(runtimeDir, 'server.lock.json');
+const leasesDir = path.join(runtimeDir, 'leases');
+const sessionsDir = path.join(configDir, 'sessions');
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function killPid(pid) {
+  try {
+    if (process.platform === 'win32') {
+      // /T = kill the entire process tree; /F = force
+      spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], {
+        stdio: 'ignore',
+      });
+    } else {
+      process.kill(pid, 'SIGTERM');
+    }
+  } catch {
+    // Process may have already exited
+  }
+}
+
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function sleepMs(ms) {
+  // Cross-platform synchronous sleep via spawnSync
+  if (process.platform === 'win32') {
+    // "ping -n 2 127.0.0.1" sleeps ~1s (more reliable than timeout in non-interactive)
+    spawnSync('ping', ['-n', '2', '127.0.0.1'], { stdio: 'ignore' });
+  } else {
+    spawnSync('sleep', [String(ms / 1000)], { stdio: 'ignore' });
+  }
+}
+
+// ── Collect PIDs ────────────────────────────────────────────────────────────
+
+const pidsToKill = new Set();
+
+// 1. Singleton server PID from server.lock.json
+const serverLock = readJsonSafe(serverLockPath);
+if (serverLock && serverLock.pid && isPidAlive(serverLock.pid)) {
+  pidsToKill.add(serverLock.pid);
+}
+
+// 2. Active session PIDs from ~/.claude/sessions/<pid>.json
+try {
+  const files = fs.readdirSync(sessionsDir);
+  for (const f of files) {
+    // Strict filename guard: only "<digits>.json" files are PID files
+    if (!/^\d+\.json$/.test(f)) continue;
+    const data = readJsonSafe(path.join(sessionsDir, f));
+    if (data && data.pid && isPidAlive(data.pid)) {
+      pidsToKill.add(data.pid);
+    }
+  }
+} catch {
+  // sessionsDir may not exist yet — that's fine
+}
+
+// ── Nothing to do ───────────────────────────────────────────────────────────
+
+if (pidsToKill.size === 0) {
+  // No running processes, npm can proceed safely
+  process.exit(0);
+}
+
+// ── Kill processes ──────────────────────────────────────────────────────────
+
+console.log(
+  `[bingocode] 检测到 ${pidsToKill.size} 个运行中的进程，正在停止以便安装...`
+);
+
+for (const pid of pidsToKill) {
+  console.log(`  停止 PID ${pid}`);
+  killPid(pid);
+}
+
+// ── Wait for processes to exit (max 5 seconds) ─────────────────────────────
+
+const MAX_WAIT_MS = 5000;
+const deadline = Date.now() + MAX_WAIT_MS;
+
+while (Date.now() < deadline) {
+  const alive = [...pidsToKill].filter(isPidAlive);
+  if (alive.length === 0) break;
+  sleepMs(500);
+}
+
+// Check if any processes are still alive after timeout
+const stillAlive = [...pidsToKill].filter(isPidAlive);
+if (stillAlive.length > 0) {
+  console.warn(
+    `[bingocode] 警告：${stillAlive.length} 个进程未能在 ${MAX_WAIT_MS / 1000} 秒内停止 (PIDs: ${stillAlive.join(', ')})`
+  );
+  console.warn(
+    '[bingocode] 安装可能仍会因文件锁定而失败，请手动关闭这些进程后重试'
+  );
+}
+
+// ── Clean up stale lock/lease files ─────────────────────────────────────────
+
+try {
+  fs.rmSync(serverLockPath, { force: true });
+} catch {
+  // Ignore — file may not exist or may already be cleaned up
+}
+
+try {
+  const leaseFiles = fs.readdirSync(leasesDir);
+  for (const f of leaseFiles) {
+    try {
+      fs.rmSync(path.join(leasesDir, f), { force: true });
+    } catch {
+      // Best-effort cleanup
+    }
+  }
+} catch {
+  // leasesDir may not exist
+}
+
+console.log('[bingocode] 进程已停止，继续安装...');

package/src/interactiveHelpers.tsx

@@ -127,8 +127,8 @@ export async function showSetupScreens(root: Root, permissionMode: PermissionMod
   // and checks CLAUDE.md external includes. bypassPermissions mode
   // only affects tool execution permissions, not workspace trust.
   // Note: non-interactive sessions (CI/CD with -p) never reach showSetupScreens at all.
-  // Skip permission checks in claubbit
-  if (!isEnvTruthy(process.env.CLAUBBIT)) {
+  // Skip permission checks in claubbit or when BINGO_SKIP_TRUST_DIALOG is set
+  if (!isEnvTruthy(process.env.CLAUBBIT) && !isEnvTruthy(process.env.BINGO_SKIP_TRUST_DIALOG)) {
     // Fast-path: skip TrustDialog import+render when CWD is already trusted.
     // If it returns true, the TrustDialog would auto-resolve regardless of
     // security features, so we can skip the dynamic import and render cycle.