@linghun/tui 0.1.0

package/dist/chunk-ZOSK2UEU.js

@@ -0,0 +1,1555 @@
+import {
+  classifyTerminalInput,
+  isMultilineEnterSequence,
+  normalizeTerminalInput,
+  sanitizeTerminalText
+} from "./chunk-JBLVBO3U.js";
+import {
+  useAnchoredCursor
+} from "./chunk-GW5YDCRZ.js";
+import {
+  SlashSuggestions
+} from "./chunk-HW2TBXVK.js";
+import {
+  resolveTerminalInteractionModes
+} from "./chunk-F46N43MG.js";
+import {
+  createUndoRing,
+  undoRingPop,
+  undoRingPush
+} from "./chunk-P4CPRJLI.js";
+import {
+  createPromptStash,
+  toggleStash
+} from "./chunk-YPQFSFYK.js";
+import {
+  computeGhostText
+} from "./chunk-TFZEFIQT.js";
+import {
+  createShellTheme
+} from "./chunk-GC55DMZV.js";
+import {
+  formatUnknownSlashCommand,
+  getCoreSlashCandidates,
+  getSlashPrefixCandidates
+} from "./chunk-4K6UB524.js";
+import {
+  resolveKeybinding
+} from "./chunk-6SMM5CMP.js";
+import {
+  charWidth,
+  composerMaxWidth,
+  fitText,
+  taskComposerMaxWidth
+} from "./chunk-APJIC2O5.js";
+
+// src/shell/components/Composer.tsx
+import { Box, Text, useInput } from "@linghun/ink-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function createEditBuffer(text = "") {
+  return { chars: Array.from(text), cursor: Array.from(text).length };
+}
+function bufferToString(buf) {
+  return buf.chars.join("");
+}
+function bufferDisplayWidth(buf) {
+  let w = 0;
+  for (const ch of buf.chars) w += charWidth(ch);
+  return w;
+}
+function bufferInsert(buf, text) {
+  const insertChars = Array.from(text);
+  const chars = [...buf.chars.slice(0, buf.cursor), ...insertChars, ...buf.chars.slice(buf.cursor)];
+  return { chars, cursor: buf.cursor + insertChars.length };
+}
+function bufferBackspace(buf) {
+  if (buf.cursor === 0) return buf;
+  const chars = [...buf.chars.slice(0, buf.cursor - 1), ...buf.chars.slice(buf.cursor)];
+  return { chars, cursor: buf.cursor - 1 };
+}
+function bufferDelete(buf) {
+  if (buf.cursor >= buf.chars.length) return buf;
+  const chars = [...buf.chars.slice(0, buf.cursor), ...buf.chars.slice(buf.cursor + 1)];
+  return { chars, cursor: buf.cursor };
+}
+function bufferMoveLeft(buf) {
+  if (buf.cursor === 0) return buf;
+  return { ...buf, cursor: buf.cursor - 1 };
+}
+function bufferMoveRight(buf) {
+  if (buf.cursor >= buf.chars.length) return buf;
+  return { ...buf, cursor: buf.cursor + 1 };
+}
+function bufferHome(buf) {
+  return { ...buf, cursor: 0 };
+}
+function bufferEnd(buf) {
+  return { ...buf, cursor: buf.chars.length };
+}
+function bufferWordLeft(buf) {
+  let pos = buf.cursor;
+  while (pos > 0 && isWordBoundary(buf.chars[pos - 1] ?? "")) pos--;
+  while (pos > 0 && !isWordBoundary(buf.chars[pos - 1] ?? "")) pos--;
+  return { ...buf, cursor: pos };
+}
+function bufferWordRight(buf) {
+  let pos = buf.cursor;
+  const len = buf.chars.length;
+  while (pos < len && !isWordBoundary(buf.chars[pos] ?? "")) pos++;
+  while (pos < len && isWordBoundary(buf.chars[pos] ?? "")) pos++;
+  return { ...buf, cursor: pos };
+}
+function bufferDeleteWordLeft(buf) {
+  const target = bufferWordLeft(buf).cursor;
+  const chars = [...buf.chars.slice(0, target), ...buf.chars.slice(buf.cursor)];
+  return { chars, cursor: target };
+}
+function bufferClearLine(buf) {
+  void buf;
+  return { chars: [], cursor: 0 };
+}
+function bufferKillToEnd(buf) {
+  return { chars: buf.chars.slice(0, buf.cursor), cursor: buf.cursor };
+}
+function bufferMoveUp(buf) {
+  const { row, col } = getCursorLinePosition(buf);
+  if (row === 0) return buf;
+  const lines = bufferToString(buf).split("\n");
+  const targetLine = lines[row - 1] ?? "";
+  const targetChars = Array.from(targetLine);
+  const targetCol = Math.min(col, targetChars.length);
+  let newCursor = 0;
+  for (let i = 0; i < row - 1; i++) {
+    newCursor += Array.from(lines[i] ?? "").length + 1;
+  }
+  newCursor += targetCol;
+  return { ...buf, cursor: newCursor };
+}
+function bufferMoveDown(buf) {
+  const { row, col } = getCursorLinePosition(buf);
+  const lines = bufferToString(buf).split("\n");
+  if (row >= lines.length - 1) return buf;
+  const targetLine = lines[row + 1] ?? "";
+  const targetChars = Array.from(targetLine);
+  const targetCol = Math.min(col, targetChars.length);
+  let newCursor = 0;
+  for (let i = 0; i <= row; i++) {
+    newCursor += Array.from(lines[i] ?? "").length + 1;
+  }
+  newCursor += targetCol;
+  return { ...buf, cursor: newCursor };
+}
+function bufferMoveVisualUp(buf, maxWidth) {
+  return bufferMoveVisual(buf, maxWidth, -1);
+}
+function bufferMoveVisualDown(buf, maxWidth) {
+  return bufferMoveVisual(buf, maxWidth, 1);
+}
+function bufferMoveVisual(buf, maxWidth, delta) {
+  const visual = getVisualLinePosition(buf, maxWidth);
+  const target = visual.lines[visual.index + delta];
+  if (!target) return buf;
+  const cursorCol = Math.max(0, visual.cursorDisplayCol - visual.current.promptWidth);
+  const targetText = getRawLineText(buf, target.rawLineIndex);
+  const targetChars = Array.from(targetText).slice(target.startChar, target.endChar);
+  let used = 0;
+  let offset = 0;
+  for (; offset < targetChars.length; offset++) {
+    const next = charWidth(targetChars[offset] ?? "");
+    if (used + next > cursorCol) break;
+    used += next;
+  }
+  return { ...buf, cursor: target.absoluteStart + offset };
+}
+function getVisualLinePosition(buf, maxWidth) {
+  const lines = buildVisualLines(buf, maxWidth);
+  const fallback = lines[0] ?? {
+    rawLineIndex: 0,
+    startChar: 0,
+    endChar: 0,
+    absoluteStart: 0,
+    promptWidth: displayWidthOf(PROMPT_MARKER)
+  };
+  let index = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? fallback;
+    const lineEnd = line.absoluteStart + line.endChar - line.startChar;
+    const nextLine = lines[i + 1];
+    const wrapsToNextVisualLine = nextLine?.rawLineIndex === line.rawLineIndex;
+    if (buf.cursor >= line.absoluteStart && (wrapsToNextVisualLine ? buf.cursor < lineEnd : buf.cursor <= lineEnd)) {
+      index = i;
+      break;
+    }
+  }
+  const current = lines[index] ?? fallback;
+  let cursorDisplayCol = current.promptWidth;
+  const inLineOffset = Math.max(0, buf.cursor - current.absoluteStart);
+  const rawLine = getRawLineText(buf, current.rawLineIndex);
+  const chars = Array.from(rawLine).slice(current.startChar, current.startChar + inLineOffset);
+  for (const ch of chars) cursorDisplayCol += charWidth(ch);
+  return { lines, index, current, cursorDisplayCol };
+}
+function buildVisualLines(buf, maxWidth) {
+  const rawLines = bufferToString(buf).split("\n");
+  const composerWidth = Math.max(8, maxWidth ?? 80);
+  const result = [];
+  let absoluteLineStart = 0;
+  for (let rawIndex = 0; rawIndex < rawLines.length; rawIndex++) {
+    const rawLine = rawLines[rawIndex] ?? "";
+    const chars = Array.from(rawLine);
+    const isFirstRawLine = rawIndex === 0;
+    let startChar = 0;
+    while (startChar < chars.length || chars.length === 0 && startChar === 0) {
+      const prompt = isFirstRawLine && startChar === 0 ? PROMPT_MARKER : PROMPT_MARKER_CONTINUATION;
+      const promptWidth = displayWidthOf(prompt);
+      const budget = Math.max(4, composerWidth - promptWidth);
+      let width = 0;
+      let endChar = startChar;
+      while (endChar < chars.length) {
+        const next = charWidth(chars[endChar] ?? "");
+        if (width > 0 && width + next > budget) break;
+        width += next;
+        endChar++;
+      }
+      if (endChar === startChar && chars.length > 0) endChar++;
+      result.push({
+        rawLineIndex: rawIndex,
+        startChar,
+        endChar,
+        absoluteStart: absoluteLineStart + startChar,
+        promptWidth
+      });
+      if (chars.length === 0) break;
+      startChar = endChar;
+    }
+    absoluteLineStart += chars.length + 1;
+  }
+  return result;
+}
+function getRawLineText(buf, rawLineIndex) {
+  return bufferToString(buf).split("\n")[rawLineIndex] ?? "";
+}
+function isWordBoundary(ch) {
+  return /[\s\p{P}]/u.test(ch);
+}
+function sanitizeComposerInput(value) {
+  return sanitizeTerminalText(value);
+}
+var MAX_HISTORY = 100;
+function createInputHistory() {
+  return { entries: [], position: -1, draft: "" };
+}
+function historyAdd(history, text) {
+  if (!text.trim()) return { ...history, position: -1, draft: "" };
+  const entries = history.entries[0] === text ? history.entries : [text, ...history.entries].slice(0, MAX_HISTORY);
+  return { entries, position: -1, draft: "" };
+}
+function historyUp(history, currentText) {
+  const nextPos = history.position + 1;
+  if (nextPos >= history.entries.length) return void 0;
+  const draft = history.position === -1 ? currentText : history.draft;
+  return { ...history, position: nextPos, draft };
+}
+function historyDown(history) {
+  if (history.position <= -1) return void 0;
+  const nextPos = history.position - 1;
+  return { ...history, position: nextPos, draft: history.draft };
+}
+function historyCurrentText(history) {
+  if (history.position === -1) return void 0;
+  return history.entries[history.position];
+}
+function shouldEnterPastePath(input, key, pastePending) {
+  if (input.length > PASTE_THRESHOLD) return true;
+  if (pastePending && input.length > 0 && !key.ctrl && !key.meta && !key.escape && !key.tab && !key.return) {
+    return true;
+  }
+  return false;
+}
+function selectInputOwner(input, key, ctx) {
+  if (ctx.permissionActive) return "permission";
+  if (ctx.panelActive === true && isPanelOwnerKey(input, key, ctx)) return "panel";
+  if (ctx.pastePending && (key.return || key.escape)) return "paste";
+  if (shouldEnterPastePath(input, key, ctx.pastePending)) return "paste";
+  if (ctx.slashVisible && isSlashOwnerKey(input, key)) return "slash";
+  return "composer";
+}
+function isPanelOwnerKey(input, key, ctx) {
+  if (key.escape) return true;
+  if (ctx.panelInteractive !== true) return false;
+  if (isModifiedEnter(input, key)) return false;
+  if (key.return || key.tab || key.upArrow || key.downArrow || key.leftArrow || key.rightArrow) {
+    return true;
+  }
+  if (ctx.panelNumericShortcuts && /^[1-9]$/.test(input) && !key.ctrl && !key.meta) return true;
+  if (ctx.panelSpaceAction && input === " " && !key.ctrl && !key.meta) return true;
+  return input.toLowerCase() === "x" && !key.ctrl && !key.meta;
+}
+function isSlashOwnerKey(input, key) {
+  return Boolean(
+    key.return && !isModifiedEnter(input, key) || key.escape || key.tab || key.upArrow || key.downArrow
+  );
+}
+function isModifiedEnter(input, key) {
+  return Boolean(
+    key.return && (key.shift || key.meta) && input.length > 0 && input !== "\r" && input !== "\n"
+  );
+}
+function isNavigationKey(key) {
+  return Boolean(key.upArrow || key.downArrow || key.leftArrow || key.rightArrow);
+}
+function isVerticalNavigationKey(key) {
+  return Boolean(key.upArrow || key.downArrow);
+}
+var OWNER_PRIORITY = [
+  "permission",
+  "panel",
+  "paste",
+  "slash",
+  "composer"
+];
+var shouldOwnerBePaste = shouldEnterPastePath;
+function isDoublePressWithin(lastPressAt, now, windowMs = DOUBLE_PRESS_WINDOW_MS) {
+  if (lastPressAt <= 0) return false;
+  return now - lastPressAt < windowMs;
+}
+function shouldUnstickSlashHidden(prevHead, nextText, nextHead) {
+  if (!nextText.startsWith("/")) return true;
+  return prevHead !== nextHead;
+}
+function isMultilineEnterSequence2(input) {
+  return isMultilineEnterSequence(input);
+}
+var COMPOSER_MAX_VISIBLE_LINES = 5;
+var PROMPT_MARKER = "\u203A ";
+var PROMPT_MARKER_CONTINUATION = " ".repeat(displayWidthOf(PROMPT_MARKER));
+var PERMISSION_ACTION_ORDER = [
+  "allow_once",
+  "allow_always_tool",
+  "deny",
+  "details"
+];
+var PASTE_THRESHOLD = 16;
+var OWNER_PASTE_THRESHOLD = PASTE_THRESHOLD;
+var PASTE_COMPLETION_TIMEOUT_MS = 100;
+var DOUBLE_PRESS_WINDOW_MS = 1e3;
+var HINT_NOTICE_DECAY_MS = 1500;
+function Composer({ view, onInput, capability }) {
+  const [buffer, setBuffer] = useState(createEditBuffer());
+  const bufferRef = useRef(buffer);
+  const [slashSelection, setSlashSelection] = useState(0);
+  const [slashHidden, setSlashHidden] = useState(false);
+  const [permissionFocus, setPermissionFocus] = useState("allow_once");
+  const [hintNotice, setHintNotice] = useState(void 0);
+  const historyRef = useRef(createInputHistory());
+  const pasteChunksRef = useRef([]);
+  const pasteTimerRef = useRef(null);
+  const pastePendingRef = useRef(false);
+  const focusReportPrefixPendingRef = useRef(false);
+  const lastEscAtRef = useRef(0);
+  const lastCtrlCAtRef = useRef(0);
+  const hintTimerRef = useRef(null);
+  const chordBufferRef = useRef([]);
+  const undoRingRef = useRef(createUndoRing());
+  const stashRef = useRef(createPromptStash());
+  const maxWidth = view.viewMode === "task" || view.viewMode === "pending" ? taskComposerMaxWidth(view.width) : composerMaxWidth(view.width);
+  const noColor = view.themeMode === "no-color";
+  const theme = useMemo(() => createShellTheme(noColor), [noColor]);
+  const anchorRef = useRef(null);
+  const emitInput = useCallback(
+    (event) => {
+      Promise.resolve(onInput(event)).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        setHintNotice(message);
+      });
+    },
+    [onInput]
+  );
+  const permissionActive = Boolean(view.permission);
+  const permissionActions = useMemo(
+    () => buildPermissionActions(view.language, view.permission?.actions),
+    [view.language, view.permission]
+  );
+  const configPanelActive = Boolean(
+    view.configPanel || view.helpPanel || view.btwPanel || view.sessionsPanel || view.backgroundTaskOverlay || view.historySearchPanel || view.shortcutPanel
+  );
+  const terminalInteractionModes = useMemo(
+    () => resolveTerminalInteractionModes({ capability, appOwnedScreen: false }),
+    [capability]
+  );
+  const text = bufferToString(buffer);
+  const commandPanelActive = Boolean(view.commandPanel);
+  const commandPanelConsumesInput = hasSelectableCommandPanelRows(view.commandPanel);
+  const slashHeadCurrent = useMemo(() => slashHead(text), [text]);
+  const isBareSlash = !permissionActive && text === "/";
+  const isSingleLineSlash = !permissionActive && text.startsWith("/") && !text.includes("\n") && text.length >= 2 && text !== "/?";
+  const slashCandidates = useMemo(() => {
+    if (isBareSlash) return getCoreSlashCandidates();
+    if (isSingleLineSlash) return getSlashPrefixCandidates(slashHeadCurrent);
+    return [];
+  }, [isBareSlash, isSingleLineSlash, slashHeadCurrent]);
+  const lastSlashHeadRef = useRef(slashHeadCurrent);
+  useEffect(() => {
+    if (!text.startsWith("/")) {
+      if (slashHidden) setSlashHidden(false);
+      lastSlashHeadRef.current = slashHeadCurrent;
+      return;
+    }
+    if (lastSlashHeadRef.current !== slashHeadCurrent) {
+      if (slashHidden) setSlashHidden(false);
+      lastSlashHeadRef.current = slashHeadCurrent;
+    }
+  }, [text, slashHeadCurrent, slashHidden]);
+  const slashSelectionClamped = slashCandidates.length === 0 ? 0 : Math.max(0, Math.min(slashSelection, slashCandidates.length - 1));
+  const resetBuffer = useCallback((nextText = "") => {
+    const next = createEditBuffer(nextText);
+    bufferRef.current = next;
+    setBuffer(next);
+    setSlashSelection(0);
+  }, []);
+  const setBufferAndResetSelection = useCallback((next) => {
+    undoRingRef.current = undoRingPush(undoRingRef.current, bufferRef.current);
+    bufferRef.current = next;
+    setBuffer(next);
+    setSlashSelection(0);
+  }, []);
+  const updateBufferAndResetSelection = useCallback(
+    (update) => {
+      undoRingRef.current = undoRingPush(undoRingRef.current, bufferRef.current);
+      const next = update(bufferRef.current);
+      bufferRef.current = next;
+      setBuffer(next);
+      setSlashSelection(0);
+    },
+    []
+  );
+  const submitPermissionAction = useCallback(
+    (id) => {
+      if (id === "cancel") {
+        emitInput({ type: "escape" });
+        return;
+      }
+      emitInput({ type: "permission-action", actionId: id });
+    },
+    [emitInput]
+  );
+  const showHintNotice = useCallback((notice) => {
+    setHintNotice(notice);
+    if (hintTimerRef.current) clearTimeout(hintTimerRef.current);
+    hintTimerRef.current = setTimeout(() => {
+      setHintNotice(void 0);
+      hintTimerRef.current = null;
+    }, HINT_NOTICE_DECAY_MS);
+  }, []);
+  const clearHintNotice = useCallback(() => {
+    if (hintTimerRef.current) {
+      clearTimeout(hintTimerRef.current);
+      hintTimerRef.current = null;
+    }
+    setHintNotice(void 0);
+  }, []);
+  const flushPaste = useCallback(() => {
+    const chunks = pasteChunksRef.current;
+    pasteChunksRef.current = [];
+    if (pasteTimerRef.current) {
+      clearTimeout(pasteTimerRef.current);
+      pasteTimerRef.current = null;
+    }
+    pastePendingRef.current = false;
+    if (chunks.length === 0) return;
+    const joined = sanitizeComposerInput(chunks.join(""));
+    if (!joined) return;
+    const next = bufferInsert(bufferRef.current, joined);
+    bufferRef.current = next;
+    setBuffer(next);
+    setSlashSelection(0);
+  }, []);
+  const cancelPaste = useCallback(() => {
+    pasteChunksRef.current = [];
+    if (pasteTimerRef.current) {
+      clearTimeout(pasteTimerRef.current);
+      pasteTimerRef.current = null;
+    }
+    pastePendingRef.current = false;
+  }, []);
+  const enqueuePasteChunk = useCallback(
+    (chunk) => {
+      pasteChunksRef.current.push(chunk);
+      pastePendingRef.current = true;
+      if (pasteTimerRef.current) clearTimeout(pasteTimerRef.current);
+      pasteTimerRef.current = setTimeout(flushPaste, PASTE_COMPLETION_TIMEOUT_MS);
+    },
+    [flushPaste]
+  );
+  useEffect(() => {
+    return () => {
+      if (pasteTimerRef.current) clearTimeout(pasteTimerRef.current);
+      if (hintTimerRef.current) clearTimeout(hintTimerRef.current);
+    };
+  }, []);
+  useInput(
+    (input, key) => {
+      if (input === "\x1B[I" || input === "\x1B[O" || input === "[I" || input === "[O") {
+        focusReportPrefixPendingRef.current = false;
+        return;
+      }
+      if (input === "\x1B[") {
+        focusReportPrefixPendingRef.current = true;
+        return;
+      }
+      if (focusReportPrefixPendingRef.current) {
+        focusReportPrefixPendingRef.current = false;
+        if (input === "I" || input === "O") return;
+      }
+      if (classifyTerminalInput(input) !== "keyboard") return;
+      const buffer2 = bufferRef.current;
+      const text2 = bufferToString(buffer2);
+      const terminalAction = normalizeTerminalInput(input, key);
+      const owner = selectInputOwner(input, key, {
+        permissionActive,
+        panelActive: configPanelActive || commandPanelActive,
+        panelInteractive: Boolean(
+          view.configPanel || view.helpPanel || view.btwPanel || view.sessionsPanel || view.backgroundTaskOverlay || view.historySearchPanel || view.shortcutPanel || view.commandPanel || commandPanelConsumesInput
+        ),
+        panelNumericShortcuts: Boolean(view.helpPanel),
+        panelSpaceAction: Boolean(view.btwPanel),
+        pastePending: pastePendingRef.current,
+        slashVisible: slashCandidates.length > 0 && !slashHidden
+      });
+      if (!permissionActive) {
+        const binding = resolveKeybinding(
+          view.keybindings ?? [],
+          "chat",
+          {
+            input,
+            ctrl: key.ctrl,
+            meta: key.meta,
+            shift: key.shift,
+            tab: key.tab,
+            escape: key.escape,
+            return: key.return,
+            backspace: key.backspace,
+            delete: key.delete
+          },
+          chordBufferRef.current
+        );
+        chordBufferRef.current = binding.chordBuffer;
+        if (binding.pending) return;
+        if (binding.action === "toggle-details") {
+          clearHintNotice();
+          emitInput({ type: "toggle-details" });
+          return;
+        }
+        if (binding.action === "cycle-permission-mode") {
+          emitInput({ type: "cycle-permission-mode" });
+          return;
+        }
+        if (binding.action === "clear-line") {
+          setBufferAndResetSelection(bufferClearLine(buffer2));
+          return;
+        }
+        if (binding.action === "delete-word-left") {
+          setBufferAndResetSelection(bufferDeleteWordLeft(buffer2));
+          return;
+        }
+        if (binding.action === "history-search") {
+          emitInput({ type: "history-search-open" });
+          return;
+        }
+        if (binding.action === "undo") {
+          const result = undoRingPop(undoRingRef.current);
+          undoRingRef.current = result.ring;
+          if (result.buffer) {
+            bufferRef.current = result.buffer;
+            setBuffer(result.buffer);
+            setSlashSelection(0);
+          }
+          return;
+        }
+        if (binding.action === "stash") {
+          const currentText = bufferToString(bufferRef.current);
+          const result = toggleStash(stashRef.current, currentText);
+          stashRef.current = result.stash;
+          if (result.bufferText !== void 0) {
+            resetBuffer(result.bufferText);
+          }
+          return;
+        }
+        if (binding.action === "external-editor") {
+          emitInput({ type: "external-editor" });
+          return;
+        }
+        if (binding.action === "shortcuts-panel") {
+          if (bufferToString(bufferRef.current).length === 0) {
+            emitInput({ type: "shortcuts-panel-open" });
+            return;
+          }
+        }
+      }
+      if (!permissionActive && key.downArrow && key.shift && (view.viewMode === "task" || view.viewMode === "pending")) {
+        emitInput({ type: "background-overlay-open" });
+        return;
+      }
+      if (key.ctrl && key.shift && input.toLowerCase() === "c") {
+        emitInput({ type: "copy-selection" });
+        return;
+      }
+      if (owner === "permission") {
+        if (key.escape) {
+          submitPermissionAction("cancel");
+          return;
+        }
+        if (key.return) {
+          submitPermissionAction(permissionFocus);
+          return;
+        }
+        if (key.tab && !key.shift) {
+          setPermissionFocus(cyclePermissionFocus(permissionActions, permissionFocus, 1));
+          return;
+        }
+        if (key.tab && key.shift) {
+          setPermissionFocus(cyclePermissionFocus(permissionActions, permissionFocus, -1));
+          return;
+        }
+        if (key.leftArrow || key.upArrow) {
+          setPermissionFocus(cyclePermissionFocus(permissionActions, permissionFocus, -1));
+          return;
+        }
+        if (key.rightArrow || key.downArrow) {
+          setPermissionFocus(cyclePermissionFocus(permissionActions, permissionFocus, 1));
+          return;
+        }
+        if (!key.ctrl && !key.meta && input && input.length === 1) {
+          const lower = input.toLowerCase();
+          if (lower === "y") {
+            submitPermissionAction(resolveActionId(permissionActions, "allow_once", "yes"));
+            return;
+          }
+          if (lower === "a") {
+            if (permissionActions.some((act) => act.id === "allow_always_tool")) {
+              submitPermissionAction("allow_always_tool");
+              return;
+            }
+          }
+          if (lower === "n") {
+            submitPermissionAction(resolveActionId(permissionActions, "deny", "no"));
+            return;
+          }
+          if (lower === "d") {
+            submitPermissionAction("details");
+            return;
+          }
+        }
+        return;
+      }
+      if (owner === "panel") {
+        if (key.escape) {
+          if (view.helpPanel) emitInput({ type: "help-close" });
+          else if (view.btwPanel) emitInput({ type: "btw-close" });
+          else if (view.sessionsPanel) emitInput({ type: "sessions-close" });
+          else if (view.backgroundTaskOverlay) emitInput({ type: "background-overlay-close" });
+          else if (view.historySearchPanel) emitInput({ type: "history-search-close" });
+          else if (view.shortcutPanel) emitInput({ type: "shortcuts-panel-close" });
+          else if (view.configPanel) emitInput({ type: "config-back" });
+          else if (view.commandPanel) emitInput({ type: "command-panel-close" });
+          else emitInput({ type: "escape" });
+          return;
+        }
+        if (view.historySearchPanel) {
+          if (key.return) emitInput({ type: "history-search-accept" });
+          else if (key.upArrow) emitInput({ type: "history-search-move", delta: -1 });
+          else if (key.downArrow) emitInput({ type: "history-search-move", delta: 1 });
+          else if (!key.ctrl && !key.meta && input.length > 0 && !key.return && !key.tab) {
+            const newQuery = (view.historySearchPanel.query ?? "") + input;
+            emitInput({ type: "history-search-input", query: newQuery });
+          } else if (key.backspace) {
+            const currentQuery = view.historySearchPanel.query ?? "";
+            emitInput({ type: "history-search-input", query: currentQuery.slice(0, -1) });
+          }
+          return;
+        }
+        if (view.shortcutPanel) {
+          emitInput({ type: "shortcuts-panel-close" });
+          return;
+        }
+        if (view.helpPanel) {
+          if (!key.ctrl && !key.meta && /^[1-9]$/.test(input)) {
+            const idx = Number(input) - 1;
+            if (idx < view.helpPanel.entries.length) {
+              emitInput({ type: "help-select", index: idx });
+            }
+          } else if (key.return) emitInput({ type: "help-enter" });
+          else if (key.upArrow) emitInput({ type: "help-move", delta: -1 });
+          else if (key.downArrow) emitInput({ type: "help-move", delta: 1 });
+          else if (key.tab || key.rightArrow) emitInput({ type: "help-switch-group", delta: 1 });
+          else if (key.leftArrow) emitInput({ type: "help-switch-group", delta: -1 });
+          return;
+        }
+        if (view.btwPanel) {
+          if (key.return || input === " ") emitInput({ type: "btw-close" });
+          return;
+        }
+        if (view.configPanel) {
+          if (key.return) {
+            if (view.configPanel.phase === "panel_list") {
+              const selected = view.configPanel.panels[view.configPanel.cursor];
+              if (selected) {
+                if (selected.id === "language") {
+                  emitInput({ type: "config-enter" });
+                } else {
+                  emitInput({ type: "config-submit", command: selected.slash });
+                }
+              }
+            } else {
+              const action = view.configPanel.actions[view.configPanel.actionCursor];
+              if (action) emitInput({ type: "config-submit", command: action.id });
+            }
+          } else if (key.upArrow) emitInput({ type: "config-move", delta: -1 });
+          else if (key.downArrow) emitInput({ type: "config-move", delta: 1 });
+          return;
+        }
+        if (view.sessionsPanel) {
+          if (view.sessionsPanel.mode === "search") {
+            if (key.escape) emitInput({ type: "sessions-search-close" });
+            else if (key.return) emitInput({ type: "sessions-search-close" });
+            else if (key.backspace || key.delete) emitInput({ type: "sessions-search-delete" });
+            else if (input && !key.ctrl && !key.meta && !key.tab) {
+              emitInput({ type: "sessions-search-input", input });
+            }
+            return;
+          }
+          if (view.sessionsPanel.mode === "preview") {
+            if (key.escape) emitInput({ type: "sessions-preview-close" });
+            return;
+          }
+          if (key.return) emitInput({ type: "sessions-resume" });
+          else if (key.upArrow) emitInput({ type: "sessions-move", delta: -1 });
+          else if (key.downArrow) emitInput({ type: "sessions-move", delta: 1 });
+          else if (input === "/" && !key.ctrl && !key.meta) {
+            emitInput({ type: "sessions-search" });
+          } else if (input === "v" && key.ctrl) {
+            emitInput({ type: "sessions-preview" });
+          }
+          return;
+        }
+        if (view.backgroundTaskOverlay) {
+          if (key.upArrow) emitInput({ type: "background-overlay-move", delta: -1 });
+          else if (key.downArrow) emitInput({ type: "background-overlay-move", delta: 1 });
+          else if (key.return) emitInput({ type: "background-overlay-toggle" });
+          else if (input.toLowerCase() === "x" && !key.ctrl && !key.meta) {
+            emitInput({ type: "background-overlay-stop" });
+          }
+          return;
+        }
+        if (commandPanelConsumesInput) {
+          if (key.upArrow) {
+            emitInput({ type: "command-panel-move", delta: -1 });
+            return;
+          }
+          if (key.downArrow) {
+            emitInput({ type: "command-panel-move", delta: 1 });
+            return;
+          }
+          if (key.return) {
+            emitInput({ type: "command-panel-toggle" });
+            return;
+          }
+          if (input.toLowerCase() === "x" && !key.ctrl && !key.meta) {
+            emitInput({ type: "command-panel-stop" });
+            return;
+          }
+          return;
+        }
+        if (view.commandPanel) return;
+      }
+      if (configPanelActive) return;
+      if (owner === "paste") {
+        if (pastePendingRef.current && key.return) {
+          enqueuePasteChunk("");
+          return;
+        }
+        if (pastePendingRef.current && key.escape) {
+          cancelPaste();
+          return;
+        }
+        enqueuePasteChunk(input);
+        return;
+      }
+      const slashVisible = slashCandidates.length > 0 && !slashHidden;
+      if (owner === "slash") {
+        if (terminalAction.type === "newline") {
+          updateBufferAndResetSelection((current) => bufferInsert(current, "\n"));
+          return;
+        }
+        if (key.escape) {
+          setSlashHidden(true);
+          setSlashSelection(-1);
+          return;
+        }
+        if (key.tab && !key.shift) {
+          if (slashSelection >= 0) {
+            const picked = slashCandidates[slashSelectionClamped];
+            if (picked) {
+              const spaceIndex = text2.indexOf(" ");
+              const args = spaceIndex >= 0 ? text2.slice(spaceIndex) : "";
+              const next = args ? `${picked.slash}${args}` : `${picked.slash} `;
+              resetBuffer(next);
+              setSlashHidden(false);
+              return;
+            }
+          }
+          return;
+        }
+        if (key.upArrow) {
+          if (slashSelection >= 0) {
+            setSlashSelection((current) => {
+              const safe = current < 0 ? 0 : current;
+              return safe === 0 ? slashCandidates.length - 1 : safe - 1;
+            });
+          }
+          return;
+        }
+        if (key.downArrow) {
+          if (slashSelection >= 0) {
+            setSlashSelection((current) => {
+              const safe = current < 0 ? 0 : current;
+              return safe >= slashCandidates.length - 1 ? 0 : safe + 1;
+            });
+          }
+          return;
+        }
+        if (key.return) {
+          if (slashSelection >= 0 && !text2.includes(" ")) {
+            const picked = slashCandidates[slashSelectionClamped];
+            if (picked && picked.slash !== text2) {
+              const submitText2 = picked.slash;
+              historyRef.current = historyAdd(historyRef.current, submitText2);
+              resetBuffer();
+              setSlashHidden(false);
+              clearHintNotice();
+              emitInput({ type: "submit", text: submitText2 });
+              return;
+            }
+          }
+          const submitText = text2.trim();
+          historyRef.current = historyAdd(historyRef.current, text2);
+          resetBuffer();
+          setSlashHidden(false);
+          clearHintNotice();
+          emitInput(submitText ? { type: "submit", text: submitText } : { type: "empty-submit" });
+          return;
+        }
+        return;
+      }
+      const inTaskMode = view.viewMode === "task" || view.viewMode === "pending";
+      const k = key;
+      if (inTaskMode && k.pageUp) {
+        emitInput({ type: "transcript-scroll", action: "halfPageUp" });
+        return;
+      }
+      if (inTaskMode && k.pageDown) {
+        emitInput({ type: "transcript-scroll", action: "halfPageDown" });
+        return;
+      }
+      if (inTaskMode && k.home && text2.length === 0) {
+        emitInput({ type: "transcript-scroll", action: "top" });
+        return;
+      }
+      if (inTaskMode && k.end && text2.length === 0) {
+        emitInput({ type: "transcript-scroll", action: "bottom" });
+        return;
+      }
+      if (terminalAction.type === "newline") {
+        updateBufferAndResetSelection((current) => bufferInsert(current, "\n"));
+        return;
+      }
+      if (key.return && text2.endsWith("\\")) {
+        const withoutBackslash = {
+          chars: buffer2.chars.slice(0, -1),
+          cursor: Math.max(0, buffer2.cursor - 1)
+        };
+        setBufferAndResetSelection(bufferInsert(withoutBackslash, "\n"));
+        return;
+      }
+      if (key.return) {
+        if (text2.length === 0 && view.agentProgressTree && view.agentProgressTree.cursor >= 0) {
+          emitInput({ type: "agent-tree-enter" });
+          return;
+        }
+        if (text2.length === 0 && view.taskSuggestions && view.taskSuggestions.length > 0) {
+          const index = Math.max(
+            0,
+            Math.min(view.taskSuggestionCursor ?? 0, view.taskSuggestions.length - 1)
+          );
+          const suggestion = view.taskSuggestions[index];
+          if (suggestion) {
+            emitInput({ type: "task-suggestion-action", suggestionId: suggestion.id });
+            return;
+          }
+        }
+        const isSlashSubmit = text2.startsWith("/");
+        const setupActive = view.composer.setupActive;
+        if (view.composer.busy && !isSlashSubmit && !setupActive) {
+          showHintNotice(
+            view.composer.busyHint ?? (view.language === "en-US" ? "Still working on the previous request. Press Ctrl+C to interrupt, then send again." : "\u6B63\u5728\u5904\u7406\u4E0A\u4E00\u6761\uFF0C\u6309 Ctrl+C \u53EF\u4E2D\u65AD\uFF0C\u7A0D\u540E\u518D\u53D1\u3002")
+          );
+          return;
+        }
+        if (slashVisible && slashSelection >= 0 && !text2.includes(" ")) {
+          const picked = slashCandidates[slashSelectionClamped];
+          if (picked && picked.slash !== text2) {
+            const submitText2 = picked.slash;
+            historyRef.current = historyAdd(historyRef.current, submitText2);
+            resetBuffer();
+            setSlashHidden(false);
+            clearHintNotice();
+            emitInput({ type: "submit", text: submitText2 });
+            return;
+          }
+        }
+        const submitText = text2.trim();
+        historyRef.current = historyAdd(historyRef.current, text2);
+        resetBuffer();
+        setSlashHidden(false);
+        clearHintNotice();
+        emitInput(submitText ? { type: "submit", text: submitText } : { type: "empty-submit" });
+        return;
+      }
+      if (key.tab && !key.shift) {
+        if (slashVisible && slashSelection >= 0) {
+          const picked = slashCandidates[slashSelectionClamped];
+          if (picked) {
+            const spaceIndex = text2.indexOf(" ");
+            const args = spaceIndex >= 0 ? text2.slice(spaceIndex) : "";
+            const next = args ? `${picked.slash}${args}` : `${picked.slash} `;
+            resetBuffer(next);
+            setSlashHidden(false);
+            return;
+          }
+        }
+        const ghost = computeGhostText(
+          text2,
+          slashCandidates.map((c) => ({ slash: c.slash, description: c.descriptionZh }))
+        );
+        if (ghost) {
+          resetBuffer(`${text2}${ghost} `);
+          return;
+        }
+        return;
+      }
+      if (key.tab && key.shift) {
+        emitInput({ type: "cycle-permission-mode" });
+        return;
+      }
+      if (key.escape) {
+        if (slashVisible && slashSelection >= 0) {
+          setSlashHidden(true);
+          setSlashSelection(-1);
+          return;
+        }
+        if (text2.length === 0 && view.agentProgressTree && view.agentProgressTree.cursor >= 0) {
+          emitInput({ type: "agent-tree-escape" });
+          return;
+        }
+        if (view.composer.busy) {
+          clearHintNotice();
+          emitInput({ type: "interrupt" });
+          return;
+        }
+        if (text2.length > 0) {
+          const now = Date.now();
+          if (now - lastEscAtRef.current < DOUBLE_PRESS_WINDOW_MS) {
+            lastEscAtRef.current = 0;
+            resetBuffer();
+            clearHintNotice();
+            return;
+          }
+          lastEscAtRef.current = now;
+          showHintNotice(view.language === "en-US" ? "Esc again to clear" : "\u518D\u6309 Esc \u6E05\u7A7A\u8F93\u5165");
+          return;
+        }
+        if (view.commandPanel || view.helpPanel || view.configPanel || view.btwPanel || view.sessionsPanel) {
+          clearHintNotice();
+          return;
+        }
+        clearHintNotice();
+        emitInput(view.composer.busy ? { type: "interrupt" } : { type: "escape" });
+        return;
+      }
+      if (text2.length === 0 && input.toLowerCase() === "x" && !key.ctrl && !key.meta && view.agentProgressTree && view.agentProgressTree.cursor >= 0) {
+        emitInput({ type: "agent-tree-close" });
+        return;
+      }
+      if (key.leftArrow || key.ctrl && input === "b") {
+        if (key.ctrl && key.leftArrow || key.meta) {
+          setBufferAndResetSelection(bufferWordLeft(buffer2));
+        } else {
+          setBufferAndResetSelection(bufferMoveLeft(buffer2));
+        }
+        return;
+      }
+      if (key.rightArrow || key.ctrl && input === "f") {
+        if (key.ctrl && key.rightArrow || key.meta) {
+          setBufferAndResetSelection(bufferWordRight(buffer2));
+        } else {
+          setBufferAndResetSelection(bufferMoveRight(buffer2));
+        }
+        return;
+      }
+      if (key.upArrow) {
+        if (slashVisible && slashSelection >= 0) {
+          setSlashSelection((current) => {
+            const safe = current < 0 ? 0 : current;
+            return safe === 0 ? slashCandidates.length - 1 : safe - 1;
+          });
+          return;
+        }
+        if (text2.length === 0 && view.taskSuggestions && view.taskSuggestions.length > 0) {
+          emitInput({ type: "task-suggestion-move", delta: -1 });
+          return;
+        }
+        if (text2.length === 0 && view.agentProgressTree && view.agentProgressTree.rows.length > 0) {
+          emitInput({ type: "agent-tree-move", delta: -1 });
+          return;
+        }
+        if (text2.length === 0 && inTaskMode) {
+          emitInput({ type: "transcript-scroll", action: "lineUp" });
+          return;
+        }
+        const moved = bufferMoveVisualUp(buffer2, maxWidth);
+        if (moved.cursor !== buffer2.cursor) {
+          setBufferAndResetSelection(moved);
+        } else {
+          const next = historyUp(historyRef.current, text2);
+          if (next) {
+            historyRef.current = next;
+            const histText = historyCurrentText(next);
+            if (histText !== void 0) resetBuffer(histText);
+          }
+        }
+        return;
+      }
+      if (key.downArrow) {
+        if (slashVisible && slashSelection >= 0) {
+          setSlashSelection((current) => {
+            const safe = current < 0 ? 0 : current;
+            return safe >= slashCandidates.length - 1 ? 0 : safe + 1;
+          });
+          return;
+        }
+        if (text2.length === 0 && view.taskSuggestions && view.taskSuggestions.length > 0) {
+          emitInput({ type: "task-suggestion-move", delta: 1 });
+          return;
+        }
+        if (text2.length === 0 && view.agentProgressTree && view.agentProgressTree.rows.length > 0) {
+          emitInput({ type: "agent-tree-move", delta: 1 });
+          return;
+        }
+        if (text2.length === 0 && inTaskMode) {
+          emitInput({ type: "transcript-scroll", action: "lineDown" });
+          return;
+        }
+        const moved = bufferMoveVisualDown(buffer2, maxWidth);
+        if (moved.cursor !== buffer2.cursor) {
+          setBufferAndResetSelection(moved);
+        } else {
+          const next = historyDown(historyRef.current);
+          if (next) {
+            historyRef.current = next;
+            const histText = historyCurrentText(next);
+            resetBuffer(histText ?? next.draft);
+          }
+        }
+        return;
+      }
+      if (key.home) {
+        setBufferAndResetSelection(bufferHome(buffer2));
+        return;
+      }
+      if (key.end) {
+        setBufferAndResetSelection(bufferEnd(buffer2));
+        return;
+      }
+      if (key.ctrl && input === "a") {
+        setBufferAndResetSelection(bufferHome(buffer2));
+        return;
+      }
+      if (key.ctrl && input === "e") {
+        setBufferAndResetSelection(bufferEnd(buffer2));
+        return;
+      }
+      if (key.ctrl && input === "u") {
+        setBufferAndResetSelection(bufferClearLine(buffer2));
+        return;
+      }
+      if (key.ctrl && input === "k") {
+        setBufferAndResetSelection(bufferKillToEnd(buffer2));
+        return;
+      }
+      if (key.ctrl && input === "w") {
+        setBufferAndResetSelection(bufferDeleteWordLeft(buffer2));
+        return;
+      }
+      if (key.ctrl && input === "c") {
+        if (text2.length > 0) {
+          const now = Date.now();
+          if (now - lastCtrlCAtRef.current < DOUBLE_PRESS_WINDOW_MS) {
+            lastCtrlCAtRef.current = 0;
+            resetBuffer();
+            clearHintNotice();
+            return;
+          }
+          lastCtrlCAtRef.current = now;
+          showHintNotice(
+            view.language === "en-US" ? "Ctrl+C again to clear" : "\u518D\u6309 Ctrl+C \u6E05\u7A7A\u8F93\u5165"
+          );
+          return;
+        }
+        clearHintNotice();
+        emitInput({ type: "interrupt" });
+        return;
+      }
+      if (key.ctrl && input === "v") {
+        return;
+      }
+      if (key.ctrl && input === "o") {
+        clearHintNotice();
+        emitInput({ type: "toggle-details" });
+        return;
+      }
+      if (terminalAction.type === "backspace") {
+        setBufferAndResetSelection(bufferBackspace(buffer2));
+        return;
+      }
+      if (terminalAction.type === "delete") {
+        setBufferAndResetSelection(bufferDelete(buffer2));
+        return;
+      }
+      if (terminalAction.type === "delete-word-left") {
+        setBufferAndResetSelection(bufferDeleteWordLeft(buffer2));
+        return;
+      }
+      if (terminalAction.type === "text" && terminalAction.text) {
+        updateBufferAndResetSelection((current) => bufferInsert(current, terminalAction.text));
+      }
+    },
+    { isActive: true }
+  );
+  const placeholderText = view.permission || view.composer.setupActive ? view.composer.placeholder : view.viewMode === "task" || view.viewMode === "pending" ? view.composer.taskPlaceholder : view.composer.placeholder;
+  const composerInnerWidth = Math.max(8, maxWidth - 4);
+  const { lines, truncatedAbove, truncatedBelow, cursorCol, cursorRow } = useMemo(
+    () => formatComposerRenderLines({
+      buffer,
+      placeholder: placeholderText,
+      masking: view.composer.masking,
+      noColor,
+      maxWidth: composerInnerWidth
+    }),
+    [buffer, placeholderText, view.composer.masking, noColor, composerInnerWidth]
+  );
+  void truncatedAbove;
+  void truncatedBelow;
+  const showSuggestions = !permissionActive && slashCandidates.length > 0 && slashSelection >= 0 && !slashHidden;
+  const declaredRow = composerCursorAnchorRowOffset({
+    textAnchorRowBase: view.viewMode === "home" ? 0 : 1,
+    permissionActive,
+    permissionActionCount: permissionActions.length,
+    showSuggestions,
+    slashCandidateCount: slashCandidates.length,
+    cursorRow
+  });
+  useAnchoredCursor(
+    permissionActive ? null : { row: declaredRow, col: cursorCol },
+    anchorRef,
+    capability
+  );
+  const placeholderColor = noColor ? void 0 : "gray";
+  const color = text ? void 0 : placeholderColor;
+  const ghostSuffix = useMemo(() => {
+    if (permissionActive || slashHidden) return void 0;
+    return computeGhostText(
+      text,
+      slashCandidates.map((c) => ({ slash: c.slash, description: c.descriptionZh }))
+    );
+  }, [text, slashCandidates, permissionActive, slashHidden]);
+  const showUnknownHint = false;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      width: maxWidth,
+      borderStyle: "round",
+      borderColor: theme.border ?? theme.muted,
+      paddingLeft: 2,
+      paddingRight: 1,
+      children: [
+        permissionActive && view.permission ? /* @__PURE__ */ jsx(
+          PermissionControl,
+          {
+            permission: view.permission,
+            actions: permissionActions,
+            focused: permissionFocus,
+            theme,
+            width: composerInnerWidth,
+            language: view.language
+          }
+        ) : null,
+        showSuggestions ? /* @__PURE__ */ jsx(
+          SlashSuggestions,
+          {
+            candidates: slashCandidates,
+            selectedIndex: slashSelectionClamped,
+            theme,
+            language: view.language,
+            width: composerInnerWidth,
+            hint: view.language === "en-US" ? "Tab accept \xB7 \u2191\u2193 pick \xB7 Esc hide \xB7 Enter submit" : "Tab \u9009\u4E2D \xB7 \u2191\u2193 \u5207\u6362 \xB7 Esc \u9690\u85CF \xB7 Enter \u63D0\u4EA4"
+          }
+        ) : null,
+        /* @__PURE__ */ jsxs(Box, { width: "100%", flexDirection: "row", alignItems: "flex-start", children: [
+          /* @__PURE__ */ jsx(Text, { color: theme.muted, dimColor: !text, children: PROMPT_MARKER }),
+          /* @__PURE__ */ jsx(
+            Box,
+            {
+              ref: anchorRef,
+              flexDirection: "column",
+              width: Math.max(4, composerInnerWidth - displayWidthOf(PROMPT_MARKER)),
+              children: lines.map((line, index) => {
+                return /* @__PURE__ */ jsxs(Text, { color, bold: Boolean(text), children: [
+                  sliceWidth(line, Math.max(4, composerInnerWidth - displayWidthOf(PROMPT_MARKER))),
+                  index === lines.length - 1 && ghostSuffix ? /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: ghostSuffix }) : null
+                ] }, `${index}-${line}`);
+              })
+            }
+          )
+        ] }),
+        showUnknownHint ? /* @__PURE__ */ jsx(Text, { color: theme.muted, children: fitText(formatUnknownSlashCommand(text, view.language), composerInnerWidth) }) : null,
+        hintNotice ? /* @__PURE__ */ jsx(Text, { color: theme.muted, children: fitText(hintNotice, composerInnerWidth) }) : null
+      ]
+    }
+  );
+}
+function PermissionControl({
+  permission,
+  actions,
+  focused,
+  theme,
+  width,
+  language
+}) {
+  const isEn = language === "en-US";
+  const cardWidth = Math.min(width, 76);
+  const innerWidth = Math.max(20, cardWidth - 4);
+  const headline = isEn ? "Permission requested" : "\u9700\u8981\u60A8\u6388\u6743";
+  const summaryLine = permission.actionSummary && permission.actionSummary.length > 0 ? permission.actionSummary : isEn ? `Use tool: ${permission.toolName}` : `\u4F7F\u7528\u5DE5\u5177\uFF1A${permission.toolName}`;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor: theme.permission ?? theme.border,
+      paddingX: 1,
+      width: cardWidth,
+      children: [
+        /* @__PURE__ */ jsx(Text, { bold: true, color: theme.permission ?? theme.assistantText ?? theme.brand, children: fitText(headline, innerWidth) }),
+        /* @__PURE__ */ jsx(Text, { color: theme.muted, children: fitText(summaryLine, innerWidth) }),
+        /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: "\u2500".repeat(Math.min(innerWidth, 60)) }),
+        /* @__PURE__ */ jsx(PermissionActionRow, { actions, focused, theme, width: innerWidth }),
+        /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: fitText(
+          isEn ? "Enter confirm \xB7 Tab switch \xB7 d details \xB7 Esc cancel" : "Enter \u786E\u8BA4 \xB7 Tab \u5207\u6362 \xB7 d \u8BE6\u60C5 \xB7 Esc \u53D6\u6D88",
+          innerWidth
+        ) })
+      ]
+    }
+  );
+}
+function PermissionActionRow({
+  actions,
+  focused,
+  theme,
+  width
+}) {
+  const segments = actions.map((action) => {
+    const isFocused = action.id === focused;
+    const shortcut = action.shortcut ? ` (${action.shortcut})` : "";
+    const text = isFocused ? `[ ${action.label}${shortcut} ]` : `  ${action.label}${shortcut}  `;
+    return { text, focused: isFocused, id: action.id };
+  });
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", width, children: segments.map((s) => /* @__PURE__ */ jsx(
+    Text,
+    {
+      color: s.focused ? void 0 : theme.muted,
+      backgroundColor: s.focused && theme.mode !== "no-color" ? theme.permission : void 0,
+      inverse: s.focused,
+      children: fitText(s.text, Math.max(8, width - 2))
+    },
+    s.id
+  )) });
+}
+function buildPermissionActions(language, actions) {
+  if (actions && actions.length > 0) {
+    return actions;
+  }
+  const isEn = language === "en-US";
+  return [
+    { id: "allow_once", label: isEn ? "Yes" : "\u662F", shortcut: "y" },
+    {
+      id: "allow_always_tool",
+      label: isEn ? "Allow future similar actions" : "\u5141\u8BB8\u4EE5\u540E\u8FD9\u7C7B\u64CD\u4F5C",
+      shortcut: "a"
+    },
+    { id: "deny", label: isEn ? "No" : "\u5426", shortcut: "n" },
+    { id: "details", label: isEn ? "Details" : "\u8BE6\u60C5", shortcut: "d" }
+  ];
+}
+function cyclePermissionFocus(actions, current, delta) {
+  const order = actions.map((a) => a.id);
+  const ids = order.length > 0 ? order : PERMISSION_ACTION_ORDER;
+  const idx = ids.indexOf(current);
+  const safeIdx = idx < 0 ? 0 : idx;
+  const next = (safeIdx + delta + ids.length) % ids.length;
+  return ids[next] ?? ids[0] ?? "allow_once";
+}
+function resolveActionId(actions, primary, legacy) {
+  if (actions.some((a) => a.id === primary)) return primary;
+  if (actions.some((a) => a.id === legacy)) return legacy;
+  return primary;
+}
+function slashHead(value) {
+  const space = value.indexOf(" ");
+  return space >= 0 ? value.slice(0, space) : value;
+}
+function formatComposerRenderLines({
+  buffer,
+  placeholder,
+  masking,
+  noColor,
+  maxWidth
+}) {
+  void noColor;
+  const text = bufferToString(buffer);
+  const displayText = text ? masking ? "*".repeat(buffer.chars.length) : text : "";
+  if (!displayText) {
+    return {
+      lines: [placeholder],
+      truncatedAbove: 0,
+      truncatedBelow: 0,
+      cursorCol: 0,
+      cursorRow: 0
+    };
+  }
+  const rawLines = displayText.split("\n");
+  const { row: cursorLineIndex, col: cursorCharCol } = getCursorLinePosition(buffer);
+  const composerWidth = Math.max(8, maxWidth ?? 80);
+  const softLines = [];
+  let cursorSoftIndex = 0;
+  let cursorOutCol = 0;
+  for (let rawIndex = 0; rawIndex < rawLines.length; rawIndex++) {
+    const rawLine = rawLines[rawIndex] ?? "";
+    const chars = Array.from(masking ? "*".repeat(Array.from(rawLine).length) : rawLine);
+    let startChar = 0;
+    while (startChar < chars.length || chars.length === 0 && startChar === 0) {
+      const budget = Math.max(4, composerWidth - displayWidthOf(PROMPT_MARKER));
+      let width = 0;
+      let endChar = startChar;
+      while (endChar < chars.length) {
+        const next = charWidth(chars[endChar] ?? "");
+        if (width > 0 && width + next > budget) break;
+        width += next;
+        endChar++;
+      }
+      if (endChar === startChar && chars.length > 0) endChar++;
+      const text2 = chars.slice(startChar, endChar).join("");
+      const softIndex = softLines.length;
+      softLines.push({ text: text2, rawLineIndex: rawIndex, startChar, endChar });
+      if (rawIndex === cursorLineIndex && cursorCharCol >= startChar && cursorCharCol <= endChar) {
+        cursorSoftIndex = softIndex;
+        let cursorWidth = 0;
+        for (let i = startChar; i < cursorCharCol && i < chars.length; i++) {
+          cursorWidth += charWidth(chars[i] ?? "");
+        }
+        cursorOutCol = cursorWidth;
+      }
+      if (chars.length === 0) break;
+      startChar = endChar;
+    }
+  }
+  const totalLines = softLines.length;
+  let startLine = 0;
+  let endLineExclusive = totalLines;
+  if (totalLines > COMPOSER_MAX_VISIBLE_LINES) {
+    const half = Math.floor(COMPOSER_MAX_VISIBLE_LINES / 2);
+    startLine = Math.max(0, cursorSoftIndex - half);
+    endLineExclusive = startLine + COMPOSER_MAX_VISIBLE_LINES;
+    if (endLineExclusive > totalLines) {
+      endLineExclusive = totalLines;
+      startLine = Math.max(0, endLineExclusive - COMPOSER_MAX_VISIBLE_LINES);
+    }
+  }
+  const renderedLines = softLines.slice(startLine, endLineExclusive).map((line) => line.text);
+  const truncatedAbove = startLine;
+  const truncatedBelow = totalLines - endLineExclusive;
+  const cursorVisibleRow = Math.max(
+    0,
+    Math.min(cursorSoftIndex - startLine, renderedLines.length - 1)
+  );
+  return {
+    lines: renderedLines,
+    truncatedAbove,
+    truncatedBelow,
+    cursorCol: maxWidth && cursorOutCol > maxWidth ? maxWidth : cursorOutCol,
+    cursorRow: cursorVisibleRow
+  };
+}
+function sliceWidth(value, max) {
+  let width = 0;
+  let result = "";
+  for (const ch of value) {
+    const next = width + charWidth(ch);
+    if (next > max) break;
+    result += ch;
+    width = next;
+  }
+  return result;
+}
+function getCursorLinePosition(buffer) {
+  let row = 0;
+  let col = 0;
+  for (let i = 0; i < buffer.cursor && i < buffer.chars.length; i++) {
+    if (buffer.chars[i] === "\n") {
+      row++;
+      col = 0;
+    } else {
+      col++;
+    }
+  }
+  return { row, col };
+}
+function displayWidthOf(value) {
+  let width = 0;
+  for (const char of value) {
+    width += charWidth(char);
+  }
+  return width;
+}
+function splitLineAtDisplayCol(line, col) {
+  const chars = Array.from(line);
+  let acc = 0;
+  let i = 0;
+  for (; i < chars.length; i++) {
+    const ch = chars[i] ?? "";
+    const w = charWidth(ch);
+    if (acc + w > col) break;
+    acc += w;
+  }
+  if (i >= chars.length) {
+    return { before: chars.join(""), cursorChar: "", after: "" };
+  }
+  const before = chars.slice(0, i).join("");
+  const cursorChar = chars[i] ?? " ";
+  const after = chars.slice(i + 1).join("");
+  return { before, cursorChar, after };
+}
+function composerCursorAnchorRowOffset({
+  textAnchorRowBase = 1,
+  permissionActive,
+  permissionActionCount,
+  showSuggestions,
+  slashCandidateCount,
+  cursorRow
+}) {
+  let offset = 0;
+  if (permissionActive) {
+    offset += 2 + Math.max(0, permissionActionCount) + 2;
+  }
+  if (showSuggestions) {
+    offset += Math.max(0, slashCandidateCount) + 1;
+  }
+  return offset + Math.max(0, textAnchorRowBase) + Math.max(0, cursorRow);
+}
+function hasSelectableCommandPanelRows(panel) {
+  return Boolean(
+    panel?.sections?.some(
+      (section) => section.rows.some(
+        (row) => typeof row !== "string" && row.selectable !== false && Boolean(row.taskRef)
+      )
+    )
+  );
+}
+function handleComposerInput(text, input, key) {
+  const normalized = normalizeTerminalInput(input, {
+    backspace: key.backspace === true,
+    delete: key.delete === true,
+    ctrl: key.ctrl === true,
+    meta: key.meta === true,
+    return: key.return === true,
+    shift: key.shift === true
+  });
+  if (key.escape) {
+    return { kind: "emit", event: { type: "escape" }, nextText: "" };
+  }
+  if (normalized.type === "newline") {
+    return { kind: "append", text: "\n" };
+  }
+  if (key.return) {
+    const submitted = text.trim();
+    return {
+      kind: "emit",
+      event: submitted ? { type: "submit", text: submitted } : { type: "empty-submit" },
+      nextText: ""
+    };
+  }
+  if (normalized.type === "backspace" || normalized.type === "delete") {
+    return { kind: "set", text: Array.from(text).slice(0, -1).join("") };
+  }
+  if (normalized.type === "ignore") {
+    return { kind: "ignore" };
+  }
+  if (normalized.type === "text") {
+    return { kind: "append", text: normalized.text };
+  }
+  return { kind: "ignore" };
+}
+
+export {
+  createEditBuffer,
+  bufferToString,
+  bufferDisplayWidth,
+  bufferInsert,
+  bufferBackspace,
+  bufferDelete,
+  bufferMoveLeft,
+  bufferMoveRight,
+  bufferHome,
+  bufferEnd,
+  bufferWordLeft,
+  bufferWordRight,
+  bufferDeleteWordLeft,
+  bufferClearLine,
+  bufferKillToEnd,
+  bufferMoveUp,
+  bufferMoveDown,
+  bufferMoveVisualUp,
+  bufferMoveVisualDown,
+  sanitizeComposerInput,
+  createInputHistory,
+  historyAdd,
+  historyUp,
+  historyDown,
+  historyCurrentText,
+  shouldEnterPastePath,
+  selectInputOwner,
+  isNavigationKey,
+  isVerticalNavigationKey,
+  OWNER_PRIORITY,
+  shouldOwnerBePaste,
+  isDoublePressWithin,
+  shouldUnstickSlashHidden,
+  isMultilineEnterSequence2 as isMultilineEnterSequence,
+  OWNER_PASTE_THRESHOLD,
+  Composer,
+  formatComposerRenderLines,
+  splitLineAtDisplayCol,
+  composerCursorAnchorRowOffset,
+  handleComposerInput
+};