@poncho-ai/cli 0.2.0

package/dist/run-interactive-ink-PLLZW6BV.js

@@ -0,0 +1,678 @@
+// src/run-interactive-ink.ts
+import { access, mkdir, readFile, writeFile } from "fs/promises";
+import { resolve } from "path";
+import { render } from "ink";
+import { createElement } from "react";
+import { parseAgentFile } from "@agentl/harness";
+
+// src/interactive-ink.tsx
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var FAUX_TOOL_LOG_PATTERN = /Tool Used:|Tool Result:|\blist_skills\b|\bcreate_skill\b|\bedit_skill\b/i;
+var MAX_PERSISTED_LINES = 500;
+var MAX_PERSISTED_TIMELINE = 200;
+var STREAM_FLUSH_MS = 33;
+var INPUT_FLUSH_MS = 33;
+var CONTROL_SEQUENCE_PATTERN = /[\u0000-\u001f\u007f\u001b]/;
+var MOUSE_SEQUENCE_FRAGMENT_PATTERN = /^\[?<\d+(;\d+){0,2}[mM]?$/;
+var formatDuration = (ms) => ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+var randomId = () => `${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
+var colorForKind = (kind) => {
+  if (kind === "user") return "cyan";
+  if (kind === "assistant") return "green";
+  if (kind === "tool") return "yellow";
+  if (kind === "warning") return "magenta";
+  if (kind === "error") return "red";
+  return "gray";
+};
+var stringifyValue = (value) => {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var truncate = (value, maxLength) => value.length <= maxLength ? value : `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+var compactPreview = (value, maxLength = 120) => truncate(stringifyValue(value).replace(/\s+/g, " "), maxLength);
+var withLimit = (items, max) => items.length <= max ? items : items.slice(items.length - max);
+var toUiLineEntries = (kind, text, turn) => text.split(/\r?\n/).map((lineText) => ({
+  id: randomId(),
+  kind,
+  text: lineText,
+  turn,
+  timestamp: Date.now()
+}));
+var createInitialLines = () => [
+  {
+    id: randomId(),
+    kind: "meta",
+    text: "AgentL Interactive (Ink) - full screen mode",
+    turn: 0,
+    timestamp: Date.now()
+  },
+  {
+    id: randomId(),
+    kind: "meta",
+    text: "Enter to send | Shift+Enter newline | /help for commands",
+    turn: 0,
+    timestamp: Date.now()
+  }
+];
+var HeaderBar = memo(function HeaderBar2({ text }) {
+  return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: "cyan", children: text }) });
+});
+var TranscriptPane = memo(function TranscriptPane2({
+  visibleLines,
+  scrollOffset,
+  capacity
+}) {
+  const padCount = Math.max(0, capacity - visibleLines.length - 1);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, wrap: "truncate-end", children: scrollOffset === 0 ? " " : `\u2191 ${scrollOffset} lines above` }),
+    Array.from({ length: padCount }, (_, i) => /* @__PURE__ */ jsx(Text, { children: " " }, `pad-${i}`)),
+    visibleLines.map((line) => /* @__PURE__ */ jsx(Text, { color: colorForKind(line.kind), wrap: "truncate-end", children: line.text }, line.id))
+  ] });
+});
+var InputBar = memo(function InputBar2({
+  inputHeight,
+  inputPreview,
+  cursorVisible
+}) {
+  const cursor = cursorVisible ? "\u2588" : " ";
+  return /* @__PURE__ */ jsx(Box, { height: inputHeight, paddingLeft: 1, children: /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+    "you> ",
+    inputPreview,
+    cursor
+  ] }) });
+});
+var StatusBar = memo(function StatusBar2({
+  notice,
+  runStateText
+}) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { color: notice ? colorForKind(notice.kind) : "gray", children: notice ? notice.text : runStateText }),
+    /* @__PURE__ */ jsx(Text, { color: "gray", children: "Ctrl+L clear | Ctrl+R resend | Ctrl+O tool details | Mouse wheel / Ctrl+U/D/Page scroll" })
+  ] });
+});
+var InteractiveInkApp = ({
+  harness,
+  params,
+  metadata,
+  initialSnapshot,
+  persistenceEnabled,
+  onPersist
+}) => {
+  const { exit } = useApp();
+  const [dimensions, setDimensions] = useState({
+    columns: process.stdout.columns ?? 120,
+    rows: process.stdout.rows ?? 40
+  });
+  const [input, setInput] = useState("");
+  const [lines, setLines] = useState(
+    initialSnapshot?.lines?.length ? initialSnapshot.lines : createInitialLines()
+  );
+  const [timeline, setTimeline] = useState(initialSnapshot?.timeline ?? []);
+  const [isRunning, setIsRunning] = useState(false);
+  const [streamingText, setStreamingText] = useState("");
+  const [showToolPayloads, setShowToolPayloads] = useState(false);
+  const [notice, setNotice] = useState();
+  const [scrollOffset, setScrollOffset] = useState(0);
+  const [toolState, setToolState] = useState({ state: "idle" });
+  const messagesRef = useRef(initialSnapshot?.messages ?? []);
+  const turnRef = useRef(initialSnapshot?.nextTurn ?? 1);
+  const lastPromptRef = useRef(initialSnapshot?.lastPrompt ?? "");
+  const persistTimer = useRef();
+  const streamBufferRef = useRef("");
+  const streamFlushRef = useRef();
+  const inputBufferRef = useRef(initialSnapshot?.lastPrompt ?? "");
+  const inputFlushRef = useRef();
+  const maxScrollOffsetRef = useRef(0);
+  const [cursorVisible, setCursorVisible] = useState(true);
+  useEffect(() => {
+    const onResize = () => {
+      setDimensions({
+        columns: process.stdout.columns ?? 120,
+        rows: process.stdout.rows ?? 40
+      });
+    };
+    process.stdout.on("resize", onResize);
+    return () => {
+      process.stdout.off("resize", onResize);
+    };
+  }, []);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setCursorVisible((current) => !current);
+    }, 500);
+    return () => clearInterval(timer);
+  }, []);
+  useEffect(() => {
+    const stdout = process.stdout;
+    const stdin = process.stdin;
+    const enableMouse = () => {
+      stdout.write("\x1B[?1000h\x1B[?1006h");
+    };
+    const disableMouse = () => {
+      stdout.write("\x1B[?1000l\x1B[?1006l");
+    };
+    const onData = (chunk) => {
+      const value = chunk.toString("utf8");
+      const matches = [...value.matchAll(/\u001B\[<(\d+);(\d+);(\d+)([mM])/g)];
+      if (matches.length === 0) {
+        return;
+      }
+      for (const match of matches) {
+        const button = Number(match[1] ?? -1);
+        if (button === 64) {
+          setScrollOffset((current) => Math.min(current + 1, maxScrollOffsetRef.current));
+        } else if (button === 65) {
+          setScrollOffset((current) => Math.max(current - 1, 0));
+        }
+      }
+    };
+    enableMouse();
+    stdin.on("data", onData);
+    return () => {
+      stdin.off("data", onData);
+      disableMouse();
+    };
+  }, []);
+  const persistSnapshot = useCallback(() => {
+    if (!persistenceEnabled || !onPersist) {
+      return;
+    }
+    if (persistTimer.current) {
+      clearTimeout(persistTimer.current);
+    }
+    persistTimer.current = setTimeout(() => {
+      void onPersist({
+        messages: messagesRef.current,
+        lines: withLimit(lines, MAX_PERSISTED_LINES),
+        timeline: withLimit(timeline, MAX_PERSISTED_TIMELINE),
+        nextTurn: turnRef.current,
+        lastPrompt: lastPromptRef.current
+      }).catch(() => {
+      });
+    }, 60);
+  }, [lines, onPersist, persistenceEnabled, timeline]);
+  const appendLine = useCallback((kind, text, turn) => {
+    const entries = toUiLineEntries(kind, text, turn);
+    setLines(
+      (previous) => withLimit(
+        [
+          ...previous,
+          ...entries
+        ],
+        MAX_PERSISTED_LINES
+      )
+    );
+  }, []);
+  const flushInputBuffer = useCallback(() => {
+    setInput(inputBufferRef.current);
+  }, []);
+  const queueInputFlush = useCallback(() => {
+    if (inputFlushRef.current) {
+      return;
+    }
+    inputFlushRef.current = setTimeout(() => {
+      inputFlushRef.current = void 0;
+      flushInputBuffer();
+    }, INPUT_FLUSH_MS);
+  }, [flushInputBuffer]);
+  const runSlashCommand = useCallback(
+    (command) => {
+      const normalized = command.trim().toLowerCase();
+      if (normalized === "/help") {
+        appendLine(
+          "meta",
+          "commands> /help /clear /sidebar /tools /export /exit",
+          Math.max(1, turnRef.current - 1)
+        );
+        return;
+      }
+      if (normalized === "/clear") {
+        setLines(createInitialLines());
+        setNotice({ kind: "meta", text: "Cleared scrollback." });
+        setScrollOffset(0);
+        return;
+      }
+      if (normalized === "/sidebar") {
+        appendLine("meta", "sidebar> removed for now", Math.max(1, turnRef.current - 1));
+        return;
+      }
+      if (normalized === "/tools") {
+        setShowToolPayloads((value) => !value);
+        return;
+      }
+      if (normalized === "/export") {
+        appendLine(
+          "meta",
+          persistenceEnabled ? "export> session is saved to .agentl/interactive-session.json" : "export> session persistence is disabled (set AGENTL_INTERACTIVE_PERSIST=true)",
+          0
+        );
+        return;
+      }
+      if (normalized === "/exit") {
+        exit();
+        return;
+      }
+      setNotice({ kind: "warning", text: `Unknown command: ${command}` });
+    },
+    [appendLine, exit, persistenceEnabled]
+  );
+  const handleToolEvent = useCallback(
+    (event, turn) => {
+      if (event.type === "tool:started") {
+        const inputPreview2 = showToolPayloads ? compactPreview(event.input, 400) : compactPreview(event.input, 100);
+        setToolState({
+          tool: event.tool,
+          state: "started",
+          startedAt: Date.now(),
+          input: inputPreview2
+        });
+        appendLine("tool", `tools> start ${event.tool} input=${inputPreview2}`, turn);
+        return 1;
+      }
+      if (event.type === "tool:completed") {
+        const outputPreview = showToolPayloads ? compactPreview(event.output, 400) : compactPreview(event.output, 100);
+        setToolState((current) => ({
+          ...current,
+          tool: event.tool,
+          state: "completed",
+          durationMs: event.duration,
+          output: outputPreview
+        }));
+        appendLine("tool", `tools> done  ${event.tool} in ${formatDuration(event.duration)}`, turn);
+        if (showToolPayloads) {
+          appendLine("tool", `tools> output ${outputPreview}`, turn);
+        }
+        return 0;
+      }
+      if (event.type === "tool:error") {
+        setToolState((current) => ({
+          ...current,
+          tool: event.tool,
+          state: "error",
+          error: event.error
+        }));
+        appendLine("error", `tools> error ${event.tool}: ${event.error}`, turn);
+        setNotice({ kind: "error", text: `Tool error on ${event.tool}` });
+      }
+      if (event.type === "tool:approval:required") {
+        appendLine("warning", `tools> approval required for ${event.tool}`, turn);
+      }
+      if (event.type === "tool:approval:granted") {
+        appendLine("meta", `tools> approval granted (${event.approvalId})`, turn);
+      }
+      if (event.type === "tool:approval:denied") {
+        appendLine("warning", `tools> approval denied (${event.approvalId})`, turn);
+      }
+      return 0;
+    },
+    [appendLine, showToolPayloads]
+  );
+  const runTurn = useCallback(
+    async (task) => {
+      if (isRunning) {
+        return;
+      }
+      setIsRunning(true);
+      setStreamingText("");
+      streamBufferRef.current = "";
+      const turn = turnRef.current;
+      turnRef.current = turn + 1;
+      const startedAt = Date.now();
+      setToolState({ state: "idle" });
+      setNotice(void 0);
+      lastPromptRef.current = task;
+      appendLine("meta", "", turn);
+      appendLine("meta", `--- turn ${turn} ---`, turn);
+      appendLine("meta", "", turn);
+      appendLine("user", `you> ${task}`, turn);
+      appendLine("meta", "", turn);
+      let responseText = "";
+      let streamedText = "";
+      let sawChunk = false;
+      let toolEvents = 0;
+      let runFailed = false;
+      let usage;
+      try {
+        const flushStreamBuffer = () => {
+          if (streamBufferRef.current.length === 0) {
+            return;
+          }
+          setStreamingText(streamBufferRef.current);
+        };
+        const queueStreamFlush = () => {
+          if (streamFlushRef.current) {
+            return;
+          }
+          streamFlushRef.current = setTimeout(() => {
+            streamFlushRef.current = void 0;
+            flushStreamBuffer();
+          }, STREAM_FLUSH_MS);
+        };
+        for await (const event of harness.run({
+          task,
+          parameters: params,
+          messages: messagesRef.current
+        })) {
+          if (event.type === "model:chunk") {
+            sawChunk = true;
+            responseText += event.content;
+            streamedText += event.content;
+            streamBufferRef.current = streamedText;
+            queueStreamFlush();
+          } else if (event.type === "tool:started" || event.type === "tool:completed" || event.type === "tool:error" || event.type === "tool:approval:required" || event.type === "tool:approval:granted" || event.type === "tool:approval:denied") {
+            toolEvents += handleToolEvent(event, turn);
+          } else if (event.type === "run:error") {
+            runFailed = true;
+            appendLine("error", `error> ${event.error.message}`, turn);
+            setNotice({ kind: "error", text: event.error.message });
+          } else if (event.type === "model:response") {
+            usage = event.usage;
+          } else if (event.type === "run:completed" && !sawChunk) {
+            responseText = event.result.response ?? "";
+            streamBufferRef.current = responseText;
+            setStreamingText(responseText);
+          }
+        }
+        if (streamFlushRef.current) {
+          clearTimeout(streamFlushRef.current);
+          streamFlushRef.current = void 0;
+        }
+        flushStreamBuffer();
+      } catch (error) {
+        runFailed = true;
+        appendLine(
+          "error",
+          `error> ${error instanceof Error ? error.message : "Unknown error"}`,
+          turn
+        );
+        setNotice({
+          kind: "error",
+          text: error instanceof Error ? error.message : "Unknown error"
+        });
+      } finally {
+        if (streamFlushRef.current) {
+          clearTimeout(streamFlushRef.current);
+          streamFlushRef.current = void 0;
+        }
+        appendLine("meta", "", turn);
+        if (streamedText.length > 0 || responseText.length > 0) {
+          appendLine("assistant", `assistant> ${streamedText || responseText}`, turn);
+        } else {
+          appendLine("assistant", "assistant> (no response)", turn);
+        }
+        appendLine("meta", "", turn);
+        if (!runFailed && toolEvents === 0 && FAUX_TOOL_LOG_PATTERN.test(streamedText || responseText)) {
+          appendLine(
+            "warning",
+            "warning> assistant described tool execution but no real tool events occurred.",
+            turn
+          );
+          setNotice({
+            kind: "warning",
+            text: "Assistant described tool calls, but no real tool events occurred."
+          });
+        }
+        const durationMs = Date.now() - startedAt;
+        appendLine("meta", `meta> ${formatDuration(durationMs)} | tools: ${toolEvents}`, turn);
+        setTimeline(
+          (previous) => withLimit(
+            [
+              ...previous,
+              {
+                turn,
+                durationMs,
+                toolEvents,
+                status: runFailed ? "error" : "ok",
+                usage
+              }
+            ],
+            MAX_PERSISTED_TIMELINE
+          )
+        );
+        messagesRef.current = [
+          ...messagesRef.current,
+          { role: "user", content: task },
+          { role: "assistant", content: streamedText || responseText }
+        ];
+        setStreamingText("");
+        streamBufferRef.current = "";
+        setIsRunning(false);
+        persistSnapshot();
+      }
+    },
+    [appendLine, handleToolEvent, harness, isRunning, params, persistSnapshot]
+  );
+  useEffect(
+    () => () => {
+      if (persistTimer.current) {
+        clearTimeout(persistTimer.current);
+      }
+      if (streamFlushRef.current) {
+        clearTimeout(streamFlushRef.current);
+      }
+      if (inputFlushRef.current) {
+        clearTimeout(inputFlushRef.current);
+      }
+    },
+    []
+  );
+  useInput((value, key) => {
+    if (MOUSE_SEQUENCE_FRAGMENT_PATTERN.test(value)) {
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "c" || value === "") {
+      exit();
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "l") {
+      setLines(createInitialLines());
+      setNotice({ kind: "meta", text: "Cleared scrollback." });
+      persistSnapshot();
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "r") {
+      if (lastPromptRef.current.trim().length > 0 && !isRunning) {
+        void runTurn(lastPromptRef.current);
+      }
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "o") {
+      setShowToolPayloads((current) => !current);
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "u") {
+      setScrollOffset((current) => Math.min(current + 1, maxScrollOffsetRef.current));
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "d") {
+      setScrollOffset((current) => Math.max(0, current - 1));
+      return;
+    }
+    if (key.pageUp) {
+      setScrollOffset((current) => Math.min(current + 12, maxScrollOffsetRef.current));
+      return;
+    }
+    if (key.pageDown) {
+      setScrollOffset((current) => Math.max(0, current - 12));
+      return;
+    }
+    if (key.return) {
+      if (key.shift) {
+        inputBufferRef.current = `${inputBufferRef.current}
+`;
+        queueInputFlush();
+        return;
+      }
+      const task = inputBufferRef.current.trimEnd();
+      if (task.length === 0 || isRunning) {
+        return;
+      }
+      if (task.toLowerCase() === "exit") {
+        exit();
+        return;
+      }
+      if (task.startsWith("/")) {
+        inputBufferRef.current = "";
+        flushInputBuffer();
+        runSlashCommand(task);
+        persistSnapshot();
+        return;
+      }
+      inputBufferRef.current = "";
+      flushInputBuffer();
+      setScrollOffset(0);
+      void runTurn(task);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      inputBufferRef.current = inputBufferRef.current.slice(0, -1);
+      queueInputFlush();
+      return;
+    }
+    if (!key.ctrl && !key.meta && value.length > 0) {
+      if (CONTROL_SEQUENCE_PATTERN.test(value) || MOUSE_SEQUENCE_FRAGMENT_PATTERN.test(value)) {
+        return;
+      }
+      inputBufferRef.current += value;
+      queueInputFlush();
+    }
+  });
+  const { columns, rows } = dimensions;
+  const headerText = `agent: ${metadata.agentName} | provider: ${metadata.provider} | model: ${metadata.model} | env: ${metadata.environment}`;
+  const inputLines = input.split("\n");
+  const inputHeight = Math.max(3, Math.min(6, inputLines.length + 1));
+  const statusHeight = 2;
+  const headerHeight = 1;
+  const separatorHeight = 1;
+  const visibleCapacity = Math.max(3, rows - headerHeight - inputHeight - statusHeight - separatorHeight);
+  const contentLines = useMemo(() => {
+    if (streamingText.length === 0) {
+      return lines;
+    }
+    const streamSegments = streamingText.split(/\r?\n/);
+    return [
+      ...lines,
+      ...streamSegments.map((segment, index) => ({
+        id: `streaming-live-${index}`,
+        kind: "assistant",
+        text: index === 0 ? `assistant> ${segment}` : segment,
+        turn: turnRef.current,
+        timestamp: Date.now()
+      }))
+    ];
+  }, [lines, streamingText]);
+  const visibleLines = useMemo(() => {
+    const endIndex = Math.max(0, contentLines.length - scrollOffset);
+    const startIndex = Math.max(0, endIndex - visibleCapacity);
+    return contentLines.slice(startIndex, endIndex);
+  }, [contentLines, scrollOffset, visibleCapacity]);
+  const maxScrollOffset = Math.max(0, contentLines.length - visibleCapacity);
+  maxScrollOffsetRef.current = maxScrollOffset;
+  useEffect(() => {
+    setScrollOffset((current) => Math.min(current, maxScrollOffset));
+  }, [maxScrollOffset]);
+  const runStateText = useMemo(() => {
+    if (isRunning && streamingText.length === 0 && toolState.state !== "started") {
+      return "assistant thinking...";
+    }
+    if (isRunning && streamingText.length > 0) {
+      return "assistant streaming...";
+    }
+    if (isRunning && toolState.state === "started") {
+      return `running tool: ${toolState.tool ?? "unknown"}`;
+    }
+    return "ready";
+  }, [isRunning, streamingText, toolState.state, toolState.tool]);
+  const inputPreview = inputLines.slice(-inputHeight).join("\n");
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [
+    /* @__PURE__ */ jsx(HeaderBar, { text: truncate(headerText, Math.max(30, columns - 4)) }),
+    /* @__PURE__ */ jsx(
+      TranscriptPane,
+      {
+        visibleLines,
+        scrollOffset,
+        capacity: visibleCapacity
+      }
+    ),
+    /* @__PURE__ */ jsx(InputBar, { inputHeight, inputPreview, cursorVisible }),
+    /* @__PURE__ */ jsx(StatusBar, { notice, runStateText })
+  ] });
+};
+
+// src/run-interactive-ink.ts
+var SESSION_PATH = [".agentl", "interactive-session.json"];
+var shouldPersistSessions = () => {
+  const value = (process.env.AGENTL_INTERACTIVE_PERSIST ?? "").toLowerCase();
+  return value === "1" || value === "true" || value === "yes";
+};
+var loadSessionSnapshot = async (workingDir) => {
+  const sessionPath = resolve(workingDir, ...SESSION_PATH);
+  try {
+    await access(sessionPath);
+    const content = await readFile(sessionPath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+};
+var persistSessionSnapshot = async (workingDir, snapshot) => {
+  const sessionPath = resolve(workingDir, ...SESSION_PATH);
+  await mkdir(resolve(workingDir, ".agentl"), { recursive: true });
+  await writeFile(sessionPath, JSON.stringify(snapshot), "utf8");
+};
+var loadMetadata = async (workingDir) => {
+  let agentName = "agent";
+  let model = "unknown";
+  let provider = "unknown";
+  try {
+    const parsedAgent = await parseAgentFile(workingDir);
+    agentName = parsedAgent.frontmatter.name ?? agentName;
+    model = parsedAgent.frontmatter.model?.name ?? model;
+    provider = parsedAgent.frontmatter.model?.provider ?? provider;
+  } catch {
+  }
+  return {
+    agentName,
+    model,
+    provider,
+    workingDir,
+    environment: process.env.AGENTL_ENV ?? process.env.NODE_ENV ?? "development"
+  };
+};
+var runInteractiveInk = async ({
+  harness,
+  params,
+  workingDir
+}) => {
+  const persistenceEnabled = shouldPersistSessions();
+  const [sessionSnapshot, metadata] = await Promise.all([
+    persistenceEnabled ? loadSessionSnapshot(workingDir) : Promise.resolve(void 0),
+    loadMetadata(workingDir)
+  ]);
+  const app = render(
+    createElement(InteractiveInkApp, {
+      harness,
+      params,
+      metadata,
+      initialSnapshot: sessionSnapshot,
+      persistenceEnabled,
+      onPersist: persistenceEnabled ? async (snapshot) => {
+        await persistSessionSnapshot(workingDir, snapshot);
+      } : void 0
+    }),
+    {
+      maxFps: 30,
+      incrementalRendering: true,
+      patchConsole: false
+    }
+  );
+  await app.waitUntilExit();
+};
+export {
+  runInteractiveInk
+};