@jdi-code/claude-code 1.0.3 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jdi-code/claude-code",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "description": "Reverse-engineered Anthropic Claude Code CLI — interactive AI coding assistant in the terminal",
   "type": "module",
   "author": "claude-code-best <claude-code-best@proton.me>",
@@ -32,14 +32,17 @@
     "packages/@ant/*"
   ],
   "files": [
-    "dist"
+    "dist",
+    "scripts/download-ripgrep.ts",
+    "scripts/postinstall.cjs"
   ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "build": "bun run build.ts",
-    "dev": "bun run src/entrypoints/cli.tsx",
+    "dev": "bun run scripts/dev.ts",
+    "dev:inspect": "bun run scripts/dev-debug.ts",
     "prepublishOnly": "bun run build",
     "lint": "biome lint src/",
     "lint:fix": "biome lint --fix src/",
@@ -48,10 +51,12 @@
     "test": "bun test",
     "check:unused": "knip-bun",
     "health": "bun run scripts/health-check.ts",
+    "postinstall": "node scripts/postinstall.cjs",
     "docs:dev": "npx mintlify dev"
   },
   "dependencies": {},
   "devDependencies": {
+    "openai": "^6.33.0",
     "@alcalzone/ansi-tokenize": "^0.3.0",
     "@ant/claude-for-chrome-mcp": "workspace:*",
     "@ant/computer-use-input": "workspace:*",
@@ -70,6 +75,7 @@
     "@aws-sdk/credential-provider-node": "^3.972.28",
     "@aws-sdk/credential-providers": "^3.1020.0",
     "@azure/identity": "^4.13.1",
+    "@biomejs/biome": "^2.4.10",
     "@commander-js/extra-typings": "^14.0.0",
     "@growthbook/growthbook": "^1.6.5",
     "@modelcontextprotocol/sdk": "^1.29.0",
@@ -91,8 +97,16 @@
     "@opentelemetry/sdk-metrics": "^2.6.1",
     "@opentelemetry/sdk-trace-base": "^2.6.1",
     "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@sentry/node": "^10.47.0",
     "@smithy/core": "^3.23.13",
     "@smithy/node-http-handler": "^4.5.1",
+    "@types/bun": "^1.3.11",
+    "@types/cacache": "^20.0.1",
+    "@types/plist": "^3.0.5",
+    "@types/react": "^19.2.14",
+    "@types/react-reconciler": "^0.33.0",
+    "@types/sharp": "^0.32.0",
+    "@types/turndown": "^5.0.6",
     "ajv": "^8.18.0",
     "asciichart": "^1.5.25",
     "audio-capture-napi": "workspace:*",
@@ -115,12 +129,15 @@
     "fuse.js": "^7.1.0",
     "get-east-asian-width": "^1.5.0",
     "google-auth-library": "^10.6.2",
+    "he": "^1.2.0",
     "highlight.js": "^11.11.1",
     "https-proxy-agent": "^8.0.0",
     "ignore": "^7.0.5",
+    "@anthropic/ink": "workspace:*",
     "image-processor-napi": "workspace:*",
     "indent-string": "^5.0.0",
     "jsonc-parser": "^3.3.1",
+    "knip": "^6.1.1",
     "lodash-es": "^4.17.23",
     "lru-cache": "^11.2.7",
     "marked": "^17.0.5",
@@ -143,6 +160,7 @@
     "tree-kill": "^1.2.2",
     "turndown": "^7.2.2",
     "type-fest": "^5.5.0",
+    "typescript": "^6.0.2",
     "undici": "^7.24.6",
     "url-handler-napi": "workspace:*",
     "usehooks-ts": "^3.1.1",
@@ -153,16 +171,6 @@
     "ws": "^8.20.0",
     "xss": "^1.0.15",
     "yaml": "^2.8.3",
-    "zod": "^4.3.6",
-    "@biomejs/biome": "^2.4.10",
-    "@types/bun": "^1.3.11",
-    "@types/cacache": "^20.0.1",
-    "@types/plist": "^3.0.5",
-    "@types/react": "^19.2.14",
-    "@types/react-reconciler": "^0.33.0",
-    "@types/sharp": "^0.32.0",
-    "@types/turndown": "^5.0.6",
-    "knip": "^6.1.1",
-    "typescript": "^6.0.2"
+    "zod": "^4.3.6"
   }
 }

package/scripts/download-ripgrep.ts

