main.tsx

#!/usr/bin/env bun

import { createCliRenderer } from "@opentui/core";
import { createRoot } from "@opentui/react";
import { formatCliError } from "./core/errors";
import {
  installJobControlInterruptSupport,
  installJobControlSuspendSupport,
  type JobControlInterruptSupport,
  type JobControlSuspendSupport,
} from "./core/jobControl";
import { pagePlainText } from "./core/pager";
import { sanitizeTerminalText } from "./lib/terminalText";
import { shutdownSession } from "./core/shutdown";
import { renderStaticDiffPager } from "./ui/staticDiffPager";
import { prepareStartupPlan } from "./core/startup";
import { shouldUseMouseForApp } from "./core/terminal";
import { resolveStartupUpdateNotice } from "./core/updateNotice";
import { AppHost } from "./ui/AppHost";
import { SessionBrokerClient } from "./session-broker/brokerClient";
import { serveSessionBrokerDaemon } from "./session-broker/brokerServer";
import {
  createInitialSessionSnapshot,
  createSessionRegistration,
} from "./hunk-session/sessionRegistration";
import type {
  HunkSessionCommandResult,
  HunkSessionInfo,
  HunkSessionServerMessage,
  HunkSessionState,
} from "./hunk-session/types";
import { runSessionCommand } from "./session/commands";

async function main() {
  const startupPlan = await prepareStartupPlan();

  if (startupPlan.kind === "help") {
    process.stdout.write(startupPlan.text);
    process.exit(0);
  }

  if (startupPlan.kind === "daemon-serve") {
    const server = serveSessionBrokerDaemon();
    await server.stopped;
    return;
  }

  if (startupPlan.kind === "session-command") {
    process.stdout.write(await runSessionCommand(startupPlan.input));
    process.exit(0);
  }

  if (startupPlan.kind === "markup-guide") {
    const { runMarkupGuideCommand } = await import("./ui/lib/stml/cli");
    process.exit(runMarkupGuideCommand({ stdout: (text) => process.stdout.write(text) }));
  }

  if (startupPlan.kind === "markup-render") {
    const { runMarkupRenderCommand } = await import("./ui/lib/stml/cli");
    process.exit(
      await runMarkupRenderCommand(startupPlan.input, {
        stdout: (text) => process.stdout.write(text),
        stderr: (text) => process.stderr.write(text),
        stdoutIsTTY: Boolean(process.stdout.isTTY),
        readStdinText: () => new Response(Bun.stdin.stream()).text(),
      }),
    );
  }

  if (startupPlan.kind === "plain-text-pager") {
    await pagePlainText(startupPlan.text);
    process.exit(0);
  }

  if (startupPlan.kind === "passthrough") {
    process.stdout.write(sanitizeTerminalText(startupPlan.text));
    process.exit(0);
  }

  if (startupPlan.kind === "static-diff-pager") {
    process.stdout.write(
      await renderStaticDiffPager(startupPlan.text, startupPlan.options, {
        customTheme: startupPlan.customTheme,
        stderr: process.stderr,
      }),
    );
    process.exit(0);
  }

  if (startupPlan.kind !== "app") {
    throw new Error("Unreachable startup plan.");
  }

  const { bootstrap, controllingTerminal } = startupPlan;
  const hostClient = new SessionBrokerClient<
    HunkSessionInfo,
    HunkSessionState,
    HunkSessionServerMessage,
    HunkSessionCommandResult
  >(createSessionRegistration(bootstrap), createInitialSessionSnapshot(bootstrap));
  hostClient.start();

  const renderer = await createCliRenderer({
    stdin: controllingTerminal?.stdin,
    stdout: process.stdout,
    useMouse: shouldUseMouseForApp({
      hasControllingTerminal: Boolean(controllingTerminal),
    }),
    screenMode: "alternate-screen",
    useThread: false,
    exitOnCtrlC: false,
    openConsoleOnError: true,
    onDestroy: () => controllingTerminal?.close(),
  });

  const appRenderer = renderer;
  const root = createRoot(appRenderer);
  const shutdownSignals: NodeJS.Signals[] = ["SIGINT", "SIGTERM"];
  let shuttingDown = false;
  let jobControlSuspendSupport: JobControlSuspendSupport = { dispose: () => undefined };
  let jobControlInterruptSupport: JobControlInterruptSupport = { dispose: () => undefined };

  /** Tear down the renderer before exit so the primary terminal screen comes back cleanly. */
  function shutdown() {
    if (shuttingDown) {
      return;
    }

    shuttingDown = true;
    for (const signal of shutdownSignals) {
      process.off(signal, shutdown);
    }
    jobControlInterruptSupport.dispose();
    jobControlSuspendSupport.dispose();
    hostClient.stop();
    shutdownSession({ root, renderer: appRenderer });
  }

  for (const signal of shutdownSignals) {
    process.once(signal, shutdown);
  }
  jobControlInterruptSupport = installJobControlInterruptSupport(appRenderer, shutdown);
  jobControlSuspendSupport = installJobControlSuspendSupport(appRenderer);

  // The app owns the full alternate screen session from this point on.
  root.render(
    <AppHost
      bootstrap={bootstrap}
      hostClient={hostClient}
      onQuit={shutdown}
      startupNoticeResolver={resolveStartupUpdateNotice}
    />,
  );
}

await main().catch((error) => {
  process.stderr.write(formatCliError(error));
  process.exit(1);
});