@qwen-code/qwen-code 0.23.2 → 0.23.3-nightly.20260911.aaa6a32aae

package/chunks/{chunk-B25JYXZE.js → chunk-ONLJBOI2.js}

@@ -1,29 +1,44 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  disableMouseEvents,
+  enableMouseEvents,
+  useKeypress,
+  useKeypressContext
+} from "./chunk-SAOJHRWY.js";
 import {
   ICON
-} from "./chunk-WXD7INFV.js";
+} from "./chunk-EO4U2X47.js";
 import {
   theme
 } from "./chunk-4LIPOIXS.js";
 import {
   require_jsx_runtime
 } from "./chunk-SV5PQVQE.js";
+import {
+  Box_default,
+  Text,
+  use_stdin_default,
+  use_stdout_default
+} from "./chunk-O4KNCAX4.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   sanitizeForOsc,
   wrapForMultiplexer
-} from "./chunk-XDNFODER.js";
+} from "./chunk-TUIW5LLK.js";
 import {
   MAIN_SOURCE,
   uiTelemetryService
-} from "./chunk-F2NYVASI.js";
+} from "./chunk-WXAWG3JS.js";
 import {
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MWIO7MF6.js";
+} from "./chunk-2WSLXP3W.js";
+import {
+  createDebugLogger
+} from "./chunk-ZAFYHRVY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -32,9 +47,23 @@ import {
   __toESM
 } from "./chunk-J2S4EL5Y.js";
 
-// packages/cli/src/ui/contexts/SessionContext.tsx
+// packages/cli/src/ui/contexts/SettingsContext.tsx
 init_esbuild_shims();
 var import_react = __toESM(require_react(), 1);
+var SettingsContext = import_react.default.createContext(
+  void 0
+);
+var useSettings = /* @__PURE__ */ __name(() => {
+  const context = (0, import_react.useContext)(SettingsContext);
+  if (context === void 0) {
+    throw new Error("useSettings must be used within a SettingsProvider");
+  }
+  return context;
+}, "useSettings");
+
+// packages/cli/src/ui/contexts/SessionContext.tsx
+init_esbuild_shims();
+var import_react2 = __toESM(require_react(), 1);
 var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
 var EMPTY_SKILL_METRICS = {
   totalCalls: 0,
@@ -231,7 +260,7 @@ function getMetricsForDisplay(sessionId) {
   );
 }
 __name(getMetricsForDisplay, "getMetricsForDisplay");