@@ -0,0 +1,335 @@
+/**
+ * Download ripgrep binary from GitHub releases.
+ *
+ * Run automatically via `bun install` (postinstall hook),
+ * or manually: `bun run scripts/download-ripgrep.ts [--force]`
+ *
+ * Idempotent — skips download if the binary already exists.
+ * Use --force to re-download.
+ *
+ * Environment:
+ * - HTTPS_PROXY / HTTP_PROXY — when set, download uses `undici` + EnvHttpProxyAgent.
+ * - RIPGREP_DOWNLOAD_BASE — override release URL prefix, e.g. mirror:
+ *   `https://ghproxy.net/https://github.com/microsoft/ripgrep-prebuilt/releases/download/v15.0.1`
+ */
+
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync } from 'fs'
+import { setDefaultResultOrder } from 'node:dns'
+import { tmpdir } from 'os'
+import { chmodSync } from 'fs'
+import { spawnSync } from 'child_process'
+import * as path from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+// Prefer IPv4 first — Bun on Windows sometimes fails GitHub over broken IPv6 paths.
+try {
+  setDefaultResultOrder('ipv4first')
+} catch {
+  /* ignore */
+}
+
+const RG_VERSION = '15.0.1'
+const DEFAULT_RELEASE_BASE = `https://github.com/microsoft/ripgrep-prebuilt/releases/download/v${RG_VERSION}`
+const RELEASE_BASE = (process.env.RIPGREP_DOWNLOAD_BASE ?? DEFAULT_RELEASE_BASE).replace(/\/$/, '')
+
+// --- Platform mapping ---
+
+type PlatformMapping = {
+  target: string
+  ext: 'tar.gz' | 'zip'
+}
+
+function getPlatformMapping(): PlatformMapping {
+  const arch = process.arch
+  const platform = process.platform
+
+  if (platform === 'darwin') {
+    if (arch === 'arm64') return { target: 'aarch64-apple-darwin', ext: 'tar.gz' }
+    if (arch === 'x64') return { target: 'x86_64-apple-darwin', ext: 'tar.gz' }
+    throw new Error(`Unsupported macOS arch: ${arch}`)
+  }
+
+  if (platform === 'win32') {
+    if (arch === 'x64') return { target: 'x86_64-pc-windows-msvc', ext: 'zip' }
+    if (arch === 'arm64') return { target: 'aarch64-pc-windows-msvc', ext: 'zip' }
+    throw new Error(`Unsupported Windows arch: ${arch}`)
+  }
+
+  if (platform === 'linux') {
+    const isMusl = detectMusl()
+    if (arch === 'x64') {
+      // x64 Linux always uses musl (statically linked, most portable)
+      return { target: 'x86_64-unknown-linux-musl', ext: 'tar.gz' }
+    }
+    if (arch === 'arm64') {
+      return isMusl
+        ? { target: 'aarch64-unknown-linux-musl', ext: 'tar.gz' }
+        : { target: 'aarch64-unknown-linux-gnu', ext: 'tar.gz' }
+    }
+    throw new Error(`Unsupported Linux arch: ${arch}`)
+  }
+
+  throw new Error(`Unsupported platform: ${platform}`)
+}
+
+function detectMusl(): boolean {
+  const muslArch = process.arch === 'x64' ? 'x86_64' : 'aarch64'
+  try {
+    statSync(`/lib/libc.musl-${muslArch}.so.1`)
+    return true
+  } catch {
+    return false
+  }
+}
+
+// --- Target vendor path (must match ripgrep.ts logic) ---
+
+function getVendorDir(): string {
+  const packageRoot = path.resolve(__dirname, '..')
+
+  // Dev mode: package root has src/ directory
+  // ripgrep.ts at src/utils/ripgrep.ts: __dirname = src/utils/
+  // vendor path = src/utils/vendor/ripgrep/
+  if (existsSync(path.join(packageRoot, 'src'))) {
+    return path.resolve(packageRoot, 'src', 'utils', 'vendor', 'ripgrep')
+  }
+
+  // Published mode: compiled chunks are flat in dist/
+  // ripgrep chunk at dist/xxxx.js: __dirname = dist/
+  // vendor path = dist/vendor/ripgrep/
+  return path.resolve(packageRoot, 'dist', 'vendor', 'ripgrep')
+}
+
+function getBinaryPath(): string {
+  const dir = getVendorDir()
+  const subdir = `${process.arch}-${process.platform}`
+  const binary = process.platform === 'win32' ? 'rg.exe' : 'rg'
+  return path.resolve(dir, subdir, binary)
+}
+
+// --- Download & extract ---
+
+function proxyEnvSet(): boolean {
+  const v = (s: string | undefined) => (s ?? '').trim()
+  return !!(
+    v(process.env.HTTPS_PROXY) ||
+    v(process.env.HTTP_PROXY) ||
+    v(process.env.ALL_PROXY) ||
+    v(process.env.https_proxy) ||
+    v(process.env.http_proxy)
+  )
+}
+
+async function fetchRelease(url: string): Promise<Response> {
+  if (proxyEnvSet()) {
+    const { EnvHttpProxyAgent, fetch: undiciFetch } = await import('undici')
+    return (await undiciFetch(url, {
+      redirect: 'follow',
+      dispatcher: new EnvHttpProxyAgent(),
+    })) as unknown as Response
+  }
+  return await fetch(url, { redirect: 'follow' })
+}
+
+function tryPowerShellDownload(url: string, dest: string): boolean {
+  const u = url.replace(/'/g, "''")
+  const d = dest.replace(/'/g, "''")
+  const cmd = `Invoke-WebRequest -Uri '${u}' -OutFile '${d}' -UseBasicParsing`
+  const result = spawnSync(
+    'powershell.exe',
+    ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', cmd],
+    { stdio: 'pipe', windowsHide: true },
+  )
+  return result.status === 0 && existsSync(dest) && statSync(dest).size > 0
+}
+
+function tryCurlDownload(url: string, dest: string): boolean {
+  const curl = process.platform === 'win32' ? 'curl.exe' : 'curl'
+  const result = spawnSync(curl, ['-fsSL', '-L', '--fail', '-o', dest, url], {
+    stdio: 'pipe',
+    windowsHide: true,
+  })
+  return result.status === 0 && existsSync(dest) && statSync(dest).size > 0
+}
+
+/** Bun `fetch` on Windows can fail while browser / WinINET still works — use subprocess fallbacks. */
+async function downloadUrlToBuffer(url: string): Promise<Buffer> {
+  const response = await fetchRelease(url)
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.status} ${response.statusText}`)
+  }
+  return Buffer.from(await response.arrayBuffer())
+}
+
+async function downloadUrlToBufferWithFallback(url: string): Promise<Buffer> {
+  let firstError: unknown
+  try {
+    return await downloadUrlToBuffer(url)
+  } catch (e) {
+    firstError = e
+  }
+
+  const tmpRoot = path.join(tmpdir(), `ripgrep-dl-${process.pid}-${Date.now()}`)
+  const tmpFile = path.join(tmpRoot, 'archive')
+  mkdirSync(tmpRoot, { recursive: true })
+  try {
+    if (process.platform === 'win32' && tryPowerShellDownload(url, tmpFile)) {
+      return readFileSync(tmpFile)
+    }
+    if (tryCurlDownload(url, tmpFile)) {
+      return readFileSync(tmpFile)
+    }
+  } finally {
+    rmSync(tmpRoot, { recursive: true, force: true })
+  }
+
+  throw firstError
+}
+
+function findZipEntryKey(files: Record<string, Uint8Array>, want: string): string | undefined {
+  return Object.keys(files).find(k => {
+    const norm = k.replace(/\\/g, '/')
+    return norm === want || norm.endsWith(`/${want}`)
+  })
+}
+
+async function downloadAndExtract(): Promise<void> {
+  const { target, ext } = getPlatformMapping()
+  const assetName = `ripgrep-v${RG_VERSION}-${target}.${ext}`
+  const downloadUrl = `${RELEASE_BASE}/${assetName}`
+
+  const binaryPath = getBinaryPath()
+  const binaryDir = path.dirname(binaryPath)
+
+  // Idempotent: skip if binary exists and has content
+  const force = process.argv.includes('--force')
+  if (!force && existsSync(binaryPath)) {
+    const stat = statSync(binaryPath)
+    if (stat.size > 0) {
+      console.log(`[ripgrep] Binary already exists at ${binaryPath}, skipping.`)
+      return
+    }
+  }
+
+  console.log(`[ripgrep] Downloading v${RG_VERSION} for ${target}...`)
+  console.log(`[ripgrep] URL: ${downloadUrl}`)
+
+  const extractedBinary = process.platform === 'win32' ? 'rg.exe' : 'rg'
+  const { writeFileSync } = await import('fs')
+
+  try {
+    const buffer = await downloadUrlToBufferWithFallback(downloadUrl)
+    console.log(`[ripgrep] Downloaded ${Math.round(buffer.length / 1024)} KB`)
+
+    mkdirSync(binaryDir, { recursive: true })
+
+    if (ext === 'tar.gz') {
+      const tmpDir = path.join(binaryDir, '.tmp-download')
+      rmSync(tmpDir, { recursive: true, force: true })
+      mkdirSync(tmpDir, { recursive: true })
+      try {
+        const archivePath = path.join(tmpDir, assetName)
+        writeFileSync(archivePath, buffer)
+        const result = spawnSync('tar', ['xzf', archivePath, '-C', tmpDir], {
+          stdio: 'pipe',
+        })
+        if (result.status !== 0) {
+          throw new Error(`tar extract failed: ${result.stderr?.toString()}`)
+        }
+        const srcBinary = path.join(tmpDir, extractedBinary)
+        if (!existsSync(srcBinary)) {
+          throw new Error(`Binary not found at expected path: ${srcBinary}`)
+        }
+        renameSync(srcBinary, binaryPath)
+      } finally {
+        rmSync(tmpDir, { recursive: true, force: true })
+      }
+    } else {
+      let fflateError: unknown
+      try {
+        const { unzipSync } = await import('fflate')
+        const unzipped = unzipSync(new Uint8Array(buffer))
+        const key = findZipEntryKey(unzipped, extractedBinary)
+        if (!key) {
+          throw new Error(`Binary ${extractedBinary} not found in zip`)
+        }
+        writeFileSync(binaryPath, Buffer.from(unzipped[key]))
+        fflateError = undefined
+      } catch (e) {
+        fflateError = e
+      }
+
+      if (fflateError) {
+        // fflate failed — try PowerShell Expand-Archive on Windows, then unzip CLI
+        const tmpDir = path.join(binaryDir, '.tmp-download')
+        rmSync(tmpDir, { recursive: true, force: true })
+        mkdirSync(tmpDir, { recursive: true })
+        try {
+          const archivePath = path.join(tmpDir, assetName)
+          writeFileSync(archivePath, buffer)
+
+          let extracted = false
+
+          // On Windows, prefer PowerShell Expand-Archive
+          if (process.platform === 'win32') {
+            const psCmd = `Expand-Archive -Path '${archivePath.replace(/'/g, "''")}' -DestinationPath '${tmpDir.replace(/'/g, "''")}' -Force`
+            const psResult = spawnSync(
+              'powershell.exe',
+              ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', psCmd],
+              { stdio: 'pipe', windowsHide: true },
+            )
+            if (psResult.status === 0) {
+              extracted = true
+            } else {
+              const psErr = psResult.stderr?.toString().trim() || 'unknown error'
+              console.log(`[ripgrep] PowerShell Expand-Archive failed: ${psErr}`)
+            }
+          }
+
+          // Fallback: unzip CLI (Git for Windows, MSYS2, or Unix)
+          if (!extracted) {
+            const result = spawnSync('unzip', ['-o', archivePath, '-d', tmpDir], {
+              stdio: 'pipe',
+            })
+            if (result.status !== 0) {
+              const unzipErr = result.stderr?.toString().trim() || 'command not found'
+              const fflateMsg = fflateError instanceof Error ? fflateError.message : String(fflateError)
+              throw new Error(`zip extraction failed (fflate: ${fflateMsg}; unzip: ${unzipErr})`)
+            }
+          }
+
+          const srcBinary = path.join(tmpDir, extractedBinary)
+          if (!existsSync(srcBinary)) {
+            throw new Error(`Binary not found at expected path: ${srcBinary}`)
+          }
+          renameSync(srcBinary, binaryPath)
+        } finally {
+          rmSync(tmpDir, { recursive: true, force: true })
+        }
+      }
+    }
+
+    if (process.platform !== 'win32') {
+      chmodSync(binaryPath, 0o755)
+    }
+
+    console.log(`[ripgrep] Installed to ${binaryPath}`)
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e)
+    const hint =
+      'Check network or set HTTPS_PROXY. If GitHub is blocked, set RIPGREP_DOWNLOAD_BASE to a mirror (see script header).'
+    throw new Error(`${msg} ${hint}`)
+  }
+}
+
+// --- Main ---
+
+downloadAndExtract().catch(error => {
+  console.error(`[ripgrep] Download failed: ${error.message}`)
+  console.error(`[ripgrep] You can install ripgrep manually: https://github.com/BurntSushi/ripgrep#installation`)
+  // Don't exit with error code — postinstall should not break bun install
+  process.exit(0)
+})