@golba98/codexa 1.0.1

package/src/index.tsx

@@ -0,0 +1,296 @@
+import React from "react";
+import { render, type Instance, type RenderOptions } from "ink";
+import { App } from "./app.js";
+import { parseLaunchArgs, type LaunchArgs } from "./config/launchArgs.js";
+import { loadSettings } from "./config/persistence.js";
+import { APP_NAME, formatTerminalTitlePath } from "./config/settings.js";
+import { getTerminalCapability } from "./core/terminal/terminalCapabilities.js";
+import * as renderDebug from "./core/perf/renderDebug.js";
+import { MIN_VIEWPORT_COLS, MIN_VIEWPORT_ROWS } from "./ui/layout.js";
+import {
+  reassertIntendedTerminalTitle,
+  setIntendedTerminalTitle,
+  startTerminalTitleStartupGuard,
+} from "./core/terminal/terminalTitle.js";
+import { resolveWorkspaceRoot } from "./core/workspaceRoot.js";
+import {
+  createTerminalModeController,
+  TERMINAL_SEQUENCES,
+  traceTerminalClear,
+  writeTerminalControl,
+} from "./core/terminal/terminalControl.js";
+
+type RenderHandle = Pick<Instance, "clear" | "cleanup" | "waitUntilExit">;
+const KITTY_KEYBOARD_OPTIONS: RenderOptions["kittyKeyboard"] = {
+  mode: "auto",
+  flags: ["disambiguateEscapeCodes"],
+};
+
+/**
+ * Typed subset of the internal Ink class instance we access to disable Ink's
+ * built-in resize listener. Post-startup repainting is driven by React layout
+ * state, not by forcing Ink's private render buffers.
+ */
+interface InkInstance {
+  unsubscribeResize?: () => void;
+}
+
+/**
+ * Resolve the real Ink class instance via Ink's internal WeakMap<stdout, Ink>.
+ * Returns null if resolution fails (e.g. different Ink version, test mocks).
+ */
+function resolveInkInstance(stdout: AppStdout): InkInstance | null {
+  try {
+    // Bun doesn't resolve bare subpath imports like "ink/build/instances.js"
+    // so we resolve ink's main entry first, then derive the sibling path.
+    const { createRequire } = require("node:module");
+    const req = createRequire(import.meta.url);
+    const inkMain = req.resolve("ink");
+    const instancesPath = inkMain.replace(/index\.js$/, "instances.js");
+    const instances = req(instancesPath);
+    const weakMap: WeakMap<object, InkInstance> =
+      instances.default ?? instances;
+    return weakMap.get(stdout as object) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export interface AppStdout {
+  isTTY: boolean;
+  write: (chunk: string) => boolean;
+  on: (event: "resize" | string, listener: (...args: unknown[]) => void) => void;
+  off: (event: "resize" | string, listener: (...args: unknown[]) => void) => void;
+  columns?: number;
+  rows?: number;
+}
+
+export interface StartAppDependencies {
+  stdin: Pick<NodeJS.ReadStream, "isTTY">;
+  stdout: AppStdout;
+  stderr: Pick<NodeJS.WriteStream, "write"> & Partial<Pick<NodeJS.WriteStream, "isTTY">>;
+  env: Record<string, string | undefined>;
+  platform: NodeJS.Platform;
+  argv: string[];
+  renderApp: (node: React.ReactElement, options?: RenderOptions) => RenderHandle;
+  resolveInkInstanceForStdout: (stdout: AppStdout) => InkInstance | null;
+  registerExitHandler: (handler: () => void) => void;
+}
+
+export interface StartAppResult {
+  started: boolean;
+  exitCode: number;
+}
+
+interface ActiveRootState {
+  cleanup: () => void;
+}
+
+let activeRoot: ActiveRootState | null = null;
+
+function debugLaunch(env: Record<string, string | undefined>, write: (chunk: string, source: string) => boolean, fields: Record<string, unknown>): void {
+  if (env.CODEXA_DEBUG_LAUNCH !== "1") {
+    return;
+  }
+
+  write(`[codexa:launch] ${JSON.stringify(fields)}\n`, "src/index.tsx:launchDebug");
+}
+
+function hasInvalidRestoreDimensions(stdout: Pick<AppStdout, "columns" | "rows">): boolean {
+  const cols = stdout.columns;
+  const rows = stdout.rows;
+  return !Number.isFinite(cols) || !Number.isFinite(rows)
+    || (cols ?? 0) < MIN_VIEWPORT_COLS || (rows ?? 0) < MIN_VIEWPORT_ROWS;
+}
+
+export function startApp({
+  stdin = process.stdin,
+  stdout = process.stdout,
+  stderr = process.stderr,
+  env = process.env,
+  platform = process.platform,
+  argv = process.argv.slice(2),
+  renderApp = render,
+  resolveInkInstanceForStdout = resolveInkInstance,
+  registerExitHandler = (handler) => {
+    process.on("exit", handler);
+  },
+}: Partial<StartAppDependencies> = {}): StartAppResult {
+  renderDebug.configureRenderDebug(env);
+
+  if (activeRoot) {
+    return { started: true, exitCode: 0 };
+  }
+
+  const terminal = createTerminalModeController((chunk) => stdout.write(chunk));
+  const writeStdout = (chunk: string, source: string): boolean => terminal.write(chunk, source);
+
+  const writeStderr = (chunk: string, source: string): boolean => {
+    return writeTerminalControl((value) => stderr.write(value), "stderr", source, chunk);
+  };
+
+  debugLaunch(env, writeStderr, {
+    phase: "startApp",
+    resolvedLaunchMode: "interactive-ui",
+    stdinIsTTY: Boolean(stdin.isTTY),
+    stdoutIsTTY: Boolean(stdout.isTTY),
+    stderrIsTTY: Boolean(stderr.isTTY),
+    TERM: env.TERM,
+    WT_SESSION: env.WT_SESSION,
+    TERM_PROGRAM: env.TERM_PROGRAM,
+    argv,
+  });
+
+  const capability = getTerminalCapability({
+    stdinIsTTY: Boolean(stdin.isTTY),
+    stdoutIsTTY: Boolean(stdout.isTTY),
+    platform,
+    env,
+  });
+
+  if (!capability.supported) {
+    writeStderr(`${capability.message}\n`, "src/index.tsx:unsupportedTerminal");
+    return { started: false, exitCode: 1 };
+  }
+  if (capability.warning) {
+    writeStderr(`${capability.warning}\n`, "src/index.tsx:terminalCapabilityWarning");
+  }
+
+  const parsedLaunchArgs = parseLaunchArgs(argv);
+  if (!parsedLaunchArgs.ok) {
+    writeStderr(`${parsedLaunchArgs.error}\n`, "src/index.tsx:launchArgs");
+    return { started: false, exitCode: 1 };
+  }
+  const launchArgs: LaunchArgs = parsedLaunchArgs.value;
+  setIntendedTerminalTitle(env.CODEXA_INITIAL_TERMINAL_TITLE ?? APP_NAME, {
+    force: true,
+    reason: "index-safe-fallback-title",
+    write: (chunk) => writeStdout(chunk, "src/index.tsx:title.fallback"),
+  });
+  const stopStartupTitleGuard = startTerminalTitleStartupGuard({
+    write: (chunk) => writeStdout(chunk, "src/index.tsx:title.startupGuard"),
+    reason: "index-startup-guard",
+    intervalMs: 150,
+    durationMs: 3500,
+  });
+
+  // Clear the screen and move cursor to home before rendering so no stale
+  // content from a previous process (e.g. bun --watch restart) ghosts above
+  // the new frame.  We stay in the normal screen buffer (no \x1b[?1049h) to
+  // preserve terminal scrollback and allow mouse text selection.
+  // NOTE: Mouse reporting (\x1b[?1000h / \x1b[?1006h) is NOT enabled here.
+  // It is managed exclusively by the React app (app.tsx) and defaults to OFF
+  // so native terminal drag-selection and copy work without any special steps.
+  traceTerminalClear("src/index.tsx:startup", { mode: "hard" });
+  writeStdout(TERMINAL_SEQUENCES.hardRepaint, "src/index.tsx:startup");
+  const startupWorkspaceRoot = resolveWorkspaceRoot();
+  const startupSettings = loadSettings();
+  const startupTitle =
+    formatTerminalTitlePath(startupWorkspaceRoot, startupSettings.ui.terminalTitleMode) || APP_NAME;
+  setIntendedTerminalTitle(startupTitle, {
+    force: true,
+    reason: "startup-title",
+    write: (chunk) => writeStdout(chunk, "src/index.tsx:startup.title"),
+  });
+  reassertIntendedTerminalTitle({
+    write: (chunk) => writeStdout(chunk, "src/index.tsx:startup.titleReady"),
+    reason: "startup-title-ready",
+  });
+  terminal.setBracketedPaste(true, "src/index.tsx:startup.bracketedPaste");
+
+  let cleanupDone = false;
+  let repaintArmed = false;
+  let renderHandle: RenderHandle | null = null;
+  let inkInstance: InkInstance | null = null;
+
+  const onResize = () => {
+    renderDebug.traceEvent("terminal", "resize", {
+      cols: stdout.columns,
+      rows: stdout.rows,
+      invalid: hasInvalidRestoreDimensions(stdout),
+    });
+
+    if (hasInvalidRestoreDimensions(stdout)) {
+      // Transient invalid dimensions (e.g. during maximize/restore on
+      // Windows). Keep the previous frame visible and let useTerminalViewport
+      // preserve the last renderable layout until valid dimensions return.
+      repaintArmed = true;
+      return;
+    }
+
+    if (repaintArmed) {
+      repaintArmed = false;
+    }
+
+    // useTerminalViewport owns resize-driven React state. Do not clear the
+    // terminal, reset Ink output caches, or force Ink renders here; those
+    // imperative paths can produce a transient empty frame during streaming.
+  };
+
+  const cleanup = () => {
+    if (cleanupDone) return;
+    cleanupDone = true;
+    stopStartupTitleGuard();
+    stdout.off("resize", onResize);
+    renderHandle?.cleanup();
+    // Restore terminal state: disable mouse reporting and bracketed paste.
+    terminal.setMouseReporting(false, "src/index.tsx:cleanup.mouse");
+    terminal.setBracketedPaste(false, "src/index.tsx:cleanup.bracketedPaste");
+    terminal.resetModes();
+    activeRoot = null;
+  };
+
+  const handleFatal = (error: unknown) => {
+    cleanup();
+    if (error instanceof Error) {
+      writeStderr(`${error.stack || error.message}\n`, "src/index.tsx:fatalError");
+    } else if (error) {
+      writeStderr(`${String(error)}\n`, "src/index.tsx:fatalUnknown");
+    }
+    process.exit(1);
+  };
+
+  const handleSignal = () => {
+    cleanup();
+    process.exit(0);
+  };
+
+  stdout.on("resize", onResize);
+  registerExitHandler(cleanup);
+
+  // Ensure clean teardown on signals and unhandled failures to prevent
+  // leaving the terminal in mouse-reporting mode.
+  process.on("SIGINT", handleSignal);
+  process.on("SIGTERM", handleSignal);
+  process.on("uncaughtException", handleFatal);
+  process.on("unhandledRejection", handleFatal);
+
+  renderHandle = renderApp(<App launchArgs={launchArgs} />, {
+    kittyKeyboard: KITTY_KEYBOARD_OPTIONS,
+  });
+
+  // Resolve the real Ink class instance to get access to lastOutput,
+  // onRender, calculateLayout, etc.  Gracefully degrades to null in tests.
+  inkInstance = resolveInkInstanceForStdout(stdout);
+
+  // Remove Ink's own resize handler so the app is the sole resize handler.
+  // This eliminates the race where Ink's resized() fires alongside our
+  // onResize, causing interleaved renders that desync logUpdate.
+  if (inkInstance?.unsubscribeResize) {
+    inkInstance.unsubscribeResize();
+  }
+
+  void renderHandle.waitUntilExit().finally(cleanup);
+
+  activeRoot = { cleanup };
+  return { started: true, exitCode: 0 };
+}
+
+const isMainModule = Boolean((import.meta as ImportMeta & { main?: boolean }).main);
+
+if (isMainModule) {
+  const result = startApp();
+  if (!result.started) {
+    process.exitCode = result.exitCode;
+  }
+}