@xelauvas/xela-cli 0.1.0

package/src/components/PromptInput/useShowFastIconHint.ts

@@ -0,0 +1,31 @@
+import { useEffect, useState } from 'react'
+
+const HINT_DISPLAY_DURATION_MS = 5000
+
+let hasShownThisSession = false
+
+/**
+ * Hook to manage the /fast hint display next to the fast icon.
+ * Shows the hint for 5 seconds once per session.
+ */
+export function useShowFastIconHint(showFastIcon: boolean): boolean {
+  const [showHint, setShowHint] = useState(false)
+
+  useEffect(() => {
+    if (hasShownThisSession || !showFastIcon) {
+      return
+    }
+
+    hasShownThisSession = true
+    setShowHint(true)
+
+    const timer = setTimeout(setShowHint, HINT_DISPLAY_DURATION_MS, false)
+
+    return () => {
+      clearTimeout(timer)
+      setShowHint(false)
+    }
+  }, [showFastIcon])
+
+  return showHint
+}

package/src/components/PromptInput/useSwarmBanner.ts

@@ -0,0 +1,155 @@
+import * as React from 'react'
+import { useAppState, useAppStateStore } from '../../state/AppState.js'
+import {
+  getActiveAgentForInput,
+  getViewedTeammateTask,
+} from '../../state/selectors.js'
+import {
+  AGENT_COLOR_TO_THEME_COLOR,
+  AGENT_COLORS,
+  type AgentColorName,
+  getAgentColor,
+} from '../../tools/AgentTool/agentColorManager.js'
+import { getStandaloneAgentName } from '../../utils/standaloneAgent.js'
+import { isInsideTmux } from '../../utils/swarm/backends/detection.js'
+import {
+  getCachedDetectionResult,
+  isInProcessEnabled,
+} from '../../utils/swarm/backends/registry.js'
+import { getSwarmSocketName } from '../../utils/swarm/constants.js'
+import {
+  getAgentName,
+  getTeammateColor,
+  getTeamName,
+  isTeammate,
+} from '../../utils/teammate.js'
+import { isInProcessTeammate } from '../../utils/teammateContext.js'
+import type { Theme } from '../../utils/theme.js'
+
+type SwarmBannerInfo = {
+  text: string
+  bgColor: keyof Theme
+} | null
+
+/**
+ * Hook that returns banner information for swarm, standalone agent, or --agent CLI context.
+ * - Leader (not in tmux): Returns "tmux -L ... attach" command with cyan background
+ * - Leader (in tmux / in-process): Falls through to standalone-agent check — shows
+ *   /rename name + /color background if set, else null
+ * - Teammate: Returns "teammate@team" format with their assigned color background
+ * - Viewing a background agent (CoordinatorTaskPanel): Returns agent name with its color
+ * - Standalone agent: Returns agent name with their color background (no @team)
+ * - --agent CLI flag: Returns "@agentName" with cyan background
+ */
+export function useSwarmBanner(): SwarmBannerInfo {
+  const teamContext = useAppState(s => s.teamContext)
+  const standaloneAgentContext = useAppState(s => s.standaloneAgentContext)
+  const agent = useAppState(s => s.agent)
+  // Subscribe so the banner updates on enter/exit teammate view even though
+  // getActiveAgentForInput reads it from store.getState().
+  useAppState(s => s.viewingAgentTaskId)
+  const store = useAppStateStore()
+  const [insideTmux, setInsideTmux] = React.useState<boolean | null>(null)
+
+  React.useEffect(() => {
+    void isInsideTmux().then(setInsideTmux)
+  }, [])
+
+  const state = store.getState()
+
+  // Teammate process: show @agentName with assigned color.
+  // In-process teammates run headless — their banner shows in the leader UI instead.
+  if (isTeammate() && !isInProcessTeammate()) {
+    const agentName = getAgentName()
+    if (agentName && getTeamName()) {
+      return {
+        text: `@${agentName}`,
+        bgColor: toThemeColor(
+          teamContext?.selfAgentColor ?? getTeammateColor(),
+        ),
+      }
+    }
+  }
+
+  // Leader with spawned teammates: tmux-attach hint when external, else show
+  // the viewed teammate's name when inside tmux / native panes / in-process.
+  const hasTeammates =
+    teamContext?.teamName &&
+    teamContext.teammates &&
+    Object.keys(teamContext.teammates).length > 0
+  if (hasTeammates) {
+    const viewedTeammate = getViewedTeammateTask(state)
+    const viewedColor = toThemeColor(viewedTeammate?.identity.color)
+    const inProcessMode = isInProcessEnabled()
+    const nativePanes = getCachedDetectionResult()?.isNative ?? false
+
+    if (insideTmux === false && !inProcessMode && !nativePanes) {
+      return {
+        text: `View teammates: \`tmux -L ${getSwarmSocketName()} a\``,
+        bgColor: viewedColor,
+      }
+    }
+    if (
+      (insideTmux === true || inProcessMode || nativePanes) &&
+      viewedTeammate
+    ) {
+      return {
+        text: `@${viewedTeammate.identity.agentName}`,
+        bgColor: viewedColor,
+      }
+    }
+    // insideTmux === null: still loading — fall through.
+    // Not viewing a teammate: fall through so /rename and /color are honored.
+  }
+
+  // Viewing a background agent (CoordinatorTaskPanel): local_agent tasks aren't
+  // InProcessTeammates, so getViewedTeammateTask misses them. Reverse-lookup the
+  // name from agentNameRegistry the same way CoordinatorAgentStatus does.
+  const active = getActiveAgentForInput(state)
+  if (active.type === 'named_agent') {
+    const task = active.task
+    let name: string | undefined
+    for (const [n, id] of state.agentNameRegistry) {
+      if (id === task.id) {
+        name = n
+        break
+      }
+    }
+    return {
+      text: name ? `@${name}` : task.description,
+      bgColor: getAgentColor(task.agentType) ?? 'cyan_FOR_SUBAGENTS_ONLY',
+    }
+  }
+
+  // Standalone agent (/rename, /color): name and/or custom color, no @team.
+  const standaloneName = getStandaloneAgentName(state)
+  const standaloneColor = standaloneAgentContext?.color
+  if (standaloneName || standaloneColor) {
+    return {
+      text: standaloneName ?? '',
+      bgColor: toThemeColor(standaloneColor),
+    }
+  }
+
+  // --agent CLI flag (when not handled above).
+  if (agent) {
+    const agentDef = state.agentDefinitions.activeAgents.find(
+      a => a.agentType === agent,
+    )
+    return {
+      text: agent,
+      bgColor: toThemeColor(agentDef?.color, 'promptBorder'),
+    }
+  }
+
+  return null
+}
+
+function toThemeColor(
+  colorName: string | undefined,
+  fallback: keyof Theme = 'cyan_FOR_SUBAGENTS_ONLY',
+): keyof Theme {
+  return colorName && AGENT_COLORS.includes(colorName as AgentColorName)
+    ? AGENT_COLOR_TO_THEME_COLOR[colorName as AgentColorName]
+    : fallback
+}

