mirror of
https://github.com/claude-code-best/claude-code.git
synced 2026-06-15 12:55:51 +00:00
305 lines
10 KiB
TypeScript
305 lines
10 KiB
TypeScript
/**
|
|
* 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 {
|
|
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]))
|
|
} catch {
|
|
// No fflate or bad archive — try `unzip` CLI (common on Unix / Git for Windows)
|
|
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('unzip', ['-o', archivePath, '-d', tmpDir], {
|
|
stdio: 'pipe',
|
|
})
|
|
if (result.status !== 0) {
|
|
throw new Error(`unzip 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 })
|
|
}
|
|
}
|
|
}
|
|
|
|
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)
|
|
})
|