-var SessionStatsContext = (0, import_react.createContext)(
+var SessionStatsContext = (0, import_react2.createContext)(
   void 0
 );
 var createDefaultStats = /* @__PURE__ */ __name((sessionId = "") => ({
@@ -242,10 +271,10 @@ var createDefaultStats = /* @__PURE__ */ __name((sessionId = "") => ({
   promptCount: 0
 }), "createDefaultStats");
 var SessionStatsProvider = /* @__PURE__ */ __name(({ sessionId, children }) => {
-  const [stats, setStats] = (0, import_react.useState)(
+  const [stats, setStats] = (0, import_react2.useState)(
     () => createDefaultStats(sessionId ?? "")
   );
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.useEffect)(() => {
     const handleUpdate = /* @__PURE__ */ __name(({
       metrics,
       lastPromptTokenCount
@@ -271,29 +300,29 @@ var SessionStatsProvider = /* @__PURE__ */ __name(({ sessionId, children }) => {
       uiTelemetryService.off("update", handleUpdate);
     };
   }, []);
-  const startNewSession = (0, import_react.useCallback)((sessionId2) => {
+  const startNewSession = (0, import_react2.useCallback)((sessionId2) => {
     setStats(() => ({
       ...createDefaultStats(sessionId2),
       lastPromptTokenCount: uiTelemetryService.getLastPromptTokenCount()
     }));
   }, []);
-  const startNewPrompt = (0, import_react.useCallback)(() => {
+  const startNewPrompt = (0, import_react2.useCallback)(() => {
     setStats((prevState) => ({
       ...prevState,
       promptCount: prevState.promptCount + 1
     }));
   }, []);
-  const getPromptCount = (0, import_react.useCallback)(
+  const getPromptCount = (0, import_react2.useCallback)(
     () => stats.promptCount,
     [stats.promptCount]
   );
-  const seedPromptCount = (0, import_react.useCallback)((count) => {
+  const seedPromptCount = (0, import_react2.useCallback)((count) => {
     setStats((prevState) => ({
       ...prevState,
       promptCount: Math.max(prevState.promptCount, count)
     }));
   }, []);
-  const value = (0, import_react.useMemo)(
+  const value = (0, import_react2.useMemo)(
     () => ({
       stats,
       startNewSession,
@@ -306,7 +335,7 @@ var SessionStatsProvider = /* @__PURE__ */ __name(({ sessionId, children }) => {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SessionStatsContext.Provider, { value, children });
 }, "SessionStatsProvider");
 var useSessionStats = /* @__PURE__ */ __name(() => {
-  const context = (0, import_react.useContext)(SessionStatsContext);
+  const context = (0, import_react2.useContext)(SessionStatsContext);
   if (context === void 0) {
     throw new Error(
       "useSessionStats must be used within a SessionStatsProvider"
@@ -315,6 +344,50 @@ var useSessionStats = /* @__PURE__ */ __name(() => {
   return context;
 }, "useSessionStats");
 
+// packages/cli/src/ui/hooks/useTerminalSize.ts
+init_esbuild_shims();
+var import_react3 = __toESM(require_react(), 1);
+function getTerminalSize() {
+  return {
+    columns: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24
+  };
+}
+__name(getTerminalSize, "getTerminalSize");
+var currentSize = getTerminalSize();
+var subscribers = /* @__PURE__ */ new Set();
+function handleResize() {
+  currentSize = getTerminalSize();
+  for (const notify of subscribers) {
+    notify(currentSize);
+  }
+}
+__name(handleResize, "handleResize");
+function subscribe(callback) {
+  if (subscribers.size === 0) {
+    currentSize = getTerminalSize();
+    process.stdout.on("resize", handleResize);
+  }
+  subscribers.add(callback);
+  return () => {
+    subscribers.delete(callback);
+    if (subscribers.size === 0) {
+      process.stdout.off("resize", handleResize);
+    }
+  };
+}
+__name(subscribe, "subscribe");
+function useTerminalSize() {
+  const [size, setSize] = (0, import_react3.useState)(getTerminalSize);
+  (0, import_react3.useEffect)(() => {
+    const unsubscribe = subscribe(setSize);
+    setSize(currentSize);
+    return unsubscribe;
+  }, []);
+  return size;
+}
+__name(useTerminalSize, "useTerminalSize");
+
 // packages/cli/src/ui/utils/osc8.ts
 init_esbuild_shims();
 function osc8Open(url) {
@@ -487,9 +560,6 @@ function formatDuration(ms) {
 }
 __name(formatDuration, "formatDuration");
 
-// packages/cli/src/ui/keyMatchers.ts
-init_esbuild_shims();
-
 // packages/cli/src/config/keyBindings.ts
 init_esbuild_shims();
 var Command = /* @__PURE__ */ ((Command2) => {
@@ -688,6 +758,7 @@ var defaultKeyBindings = {
 };
 
 // packages/cli/src/ui/keyMatchers.ts
+init_esbuild_shims();
 function matchKeyBinding(keyBinding, key) {
   let keyMatches = false;
   if (keyBinding.key !== void 0) {
@@ -733,6 +804,781 @@ function createKeyMatchers(config = defaultKeyBindings) {
 __name(createKeyMatchers, "createKeyMatchers");
 var keyMatchers = createKeyMatchers(defaultKeyBindings);
 
+// packages/cli/src/ui/contexts/VirtualViewportContext.tsx
+init_esbuild_shims();
+var import_react4 = __toESM(require_react(), 1);
+var VirtualViewportContext = (0, import_react4.createContext)(
+  void 0
+);
+function useVirtualViewport(fallback) {
+  return (0, import_react4.useContext)(VirtualViewportContext) ?? fallback ?? false;
+}
+__name(useVirtualViewport, "useVirtualViewport");
+
+// packages/cli/src/ui/context-menu/ContextMenuContext.tsx
+init_esbuild_shims();
+var import_react5 = __toESM(require_react(), 1);
+var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
+var ContextMenuContext = (0, import_react5.createContext)({
+  menu: null,
+  selectedIndex: 0,
+  openMenu: /* @__PURE__ */ __name(() => {
+  }, "openMenu"),
+  closeMenu: /* @__PURE__ */ __name(() => {
+  }, "closeMenu"),
+  setSelectedIndex: /* @__PURE__ */ __name(() => {
+  }, "setSelectedIndex"),
+  executeIndex: /* @__PURE__ */ __name(() => {
+  }, "executeIndex")
+});
+var ContextMenuProvider = /* @__PURE__ */ __name(({ children, onMenuChange }) => {
+  const [menu, setMenu] = (0, import_react5.useState)(null);
+  const [selectedIndex, setSelectedIndexState] = (0, import_react5.useState)(0);
+  const menuRef = (0, import_react5.useRef)(null);
+  menuRef.current = menu;
+  const openMenu = (0, import_react5.useCallback)(
+    (items, position) => {
+      if (items.length === 0) return;
+      setMenu({ items, position });
+      setSelectedIndexState(0);
+    },
+    []
+  );
+  const closeMenu = (0, import_react5.useCallback)(() => {
+    menuRef.current = null;
+    setMenu(null);
+  }, []);
+  (0, import_react5.useEffect)(() => {
+    onMenuChange?.(menu !== null);
+  }, [menu, onMenuChange]);
+  const setSelectedIndex = (0, import_react5.useCallback)((index) => {
+    setSelectedIndexState(index);
+  }, []);
+  const executeIndex = (0, import_react5.useCallback)((index) => {
+    const current = menuRef.current;
+    menuRef.current = null;
+    setMenu(null);
+    current?.items[index]?.onSelect();
+  }, []);
+  const value = (0, import_react5.useMemo)(
+    () => ({
+      menu,
+      selectedIndex,
+      openMenu,
+      closeMenu,
+      setSelectedIndex,
+      executeIndex
+    }),
+    [menu, selectedIndex, openMenu, closeMenu, setSelectedIndex, executeIndex]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ContextMenuContext.Provider, { value, children });
+}, "ContextMenuProvider");
+function useContextMenu() {
+  return (0, import_react5.useContext)(ContextMenuContext);
+}
+__name(useContextMenu, "useContextMenu");
+function contextMenuSize(items) {
+  const longest = items.reduce(
+    (max, item) => Math.max(max, item.label.length),
+    0
+  );
+  return { width: longest + 4, height: items.length + 2 };
+}
+__name(contextMenuSize, "contextMenuSize");
+function clampMenuPosition(desired, size, terminalColumns, terminalRows) {
+  return {
+    x: Math.max(0, Math.min(desired.x, terminalColumns - size.width)),
+    y: Math.max(0, Math.min(desired.y, terminalRows - size.height))
+  };
+}
+__name(clampMenuPosition, "clampMenuPosition");
+
+// packages/cli/src/ui/hooks/use-mouse-tracking-enabled.ts
+init_esbuild_shims();
+var import_react6 = __toESM(require_react(), 1);
+function useMouseTrackingEnabled() {
+  return (0, import_react6.useContext)(SettingsContext)?.merged.ui?.mouseTracking !== false;
+}
+__name(useMouseTrackingEnabled, "useMouseTrackingEnabled");
+
+// packages/cli/src/ui/components/shared/RadioButtonSelect.tsx
+init_esbuild_shims();
+
+// packages/cli/src/ui/components/shared/BaseSelectionList.tsx
+init_esbuild_shims();
+var import_react10 = __toESM(require_react(), 1);
+
+// packages/cli/src/ui/hooks/useSelectionList.ts
+init_esbuild_shims();
+var import_react7 = __toESM(require_react(), 1);
+var debugLogger = createDebugLogger("SELECTION_LIST");
+var NUMBER_INPUT_TIMEOUT_MS = 1e3;
+var findNextValidIndex = /* @__PURE__ */ __name((currentIndex, direction, items) => {
+  const len = items.length;
+  if (len === 0) return currentIndex;
+  let nextIndex = currentIndex;
+  const step = direction === "down" ? 1 : -1;
+  for (let i = 0; i < len; i++) {
+    nextIndex = (nextIndex + step + len) % len;
+    if (!items[nextIndex]?.disabled) {
+      return nextIndex;
+    }
+  }
+  return currentIndex;
+}, "findNextValidIndex");
+var computeInitialIndex = /* @__PURE__ */ __name((initialIndex, items, initialKey) => {
+  if (items.length === 0) {
+    return 0;
+  }
+  if (initialKey !== void 0) {
+    for (let i = 0; i < items.length; i++) {
+      if (items[i].key === initialKey && !items[i].disabled) {
+        return i;
+      }
+    }
+  }
+  let targetIndex = initialIndex;
+  if (targetIndex < 0 || targetIndex >= items.length) {
+    targetIndex = 0;
+  }
+  if (items[targetIndex]?.disabled) {
+    const nextValid = findNextValidIndex(targetIndex, "down", items);
+    targetIndex = nextValid;
+  }
+  return targetIndex;
+}, "computeInitialIndex");
+var areItemsStructurallyEqual = /* @__PURE__ */ __name((a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i]?.key !== b[i]?.key || a[i]?.disabled !== b[i]?.disabled) {
+      return false;
+    }
+  }
+  return true;
+}, "areItemsStructurallyEqual");
+function selectionListReducer(state, action) {
+  switch (action.type) {
+    case "SET_ACTIVE_INDEX": {
+      const { index, items } = action.payload;
+      if (index === state.activeIndex) {
+        return state;
+      }
+      if (index >= 0 && index < items.length) {
+        return { ...state, activeIndex: index, pendingHighlight: true };
+      }
+      return state;
+    }
+    case "MOVE_UP": {
+      const { items } = action.payload;
+      const newIndex = findNextValidIndex(state.activeIndex, "up", items);
+      if (newIndex !== state.activeIndex) {
+        return { ...state, activeIndex: newIndex, pendingHighlight: true };
+      }
+      return state;
+    }
+    case "MOVE_DOWN": {
+      const { items } = action.payload;
+      const newIndex = findNextValidIndex(state.activeIndex, "down", items);
+      if (newIndex !== state.activeIndex) {
+        return { ...state, activeIndex: newIndex, pendingHighlight: true };
+      }
+      return state;
+    }
+    case "SELECT_CURRENT": {
+      return { ...state, pendingSelect: true };
+    }
+    case "INITIALIZE": {
+      const { initialIndex, items } = action.payload;
+      const initialIndexChanged = initialIndex !== state.initialIndex;
+      const activeKey = !initialIndexChanged && state.activeIndex !== state.initialIndex ? state.items[state.activeIndex]?.key : void 0;
+      const targetIndex = computeInitialIndex(initialIndex, items, activeKey);
+      const itemsStructurallyEqual = areItemsStructurallyEqual(
+        items,
+        state.items
+      );
+      if (!initialIndexChanged && targetIndex === state.activeIndex && itemsStructurallyEqual) {
+        return state;
+      }
+      return {
+        ...state,
+        items: itemsStructurallyEqual ? state.items : items,
+        activeIndex: targetIndex,
+        initialIndex,
+        pendingHighlight: false
+      };
+    }
+    case "CLEAR_PENDING_FLAGS": {
+      return {
+        ...state,
+        pendingHighlight: false,
+        pendingSelect: false
+      };
+    }
+    default: {
+      const exhaustiveCheck = action;
+      debugLogger.error(`Unknown selection list action: ${exhaustiveCheck}`);
+      return state;
+    }
+  }
+}
+__name(selectionListReducer, "selectionListReducer");
+function useSelectionList({
+  items,
+  initialIndex = 0,
+  onSelect,
+  onHighlight,
+  isFocused = true,
+  showNumbers = false,
+  disableVimNav = false
+}) {
+  const [state, dispatch] = (0, import_react7.useReducer)(selectionListReducer, {
+    activeIndex: computeInitialIndex(initialIndex, items),
+    initialIndex,
+    pendingHighlight: false,
+    pendingSelect: false,
+    items
+  });
+  const numberInputRef = (0, import_react7.useRef)("");
+  const numberInputTimer = (0, import_react7.useRef)(null);
+  (0, import_react7.useEffect)(() => {
+    dispatch({ type: "INITIALIZE", payload: { initialIndex, items } });
+  }, [initialIndex, items]);
+  (0, import_react7.useEffect)(() => {
+    let needsClear = false;
+    if (state.pendingHighlight && items[state.activeIndex]) {
+      onHighlight?.(items[state.activeIndex].value);
+      needsClear = true;
+    }
+    if (state.pendingSelect && items[state.activeIndex]) {
+      const currentItem = items[state.activeIndex];
+      if (currentItem && !currentItem.disabled) {
+        onSelect(currentItem.value);
+      }
+      needsClear = true;
+    }
+    if (needsClear) {
+      dispatch({ type: "CLEAR_PENDING_FLAGS" });
+    }
+  }, [
+    state.pendingHighlight,
+    state.pendingSelect,
+    state.activeIndex,
+    items,
+    onHighlight,
+    onSelect
+  ]);
+  (0, import_react7.useEffect)(
+    () => () => {
+      if (numberInputTimer.current) {
+        clearTimeout(numberInputTimer.current);
+      }
+    },
+    []
+  );
+  useKeypress(
+    (key) => {
+      const { sequence, name } = key;
+      const isNumeric = showNumbers && /^[0-9]$/.test(sequence);
+      if (!isNumeric && numberInputTimer.current) {
+        clearTimeout(numberInputTimer.current);
+        numberInputRef.current = "";
+      }
+      if (keyMatchers["selectionUp" /* SELECTION_UP */](key)) {
+        if (disableVimNav && key.name === "k" && !key.ctrl) {
+        } else {
+          dispatch({ type: "MOVE_UP", payload: { items } });
+          return;
+        }
+      }
+      if (keyMatchers["selectionDown" /* SELECTION_DOWN */](key)) {
+        if (disableVimNav && key.name === "j" && !key.ctrl) {
+        } else {
+          dispatch({ type: "MOVE_DOWN", payload: { items } });
+          return;
+        }
+      }
+      if (name === "return") {
+        dispatch({ type: "SELECT_CURRENT", payload: { items } });
+        return;
+      }
+      if (isNumeric) {
+        if (numberInputTimer.current) {
+          clearTimeout(numberInputTimer.current);
+        }
+        const newNumberInput = numberInputRef.current + sequence;
+        numberInputRef.current = newNumberInput;
+        const targetIndex = Number.parseInt(newNumberInput, 10) - 1;
+        if (newNumberInput === "0") {
+          numberInputTimer.current = setTimeout(() => {
+            numberInputRef.current = "";
+          }, NUMBER_INPUT_TIMEOUT_MS);
+          return;
+        }
+        if (targetIndex >= 0 && targetIndex < items.length) {
+          dispatch({
+            type: "SET_ACTIVE_INDEX",
+            payload: { index: targetIndex, items }
+          });
+          const potentialNextNumber = Number.parseInt(newNumberInput + "0", 10);
+          if (potentialNextNumber > items.length) {
+            dispatch({
+              type: "SELECT_CURRENT",
+              payload: { items }
+            });
+            numberInputRef.current = "";
+          } else {
+            numberInputTimer.current = setTimeout(() => {
+              dispatch({
+                type: "SELECT_CURRENT",
+                payload: { items }
+              });
+              numberInputRef.current = "";
+            }, NUMBER_INPUT_TIMEOUT_MS);
+          }
+        } else {
+          numberInputRef.current = "";
+        }
+      }
+    },
+    { isActive: !!(isFocused && items.length > 0) }
+  );
+  const setActiveIndex = /* @__PURE__ */ __name((index) => {
+    dispatch({
+      type: "SET_ACTIVE_INDEX",
+      payload: { index, items }
+    });
+  }, "setActiveIndex");
+  const selectIndex = /* @__PURE__ */ __name((index) => {
+    if (items[index]?.disabled) return;
+    dispatch({ type: "SET_ACTIVE_INDEX", payload: { index, items } });
+    dispatch({ type: "SELECT_CURRENT", payload: { items } });
+  }, "selectIndex");
+  return {
+    activeIndex: state.activeIndex,
+    setActiveIndex,
+    selectIndex
+  };
+}
+__name(useSelectionList, "useSelectionList");
+
+// packages/cli/src/ui/components/shared/RowMouseController.tsx
+init_esbuild_shims();
+var import_react9 = __toESM(require_react(), 1);
+
+// packages/cli/src/ui/hooks/useMouseEvents.ts
+init_esbuild_shims();
+var import_react8 = __toESM(require_react(), 1);
+var mouseModeRefs = /* @__PURE__ */ new Map();
+function effectiveTracking(entry) {
+  if (entry.any > 0) return "any";
+  if (entry.button > 0) return "button";
+  return null;
+}
+__name(effectiveTracking, "effectiveTracking");
+function reconcileMouseMode(stdout, entry) {
+  const desired = effectiveTracking(entry);
+  if (desired === entry.active) return;
+  if (entry.active) disableMouseEvents(stdout, entry.active);
+  if (desired) enableMouseEvents(stdout, desired);
+  entry.active = desired;
+}
+__name(reconcileMouseMode, "reconcileMouseMode");
+var disableAllMouseModes = /* @__PURE__ */ __name(() => {
+  for (const [stdout, entry] of mouseModeRefs) {
+    if (entry.active) disableMouseEvents(stdout, entry.active);
+  }
+  mouseModeRefs.clear();
+}, "disableAllMouseModes");
+function acquireMouseMode(stdout, tracking) {
+  let entry = mouseModeRefs.get(stdout);
+  if (!entry) {
+    if (mouseModeRefs.size === 0) {
+      process.on("exit", disableAllMouseModes);
+    }
+    entry = { button: 0, any: 0, active: null };
+    mouseModeRefs.set(stdout, entry);
+  }
+  entry[tracking] += 1;
+  reconcileMouseMode(stdout, entry);
+}
+__name(acquireMouseMode, "acquireMouseMode");
+function releaseMouseMode(stdout, tracking) {
+  const entry = mouseModeRefs.get(stdout);
+  if (!entry) return;
+  entry[tracking] = Math.max(0, entry[tracking] - 1);
+  reconcileMouseMode(stdout, entry);
+  if (entry.button === 0 && entry.any === 0) {
+    mouseModeRefs.delete(stdout);
+    if (mouseModeRefs.size === 0) {
+      process.removeListener("exit", disableAllMouseModes);
+    }
+  }
+}
+__name(releaseMouseMode, "releaseMouseMode");
+function useMouseEvents(handler, { isActive, tracking = "button", bypassVpGate = false }) {
+  const { isRawModeSupported } = use_stdin_default();
+  const { stdout } = use_stdout_default();
+  const { subscribeMouse, unsubscribeMouse } = useKeypressContext();
+  const settings = (0, import_react8.useContext)(SettingsContext);
+  const isVpMode = useVirtualViewport(settings?.merged.ui?.useTerminalBuffer);
+  const vpGateOpen = isVpMode || bypassVpGate;
+  const handlerRef = (0, import_react8.useRef)(handler);
+  handlerRef.current = handler;
+  const mouseTrackingEnabled = useMouseTrackingEnabled();
+  const enabled = isActive && isRawModeSupported && vpGateOpen && mouseTrackingEnabled && Boolean(stdout.isTTY);
+  const enabledRef = (0, import_react8.useRef)(enabled);
+  enabledRef.current = enabled;
+  (0, import_react8.useEffect)(() => {
+    if (!enabled) return;
+    acquireMouseMode(stdout, tracking);
+    return () => {
+      releaseMouseMode(stdout, tracking);
+    };
+  }, [enabled, stdout, tracking]);
+  const mouseCallback = (0, import_react8.useCallback)((event) => {
+    if (!enabledRef.current) return;
+    handlerRef.current(event);
+  }, []);
+  (0, import_react8.useEffect)(() => {
+    if (!enabled) return;
+    subscribeMouse(mouseCallback);
+    return () => unsubscribeMouse(mouseCallback);
+  }, [enabled, subscribeMouse, unsubscribeMouse, mouseCallback]);
+}
+__name(useMouseEvents, "useMouseEvents");
+
+// packages/cli/src/ui/utils/mouse-hit.ts
+init_esbuild_shims();
+
+// packages/cli/src/ui/utils/measure-element-position.ts
+init_esbuild_shims();
+
+// packages/cli/src/ui/utils/list-mouse.ts
+init_esbuild_shims();
+function frameAnchor(terminalHeight, frameHeight) {
+  return Math.min(0, terminalHeight - frameHeight);
+}
+__name(frameAnchor, "frameAnchor");
+function terminalRowToLayoutRow(terminalRow1Based, anchor) {
+  return terminalRow1Based - 1 - anchor;
+}
+__name(terminalRowToLayoutRow, "terminalRowToLayoutRow");
+function findItemAtLayoutRow(rects, layoutRow) {
+  for (const rect of rects) {
+    if (layoutRow >= rect.top && layoutRow < rect.top + rect.height) {
+      return rect.index;
+    }
+  }
+  return null;
+}
+__name(findItemAtLayoutRow, "findItemAtLayoutRow");
+
+// packages/cli/src/ui/utils/measure-element-position.ts
+function measureElementPosition(node) {
+  const { yogaNode } = node;
+  if (!yogaNode) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  let x = yogaNode.getComputedLeft();
+  let y = yogaNode.getComputedTop();
+  let current = node.parentNode;
+  while (current) {
+    if (current.yogaNode) {
+      x += current.yogaNode.getComputedLeft();
+      y += current.yogaNode.getComputedTop();
+    }
+    current = current.parentNode;
+  }
+  return {
+    x,
+    y,
+    width: yogaNode.getComputedWidth(),
+    height: yogaNode.getComputedHeight()
+  };
+}
+__name(measureElementPosition, "measureElementPosition");
+function measureFrameHeight(node) {
+  let root = node;
+  let current = node;
+  while (current) {
+    root = current;
+    current = current.parentNode;
+  }
+  return root.yogaNode?.getComputedHeight() ?? 0;
+}
+__name(measureFrameHeight, "measureFrameHeight");
+function layoutRowForEvent(node, terminalRow1Based, terminalHeight) {
+  const anchor = frameAnchor(terminalHeight, measureFrameHeight(node));
+  return terminalRowToLayoutRow(terminalRow1Based, anchor);
+}
+__name(layoutRowForEvent, "layoutRowForEvent");
+
+// packages/cli/src/ui/utils/mouse-hit.ts
+function containsPoint(rect, point) {
+  const containsRow = point.y >= rect.y && point.y < rect.y + rect.height;
+  return containsRow && point.x >= rect.x && point.x < rect.x + rect.width;
+}
+__name(containsPoint, "containsPoint");
+function findElementAtMouseEvent(container, elements, event, terminalHeight, mode, indexOffset = 0) {
+  if (!container) return null;
+  const point = {
+    x: event.col - 1,
+    y: layoutRowForEvent(container, event.row, terminalHeight)
+  };
+  const containerRect = measureElementPosition(container);
+  if (containerRect.width > 0 && (point.x < containerRect.x || point.x >= containerRect.x + containerRect.width)) {
+    return null;
+  }
+  if (mode === "row") {
+    const rects = [];
+    for (let index = 0; index < elements.length; index++) {
+      const element = elements[index];
+      if (!element) continue;
+      const rect = measureElementPosition(element);
+      if (rect.height <= 0) continue;
+      rects.push({
+        index: indexOffset + index,
+        top: rect.y,
+        height: rect.height
+      });
+    }
+    return findItemAtLayoutRow(rects, point.y);
+  }
+  for (let index = 0; index < elements.length; index++) {
+    const element = elements[index];
+    if (!element) continue;
+    const rect = measureElementPosition(element);
+    if (rect.height <= 0 || rect.width <= 0) continue;
+    if (containsPoint(rect, point)) return index;
+  }
+  return null;
+}
+__name(findElementAtMouseEvent, "findElementAtMouseEvent");
+
+// packages/cli/src/ui/components/shared/RowMouseController.tsx
+function RowMouseController({
+  containerRef,
+  itemRefs,
+  scrollOffset,
+  isDisabled,
+  onHoverIndex,
+  onSelectIndex
+}) {
+  const { rows: terminalHeight } = useTerminalSize();
+  const { menu: contextMenu } = useContextMenu();
+  const resolveIndex = (0, import_react9.useCallback)(
+    (event) => findElementAtMouseEvent(
+      containerRef.current,
+      itemRefs.current,
+      event,
+      terminalHeight,
+      "row",
+      scrollOffset
+    ),
+    [containerRef, itemRefs, scrollOffset, terminalHeight]
+  );
+  const handleMouse = (0, import_react9.useCallback)(
+    (event) => {
+      if (event.name !== "move" && event.name !== "left-press") return;
+      const index = resolveIndex(event);
+      if (index === null || isDisabled?.(index)) return;
+      if (event.name === "move") {
+        onHoverIndex(index);
+      } else {
+        onSelectIndex(index);
+      }
+    },
+    [resolveIndex, isDisabled, onHoverIndex, onSelectIndex]
+  );
+  useMouseEvents(handleMouse, {
+    isActive: contextMenu === null,
+    tracking: "any"
+  });
+  return null;
+}
+__name(RowMouseController, "RowMouseController");
+
+// packages/cli/src/ui/components/shared/BaseSelectionList.tsx
+var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
+function getScrollOffsetForIndex(activeIndex, itemCount, maxItemsToShow) {
+  return Math.max(
+    0,
+    Math.min(activeIndex - maxItemsToShow + 1, itemCount - maxItemsToShow)
+  );
+}
+__name(getScrollOffsetForIndex, "getScrollOffsetForIndex");
+function BaseSelectionList({
+  items,
+  initialIndex = 0,
+  onSelect,
+  onHighlight,
+  isFocused = true,
+  showNumbers = true,
+  showScrollArrows = false,
+  maxItemsToShow = 10,
+  itemGap = 0,
+  renderItem
+}) {
+  const { activeIndex, setActiveIndex, selectIndex } = useSelectionList({
+    items,
+    initialIndex,
+    onSelect,
+    onHighlight,
+    isFocused,
+    showNumbers
+  });
+  const [scrollOffset, setScrollOffset] = (0, import_react10.useState)(
+    () => getScrollOffsetForIndex(activeIndex, items.length, maxItemsToShow)
+  );
+  (0, import_react10.useEffect)(() => {
+    const newScrollOffset = getScrollOffsetForIndex(
+      activeIndex,
+      items.length,
+      maxItemsToShow
+    );
+    if (activeIndex < scrollOffset) {
+      setScrollOffset(activeIndex);
+    } else if (activeIndex >= scrollOffset + maxItemsToShow) {
+      setScrollOffset(newScrollOffset);
+    }
+  }, [activeIndex, items.length, scrollOffset, maxItemsToShow]);
+  const settings = (0, import_react10.useContext)(SettingsContext);
+  const mouseTrackingEnabled = useMouseTrackingEnabled();
+  const mouseEnabled = useVirtualViewport(settings?.merged.ui?.useTerminalBuffer) && mouseTrackingEnabled;
+  const containerRef = (0, import_react10.useRef)(null);
+  const itemRefs = (0, import_react10.useRef)([]);
+  const visibleItems = items.slice(scrollOffset, scrollOffset + maxItemsToShow);
+  const numberColumnWidth = String(items.length).length;
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Box_default, { ref: containerRef, flexDirection: "column", gap: itemGap, children: [
+    mouseEnabled && isFocused && items.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      RowMouseController,
+      {
+        containerRef,
+        itemRefs,
+        scrollOffset,
+        isDisabled: (index) => !!items[index]?.disabled,
+        onHoverIndex: setActiveIndex,
+        onSelectIndex: selectIndex
+      }
+    ),
+    showScrollArrows && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      Text,
+      {
+        color: scrollOffset > 0 ? theme.text.primary : theme.text.secondary,
+        children: "\u25B2"
+      }
+    ),
+    visibleItems.map((item, index) => {
+      const itemIndex = scrollOffset + index;
+      const isSelected = activeIndex === itemIndex;
+      let titleColor = theme.text.primary;
+      let numberColor = theme.text.primary;
+      if (isSelected) {
+        titleColor = theme.status.success;
+        numberColor = theme.status.success;
+      } else if (item.disabled) {
+        titleColor = theme.text.secondary;
+        numberColor = theme.text.secondary;
+      }
+      if (!isFocused && !item.disabled) {
+        numberColor = theme.text.secondary;
+      }
+      if (!showNumbers) {
+        numberColor = theme.text.secondary;
+      }
+      const itemNumberText = `${String(itemIndex + 1).padStart(
+        numberColumnWidth
+      )}.`;
+      return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+        Box_default,
+        {
+          alignItems: "flex-start",
+          ref: (node) => {
+            itemRefs.current[index] = node;
+          },
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Box_default, { minWidth: 2, flexShrink: 0, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+              Text,
+              {
+                color: isSelected ? theme.status.success : theme.text.primary,
+                "aria-hidden": true,
+                children: isSelected ? "\u203A" : " "
+              }
+            ) }),
+            showNumbers && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+              Box_default,
+              {
+                marginRight: 1,
+                flexShrink: 0,
+                minWidth: itemNumberText.length,
+                "aria-state": { checked: isSelected },
+                children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { color: numberColor, children: itemNumberText })
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Box_default, { flexGrow: 1, children: renderItem(item, {
+              isSelected,
+              titleColor,
+              numberColor
+            }) })
+          ]
+        },
+        item.key
+      );
+    }),
+    showScrollArrows && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      Text,
+      {
+        color: scrollOffset + maxItemsToShow < items.length ? theme.text.primary : theme.text.secondary,
+        children: "\u25BC"
+      }
+    )
+  ] });
+}
+__name(BaseSelectionList, "BaseSelectionList");
+
+// packages/cli/src/ui/components/shared/RadioButtonSelect.tsx
+var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
+function RadioButtonSelect({
+  items,
+  initialIndex = 0,
+  onSelect,
+  onHighlight,
+  isFocused = true,
+  showScrollArrows = false,
+  maxItemsToShow = 10,
+  showNumbers = true
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    BaseSelectionList,
+    {
+      items,
+      initialIndex,
+      onSelect,
+      onHighlight,
+      isFocused,
+      showNumbers,
+      showScrollArrows,
+      maxItemsToShow,
+      renderItem: (item, { titleColor }) => {
+        if (item.themeNameDisplay && item.themeTypeDisplay) {
+          return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(Text, { color: titleColor, wrap: "truncate", children: [
+            item.themeNameDisplay,
+            " ",
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Text, { color: theme.text.secondary, children: item.themeTypeDisplay })
+          ] }, item.key);
+        }
+        return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Text, { color: titleColor, wrap: "truncate", children: item.label });
+      }
+    }
+  );
+}
+__name(RadioButtonSelect, "RadioButtonSelect");
+
 // packages/cli/src/ui/utils/tool-display-map.ts
 init_esbuild_shims();
 var TOOL_DISPLAY_BY_NAME = Object.fromEntries(
@@ -742,6 +1588,65 @@ var TOOL_DISPLAY_BY_NAME = Object.fromEntries(
   ])
 );
 
+// packages/cli/src/ui/components/mcp/MCPServerApprovalDialog.tsx
+init_esbuild_shims();
+var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
+var MCPServerApprovalDialog = /* @__PURE__ */ __name(({ serverName, summary, source, pendingServers, remaining, onSelect }) => {
+  useKeypress(
+    (key) => {
+      if (key.name === "escape") {
+        onSelect("reject" /* REJECT */);
+      }
+    },
+    { isActive: true }
+  );
+  const options = [
+    {
+      label: "Approve this server",
+      value: "approve" /* APPROVE */,
+      key: "approve"
+    },
+    {
+      label: "Approve all pending servers in this workspace",
+      value: "approve_all" /* APPROVE_ALL */,
+      key: "approve_all"
+    },
+    {
+      label: "Reject (esc)",
+      value: "reject" /* REJECT */,
+      key: "reject"
+    }
+  ];
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Box_default, { flexDirection: "column", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
+    Box_default,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: theme.status.warning,
+      padding: 1,
+      width: "100%",
+      marginLeft: 1,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(Box_default, { flexDirection: "column", marginBottom: 1, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Text, { bold: true, color: theme.text.primary, children: `Untrusted MCP server in ${source}` }),
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Text, { color: theme.text.primary, children: `This workspace declares an MCP server. Approving lets Qwen Code start it and run its tools. Approval is bound to this exact configuration \u2014 if ${source} changes, you will be asked again.` })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(Box_default, { flexDirection: "column", marginBottom: 1, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(Text, { color: theme.text.primary, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Text, { bold: true, children: serverName }),
+            `  ${summary}`
+          ] }),
+          remaining > 0 && /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(Box_default, { flexDirection: "column", marginTop: 1, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Text, { color: theme.text.secondary, children: "Approve all will trust these servers:" }),
+            pendingServers.map((server) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Text, { color: theme.text.secondary, children: `  ${server.name}  ${server.summary}` }, server.name))
+          ] })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(RadioButtonSelect, { items: options, onSelect, isFocused: true })
+      ]
+    }
+  ) });
+}, "MCPServerApprovalDialog");
+
 // packages/cli/src/ui/statusLinePresets.ts
 init_esbuild_shims();
 import nodePath from "node:path";
@@ -1131,6 +2036,9 @@ function sortSources(sources) {
 __name(sortSources, "sortSources");
 
 export {
+  SettingsContext,
+  useSettings,
+  useTerminalSize,
   osc8Open,
   osc8Close,
   isSafeOscScheme,
@@ -1148,10 +2056,27 @@ export {
   getStatusColor,
   formatDuration,
   keyMatchers,
+  useSelectionList,
+  VirtualViewportContext,
+  useVirtualViewport,
+  useMouseTrackingEnabled,
+  useMouseEvents,
+  ContextMenuProvider,
+  useContextMenu,
+  contextMenuSize,
+  clampMenuPosition,
+  frameAnchor,
+  measureElementPosition,
+  layoutRowForEvent,
+  findElementAtMouseEvent,
+  RowMouseController,
+  BaseSelectionList,
+  RadioButtonSelect,
   TOOL_DISPLAY_BY_NAME,
   SessionStatsProvider,
   useSessionStats,
   flattenModelsBySource,
+  MCPServerApprovalDialog,
   aggregateModelTokens,
   STATUS_LINE_PRESET_ITEMS,
   orderStatusLinePresetItems,
@@ -1171,6 +2096,35 @@ export {
  * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Inspired by gemini-cli's MouseContext (Google LLC, Apache-2.0): enable SGR
+ * mouse mode while at least one subscriber is active, parse mouse sequences
+ * out of the KeypressContext pipeline, call each handler, restore on cleanup.
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Pure geometry helper for mapping a terminal mouse row onto a vertical list of
+ * items. The DOM measurement (reading yoga layout via measureElementPosition)
+ * lives in the component that owns the refs; this is pure arithmetic so it can
+ * be unit-tested without a renderer.
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Shim for ink PR #968 (vadimdemedes/ink#968): extends measureElement()
+ * to return {x, y, width, height}. Once the upstream PR is merged and
+ * ink is upgraded, replace usages with `measureElement` from 'ink'
+ * and delete this file.
+ */
 /**
  * @license
  * Copyright 2025 Qwen Team