@docyrus/docyrus 0.0.3 → 0.0.5

package/tui.mjs

@@ -0,0 +1,1073 @@
+// src/tui/opentuiMain.tsx
+import { createCliRenderer } from "@opentui/core";
+import { createRoot } from "@opentui/react";
+
+// src/tui/opentui/DocyrusOpenTuiApp.tsx
+import { useKeyboard as useKeyboard2, useRenderer } from "@opentui/react";
+import { useCallback as useCallback2, useEffect, useMemo, useState as useState2 } from "react";
+
+// src/services/tuiProcessExecutor.ts
+import { spawnSync } from "node:child_process";
+
+// src/errors.ts
+var ApplicationError = class extends Error {
+  constructor(message, data = {}, httpStatusCode = 500) {
+    super(message);
+    this.data = data;
+    this.httpStatusCode = httpStatusCode;
+  }
+};
+var UserInputError = class extends ApplicationError {
+  constructor(message, data = {}) {
+    super(message, data, 400);
+  }
+};
+
+// src/services/tuiProcessExecutor.ts
+function normalizeCommandArg(arg) {
+  return arg.trim();
+}
+function sanitizeTuiCommandArgs(args) {
+  const normalized = args.map(normalizeCommandArg).filter((value) => value.length > 0);
+  const withoutBinary = normalized[0] === "docyrus" ? normalized.slice(1) : normalized;
+  const withoutJson = withoutBinary.filter((value) => value !== "--json");
+  const firstArg = withoutJson[0];
+  if (firstArg === "tui" || firstArg === "interactive") {
+    throw new UserInputError("Already in TUI session.");
+  }
+  return withoutJson;
+}
+function parseJsonOutput(rawOutput) {
+  const trimmedOutput = rawOutput.trim();
+  if (!trimmedOutput) {
+    throw new UserInputError("Command produced no output.");
+  }
+  const lines = trimmedOutput.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  const lastLine = lines.at(-1);
+  if (lastLine) {
+    try {
+      return {
+        data: JSON.parse(lastLine),
+        messages: lines.slice(0, -1)
+      };
+    } catch {
+    }
+  }
+  try {
+    return {
+      data: JSON.parse(trimmedOutput),
+      messages: []
+    };
+  } catch (error) {
+    throw new UserInputError("Invalid command output format. Expected JSON output.", {
+      cause: error,
+      rawOutput: trimmedOutput
+    });
+  }
+}
+function toErrorMessage(error) {
+  if (error instanceof Error && error.message.trim().length > 0) {
+    return error.message;
+  }
+  return "Failed to execute command.";
+}
+function createTuiProcessExecutor(options) {
+  const spawnCommand = options.spawnSyncFn ?? spawnSync;
+  const now = options.now ?? Date.now;
+  const runCliCommand = async (args) => {
+    const startedAt = now();
+    let commandArgs = [];
+    let commandLabel = "";
+    let rawOutput = "";
+    let messageLines = [];
+    try {
+      commandArgs = sanitizeTuiCommandArgs(args);
+      commandLabel = commandArgs.join(" ").trim();
+      const spawnResult = spawnCommand(
+        options.executionConfig.executable,
+        [
+          options.executionConfig.scriptPath,
+          ...commandArgs,
+          "--json"
+        ],
+        {
+          encoding: "utf8",
+          cwd: options.executionConfig.cwd,
+          env: {
+            ...process.env,
+            ...options.executionConfig.env || {}
+          }
+        }
+      );
+      const stdout = spawnResult.stdout?.toString() || "";
+      const stderr = spawnResult.stderr?.toString() || "";
+      rawOutput = stdout.trim();
+      if (spawnResult.error) {
+        throw spawnResult.error;
+      }
+      if (spawnResult.status !== 0) {
+        const details = [rawOutput, stderr.trim()].filter((line) => line.length > 0).join("\n");
+        return {
+          ok: false,
+          command: commandLabel,
+          rawOutput: details,
+          error: {
+            message: stderr.trim() || `Command exited with code ${spawnResult.status ?? "unknown"}.`,
+            details: details || void 0
+          },
+          durationMs: now() - startedAt
+        };
+      }
+      const parsed = parseJsonOutput(stdout);
+      messageLines = parsed.messages;
+      return {
+        ok: true,
+        command: commandLabel,
+        rawOutput,
+        data: parsed.data,
+        durationMs: now() - startedAt,
+        messages: messageLines.length > 0 ? messageLines : void 0
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        command: commandLabel,
+        rawOutput,
+        error: {
+          message: toErrorMessage(error),
+          details: rawOutput || void 0
+        },
+        durationMs: now() - startedAt,
+        messages: messageLines.length > 0 ? messageLines : void 0
+      };
+    }
+  };
+  return {
+    runCliCommand
+  };
+}
+
+// src/tui/opentui/commandInput.ts
+import { useKeyboard } from "@opentui/react";
+import { useCallback, useState } from "react";
+function parseCommandLine(command) {
+  const args = [];
+  let current = "";
+  let quote = null;
+  let escaped = false;
+  for (const char of command) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        args.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (quote) {
+    throw new Error("Invalid command syntax: unmatched quote.");
+  }
+  if (escaped) {
+    current += "\\";
+  }
+  if (current.length > 0) {
+    args.push(current);
+  }
+  return args;
+}
+function preventDefault(event) {
+  if (typeof event.preventDefault === "function") {
+    event.preventDefault();
+  }
+}
+function resolveSectionJumpKey(keyName, shift) {
+  if (keyName === "s") {
+    return "shortcuts";
+  }
+  if (keyName === "h") {
+    return "history";
+  }
+  if (keyName === "m") {
+    return "messages";
+  }
+  if (keyName === "?" || keyName === "/" && shift) {
+    return "help";
+  }
+  return null;
+}
+function useCommandInput(options) {
+  const [history, setHistory] = useState([]);
+  const [historyCursor, setHistoryCursor] = useState(null);
+  const [draftInput, setDraftInput] = useState("");
+  const submitInput = useCallback((value) => {
+    if (options.busy) {
+      return;
+    }
+    const trimmed = (value ?? options.input).trim();
+    if (trimmed.length === 0) {
+      return;
+    }
+    setHistory((previous) => {
+      if (previous[0] === trimmed) {
+        return previous;
+      }
+      return [trimmed, ...previous];
+    });
+    setHistoryCursor(null);
+    setDraftInput("");
+    options.setInput("");
+    options.onSubmit(trimmed);
+  }, [options]);
+  const recallHistory = useCallback((direction) => {
+    if (history.length === 0) {
+      return;
+    }
+    if (direction === "up") {
+      if (historyCursor === null) {
+        setDraftInput(options.input);
+        setHistoryCursor(0);
+        options.setInput(history[0] || "");
+        return;
+      }
+      const nextCursor2 = Math.min(historyCursor + 1, history.length - 1);
+      setHistoryCursor(nextCursor2);
+      options.setInput(history[nextCursor2] || "");
+      return;
+    }
+    if (historyCursor === null) {
+      return;
+    }
+    const nextCursor = historyCursor - 1;
+    if (nextCursor < 0) {
+      setHistoryCursor(null);
+      options.setInput(draftInput);
+      return;
+    }
+    setHistoryCursor(nextCursor);
+    options.setInput(history[nextCursor] || "");
+  }, [draftInput, history, historyCursor, options]);
+  useKeyboard((keyEvent) => {
+    if (options.isModalOpen) {
+      return;
+    }
+    const keyName = keyEvent.name;
+    if (keyEvent.ctrl && keyName === "l") {
+      preventDefault(keyEvent);
+      options.onClear();
+      return;
+    }
+    if (keyName === "tab") {
+      preventDefault(keyEvent);
+      if (keyEvent.shift) {
+        options.onPreviousSection();
+        return;
+      }
+      options.onNextSection();
+      return;
+    }
+    if (keyName === "[") {
+      preventDefault(keyEvent);
+      options.onPreviousSection();
+      return;
+    }
+    if (keyName === "]") {
+      preventDefault(keyEvent);
+      options.onNextSection();
+      return;
+    }
+    if (options.isInputFocused && keyName === "up") {
+      preventDefault(keyEvent);
+      recallHistory("up");
+      return;
+    }
+    if (options.isInputFocused && keyName === "down") {
+      preventDefault(keyEvent);
+      recallHistory("down");
+      return;
+    }
+    if (options.input.length === 0) {
+      const jumpSection = resolveSectionJumpKey(keyName, Boolean(keyEvent.shift));
+      if (jumpSection) {
+        preventDefault(keyEvent);
+        options.onJumpSection(jumpSection);
+        return;
+      }
+    }
+    if (options.busy) {
+      return;
+    }
+    if (options.input.length === 0 && /^[1-6]$/.test(keyName)) {
+      preventDefault(keyEvent);
+      options.onShortcut(Number(keyName));
+    }
+  });
+  return {
+    submitInput
+  };
+}
+
+// src/tui/opentui/renderResult.tsx
+import { RGBA, SyntaxStyle } from "@opentui/core";
+
+// src/tui/opentui/resultDocument.ts
+function toErrorPayload(entry) {
+  return {
+    message: entry.result.error?.message || "Command failed.",
+    details: entry.result.error?.details
+  };
+}
+function buildPayload(entry) {
+  if (entry.result.ok) {
+    return entry.result.data ?? null;
+  }
+  return toErrorPayload(entry);
+}
+function buildResultDocument(entry) {
+  return {
+    command: entry.command || "(root)",
+    ok: entry.result.ok,
+    durationMs: entry.result.durationMs,
+    timestamp: new Date(entry.createdAt).toISOString(),
+    payload: buildPayload(entry),
+    messages: entry.result.messages,
+    rawOutput: entry.result.rawOutput || void 0
+  };
+}
+function serializeResultDocument(document) {
+  try {
+    const result = JSON.stringify(document, null, 2);
+    if (!result) {
+      return "null";
+    }
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return JSON.stringify({
+      command: document.command,
+      ok: false,
+      durationMs: document.durationMs,
+      timestamp: document.timestamp,
+      payload: {
+        message: "Serialization failed",
+        details: message
+      }
+    }, null, 2);
+  }
+}
+
+// src/tui/opentui/renderResult.tsx
+import { jsx, jsxs } from "@opentui/react/jsx-runtime";
+var jsonSyntaxStyle = null;
+function getJsonSyntaxStyle() {
+  if (jsonSyntaxStyle) {
+    return jsonSyntaxStyle;
+  }
+  jsonSyntaxStyle = SyntaxStyle.fromStyles({
+    default: {
+      fg: RGBA.fromHex("#d4d4d4")
+    },
+    property: {
+      fg: RGBA.fromHex("#9cdcfe")
+    },
+    string: {
+      fg: RGBA.fromHex("#ce9178")
+    },
+    number: {
+      fg: RGBA.fromHex("#b5cea8")
+    },
+    keyword: {
+      fg: RGBA.fromHex("#569cd6")
+    },
+    constant: {
+      fg: RGBA.fromHex("#4fc1ff")
+    },
+    punctuation: {
+      fg: RGBA.fromHex("#c586c0")
+    },
+    operator: {
+      fg: RGBA.fromHex("#d4d4d4")
+    }
+  });
+  return jsonSyntaxStyle;
+}
+function renderResult(params) {
+  const {
+    entry,
+    isFocused
+  } = params;
+  if (!entry) {
+    return /* @__PURE__ */ jsx("text", { fg: "yellow", children: "No command executed yet." });
+  }
+  const document = buildResultDocument(entry);
+  const json = serializeResultDocument(document);
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "column", width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx("box", { paddingBottom: 1, children: /* @__PURE__ */ jsxs("text", { fg: document.ok ? "green" : "red", children: [
+      document.ok ? "OK" : "ERR",
+      " ",
+      document.command,
+      " [",
+      document.durationMs,
+      "ms]"
+    ] }) }),
+    /* @__PURE__ */ jsx("box", { flexGrow: 1, width: "100%", height: "100%", children: /* @__PURE__ */ jsx("scrollbox", { focused: isFocused, style: { height: "100%" }, children: /* @__PURE__ */ jsx(
+      "code",
+      {
+        width: "100%",
+        content: json,
+        filetype: "json",
+        syntaxStyle: getJsonSyntaxStyle(),
+        streaming: false,
+        conceal: false
+      }
+    ) }) })
+  ] });
+}
+
+// src/tui/opentui/DocyrusOpenTuiApp.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "@opentui/react/jsx-runtime";
+var SHORTCUTS = [
+  {
+    id: 1,
+    run: "env list",
+    label: "env list"
+  },
+  {
+    id: 2,
+    run: "auth who",
+    label: "auth who"
+  },
+  {
+    id: 3,
+    run: "apps list",
+    label: "apps list"
+  },
+  {
+    id: 4,
+    run: "discover namespaces",
+    label: "discover namespaces"
+  },
+  {
+    id: 5,
+    template: "studio list-data-sources --appSlug ",
+    label: "insert: studio list-data-sources --appSlug "
+  },
+  {
+    id: 6,
+    template: "ds list <appSlug> <dataSourceSlug>",
+    label: "insert: ds list <appSlug> <dataSourceSlug>"
+  }
+];
+var SECTION_ORDER = ["shortcuts", "history", "messages", "help"];
+var FOCUS_ORDER = ["input", "left", "result"];
+var ESC_ARM_TIMEOUT_MS = 1400;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractMetadata(payload) {
+  if (!isRecord(payload)) {
+    return {};
+  }
+  const environmentValue = payload.environment;
+  const contextValue = payload.context;
+  const environment = isRecord(environmentValue) && typeof environmentValue.id === "string" && typeof environmentValue.name === "string" ? { id: environmentValue.id, name: environmentValue.name } : void 0;
+  if (contextValue === null) {
+    return {
+      environment,
+      context: null
+    };
+  }
+  const context = isRecord(contextValue) && typeof contextValue.email === "string" && typeof contextValue.tenantDisplay === "string" ? {
+    email: contextValue.email,
+    tenantDisplay: contextValue.tenantDisplay
+  } : void 0;
+  return {
+    environment,
+    context
+  };
+}
+function toFailedResult(error, command) {
+  const message = error instanceof Error ? error.message : "Invalid command syntax.";
+  return {
+    ok: false,
+    command,
+    rawOutput: "",
+    error: {
+      message
+    },
+    durationMs: 0
+  };
+}
+function formatHistoryLabel(entry) {
+  const status = entry.result.ok ? "OK" : "ERR";
+  const command = entry.command || "(root)";
+  return `${status} ${command} [${entry.result.durationMs}ms]`;
+}
+function preventDefault2(keyEvent) {
+  if (typeof keyEvent.preventDefault === "function") {
+    keyEvent.preventDefault();
+  }
+}
+function isEscapeKey(keyName) {
+  return keyName === "escape" || keyName === "esc";
+}
+function isEnterKey(keyName) {
+  return keyName === "enter" || keyName === "return";
+}
+function DocyrusOpenTuiApp(props) {
+  const renderer = useRenderer();
+  const [input, setInput] = useState2("");
+  const [entries, setEntries] = useState2([]);
+  const [activeEntryId, setActiveEntryId] = useState2(null);
+  const [systemMessages, setSystemMessages] = useState2([]);
+  const [activeSection, setActiveSection] = useState2("shortcuts");
+  const [focusedPanel, setFocusedPanel] = useState2("left");
+  const [environment, setEnvironment] = useState2();
+  const [context, setContext] = useState2(void 0);
+  const [isRunning, setIsRunning] = useState2(false);
+  const [spinnerFrame, setSpinnerFrame] = useState2(0);
+  const [selectedShortcutIndex, setSelectedShortcutIndex] = useState2(0);
+  const [selectedHistoryIndex, setSelectedHistoryIndex] = useState2(0);
+  const [isExitConfirmOpen, setIsExitConfirmOpen] = useState2(false);
+  const [isEscArmed, setIsEscArmed] = useState2(false);
+  const executor = useMemo(() => {
+    return createTuiProcessExecutor({
+      executionConfig: props.executionConfig
+    });
+  }, [props.executionConfig]);
+  const applyCommandResult = useCallback2((result, command) => {
+    const entry = {
+      id: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+      command,
+      result,
+      createdAt: Date.now()
+    };
+    setEntries((previous) => [entry, ...previous]);
+    setActiveEntryId(entry.id);
+    setSelectedHistoryIndex(0);
+    if (result.messages && result.messages.length > 0) {
+      setSystemMessages((previous) => [...previous, ...result.messages || []]);
+    }
+    if (result.ok && result.data !== void 0) {
+      const metadata = extractMetadata(result.data);
+      if (metadata.environment) {
+        setEnvironment(metadata.environment);
+      }
+      if (metadata.context !== void 0) {
+        setContext(metadata.context);
+      }
+    }
+  }, []);
+  const executeArgs = useCallback2(async (args, commandText) => {
+    setIsRunning(true);
+    try {
+      const result = await executor.runCliCommand(args);
+      applyCommandResult(result, commandText);
+    } finally {
+      setIsRunning(false);
+    }
+  }, [applyCommandResult, executor]);
+  const executeLine = useCallback2((line) => {
+    let args;
+    try {
+      args = parseCommandLine(line);
+    } catch (error) {
+      applyCommandResult(toFailedResult(error, line.trim()), line.trim());
+      return;
+    }
+    if (args.length === 0) {
+      return;
+    }
+    void executeArgs(args, line.trim());
+  }, [applyCommandResult, executeArgs]);
+  const runHistoryEntry = useCallback2(async (entry) => {
+    if (entry.command === "(root)") {
+      await executeArgs([], "(root)");
+      return;
+    }
+    try {
+      const args = parseCommandLine(entry.command);
+      await executeArgs(args, entry.command);
+    } catch (error) {
+      applyCommandResult(toFailedResult(error, entry.command), entry.command);
+    }
+  }, [applyCommandResult, executeArgs]);
+  const applyShortcut = useCallback2((shortcutId) => {
+    const action = SHORTCUTS.find((shortcut) => shortcut.id === shortcutId);
+    if (!action || isRunning) {
+      return;
+    }
+    if (action.template) {
+      setInput(action.template);
+      setFocusedPanel("input");
+      return;
+    }
+    if (action.run) {
+      void executeArgs(parseCommandLine(action.run), action.run);
+    }
+  }, [executeArgs, isRunning]);
+  const setSectionByIndex = useCallback2((index) => {
+    const safeIndex = index < 0 ? SECTION_ORDER.length - 1 : index >= SECTION_ORDER.length ? 0 : index;
+    const section = SECTION_ORDER[safeIndex];
+    if (section) {
+      setActiveSection(section);
+    }
+  }, []);
+  const nextSection = useCallback2(() => {
+    const currentIndex = SECTION_ORDER.indexOf(activeSection);
+    setSectionByIndex(currentIndex + 1);
+  }, [activeSection, setSectionByIndex]);
+  const previousSection = useCallback2(() => {
+    const currentIndex = SECTION_ORDER.indexOf(activeSection);
+    setSectionByIndex(currentIndex - 1);
+  }, [activeSection, setSectionByIndex]);
+  const setPanelByIndex = useCallback2((index) => {
+    const safeIndex = index < 0 ? FOCUS_ORDER.length - 1 : index >= FOCUS_ORDER.length ? 0 : index;
+    const panel = FOCUS_ORDER[safeIndex];
+    if (panel) {
+      setFocusedPanel(panel);
+    }
+  }, []);
+  const nextPanel = useCallback2(() => {
+    const currentIndex = FOCUS_ORDER.indexOf(focusedPanel);
+    setPanelByIndex(currentIndex + 1);
+  }, [focusedPanel, setPanelByIndex]);
+  const previousPanel = useCallback2(() => {
+    const currentIndex = FOCUS_ORDER.indexOf(focusedPanel);
+    setPanelByIndex(currentIndex - 1);
+  }, [focusedPanel, setPanelByIndex]);
+  const openExitConfirmation = useCallback2(() => {
+    setIsEscArmed(false);
+    setIsExitConfirmOpen(true);
+  }, []);
+  const closeExitConfirmation = useCallback2(() => {
+    setIsExitConfirmOpen(false);
+    setIsEscArmed(false);
+  }, []);
+  const armEscapeExit = useCallback2(() => {
+    setIsEscArmed(true);
+    setSystemMessages((previous) => {
+      const lastMessage = previous[previous.length - 1];
+      const message = "Press Esc again to open exit confirmation.";
+      if (lastMessage === message) {
+        return previous;
+      }
+      return [...previous, message];
+    });
+  }, []);
+  const { submitInput } = useCommandInput({
+    busy: isRunning,
+    input,
+    isInputFocused: focusedPanel === "input",
+    isModalOpen: isExitConfirmOpen,
+    setInput,
+    onSubmit: executeLine,
+    onClear: () => {
+      setEntries([]);
+      setActiveEntryId(null);
+      setSystemMessages([]);
+      setSelectedHistoryIndex(0);
+    },
+    onShortcut: applyShortcut,
+    onNextSection: nextSection,
+    onPreviousSection: previousSection,
+    onJumpSection: (section) => {
+      setActiveSection(section);
+      setFocusedPanel("left");
+    }
+  });
+  useKeyboard2((keyEvent) => {
+    const keyName = keyEvent.name;
+    if (isExitConfirmOpen) {
+      if (isEscapeKey(keyName)) {
+        preventDefault2(keyEvent);
+        closeExitConfirmation();
+        return;
+      }
+      if (isEnterKey(keyName)) {
+        preventDefault2(keyEvent);
+        renderer.destroy();
+        return;
+      }
+      if (keyEvent.ctrl && keyName === "c") {
+        renderer.destroy();
+      }
+      return;
+    }
+    if (keyEvent.ctrl && keyName === "c") {
+      renderer.destroy();
+      return;
+    }
+    if (isEscapeKey(keyName)) {
+      preventDefault2(keyEvent);
+      if (focusedPanel !== "input") {
+        setFocusedPanel("input");
+        armEscapeExit();
+        return;
+      }
+      if (!isEscArmed) {
+        armEscapeExit();
+        return;
+      }
+      openExitConfirmation();
+      return;
+    }
+    if (keyName === "left" || keyName === "right") {
+      if (focusedPanel === "input" && input.length > 0) {
+        return;
+      }
+      preventDefault2(keyEvent);
+      setIsEscArmed(false);
+      if (keyName === "left") {
+        previousPanel();
+      } else {
+        nextPanel();
+      }
+      return;
+    }
+    if (keyName === "r" && activeSection === "history" && focusedPanel === "left" && input.length === 0 && !isRunning) {
+      const entry = entries[selectedHistoryIndex];
+      if (entry) {
+        void runHistoryEntry(entry);
+      }
+    }
+  });
+  useEffect(() => {
+    void executeArgs([], "(root)");
+  }, [executeArgs]);
+  useEffect(() => {
+    if (!isEscArmed) {
+      return;
+    }
+    const timer = setTimeout(() => {
+      setIsEscArmed(false);
+    }, ESC_ARM_TIMEOUT_MS);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [isEscArmed]);
+  useEffect(() => {
+    if (!isRunning) {
+      return;
+    }
+    const timer = setInterval(() => {
+      setSpinnerFrame((previous) => (previous + 1) % 4);
+    }, 120);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [isRunning]);
+  useEffect(() => {
+    if (selectedHistoryIndex < entries.length) {
+      return;
+    }
+    const nextIndex = Math.max(entries.length - 1, 0);
+    setSelectedHistoryIndex(nextIndex);
+  }, [entries.length, selectedHistoryIndex]);
+  const spinner = useMemo(() => {
+    return ["|", "/", "-", "\\"][spinnerFrame] || "|";
+  }, [spinnerFrame]);
+  const activeEntry = useMemo(() => {
+    if (activeEntryId) {
+      const found = entries.find((entry) => entry.id === activeEntryId);
+      if (found) {
+        return found;
+      }
+    }
+    return entries[0] || null;
+  }, [activeEntryId, entries]);
+  const sectionOptions = useMemo(() => {
+    const ordered = [
+      activeSection,
+      ...SECTION_ORDER.filter((section) => section !== activeSection)
+    ];
+    return ordered.map((section) => ({
+      name: section === "shortcuts" ? "Shortcuts" : section === "history" ? "History" : section === "messages" ? "Messages" : "Help",
+      description: section === "shortcuts" ? "Quick actions" : section === "history" ? "Past runs" : section === "messages" ? "System output" : "Key map",
+      value: section
+    }));
+  }, [activeSection]);
+  const shortcutOptions = useMemo(() => {
+    return SHORTCUTS.map((shortcut) => ({
+      name: `${shortcut.id}. ${shortcut.label}`,
+      description: shortcut.run || shortcut.template || "",
+      value: shortcut.id
+    }));
+  }, []);
+  const historyOptions = useMemo(() => {
+    return entries.map((entry) => ({
+      name: formatHistoryLabel(entry),
+      description: new Date(entry.createdAt).toLocaleTimeString(),
+      value: entry.id
+    }));
+  }, [entries]);
+  const renderLeftSection = () => {
+    if (activeSection === "shortcuts") {
+      return /* @__PURE__ */ jsx2(
+        "select",
+        {
+          focused: focusedPanel === "left" && !isExitConfirmOpen,
+          options: shortcutOptions,
+          selectedIndex: selectedShortcutIndex,
+          onChange: (index) => {
+            setSelectedShortcutIndex(index);
+          },
+          onSelect: (index, option) => {
+            setSelectedShortcutIndex(index);
+            const shortcutId = Number(option?.value || 0);
+            if (Number.isFinite(shortcutId) && shortcutId > 0) {
+              applyShortcut(shortcutId);
+            }
+          },
+          showScrollIndicator: true,
+          style: {
+            flexGrow: 1
+          }
+        }
+      );
+    }
+    if (activeSection === "history") {
+      if (entries.length === 0) {
+        return /* @__PURE__ */ jsx2("text", { fg: "gray", children: "No command history yet." });
+      }
+      return /* @__PURE__ */ jsxs2("box", { flexDirection: "column", flexGrow: 1, children: [
+        /* @__PURE__ */ jsx2("text", { fg: "cyan", children: "Press `r` to re-run selected command." }),
+        /* @__PURE__ */ jsx2(
+          "select",
+          {
+            focused: focusedPanel === "left" && !isExitConfirmOpen,
+            options: historyOptions,
+            selectedIndex: selectedHistoryIndex,
+            onChange: (index, option) => {
+              setSelectedHistoryIndex(index);
+              if (typeof option?.value === "string") {
+                setActiveEntryId(option.value);
+              }
+            },
+            onSelect: (index, option) => {
+              setSelectedHistoryIndex(index);
+              if (typeof option?.value === "string") {
+                setActiveEntryId(option.value);
+              }
+            },
+            showScrollIndicator: true,
+            style: {
+              flexGrow: 1
+            }
+          }
+        )
+      ] });
+    }
+    if (activeSection === "messages") {
+      return /* @__PURE__ */ jsxs2("scrollbox", { focused: focusedPanel === "left" && !isExitConfirmOpen, style: { height: "100%" }, children: [
+        systemMessages.length === 0 && /* @__PURE__ */ jsx2("text", { fg: "gray", children: "No messages yet." }),
+        systemMessages.map((line, index) => /* @__PURE__ */ jsx2("text", { children: line }, `message-${index}`))
+      ] });
+    }
+    return /* @__PURE__ */ jsxs2("scrollbox", { focused: focusedPanel === "left" && !isExitConfirmOpen, style: { height: "100%" }, children: [
+      /* @__PURE__ */ jsx2("text", { fg: "cyan", children: "Key Bindings" }),
+      /* @__PURE__ */ jsx2("text", { children: "Left/Right: switch focused panel" }),
+      /* @__PURE__ */ jsx2("text", { children: "Up/Down in left lists: selection" }),
+      /* @__PURE__ */ jsx2("text", { children: "Up/Down in result: scroll" }),
+      /* @__PURE__ */ jsx2("text", { children: "Enter: run command" }),
+      /* @__PURE__ */ jsx2("text", { children: "Up/Down in input: command history" }),
+      /* @__PURE__ */ jsx2("text", { children: "Tab / Shift+Tab: next/prev left section" }),
+      /* @__PURE__ */ jsx2("text", { children: "[ / ]: next/prev left section" }),
+      /* @__PURE__ */ jsx2("text", { children: "s/h/m/?: jump to section" }),
+      /* @__PURE__ */ jsx2("text", { children: "1..6: run shortcut" }),
+      /* @__PURE__ */ jsx2("text", { children: "Ctrl+L: clear command and message history" }),
+      /* @__PURE__ */ jsx2("text", { children: "Esc (other panel): focus command input" }),
+      /* @__PURE__ */ jsx2("text", { children: "Esc then Esc: open exit confirmation" }),
+      /* @__PURE__ */ jsx2("text", { children: "Enter (confirm): exit, Esc (confirm): cancel" }),
+      /* @__PURE__ */ jsx2("text", { children: "Ctrl+C: force quit" })
+    ] });
+  };
+  return /* @__PURE__ */ jsxs2("box", { flexDirection: "column", width: "100%", height: "100%", padding: 1, children: [
+    /* @__PURE__ */ jsxs2("box", { flexDirection: "row", justifyContent: "space-between", marginBottom: 1, paddingX: 1, children: [
+      /* @__PURE__ */ jsx2("ascii-font", { text: "DOCYRUS", font: "tiny", color: "#7aa2f7" }),
+      /* @__PURE__ */ jsxs2("box", { flexDirection: "column", alignItems: "flex-end", justifyContent: "center", children: [
+        /* @__PURE__ */ jsxs2("text", { children: [
+          "env: ",
+          environment ? `${environment.name} (${environment.id})` : "unknown"
+        ] }),
+        /* @__PURE__ */ jsxs2("text", { children: [
+          "status: ",
+          isRunning ? `${spinner} running` : "idle"
+        ] }),
+        /* @__PURE__ */ jsxs2("text", { children: [
+          "account: ",
+          context ? context.email : "not-authenticated"
+        ] }),
+        /* @__PURE__ */ jsxs2("text", { children: [
+          "tenant: ",
+          context ? context.tenantDisplay : "-"
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs2("box", { flexDirection: "row", flexGrow: 1, children: [
+      /* @__PURE__ */ jsxs2(
+        "box",
+        {
+          width: 46,
+          marginRight: 1,
+          border: true,
+          borderStyle: "rounded",
+          borderColor: focusedPanel === "left" ? "#7aa2f7" : "#3b4261",
+          padding: 1,
+          flexDirection: "column",
+          children: [
+            /* @__PURE__ */ jsx2(
+              "tab-select",
+              {
+                options: sectionOptions,
+                onChange: (_index, option) => {
+                  if (typeof option?.value === "string") {
+                    setActiveSection(option.value);
+                  }
+                }
+              }
+            ),
+            /* @__PURE__ */ jsx2("box", { marginTop: 1, flexGrow: 1, border: true, borderStyle: "single", borderColor: "#414868", padding: 1, children: renderLeftSection() })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        "box",
+        {
+          border: true,
+          borderStyle: "double",
+          borderColor: focusedPanel === "result" ? "#9ece6a" : "#3b4261",
+          padding: 1,
+          flexGrow: 1,
+          children: renderResult({
+            entry: activeEntry,
+            isFocused: focusedPanel === "result" && !isExitConfirmOpen
+          })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs2(
+      "box",
+      {
+        border: true,
+        borderStyle: "rounded",
+        borderColor: focusedPanel === "input" ? "#e0af68" : "#3b4261",
+        padding: 1,
+        marginTop: 1,
+        children: [
+          /* @__PURE__ */ jsx2("text", { fg: "cyan", children: "> " }),
+          /* @__PURE__ */ jsx2(
+            "input",
+            {
+              style: { flexGrow: 1 },
+              value: input,
+              placeholder: "Type a command...",
+              onChange: (value) => {
+                setInput(value);
+              },
+              onSubmit: (value) => {
+                submitInput(typeof value === "string" ? value : void 0);
+              },
+              focused: !isRunning && focusedPanel === "input" && !isExitConfirmOpen
+            }
+          )
+        ]
+      }
+    ),
+    isExitConfirmOpen && /* @__PURE__ */ jsx2(
+      "box",
+      {
+        style: {
+          position: "absolute",
+          top: 0,
+          left: 0,
+          width: "100%",
+          height: "100%"
+        },
+        alignItems: "center",
+        justifyContent: "center",
+        children: /* @__PURE__ */ jsxs2(
+          "box",
+          {
+            width: 58,
+            padding: 1,
+            border: true,
+            borderStyle: "double",
+            borderColor: "#f7768e",
+            flexDirection: "column",
+            style: {
+              backgroundColor: "#1f2335"
+            },
+            children: [
+              /* @__PURE__ */ jsx2("text", { fg: "#f7768e", children: "Exit Docyrus TUI?" }),
+              /* @__PURE__ */ jsx2("text", { children: "Press Enter to exit." }),
+              /* @__PURE__ */ jsx2("text", { children: "Press Esc to stay in this session." })
+            ]
+          }
+        )
+      }
+    )
+  ] });
+}
+
+// src/tui/opentuiMain.tsx
+import { jsx as jsx3 } from "@opentui/react/jsx-runtime";
+function readRequiredEnv(name) {
+  const value = process.env[name];
+  if (!value || value.trim().length === 0) {
+    throw new Error(`Missing required launch variable: ${name}`);
+  }
+  return value;
+}
+function readLaunchConfig() {
+  return {
+    version: process.env.DOCYRUS_TUI_VERSION || "dev",
+    executionConfig: {
+      executable: readRequiredEnv("DOCYRUS_TUI_EXECUTABLE"),
+      scriptPath: readRequiredEnv("DOCYRUS_TUI_SCRIPT")
+    }
+  };
+}
+async function startTui() {
+  const launchConfig = readLaunchConfig();
+  const renderer = await createCliRenderer({
+    exitOnCtrlC: false
+  });
+  const root = createRoot(renderer);
+  root.render(
+    /* @__PURE__ */ jsx3(
+      DocyrusOpenTuiApp,
+      {
+        executionConfig: launchConfig.executionConfig,
+        version: launchConfig.version
+      }
+    )
+  );
+}
+void startTui().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Failed to start Docyrus OpenTUI: ${message}`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=tui.mjs.map