Move --smoke-tree-sitter handler to main() to bypass commander

Last attempt put the handler at top-level in the pre-init module behind
a top-level await, on the theory that ESM would pause subsequent module
evaluation until it resolved. That worked on macOS locally but not on
Windows in CI:

    smoke-binary: spawning ./codebuff.exe for 10s…
    error: tree-sitter smoke failed with exit code 1
    error: unknown option '--smoke-tree-sitter'

So commander.parse() ran before our handler exited, which means
top-level await is not actually blocking parent-module evaluation in
the bun --compile output on Windows (or it's getting transformed away
by `--production` minification).

Move the handler to the top of main() in cli/src/index.tsx, before
parseArgs(). At that point commander hasn't run yet, so we can short-
circuit cleanly. The pre-init module's only job is now to publish the
embedded wasm bytes (globalThis) and path (env var); the handler reads
those out of the same channels the production runtime uses.

Verified locally: ./codebuff --smoke-tree-sitter prints
"tree-sitter smoke ok (wasmBinary, 205488 bytes)" and exits 0; full
smoke-binary.ts run passes both the tree-sitter pre-check and the
boot-screen window.

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

Author: jahooma

cli/src/index.tsx

@@ -186,6 +186,44 @@ function parseArgs(): ParsedArgs {
 }
 
 async function main(): Promise<void> {
+  // CI gate: `<binary> --smoke-tree-sitter` proves the embedded wasm boots
+  // through Parser.init end-to-end. Has to live BEFORE commander.parse() —
+  // an earlier attempt put this in a pre-init module with top-level await,
+  // and on Windows that didn't actually pause module evaluation (commander
+  // still ran first and rejected the unknown flag).
+  if (process.argv.includes('--smoke-tree-sitter')) {
+    const wasmBinary = (
+      globalThis as { __CODEBUFF_TREE_SITTER_WASM_BINARY__?: Uint8Array }
+    ).__CODEBUFF_TREE_SITTER_WASM_BINARY__
+    const wasmPath = process.env.CODEBUFF_TREE_SITTER_WASM_PATH
+    try {
+      const { Parser } = await import('web-tree-sitter')
+      if (wasmBinary) {
+        await Parser.init({ wasmBinary })
+        // Marker grepped by cli/scripts/smoke-binary.ts — keep this exact text.
+        console.log(
+          `tree-sitter smoke ok (wasmBinary, ${wasmBinary.byteLength} bytes)`,
+        )
+      } else if (wasmPath) {
+        await Parser.init({
+          locateFile: (name: string) =>
+            name === 'tree-sitter.wasm' ? wasmPath : name,
+        })
+        console.log(`tree-sitter smoke ok (locateFile, path=${wasmPath})`)
+      } else {
+        console.error(
+          'tree-sitter smoke FAIL: pre-init published neither globalThis bytes nor an env path. ' +
+            'The `with { type: \'file\' }` import returned falsy.',
+        )
+        process.exit(1)
+      }
+      process.exit(0)
+    } catch (err) {
+      console.error('tree-sitter smoke FAIL:', err)
+      process.exit(1)
+    }
+  }
+
   // Run OSC theme detection BEFORE anything else.
   // This MUST happen before OpenTUI starts because OSC responses come through stdin,
   // and OpenTUI also listens to stdin. Running detection here ensures stdin is clean.

cli/src/pre-init/tree-sitter-wasm.ts

@@ -50,50 +50,11 @@ if (treeSitterWasmPath) {
   }
 }
 
-// Deterministic CI gate: `<binary> --smoke-tree-sitter` proves the embed
-// shipped end-to-end. Lives here, in the very first import, on purpose:
-//
-// - We're testing whether the *embed* works. Going through commander +
-//   initTreeSitterForNode would pass via the path-resolution fallback
-//   when the embed is empty (e.g. dev mode), giving false positives that
-//   mask a broken production build.
-// - Failing here, before any other module loads, gives a sharp signal:
-//   either the wasm reached the runtime or it didn't.
-//
-// Top-level await (not a fire-and-forget IIFE) because subsequent module
-// evaluation has to *wait* — otherwise `commander.parse()` runs first and
-// fails on the unknown flag before our handler can exit cleanly.
-if (process.argv.includes('--smoke-tree-sitter')) {
-  try {
-    const { Parser } = await import('web-tree-sitter')
-    // Prefer the wasmBinary path (no filesystem step). Fall back to
-    // letting Parser.init resolve the path via its locateFile callback,
-    // which init-node.ts wires up to accept bunfs paths even when
-    // fs.existsSync says otherwise.
-    if (embeddedWasm) {
-      await Parser.init({ wasmBinary: embeddedWasm })
-      console.log(
-        `tree-sitter smoke ok (wasmBinary, ${embeddedWasm.byteLength} bytes)`,
-      )
-    } else if (treeSitterWasmPath) {
-      await Parser.init({
-        locateFile: (name: string) =>
-          name === 'tree-sitter.wasm' ? treeSitterWasmPath : name,
-      })
-      console.log(
-        `tree-sitter smoke ok (locateFile, path=${treeSitterWasmPath})`,
-      )
-    } else {
-      console.error(
-        'tree-sitter smoke FAIL: no embedded wasm path. The `with { type: ' +
-          "'file' }` import returned a falsy value, which means the bundler " +
-          'did not embed the asset.',
-      )
-      process.exit(1)
-    }
-    process.exit(0)
-  } catch (err) {
-    console.error('tree-sitter smoke FAIL:', err)
-    process.exit(1)
-  }
-}
+// `--smoke-tree-sitter` is the deterministic CI gate. We can't handle it
+// here with top-level await — bun --compile on Windows didn't preserve the
+// blocking semantics in our last attempt, so commander still ran and
+// rejected the unknown flag. Instead, the handler lives at the top of
+// main() in cli/src/index.tsx (before parseArgs), where we can synchronously
+// short-circuit before commander parses argv. This module's job is just to
+// publish the wasm bytes / path on globalThis + process.env so that the
+// handler (and the SDK's eager Parser.init) can find them.