package/src/components/PromptInput/utils.ts

@@ -0,0 +1,60 @@
+import {
+  hasUsedBackslashReturn,
+  isShiftEnterKeyBindingInstalled,
+} from '../../commands/terminalSetup/terminalSetup.js'
+import type { Key } from '../../ink.js'
+import { getGlobalConfig } from '../../utils/config.js'
+import { env } from '../../utils/env.js'
+/**
+ * Helper function to check if vim mode is currently enabled
+ * @returns boolean indicating if vim mode is active
+ */
+export function isVimModeEnabled(): boolean {
+  const config = getGlobalConfig()
+  return config.editorMode === 'vim'
+}
+
+export function getNewlineInstructions(): string {
+  // Apple Terminal on macOS uses native modifier key detection for Shift+Enter
+  if (env.terminal === 'Apple_Terminal' && process.platform === 'darwin') {
+    return 'shift + ⏎ for newline'
+  }
+
+  // For iTerm2 and VSCode, show Shift+Enter instructions if installed
+  if (isShiftEnterKeyBindingInstalled()) {
+    return 'shift + ⏎ for newline'
+  }
+
+  // Otherwise show backslash+return instructions
+  return hasUsedBackslashReturn()
+    ? '\\⏎ for newline'
+    : 'backslash (\\) + return (⏎) for newline'
+}
+
+/**
+ * True when the keystroke is a printable character that does not begin
+ * with whitespace — i.e., a normal letter/digit/symbol the user typed.
+ * Used to gate the lazy space inserted after an image pill.
+ */
+export function isNonSpacePrintable(input: string, key: Key): boolean {
+  if (
+    key.ctrl ||
+    key.meta ||
+    key.escape ||
+    key.return ||
+    key.tab ||
+    key.backspace ||
+    key.delete ||
+    key.upArrow ||
+    key.downArrow ||
+    key.leftArrow ||
+    key.rightArrow ||
+    key.pageUp ||
+    key.pageDown ||
+    key.home ||
+    key.end
+  ) {
+    return false
+  }
+  return input.length > 0 && !/^\s/.test(input) && !input.startsWith('\x1b')
+}

package/src/components/QuickOpenDialog.tsx

