feat(init): replace OpenTUI with Ink for the wizard UI

biome.jsonc

@@ -33,6 +33,26 @@
     }
   },
   "overrides": [
+    {
+      // The React-hook lint rules infer "this is a hook" from the
+      // `use*` naming convention. We have a couple of test helpers
+      // (`useTestConfigDir`, `useEnvSandbox`) that share the prefix
+      // by coincidence — they register `beforeEach`/`afterEach` and
+      // have nothing to do with React. Without these overrides every
+      // call site lights up `useHookAtTopLevel` since making the
+      // tsconfig JSX-aware (for `OpenTuiUI`) flipped the rule on.
+      // The actual React tree lives in `src/lib/init/ui/opentui-app.tsx`
+      // and keeps the rule active.
+      "includes": ["test/**/*.ts", "src/**/*.ts", "!src/**/*.tsx"],
+      "linter": {
+        "rules": {
+          "correctness": {
+            "useHookAtTopLevel": "off",
+            "useExhaustiveDependencies": "off"
+          }
+        }
+      }
+    },
     {
       "includes": ["test/**/*.ts"],
       "linter": {

package.json

@@ -9,7 +9,6 @@
   "devDependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
     "@biomejs/biome": "2.3.8",
-    "@clack/prompts": "^0.11.0",
     "@mastra/client-js": "^1.4.0",
     "@sentry/api": "^0.113.0",
     "@sentry/node-core": "10.50.0",
@@ -21,6 +20,7 @@
     "@types/node": "^22",
     "@types/picomatch": "^4.0.3",
     "@types/qrcode-terminal": "^0.12.2",
+    "@types/react": "^19.2.14",
     "@types/semver": "^7.7.1",
     "binpunch": "^1.0.0",
     "chalk": "^5.6.2",
@@ -30,12 +30,16 @@
     "fast-check": "^4.5.3",
     "http-cache-semantics": "^4.2.0",
     "ignore": "^7.0.5",
+    "ink": "^7.0.1",
+    "ink-spinner": "^5.0.0",
     "marked": "^15",
     "p-limit": "^7.2.0",
     "peggy": "^5.1.0",
     "picomatch": "^4.0.3",
     "pretty-ms": "^9.3.0",
     "qrcode-terminal": "^0.12.0",
+    "react": "^19.2.5",
+    "react-devtools-core": "^7.0.1",
     "semver": "^7.7.3",
     "string-width": "^8.2.0",
     "tinyglobby": "^0.2.15",

plugins/sentry-cli/skills/sentry-cli/references/init.md

@@ -20,6 +20,7 @@ Initialize Sentry in your project (experimental)
 - `-n, --dry-run - Show what would happen without making changes`
 - `--features <value>... - Features to enable: errors,tracing,logs,replay,profiling,ai-monitoring,user-feedback`
 - `-t, --team <value> - Team slug to create the project under`
+- `--tui - Use the Ink-based interactive UI (default on the Bun binary). Pass --no-tui to fall back to plain log output.`
 
 **Examples:**
 

script/build.ts

@@ -124,7 +124,27 @@ async function bundleJs(): Promise<boolean> {
       platform: "node",
       target: "esnext",
       format: "esm",
-      external: ["bun:*"],
+      // Externalize the Ink + React stack from the esbuild bundling
+      // step. `react`'s CJS jsx-runtime, when pulled into esbuild's
+      // `__commonJS` wrappers and re-bundled by Bun.compile, produces
+      // malformed output containing a TDZ `init_react` symbol
+      // embedded in the wrong scope. Keeping React (and its
+      // consumers) external lets Bun's runtime resolve them fresh at
+      // first invocation, outside the buggy bundler path.
+      //
+      // The npm bundle (`script/bundle.ts`) externalizes the same
+      // packages for the same reason — bundling Ink's React tree
+      // through esbuild produces a CJS wrapper that hits a TDZ at
+      // runtime when React is first touched.
+      external: [
+        "bun:*",
+        "ink",
+        "ink-spinner",
+        "react",
+        "react/*",
+        "react-reconciler",
+        "react-reconciler/*",
+      ],
       sourcemap: "linked",
       // Minify syntax and whitespace but NOT identifiers. Bun.build
       minify: true,
@@ -295,6 +315,25 @@ async function compileTarget(target: BuildTarget): Promise<boolean> {
   try {
     const result = await Bun.build({
       entrypoints: [BUNDLE_JS],
+      // Force React to load its production builds. React's CJS
+      // entry switches at runtime via
+      //   `if (process.env.NODE_ENV === "production")`
+      // — leaving NODE_ENV unset would drag in the development
+      // builds, whose CJS wrappers Bun.compile can't bundle cleanly
+      // (it injects `__promiseAll` runtime helpers in positions the
+      // dev-build's IIFE doesn't tolerate, causing a SyntaxError at
+      // startup). Production builds parse fine.
+      //
+      // `react-devtools-core` is gated behind `process.env.DEV ===
+      // "true"` inside Ink's reconciler — never reached in our
+      // production binary. We still install it as a devDep so
+      // Bun.compile can resolve the static `import devtools from
+      // "react-devtools-core"` reference; without it the build
+      // fails with "Could not resolve". The inlined module gets
+      // dead-code-eliminated by the DEV gate at runtime.
+      define: {
+        "process.env.NODE_ENV": JSON.stringify("production"),
+      },
       compile: {
         target: getBunTarget(target) as
           | "bun-darwin-arm64"
@@ -480,8 +519,12 @@ async function build(): Promise<void> {
   // Step 3: Upload the composed sourcemap to Sentry (after compilation)
   await uploadSourcemapToSentry();
 
-  // Clean up intermediate bundle (only the binaries are artifacts)
-  await $`rm -f ${BUNDLE_JS} ${SOURCEMAP_FILE}`;
+  // Clean up intermediate bundle (only the binaries are artifacts).
+  // The `ink-app.tsx` copy comes from the text-import-plugin's
+  // `with { type: "file" }` handling — it gets embedded into the
+  // compiled binary, so the sidecar copy is no longer needed once
+  // every target has compiled.
+  await $`rm -f ${BUNDLE_JS} ${SOURCEMAP_FILE} dist-bin/ink-app.tsx`;
 
   // Summary
   console.log(`\n${"=".repeat(40)}`);

script/bundle.ts

@@ -215,8 +215,30 @@ const result = await build({
     // Replace import.meta.url with the injected shim variable for CJS
     "import.meta.url": "import_meta_url",
   },
-  // Only externalize Node.js built-ins - bundle all npm packages
-  external: ["node:*"],
+  // Externalize Node.js built-ins, plus Ink + React + companions.
+  // Ink uses top-level await (in `node_modules/ink/build/reconciler.js`
+  // and `yoga-layout/dist/src/index.js`) which esbuild can't emit in
+  // a CJS bundle, so the packages must stay external for the
+  // npm/Node distribution. The factory in `factory.ts` lazy-imports
+  // the Ink path via `with { type: "file" }` and falls back to
+  // `LoggingUI` on import failure, so a Node user without Ink
+  // installed simply gets the non-TUI flow without a crash.
+  //
+  // The Bun compile (`script/build.ts`) embeds `ink-app.tsx` as a
+  // file resource — at runtime Bun's loader resolves Ink + React
+  // fresh, sidestepping the same CJS-wrapping bug that'd hit if
+  // these were bundled into the binary's pre-compiled JS.
+  external: [
+    "node:*",
+    "ink",
+    "ink-spinner",
+    "react",
+    "react/*",
+    "react-reconciler",
+    "react-reconciler/*",
+    "react-devtools-core",
+    "yoga-layout",
+  ],
   metafile: true,
   plugins,
 });
@@ -278,6 +300,20 @@ await Bun.write("./dist/index.d.cts", TYPE_DECLARATIONS);
 console.log("  -> dist/bin.cjs (CLI wrapper)");
 console.log("  -> dist/index.d.cts (type declarations)");
 
+// Clean up the `ink-app.tsx` sidecar that the text-import-plugin
+// drops into `dist/` when it sees the `with { type: "file" }` import
+// in `src/lib/init/ui/ink-ui.ts`. The npm distribution doesn't run
+// the InkUI factory at all (it's gated to the Bun binary because
+// Ink uses top-level await that we can't bundle into CJS), so the
+// sidecar is unused — and it's not in `package.json#files` either,
+// so it wouldn't ship even without this cleanup. Removing it just
+// keeps the local `dist/` directory tidy.
+try {
+  await unlink("./dist/ink-app.tsx");
+} catch {
+  // Sidecar may not exist (e.g. plugin path not exercised) — fine.
+}
+
 // Calculate bundle size (only the main bundle, not source maps)
 const bundleOutput = result.metafile?.outputs["dist/index.cjs"];
 const bundleSize = bundleOutput?.bytes ?? 0;

script/text-import-plugin.ts

@@ -1,17 +1,28 @@
 /**
- * esbuild plugin that polyfills Bun's `with { type: "text" }` import
- * attribute (esbuild only supports `json`). Intercepts matching
- * imports, reads the file, and default-exports its contents as a
- * string. Runtime behavior matches Bun's native handling.
+ * esbuild plugin that polyfills Bun's `with { type: "text" }` and
+ * `with { type: "file" }` import attributes (esbuild only supports
+ * `json`).
+ *
+ * - `text` — intercepts the import, reads the file, and default-
+ *   exports its contents as a string. Runtime behavior matches Bun's
+ *   native handling.
+ * - `file` — copies the source file into the esbuild output
+ *   directory, then marks the import external so the original
+ *   `import path from "./foo" with { type: "file" }` clause
+ *   survives in the bundled JS. Bun.compile downstream understands
+ *   the attribute natively, embeds the file as a binary asset, and
+ *   resolves the import to a virtual-filesystem path string at
+ *   runtime.
  *
  * Used by `script/build.ts` (single-file executable) and
  * `script/bundle.ts` (CJS library bundle) so the grep-worker source
  * in `src/lib/scan/worker-pool.ts` loads correctly in both dev and
- * compiled builds.
+ * compiled builds (`text` branch). The `file` branch is kept for
+ * future use; today no source file goes through it.
  */
 
-import { readFileSync } from "node:fs";
-import { resolve as resolvePath } from "node:path";
+import { copyFileSync, mkdirSync, readFileSync } from "node:fs";
+import { basename, dirname, resolve as resolvePath } from "node:path";
 import type { Plugin } from "esbuild";
 
 const TEXT_IMPORT_NS = "text-import";
@@ -21,13 +32,48 @@ export const textImportPlugin: Plugin = {
   name: "text-import",
   setup(build) {
     build.onResolve({ filter: ANY_FILTER }, (args) => {
-      if (args.with?.type !== "text") {
-        return null;
+      if (args.with?.type === "text") {
+        return {
+          path: resolvePath(args.resolveDir, args.path),
+          namespace: TEXT_IMPORT_NS,
+        };
       }
-      return {
-        path: resolvePath(args.resolveDir, args.path),
-        namespace: TEXT_IMPORT_NS,
-      };
+      if (args.with?.type === "file") {
+        // Copy the source into the bundle's output directory and
+        // rewrite the import path so it sits next to the bundle.
+        // esbuild keeps the import external (preserving the
+        // `with { type: "file" }` clause) so Bun.compile can pick
+        // it up from the new location. The copy is needed because
+        // Bun.compile resolves imports relative to the bundle file's
+        // directory at compile time, not the original source.
+        //
+        // `mkdirSync` guards against the bundle's `outdir` not yet
+        // existing when the plugin fires — esbuild creates the
+        // outdir lazily on first write.
+        const sourcePath = resolvePath(args.resolveDir, args.path);
+        const outdir = build.initialOptions.outdir
+          ? resolvePath(build.initialOptions.outdir)
+          : dirname(resolvePath(build.initialOptions.outfile ?? "."));
+        const filename = basename(sourcePath);
+        const copyPath = resolvePath(outdir, filename);
+        try {
+          mkdirSync(outdir, { recursive: true });
+          copyFileSync(sourcePath, copyPath);
+        } catch (err) {
+          // Surface the failure so the build fails visibly rather
+          // than producing a binary that crashes at startup.
+          throw new Error(
+            `text-import-plugin: failed to copy ${sourcePath} → ${copyPath}: ${
+              err instanceof Error ? err.message : String(err)
+            }`
+          );
+        }
+        return {
+          path: `./${filename}`,
+          external: true,
+        };
+      }
+      return null;
     });
     build.onLoad({ filter: ANY_FILTER, namespace: TEXT_IMPORT_NS }, (args) => {
       const content = readFileSync(args.path, "utf-8");

src/commands/init.ts

@@ -45,6 +45,16 @@ type InitFlags = {
   readonly "dry-run": boolean;
   readonly features?: string[];
   readonly team?: string;
+  /**
+   * Default `true` (Ink is the default UI on the Bun binary). Stricli
+   * auto-generates a negated `--no-tui` flag that flips this to
+   * `false` — that's the escape hatch users invoke when the Ink path
+   * misbehaves (e.g. on unusual terminal emulators). The positive
+   * `--tui` flag is also accepted for symmetry but is a no-op versus
+   * the default. On the npm/Node distribution this flag has no
+   * effect; the factory always picks `LoggingUI` there.
+   */
+  readonly tui: boolean;
 };
 
 /**
@@ -226,6 +236,12 @@ export const initCommand = buildCommand<
         brief: "Team slug to create the project under",
         optional: true,
       },
+      tui: {
+        kind: "boolean",
+        brief:
+          "Use the Ink-based interactive UI (default on the Bun binary). Pass --no-tui to fall back to plain log output.",
+        default: true,
+      },
     },
     aliases: {
       ...DRY_RUN_ALIASES,
@@ -285,25 +301,29 @@ export const initCommand = buildCommand<
         team: flags.team,
         org: explicitOrg,
         project: explicitProject,
+        // `flags.tui` defaults to `true`. `--no-tui` (auto-generated
+        // by stricli's flag negation) flips it to `false` — that's the
+        // signal we forward to the factory as `forceLegacyUi`.
+        forceLegacyUi: flags.tui === false,
       });
     } finally {
       // 7. macOS-only force-exit safety net.
       //
-      // On Darwin, `runWizard` installs the `/dev/tty` forwarding
-      // workaround from stdin-reopen.ts to get keystrokes through to
-      // clack. That workaround opens a second `tty.ReadStream` which
-      // leaks a libuv handle on Bun 1.3.11 — no userland cleanup
-      // releases it (upstream oven-sh/bun#29126). After `runWizard`
-      // returns (or throws), the event loop stays ref'd and the process
-      // hangs until the user presses a key.
+      // On Darwin, `InkUI` opens a fresh `/dev/tty` `tty.ReadStream`
+      // (so Ink's `useInput` actually receives keystrokes — Bun's
+      // `process.stdin` doesn't deliver `readable` events properly,
+      // see oven-sh/bun#6862 / vadimdemedes/ink#636). The fresh
+      // stream is destroyed in the InkUI dispose path, but Bun's
+      // libuv handle for it can linger past `destroy()` on Darwin
+      // (oven-sh/bun#29126), keeping the event loop ref'd so the
+      // process hangs until the user presses a key.
       //
       // The .unref() timer doesn't hold the loop itself, so it's a no-op
-      // in the happy path (Linux: no workaround installed, loop drains
-      // naturally; `--yes` on Darwin: no prompts, no keystroke issue,
-      // may still drain naturally). On the Darwin hang path, it
-      // force-exits after a 100ms grace window — imperceptible to the
-      // user and enough for Sentry telemetry + stdio flushes to
-      // complete first.
+      // in the happy path (Linux: handle drains naturally; `--yes`
+      // on Darwin: LoggingUI doesn't open /dev/tty, may still drain
+      // naturally). On the Darwin hang path, it force-exits after a
+      // 100ms grace window — imperceptible to the user and enough
+      // for Sentry telemetry + stdio flushes to complete first.
       //
       // Skipped under `bun test` (which sets NODE_ENV=test automatically)
       // because the test runner calls `initCommand.func` directly; an