Self-heal missing tree-sitter.wasm by fetching from unpkg / jsdelivr

Round 11 shipped a binary that needs tree-sitter.wasm next to it
(bun --compile asset embedding was broken on Windows for every
mechanism we tried). The new freebuff/codebuff npm wrappers know to
extract the wasm from the release tarball next to the binary, but
the wrapper auto-updates only the binary, not itself — so users
who installed a pre-fix wrapper download the new binary, the
wrapper strips the wasm with the temp dir, and the new binary
crashes on first run.

Closing that loop in the binary itself: when init-node.ts's
locateFile fallback can't find a sibling tree-sitter.wasm, fetch it
synchronously from a CDN (unpkg, with jsdelivr as backup) and cache
it next to the binary. Subsequent runs short-circuit at the
existsSync check so the download only happens once.

Sync via execFileSync('curl', ...) because emscripten's locateFile
callback must return a path immediately. curl is built into macOS,
Linux, and Windows 10 1803+. If it isn't, we fall through to the
existing thrown error with a clear message.

WEB_TREE_SITTER_VERSION is pinned to match sdk/package.json — a wasm
built for a different web-tree-sitter runtime would crash with a
much more confusing error than "missing wasm".

Verified locally: deleted the sibling wasm, ran the binary,
download fired ("[tree-sitter] downloaded https://unpkg.com/..."),
file cached next to the binary, init succeeded; second run used the
cache and made no network calls.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jahooma

packages/code-map/src/init-node.ts

@@ -1,3 +1,4 @@
+import { execFileSync } from 'child_process'
 import * as fs from 'fs'
 import * as path from 'path'
 
@@ -6,6 +7,22 @@ import { Parser } from 'web-tree-sitter'
 const TREE_SITTER_WASM_ENV_VAR = 'CODEBUFF_TREE_SITTER_WASM_PATH'
 const WASM_BINARY_GLOBAL_KEY = '__CODEBUFF_TREE_SITTER_WASM_BINARY__'
 
+// Pinned to the version in sdk/package.json. If we bump web-tree-sitter,
+// update this too — fetching a wasm built for a different version of the
+// runtime would crash with a more confusing error than "missing wasm".
+const WEB_TREE_SITTER_VERSION = '0.25.10'
+
+// Self-heal endpoints for users on an old npm wrapper. The wrapper
+// auto-updates the binary but not itself, so users on pre-0.0.74
+// (freebuff) / pre-1.0.666 (codebuff) wrappers download the new binary
+// but their wrapper drops the sibling tree-sitter.wasm we tarball
+// alongside it. On missing wasm, the binary fetches it from one of
+// these CDNs and caches it next to itself for subsequent runs.
+const WASM_DOWNLOAD_URLS = [
+  `https://unpkg.com/web-tree-sitter@${WEB_TREE_SITTER_VERSION}/tree-sitter.wasm`,
+  `https://cdn.jsdelivr.net/npm/web-tree-sitter@${WEB_TREE_SITTER_VERSION}/tree-sitter.wasm`,
+]
+
 /**
  * Override the path to `tree-sitter.wasm` used during {@link initTreeSitterForNode}.
  *
@@ -30,6 +47,56 @@ function getEmbeddedWasmBinary(): Uint8Array | undefined {
   )[WASM_BINARY_GLOBAL_KEY]
 }
 
+/**
+ * Synchronously download tree-sitter.wasm from a public CDN and write it
+ * to `targetPath`. Returns the path on success, null on any failure.
+ *
+ * Sync rather than async because this is called from emscripten's
+ * locateFile callback, which must return a path immediately. We shell
+ * out to `curl` (built-in on macOS / Linux / Windows 10+); if that
+ * isn't available or the network's down, the caller falls through to
+ * the next resolution strategy and ultimately throws a clear error.
+ *
+ * Logs a one-line status to stderr so users see what's happening on
+ * the first run after an old-wrapper auto-update.
+ */
+function downloadWasmTo(targetPath: string): string | null {
+  // Print to stderr so it doesn't pollute machine-readable stdout.
+  // Visible to humans during the (briefly noticeable) first launch.
+  process.stderr.write(
+    `[tree-sitter] tree-sitter.wasm missing; downloading to ${targetPath}\n`,
+  )
+  for (const url of WASM_DOWNLOAD_URLS) {
+    try {
+      execFileSync(
+        'curl',
+        [
+          '-fsSL',
+          '--connect-timeout',
+          '10',
+          '--max-time',
+          '60',
+          '-o',
+          targetPath,
+          url,
+        ],
+        { stdio: 'pipe' },
+      )
+      if (fs.existsSync(targetPath) && fs.statSync(targetPath).size > 0) {
+        process.stderr.write(`[tree-sitter] downloaded ${url}\n`)
+        return targetPath
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[tree-sitter] download from ${url} failed: ${
+          err instanceof Error ? err.message : String(err)
+        }\n`,
+      )
+    }
+  }
+  return null
+}
+
 function resolveTreeSitterWasm(scriptDir: string): string {
   // Only return paths that fs.existsSync confirms — emscripten will
   // fs.readFile whatever we hand it, and bunfs internal paths (the
@@ -56,13 +123,19 @@ function resolveTreeSitterWasm(scriptDir: string): string {
   // path later. emscripten calls this locateFile callback during
   // Parser.init's async work, by which time execPath has stabilized.
   try {
-    const sibling = path.join(
-      path.dirname(process.execPath),
-      'tree-sitter.wasm',
-    )
+    const siblingDir = path.dirname(process.execPath)
+    const sibling = path.join(siblingDir, 'tree-sitter.wasm')
     if (fs.existsSync(sibling)) {
       return sibling
     }
+
+    // Self-heal: download from a CDN and cache next to the binary. This
+    // is the path users on old npm wrappers take — their wrapper
+    // auto-updated the binary but didn't extract the tarballed wasm
+    // sibling, so the file isn't there on first run. Once we cache it,
+    // subsequent runs short-circuit at the existsSync above.
+    const downloaded = downloadWasmTo(sibling)
+    if (downloaded) return downloaded
   } catch {
     // process.execPath may be unavailable in exotic runtimes; fall through.
   }