YeonGyu-Kim
3ddc757b15
Root cause: bun build --target bun inlines top-level
var { spawn } = globalThis.Bun;
for every file that contains 'import { spawn } from "bun"'. On Node/Electron
where globalThis.Bun is undefined, this crashes with
Cannot destructure property 'spawn' of 'globalThis.Bun' as it is undefined.
26 source files had this import; the bundled output had 25 top-level destructures.
Fix:
- Add src/shared/bun-spawn-shim.ts: a thin wrapper that
- delegates to Bun.spawn/spawnSync when globalThis.Bun is present (real Bun)
- falls back to static ESM imports of node:child_process otherwise
- uses static 'import { spawn } from "node:child_process"' so Bun bundler
does NOT emit any globalThis.Bun destructures for this module
- Replace all 26 'from "bun"' spawn/spawnSync imports with relative paths to shim
- Replace 4 direct Bun.spawn() call sites with shim's spawn()
- Remove src/electron-compat.ts and script/prepend-electron-shim.ts (no longer needed)
- Update src/electron-compat.test.ts to assert 0 top-level globalThis.Bun destructures
Verification: grep -c '} = globalThis.Bun;' dist/index.js → 0 (was 25)
All 5921 tests pass (1 pre-existing timeout failure unrelated to this change).
Fixes #3797
94 lines
2.2 KiB
TypeScript
94 lines
2.2 KiB
TypeScript
import { spawn } from "../bun-spawn-shim"
|
|
|
|
import type { ArchiveEntry } from "../archive-entry-validator"
|
|
import { log } from "../logger"
|
|
|
|
|
|
|
|
function parseTarListedZipEntry(line: string): ArchiveEntry | null {
|
|
const match = line.match(
|
|
/^([^\s])\S*\s+\d+\s+\S+\s+\S+\s+\d+\s+\w+\s+\d+\s+(?:\d{2}:\d{2}|\d{4})\s+(.*)$/
|
|
)
|
|
if (!match) {
|
|
return null
|
|
}
|
|
|
|
const [, rawType, rawEntryPath] = match
|
|
if (rawType === "l" || rawType === "h") {
|
|
const arrowIndex = rawEntryPath.lastIndexOf(" -> ")
|
|
return {
|
|
path: arrowIndex === -1 ? rawEntryPath : rawEntryPath.slice(0, arrowIndex),
|
|
type: rawType === "l" ? "symlink" : "hardlink",
|
|
linkPath: arrowIndex === -1 ? undefined : rawEntryPath.slice(arrowIndex + 4),
|
|
}
|
|
}
|
|
|
|
return {
|
|
path: rawEntryPath,
|
|
type: rawType === "d" ? "directory" : "file",
|
|
}
|
|
}
|
|
|
|
function validateParsedTarListing(
|
|
totalLineCount: number,
|
|
unparsedLines: string[]
|
|
): void {
|
|
if (unparsedLines.length === 0) {
|
|
return
|
|
}
|
|
|
|
throw new Error(
|
|
`zip entry listing failed: ${unparsedLines.length}/${totalLineCount} tar listing lines could not be parsed (fail-closed)`
|
|
)
|
|
}
|
|
|
|
export function parseTarListingOutput(stdout: string): ArchiveEntry[] {
|
|
const listingLines = stdout
|
|
.split(/\r?\n/)
|
|
.map(line => line.trim())
|
|
.filter(Boolean)
|
|
|
|
if (listingLines.length === 0) {
|
|
return []
|
|
}
|
|
|
|
const parsedEntries: ArchiveEntry[] = []
|
|
const unparsedLines: string[] = []
|
|
|
|
for (const listingLine of listingLines) {
|
|
const parsedEntry = parseTarListedZipEntry(listingLine)
|
|
if (parsedEntry === null) {
|
|
unparsedLines.push(listingLine)
|
|
log("warning: unparsed tar listing line", { line: listingLine })
|
|
continue
|
|
}
|
|
|
|
parsedEntries.push(parsedEntry)
|
|
}
|
|
|
|
validateParsedTarListing(listingLines.length, unparsedLines)
|
|
|
|
return parsedEntries
|
|
}
|
|
|
|
export async function listZipEntriesWithTar(
|
|
archivePath: string
|
|
): Promise<ArchiveEntry[]> {
|
|
const proc = spawn(["tar", "-tvf", archivePath], {
|
|
stdout: "pipe",
|
|
stderr: "pipe",
|
|
})
|
|
|
|
const [exitCode, stdout, stderr] = await Promise.all([
|
|
proc.exited,
|
|
new Response(proc.stdout).text(),
|
|
new Response(proc.stderr).text(),
|
|
])
|
|
|
|
if (exitCode !== 0) {
|
|
throw new Error(`zip entry listing failed (exit ${exitCode}): ${stderr}`)
|
|
}
|
|
|
|
return parseTarListingOutput(stdout)
|
|
}
|