@@ -0,0 +1,244 @@
+import { c as _c } from "react/compiler-runtime";
+import * as path from 'path';
+import * as React from 'react';
+import { useEffect, useRef, useState } from 'react';
+import { useRegisterOverlay } from '../context/overlayContext.js';
+import { generateFileSuggestions } from '../hooks/fileSuggestions.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { Text } from '../ink.js';
+import { logEvent } from '../services/analytics/index.js';
+import { getCwd } from '../utils/cwd.js';
+import { openFileInExternalEditor } from '../utils/editor.js';
+import { truncatePathMiddle, truncateToWidth } from '../utils/format.js';
+import { highlightMatch } from '../utils/highlightMatch.js';
+import { readFileInRange } from '../utils/readFileInRange.js';
+import { FuzzyPicker } from './design-system/FuzzyPicker.js';
+import { LoadingState } from './design-system/LoadingState.js';
+type Props = {
+  onDone: () => void;
+  onInsert: (text: string) => void;
+};
+const VISIBLE_RESULTS = 8;
+const PREVIEW_LINES = 20;
+
+/**
+ * Quick Open dialog (ctrl+shift+p / cmd+shift+p).
+ * Fuzzy file finder with a syntax-highlighted preview of the focused file.
+ */
+export function QuickOpenDialog(t0) {
+  const $ = _c(35);
+  const {
+    onDone,
+    onInsert
+  } = t0;
+  useRegisterOverlay("quick-open");
+  const {
+    columns,
+    rows
+  } = useTerminalSize();
+  const visibleResults = Math.min(VISIBLE_RESULTS, Math.max(4, rows - 14));
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = [];
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const [results, setResults] = useState(t1);
+  const [query, setQuery] = useState("");
+  const [focusedPath, setFocusedPath] = useState(undefined);
+  const [preview, setPreview] = useState(null);
+  const queryGenRef = useRef(0);
+  let t2;
+  let t3;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = () => () => {
+      queryGenRef.current = queryGenRef.current + 1;
+      return void queryGenRef.current;
+    };
+    t3 = [];
+    $[1] = t2;
+    $[2] = t3;
+  } else {
+    t2 = $[1];
+    t3 = $[2];
+  }
+  useEffect(t2, t3);
+  const previewOnRight = columns >= 120;
+  const effectivePreviewLines = previewOnRight ? VISIBLE_RESULTS - 1 : PREVIEW_LINES;
+  let t4;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = q => {
+      setQuery(q);
+      const gen = queryGenRef.current = queryGenRef.current + 1;
+      if (!q.trim()) {
+        setResults([]);
+        return;
+      }
+      generateFileSuggestions(q, true).then(items => {
+        if (gen !== queryGenRef.current) {
+          return;
+        }
+        const paths = items.filter(_temp).map(_temp2).filter(_temp3).map(_temp4);
+        setResults(paths);
+      });
+    };
+    $[3] = t4;
+  } else {
+    t4 = $[3];
+  }
+  const handleQueryChange = t4;
+  let t5;
+  let t6;
+  if ($[4] !== effectivePreviewLines || $[5] !== focusedPath) {
+    t5 = () => {
+      if (!focusedPath) {
+        setPreview(null);
+        return;
+      }
+      const controller = new AbortController();
+      const absolute = path.resolve(getCwd(), focusedPath);
+      readFileInRange(absolute, 0, effectivePreviewLines, undefined, controller.signal).then(r => {
+        if (controller.signal.aborted) {
+          return;
+        }
+        setPreview({
+          path: focusedPath,
+          content: r.content
+        });
+      }).catch(() => {
+        if (controller.signal.aborted) {
+          return;
+        }
+        setPreview({
+          path: focusedPath,
+          content: "(preview unavailable)"
+        });
+      });
+      return () => controller.abort();
+    };
+    t6 = [focusedPath, effectivePreviewLines];
+    $[4] = effectivePreviewLines;
+    $[5] = focusedPath;
+    $[6] = t5;
+    $[7] = t6;
+  } else {
+    t5 = $[6];
+    t6 = $[7];
+  }
+  useEffect(t5, t6);
+  const maxPathWidth = previewOnRight ? Math.max(20, Math.floor((columns - 10) * 0.4)) : Math.max(20, columns - 8);
+  const previewWidth = previewOnRight ? Math.max(40, columns - maxPathWidth - 14) : columns - 6;
+  let t7;
+  if ($[8] !== onDone || $[9] !== results.length) {
+    t7 = p_1 => {
+      const opened = openFileInExternalEditor(path.resolve(getCwd(), p_1));
+      logEvent("tengu_quick_open_select", {
+        result_count: results.length,
+        opened_editor: opened
+      });
+      onDone();
+    };
+    $[8] = onDone;
+    $[9] = results.length;
+    $[10] = t7;
+  } else {
+    t7 = $[10];
+  }
+  const handleOpen = t7;
+  let t8;
+  if ($[11] !== onDone || $[12] !== onInsert || $[13] !== results.length) {
+    t8 = (p_2, mention) => {
+      onInsert(mention ? `@${p_2} ` : `${p_2} `);
+      logEvent("tengu_quick_open_insert", {
+        result_count: results.length,
+        mention
+      });
+      onDone();
+    };
+    $[11] = onDone;
+    $[12] = onInsert;
+    $[13] = results.length;
+    $[14] = t8;
+  } else {
+    t8 = $[14];
+  }
+  const handleInsert = t8;
+  const t9 = previewOnRight ? "right" : "bottom";
+  let t10;
+  if ($[15] !== handleInsert) {
+    t10 = {
+      action: "mention",
+      handler: p_4 => handleInsert(p_4, true)
+    };
+    $[15] = handleInsert;
+    $[16] = t10;
+  } else {
+    t10 = $[16];
+  }
+  let t11;
+  if ($[17] !== handleInsert) {
+    t11 = {
+      action: "insert path",
+      handler: p_5 => handleInsert(p_5, false)
+    };
+    $[17] = handleInsert;
+    $[18] = t11;
+  } else {
+    t11 = $[18];
+  }
+  let t12;
+  if ($[19] !== maxPathWidth) {
+    t12 = (p_6, isFocused) => <Text color={isFocused ? "suggestion" : undefined}>{truncatePathMiddle(p_6, maxPathWidth)}</Text>;
+    $[19] = maxPathWidth;
+    $[20] = t12;
+  } else {
+    t12 = $[20];
+  }
+  let t13;
+  if ($[21] !== preview || $[22] !== previewWidth || $[23] !== query) {
+    t13 = p_7 => preview ? <><Text dimColor={true}>{truncatePathMiddle(p_7, previewWidth)}{preview.path !== p_7 ? " \xB7 loading\u2026" : ""}</Text>{preview.content.split("\n").map((line, i_1) => <Text key={i_1}>{highlightMatch(truncateToWidth(line, previewWidth), query)}</Text>)}</> : <LoadingState message={"Loading preview\u2026"} dimColor={true} />;
+    $[21] = preview;
+    $[22] = previewWidth;
+    $[23] = query;
+    $[24] = t13;
+  } else {
+    t13 = $[24];
+  }
+  let t14;
+  if ($[25] !== handleOpen || $[26] !== onDone || $[27] !== results || $[28] !== t10 || $[29] !== t11 || $[30] !== t12 || $[31] !== t13 || $[32] !== t9 || $[33] !== visibleResults) {
+    t14 = <FuzzyPicker title="Quick Open" placeholder={"Type to search files\u2026"} items={results} getKey={_temp5} visibleCount={visibleResults} direction="up" previewPosition={t9} onQueryChange={handleQueryChange} onFocus={setFocusedPath} onSelect={handleOpen} onTab={t10} onShiftTab={t11} onCancel={onDone} emptyMessage={_temp6} selectAction="open in editor" renderItem={t12} renderPreview={t13} />;
+    $[25] = handleOpen;
+    $[26] = onDone;
+    $[27] = results;
+    $[28] = t10;
+    $[29] = t11;
+    $[30] = t12;
+    $[31] = t13;
+    $[32] = t9;
+    $[33] = visibleResults;
+    $[34] = t14;
+  } else {
+    t14 = $[34];
+  }
+  return t14;
+}
+function _temp6(q_0) {
+  return q_0 ? "No matching files" : "Start typing to search\u2026";
+}
+function _temp5(p_3) {
+  return p_3;
+}
+function _temp4(p_0) {
+  return p_0.split(path.sep).join("/");
+}
+function _temp3(p) {
+  return !p.endsWith(path.sep);
+}
+function _temp2(i_0) {
+  return i_0.displayText;
+}
+function _temp(i) {
+  return i.id.startsWith("file-");
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["path","React","useEffect","useRef","useState","useRegisterOverlay","generateFileSuggestions","useTerminalSize","Text","logEvent","getCwd","openFileInExternalEditor","truncatePathMiddle","truncateToWidth","highlightMatch","readFileInRange","FuzzyPicker","LoadingState","Props","onDone","onInsert","text","VISIBLE_RESULTS","PREVIEW_LINES","QuickOpenDialog","t0","$","_c","columns","rows","visibleResults","Math","min","max","t1","Symbol","for","results","setResults","query","setQuery","focusedPath","setFocusedPath","undefined","preview","setPreview","queryGenRef","t2","t3","current","previewOnRight","effectivePreviewLines","t4","q","gen","trim","then","items","paths","filter","_temp","map","_temp2","_temp3","_temp4","handleQueryChange","t5","t6","controller","AbortController","absolute","resolve","signal","r","aborted","content","catch","abort","maxPathWidth","floor","previewWidth","t7","length","p_1","opened","p","result_count","opened_editor","handleOpen","t8","p_2","mention","handleInsert","t9","t10","action","handler","p_4","t11","p_5","t12","p_6","isFocused","t13","p_7","split","line","i_1","i","t14","_temp5","_temp6","q_0","p_3","p_0","sep","join","endsWith","i_0","displayText","id","startsWith"],"sources":["QuickOpenDialog.tsx"],"sourcesContent":["import * as path from 'path'\nimport * as React from 'react'\nimport { useEffect, useRef, useState } from 'react'\nimport { useRegisterOverlay } from '../context/overlayContext.js'\nimport { generateFileSuggestions } from '../hooks/fileSuggestions.js'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport { Text } from '../ink.js'\nimport { logEvent } from '../services/analytics/index.js'\nimport { getCwd } from '../utils/cwd.js'\nimport { openFileInExternalEditor } from '../utils/editor.js'\nimport { truncatePathMiddle, truncateToWidth } from '../utils/format.js'\nimport { highlightMatch } from '../utils/highlightMatch.js'\nimport { readFileInRange } from '../utils/readFileInRange.js'\nimport { FuzzyPicker } from './design-system/FuzzyPicker.js'\nimport { LoadingState } from './design-system/LoadingState.js'\n\ntype Props = {\n  onDone: () => void\n  onInsert: (text: string) => void\n}\n\nconst VISIBLE_RESULTS = 8\nconst PREVIEW_LINES = 20\n\n/**\n * Quick Open dialog (ctrl+shift+p / cmd+shift+p).\n * Fuzzy file finder with a syntax-highlighted preview of the focused file.\n */\nexport function QuickOpenDialog({ onDone, onInsert }: Props): React.ReactNode {\n  useRegisterOverlay('quick-open')\n  const { columns, rows } = useTerminalSize()\n  // Chrome (title + search + hints + pane border + gaps) eats ~14 rows.\n  // Shrink the list on short terminals so the dialog doesn't clip.\n  const visibleResults = Math.min(VISIBLE_RESULTS, Math.max(4, rows - 14))\n\n  const [results, setResults] = useState<string[]>([])\n  const [query, setQuery] = useState('')\n  const [focusedPath, setFocusedPath] = useState<string | undefined>(undefined)\n  const [preview, setPreview] = useState<{\n    path: string\n    content: string\n  } | null>(null)\n  const queryGenRef = useRef(0)\n  useEffect(() => () => void queryGenRef.current++, [])\n\n  const previewOnRight = columns >= 120\n  // Side preview sits in a fixed-height row alongside the list (visibleCount\n  // rows), so overflowing that height garbles the layout — cap to fit, minus\n  // one for the path header line.\n  const effectivePreviewLines = previewOnRight\n    ? VISIBLE_RESULTS - 1\n    : PREVIEW_LINES\n\n  // A generation counter invalidates stale results if the user types faster\n  // than the index can respond.\n  const handleQueryChange = (q: string) => {\n    setQuery(q)\n    const gen = ++queryGenRef.current\n    if (!q.trim()) {\n      // generateFileSuggestions('') returns raw readdir() of cwd (designed for\n      // @-mentions). For Quick Open that's just noise — show the empty state.\n      setResults([])\n      return\n    }\n    void generateFileSuggestions(q, true).then(items => {\n      if (gen !== queryGenRef.current) return\n      // Filter out directory entries — they come back with a trailing path.sep\n      // from getTopLevelPaths() and would cause readFileInRange to throw EISDIR,\n      // leaving the preview pane stuck on \"Loading preview…\".\n      // Normalize separators to '/' so truncatePathMiddle (which uses\n      // lastIndexOf('/')) can find the filename on Windows too.\n      const paths = items\n        .filter(i => i.id.startsWith('file-'))\n        .map(i => i.displayText)\n        .filter(p => !p.endsWith(path.sep))\n        .map(p => p.split(path.sep).join('/'))\n      setResults(paths)\n    })\n  }\n\n  // Load a short preview of the focused file. Each navigation aborts the\n  // previous read so holding ↓ doesn't pile up whole-file reads and so a\n  // slow early read can't overwrite a faster later one. The stale preview\n  // stays visible until the new one arrives — renderPreview overlays a dim\n  // loading indicator rather than blanking the pane.\n  useEffect(() => {\n    if (!focusedPath) {\n      // No results — clear so the empty-state renders instead of a stale\n      // preview from a previous query.\n      setPreview(null)\n      return\n    }\n    const controller = new AbortController()\n    const absolute = path.resolve(getCwd(), focusedPath)\n    void readFileInRange(\n      absolute,\n      0,\n      effectivePreviewLines,\n      undefined,\n      controller.signal,\n    )\n      .then(r => {\n        if (controller.signal.aborted) return\n        setPreview({ path: focusedPath, content: r.content })\n      })\n      .catch(() => {\n        if (controller.signal.aborted) return\n        setPreview({ path: focusedPath, content: '(preview unavailable)' })\n      })\n    return () => controller.abort()\n  }, [focusedPath, effectivePreviewLines])\n\n  const maxPathWidth = previewOnRight\n    ? Math.max(20, Math.floor((columns - 10) * 0.4))\n    : Math.max(20, columns - 8)\n  const previewWidth = previewOnRight\n    ? Math.max(40, columns - maxPathWidth - 14)\n    : columns - 6\n\n  const handleOpen = (p: string) => {\n    const opened = openFileInExternalEditor(path.resolve(getCwd(), p))\n    logEvent('tengu_quick_open_select', {\n      result_count: results.length,\n      opened_editor: opened,\n    })\n    onDone()\n  }\n\n  const handleInsert = (p: string, mention: boolean) => {\n    onInsert(mention ? `@${p} ` : `${p} `)\n    logEvent('tengu_quick_open_insert', {\n      result_count: results.length,\n      mention,\n    })\n    onDone()\n  }\n\n  return (\n    <FuzzyPicker\n      title=\"Quick Open\"\n      placeholder=\"Type to search files…\"\n      items={results}\n      getKey={p => p}\n      visibleCount={visibleResults}\n      direction=\"up\"\n      previewPosition={previewOnRight ? 'right' : 'bottom'}\n      onQueryChange={handleQueryChange}\n      onFocus={setFocusedPath}\n      onSelect={handleOpen}\n      onTab={{ action: 'mention', handler: p => handleInsert(p, true) }}\n      onShiftTab={{\n        action: 'insert path',\n        handler: p => handleInsert(p, false),\n      }}\n      onCancel={onDone}\n      emptyMessage={q => (q ? 'No matching files' : 'Start typing to search…')}\n      selectAction=\"open in editor\"\n      renderItem={(p, isFocused) => (\n        <Text color={isFocused ? 'suggestion' : undefined}>\n          {truncatePathMiddle(p, maxPathWidth)}\n        </Text>\n      )}\n      renderPreview={p =>\n        preview ? (\n          <>\n            <Text dimColor>\n              {truncatePathMiddle(p, previewWidth)}\n              {preview.path !== p ? ' · loading…' : ''}\n            </Text>\n            {preview.content.split('\\n').map((line, i) => (\n              <Text key={i}>\n                {highlightMatch(truncateToWidth(line, previewWidth), query)}\n              </Text>\n            ))}\n          </>\n        ) : (\n          <LoadingState message=\"Loading preview…\" dimColor />\n        )\n      }\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/RemoteCallout.tsx

@@ -0,0 +1,76 @@
+import React, { useCallback, useEffect, useRef } from 'react';
+import { isBridgeEnabled } from '../bridge/bridgeEnabled.js';
+import { Box, Text } from '../ink.js';
+import { getClaudeAIOAuthTokens } from '../utils/auth.js';
+import { getGlobalConfig, saveGlobalConfig } from '../utils/config.js';
+import type { OptionWithDescription } from './CustomSelect/select.js';
+import { Select } from './CustomSelect/select.js';
+import { PermissionDialog } from './permissions/PermissionDialog.js';
+type RemoteCalloutSelection = 'enable' | 'dismiss';
+type Props = {
+  onDone: (selection: RemoteCalloutSelection) => void;
+};
+export function RemoteCallout({
+  onDone
+}: Props): React.ReactNode {
+  const onDoneRef = useRef(onDone);
+  onDoneRef.current = onDone;
+  const handleCancel = useCallback((): void => {
+    onDoneRef.current('dismiss');
+  }, []);
+
+  // Permanently mark as seen on mount so it only shows once
+  useEffect(() => {
+    saveGlobalConfig(current => {
+      if (current.remoteDialogSeen) return current;
+      return {
+        ...current,
+        remoteDialogSeen: true
+      };
+    });
+  }, []);
+  const handleSelect = useCallback((value: RemoteCalloutSelection): void => {
+    onDoneRef.current(value);
+  }, []);
+  const options: OptionWithDescription<RemoteCalloutSelection>[] = [{
+    label: 'Enable Remote Control for this session',
+    description: 'Opens a secure connection to claude.ai.',
+    value: 'enable'
+  }, {
+    label: 'Never mind',
+    description: 'You can always enable it later with /remote-control.',
+    value: 'dismiss'
+  }];
+  return <PermissionDialog title="Remote Control">
+      <Box flexDirection="column" paddingX={2} paddingY={1}>
+        <Box marginBottom={1} flexDirection="column">
+          <Text>
+            Remote Control lets you access this CLI session from the web
+            (claude.ai/code) or the Claude app, so you can pick up where you
+            left off on any device.
+          </Text>
+          <Text> </Text>
+          <Text>
+            You can disconnect remote access anytime by running /remote-control
+            again.
+          </Text>
+        </Box>
+        <Box>
+          <Select options={options} onChange={handleSelect} onCancel={handleCancel} />
+        </Box>
+      </Box>
+    </PermissionDialog>;
+}
+
+/**
+ * Check whether to show the remote callout (first-time dialog).
+ */
+export function shouldShowRemoteCallout(): boolean {
+  const config = getGlobalConfig();
+  if (config.remoteDialogSeen) return false;
+  if (!isBridgeEnabled()) return false;
+  const tokens = getClaudeAIOAuthTokens();
+  if (!tokens?.accessToken) return false;
+  return true;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsInVzZUNhbGxiYWNrIiwidXNlRWZmZWN0IiwidXNlUmVmIiwiaXNCcmlkZ2VFbmFibGVkIiwiQm94IiwiVGV4dCIsImdldENsYXVkZUFJT0F1dGhUb2tlbnMiLCJnZXRHbG9iYWxDb25maWciLCJzYXZlR2xvYmFsQ29uZmlnIiwiT3B0aW9uV2l0aERlc2NyaXB0aW9uIiwiU2VsZWN0IiwiUGVybWlzc2lvbkRpYWxvZyIsIlJlbW90ZUNhbGxvdXRTZWxlY3Rpb24iLCJQcm9wcyIsIm9uRG9uZSIsInNlbGVjdGlvbiIsIlJlbW90ZUNhbGxvdXQiLCJSZWFjdE5vZGUiLCJvbkRvbmVSZWYiLCJjdXJyZW50IiwiaGFuZGxlQ2FuY2VsIiwicmVtb3RlRGlhbG9nU2VlbiIsImhhbmRsZVNlbGVjdCIsInZhbHVlIiwib3B0aW9ucyIsImxhYmVsIiwiZGVzY3JpcHRpb24iLCJzaG91bGRTaG93UmVtb3RlQ2FsbG91dCIsImNvbmZpZyIsInRva2VucyIsImFjY2Vzc1Rva2VuIl0sInNvdXJjZXMiOlsiUmVtb3RlQ2FsbG91dC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0LCB7IHVzZUNhbGxiYWNrLCB1c2VFZmZlY3QsIHVzZVJlZiB9IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgaXNCcmlkZ2VFbmFibGVkIH0gZnJvbSAnLi4vYnJpZGdlL2JyaWRnZUVuYWJsZWQuanMnXG5pbXBvcnQgeyBCb3gsIFRleHQgfSBmcm9tICcuLi9pbmsuanMnXG5pbXBvcnQgeyBnZXRDbGF1ZGVBSU9BdXRoVG9rZW5zIH0gZnJvbSAnLi4vdXRpbHMvYXV0aC5qcydcbmltcG9ydCB7IGdldEdsb2JhbENvbmZpZywgc2F2ZUdsb2JhbENvbmZpZyB9IGZyb20gJy4uL3V0aWxzL2NvbmZpZy5qcydcbmltcG9ydCB0eXBlIHsgT3B0aW9uV2l0aERlc2NyaXB0aW9uIH0gZnJvbSAnLi9DdXN0b21TZWxlY3Qvc2VsZWN0LmpzJ1xuaW1wb3J0IHsgU2VsZWN0IH0gZnJvbSAnLi9DdXN0b21TZWxlY3Qvc2VsZWN0LmpzJ1xuaW1wb3J0IHsgUGVybWlzc2lvbkRpYWxvZyB9IGZyb20gJy4vcGVybWlzc2lvbnMvUGVybWlzc2lvbkRpYWxvZy5qcydcblxudHlwZSBSZW1vdGVDYWxsb3V0U2VsZWN0aW9uID0gJ2VuYWJsZScgfCAnZGlzbWlzcydcblxudHlwZSBQcm9wcyA9IHtcbiAgb25Eb25lOiAoc2VsZWN0aW9uOiBSZW1vdGVDYWxsb3V0U2VsZWN0aW9uKSA9PiB2b2lkXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBSZW1vdGVDYWxsb3V0KHsgb25Eb25lIH06IFByb3BzKTogUmVhY3QuUmVhY3ROb2RlIHtcbiAgY29uc3Qgb25Eb25lUmVmID0gdXNlUmVmKG9uRG9uZSlcbiAgb25Eb25lUmVmLmN1cnJlbnQgPSBvbkRvbmVcblxuICBjb25zdCBoYW5kbGVDYW5jZWwgPSB1c2VDYWxsYmFjaygoKTogdm9pZCA9PiB7XG4gICAgb25Eb25lUmVmLmN1cnJlbnQoJ2Rpc21pc3MnKVxuICB9LCBbXSlcblxuICAvLyBQZXJtYW5lbnRseSBtYXJrIGFzIHNlZW4gb24gbW91bnQgc28gaXQgb25seSBzaG93cyBvbmNlXG4gIHVzZUVmZmVjdCgoKSA9PiB7XG4gICAgc2F2ZUdsb2JhbENvbmZpZyhjdXJyZW50ID0+IHtcbiAgICAgIGlmIChjdXJyZW50LnJlbW90ZURpYWxvZ1NlZW4pIHJldHVybiBjdXJyZW50XG4gICAgICByZXR1cm4geyAuLi5jdXJyZW50LCByZW1vdGVEaWFsb2dTZWVuOiB0cnVlIH1cbiAgICB9KVxuICB9LCBbXSlcblxuICBjb25zdCBoYW5kbGVTZWxlY3QgPSB1c2VDYWxsYmFjaygodmFsdWU6IFJlbW90ZUNhbGxvdXRTZWxlY3Rpb24pOiB2b2lkID0+IHtcbiAgICBvbkRvbmVSZWYuY3VycmVudCh2YWx1ZSlcbiAgfSwgW10pXG5cbiAgY29uc3Qgb3B0aW9uczogT3B0aW9uV2l0aERlc2NyaXB0aW9uPFJlbW90ZUNhbGxvdXRTZWxlY3Rpb24+W10gPSBbXG4gICAge1xuICAgICAgbGFiZWw6ICdFbmFibGUgUmVtb3RlIENvbnRyb2wgZm9yIHRoaXMgc2Vzc2lvbicsXG4gICAgICBkZXNjcmlwdGlvbjogJ09wZW5zIGEgc2VjdXJlIGNvbm5lY3Rpb24gdG8gY2xhdWRlLmFpLicsXG4gICAgICB2YWx1ZTogJ2VuYWJsZScsXG4gICAgfSxcbiAgICB7XG4gICAgICBsYWJlbDogJ05ldmVyIG1pbmQnLFxuICAgICAgZGVzY3JpcHRpb246ICdZb3UgY2FuIGFsd2F5cyBlbmFibGUgaXQgbGF0ZXIgd2l0aCAvcmVtb3RlLWNvbnRyb2wuJyxcbiAgICAgIHZhbHVlOiAnZGlzbWlzcycsXG4gICAgfSxcbiAgXVxuXG4gIHJldHVybiAoXG4gICAgPFBlcm1pc3Npb25EaWFsb2cgdGl0bGU9XCJSZW1vdGUgQ29udHJvbFwiPlxuICAgICAgPEJveCBmbGV4RGlyZWN0aW9uPVwiY29sdW1uXCIgcGFkZGluZ1g9ezJ9IHBhZGRpbmdZPXsxfT5cbiAgICAgICAgPEJveCBtYXJnaW5Cb3R0b209ezF9IGZsZXhEaXJlY3Rpb249XCJjb2x1bW5cIj5cbiAgICAgICAgICA8VGV4dD5cbiAgICAgICAgICAgIFJlbW90ZSBDb250cm9sIGxldHMgeW91IGFjY2VzcyB0aGlzIENMSSBzZXNzaW9uIGZyb20gdGhlIHdlYlxuICAgICAgICAgICAgKGNsYXVkZS5haS9jb2RlKSBvciB0aGUgQ2xhdWRlIGFwcCwgc28geW91IGNhbiBwaWNrIHVwIHdoZXJlIHlvdVxuICAgICAgICAgICAgbGVmdCBvZmYgb24gYW55IGRldmljZS5cbiAgICAgICAgICA8L1RleHQ+XG4gICAgICAgICAgPFRleHQ+IDwvVGV4dD5cbiAgICAgICAgICA8VGV4dD5cbiAgICAgICAgICAgIFlvdSBjYW4gZGlzY29ubmVjdCByZW1vdGUgYWNjZXNzIGFueXRpbWUgYnkgcnVubmluZyAvcmVtb3RlLWNvbnRyb2xcbiAgICAgICAgICAgIGFnYWluLlxuICAgICAgICAgIDwvVGV4dD5cbiAgICAgICAgPC9Cb3g+XG4gICAgICAgIDxCb3g+XG4gICAgICAgICAgPFNlbGVjdFxuICAgICAgICAgICAgb3B0aW9ucz17b3B0aW9uc31cbiAgICAgICAgICAgIG9uQ2hhbmdlPXtoYW5kbGVTZWxlY3R9XG4gICAgICAgICAgICBvbkNhbmNlbD17aGFuZGxlQ2FuY2VsfVxuICAgICAgICAgIC8+XG4gICAgICAgIDwvQm94PlxuICAgICAgPC9Cb3g+XG4gICAgPC9QZXJtaXNzaW9uRGlhbG9nPlxuICApXG59XG5cbi8qKlxuICogQ2hlY2sgd2hldGhlciB0byBzaG93IHRoZSByZW1vdGUgY2FsbG91dCAoZmlyc3QtdGltZSBkaWFsb2cpLlxuICovXG5leHBvcnQgZnVuY3Rpb24gc2hvdWxkU2hvd1JlbW90ZUNhbGxvdXQoKTogYm9vbGVhbiB7XG4gIGNvbnN0IGNvbmZpZyA9IGdldEdsb2JhbENvbmZpZygpXG4gIGlmIChjb25maWcucmVtb3RlRGlhbG9nU2VlbikgcmV0dXJuIGZhbHNlXG4gIGlmICghaXNCcmlkZ2VFbmFibGVkKCkpIHJldHVybiBmYWxzZVxuICBjb25zdCB0b2tlbnMgPSBnZXRDbGF1ZGVBSU9BdXRoVG9rZW5zKClcbiAgaWYgKCF0b2tlbnM/LmFjY2Vzc1Rva2VuKSByZXR1cm4gZmFsc2VcbiAgcmV0dXJuIHRydWVcbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBT0EsS0FBSyxJQUFJQyxXQUFXLEVBQUVDLFNBQVMsRUFBRUMsTUFBTSxRQUFRLE9BQU87QUFDN0QsU0FBU0MsZUFBZSxRQUFRLDRCQUE0QjtBQUM1RCxTQUFTQyxHQUFHLEVBQUVDLElBQUksUUFBUSxXQUFXO0FBQ3JDLFNBQVNDLHNCQUFzQixRQUFRLGtCQUFrQjtBQUN6RCxTQUFTQyxlQUFlLEVBQUVDLGdCQUFnQixRQUFRLG9CQUFvQjtBQUN0RSxjQUFjQyxxQkFBcUIsUUFBUSwwQkFBMEI7QUFDckUsU0FBU0MsTUFBTSxRQUFRLDBCQUEwQjtBQUNqRCxTQUFTQyxnQkFBZ0IsUUFBUSxtQ0FBbUM7QUFFcEUsS0FBS0Msc0JBQXNCLEdBQUcsUUFBUSxHQUFHLFNBQVM7QUFFbEQsS0FBS0MsS0FBSyxHQUFHO0VBQ1hDLE1BQU0sRUFBRSxDQUFDQyxTQUFTLEVBQUVILHNCQUFzQixFQUFFLEdBQUcsSUFBSTtBQUNyRCxDQUFDO0FBRUQsT0FBTyxTQUFTSSxhQUFhQSxDQUFDO0VBQUVGO0FBQWMsQ0FBTixFQUFFRCxLQUFLLENBQUMsRUFBRWQsS0FBSyxDQUFDa0IsU0FBUyxDQUFDO0VBQ2hFLE1BQU1DLFNBQVMsR0FBR2hCLE1BQU0sQ0FBQ1ksTUFBTSxDQUFDO0VBQ2hDSSxTQUFTLENBQUNDLE9BQU8sR0FBR0wsTUFBTTtFQUUxQixNQUFNTSxZQUFZLEdBQUdwQixXQUFXLENBQUMsRUFBRSxFQUFFLElBQUksSUFBSTtJQUMzQ2tCLFNBQVMsQ0FBQ0MsT0FBTyxDQUFDLFNBQVMsQ0FBQztFQUM5QixDQUFDLEVBQUUsRUFBRSxDQUFDOztFQUVOO0VBQ0FsQixTQUFTLENBQUMsTUFBTTtJQUNkTyxnQkFBZ0IsQ0FBQ1csT0FBTyxJQUFJO01BQzFCLElBQUlBLE9BQU8sQ0FBQ0UsZ0JBQWdCLEVBQUUsT0FBT0YsT0FBTztNQUM1QyxPQUFPO1FBQUUsR0FBR0EsT0FBTztRQUFFRSxnQkFBZ0IsRUFBRTtNQUFLLENBQUM7SUFDL0MsQ0FBQyxDQUFDO0VBQ0osQ0FBQyxFQUFFLEVBQUUsQ0FBQztFQUVOLE1BQU1DLFlBQVksR0FBR3RCLFdBQVcsQ0FBQyxDQUFDdUIsS0FBSyxFQUFFWCxzQkFBc0IsQ0FBQyxFQUFFLElBQUksSUFBSTtJQUN4RU0sU0FBUyxDQUFDQyxPQUFPLENBQUNJLEtBQUssQ0FBQztFQUMxQixDQUFDLEVBQUUsRUFBRSxDQUFDO0VBRU4sTUFBTUMsT0FBTyxFQUFFZixxQkFBcUIsQ0FBQ0csc0JBQXNCLENBQUMsRUFBRSxHQUFHLENBQy9EO0lBQ0VhLEtBQUssRUFBRSx3Q0FBd0M7SUFDL0NDLFdBQVcsRUFBRSx5Q0FBeUM7SUFDdERILEtBQUssRUFBRTtFQUNULENBQUMsRUFDRDtJQUNFRSxLQUFLLEVBQUUsWUFBWTtJQUNuQkMsV0FBVyxFQUFFLHNEQUFzRDtJQUNuRUgsS0FBSyxFQUFFO0VBQ1QsQ0FBQyxDQUNGO0VBRUQsT0FDRSxDQUFDLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxnQkFBZ0I7QUFDNUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUMzRCxRQUFRLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLGFBQWEsQ0FBQyxRQUFRO0FBQ3BELFVBQVUsQ0FBQyxJQUFJO0FBQ2Y7QUFDQTtBQUNBO0FBQ0EsVUFBVSxFQUFFLElBQUk7QUFDaEIsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQUUsSUFBSTtBQUN2QixVQUFVLENBQUMsSUFBSTtBQUNmO0FBQ0E7QUFDQSxVQUFVLEVBQUUsSUFBSTtBQUNoQixRQUFRLEVBQUUsR0FBRztBQUNiLFFBQVEsQ0FBQyxHQUFHO0FBQ1osVUFBVSxDQUFDLE1BQU0sQ0FDTCxPQUFPLENBQUMsQ0FBQ0MsT0FBTyxDQUFDLENBQ2pCLFFBQVEsQ0FBQyxDQUFDRixZQUFZLENBQUMsQ0FDdkIsUUFBUSxDQUFDLENBQUNGLFlBQVksQ0FBQztBQUVuQyxRQUFRLEVBQUUsR0FBRztBQUNiLE1BQU0sRUFBRSxHQUFHO0FBQ1gsSUFBSSxFQUFFLGdCQUFnQixDQUFDO0FBRXZCOztBQUVBO0FBQ0E7QUFDQTtBQUNBLE9BQU8sU0FBU08sdUJBQXVCQSxDQUFBLENBQUUsRUFBRSxPQUFPLENBQUM7RUFDakQsTUFBTUMsTUFBTSxHQUFHckIsZUFBZSxDQUFDLENBQUM7RUFDaEMsSUFBSXFCLE1BQU0sQ0FBQ1AsZ0JBQWdCLEVBQUUsT0FBTyxLQUFLO0VBQ3pDLElBQUksQ0FBQ2xCLGVBQWUsQ0FBQyxDQUFDLEVBQUUsT0FBTyxLQUFLO0VBQ3BDLE1BQU0wQixNQUFNLEdBQUd2QixzQkFBc0IsQ0FBQyxDQUFDO0VBQ3ZDLElBQUksQ0FBQ3VCLE1BQU0sRUFBRUMsV0FBVyxFQUFFLE9BQU8sS0FBSztFQUN0QyxPQUFPLElBQUk7QUFDYiIsImlnbm9yZUxpc3QiOltdfQ==