@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/hooks/useCancelRequest.js

@@ -0,0 +1,195 @@
+/**
+ * CancelRequestHandler component for handling cancel/escape keybinding.
+ *
+ * Must be rendered inside KeybindingSetup to have access to the keybinding context.
+ * This component renders nothing - it just registers the cancel keybinding handler.
+ */
+import { useCallback, useRef } from 'react';
+import { logEvent } from '../services/analytics/index.js';
+import { useAppState, useAppStateStore, useSetAppState, } from '../state/AppState.js';
+import { isVimModeEnabled } from '../components/PromptInput/utils.js';
+import { useNotifications } from '../context/notifications.js';
+import { useIsOverlayActive } from '../context/overlayContext.js';
+import { useCommandQueue } from './useCommandQueue.js';
+import { getShortcutDisplay } from '../keybindings/shortcutFormat.js';
+import { useKeybinding } from '../keybindings/useKeybinding.js';
+import { exitTeammateView } from '../state/teammateViewHelpers.js';
+import { killAllRunningAgentTasks, markAgentsNotified, } from '../tasks/LocalAgentTask/LocalAgentTask.js';
+import { clearCommandQueue, enqueuePendingNotification, hasCommandsInQueue, } from '../utils/messageQueueManager.js';
+import { emitTaskTerminatedSdk } from '../utils/sdkEventQueue.js';
+/** Time window in ms during which a second press kills all background agents. */
+const KILL_AGENTS_CONFIRM_WINDOW_MS = 3000;
+/**
+ * Component that handles cancel requests via keybinding.
+ * Renders null but registers the 'chat:cancel' keybinding handler.
+ */
+export function CancelRequestHandler(props) {
+    const { setToolUseConfirmQueue, onCancel, onAgentsKilled, isMessageSelectorVisible, screen, abortSignal, popCommandFromQueue, vimMode, isLocalJSXCommand, isSearchingHistory, isHelpOpen, inputMode, inputValue, streamMode, } = props;
+    const store = useAppStateStore();
+    const setAppState = useSetAppState();
+    const queuedCommandsLength = useCommandQueue().length;
+    const { addNotification, removeNotification } = useNotifications();
+    const lastKillAgentsPressRef = useRef(0);
+    const viewSelectionMode = useAppState(s => s.viewSelectionMode);
+    const handleCancel = useCallback(() => {
+        const cancelProps = {
+            source: 'escape',
+            streamMode: streamMode,
+        };
+        // Priority 1: If there's an active task running, cancel it first
+        // This takes precedence over queue management so users can always interrupt Claude
+        if (abortSignal !== undefined && !abortSignal.aborted) {
+            logEvent('tengu_cancel', cancelProps);
+            setToolUseConfirmQueue(() => []);
+            onCancel();
+            return;
+        }
+        // Priority 2: Pop queue when Claude is idle (no running task to cancel)
+        if (hasCommandsInQueue()) {
+            if (popCommandFromQueue) {
+                popCommandFromQueue();
+                return;
+            }
+        }
+        // Fallback: nothing to cancel or pop (shouldn't reach here if isActive is correct)
+        logEvent('tengu_cancel', cancelProps);
+        setToolUseConfirmQueue(() => []);
+        onCancel();
+    }, [
+        abortSignal,
+        popCommandFromQueue,
+        setToolUseConfirmQueue,
+        onCancel,
+        streamMode,
+    ]);
+    // Determine if this handler should be active
+    // Other contexts (Transcript, HistorySearch, Help) have their own escape handlers
+    // Overlays (ModelPicker, ThinkingToggle, etc.) register themselves via useRegisterOverlay
+    // Local JSX commands (like /model, /btw) handle their own input
+    const isOverlayActive = useIsOverlayActive();
+    const canCancelRunningTask = abortSignal !== undefined && !abortSignal.aborted;
+    const hasQueuedCommands = queuedCommandsLength > 0;
+    // When in bash/background mode with empty input, escape should exit the mode
+    // rather than cancel the request. Let PromptInput handle mode exit.
+    // This only applies to Escape, not Ctrl+C which should always cancel.
+    const isInSpecialModeWithEmptyInput = inputMode !== undefined && inputMode !== 'prompt' && !inputValue;
+    // When viewing a teammate's transcript, let useBackgroundTaskNavigation handle Escape
+    const isViewingTeammate = viewSelectionMode === 'viewing-agent';
+    // Context guards: other screens/overlays handle their own cancel
+    const isContextActive = screen !== 'transcript' &&
+        !isSearchingHistory &&
+        !isMessageSelectorVisible &&
+        !isLocalJSXCommand &&
+        !isHelpOpen &&
+        !isOverlayActive &&
+        !(isVimModeEnabled() && vimMode === 'INSERT');
+    // Escape (chat:cancel) defers to mode-exit when in special mode with empty
+    // input, and to useBackgroundTaskNavigation when viewing a teammate
+    const isEscapeActive = isContextActive &&
+        (canCancelRunningTask || hasQueuedCommands) &&
+        !isInSpecialModeWithEmptyInput &&
+        !isViewingTeammate;
+    // Ctrl+C (app:interrupt): when viewing a teammate, stops everything and
+    // returns to main thread. Otherwise just handleCancel. Must NOT claim
+    // ctrl+c when main is idle at the prompt — that blocks the copy-selection
+    // handler and double-press-to-exit from ever seeing the keypress.
+    const isCtrlCActive = isContextActive &&
+        (canCancelRunningTask || hasQueuedCommands || isViewingTeammate);
+    useKeybinding('chat:cancel', handleCancel, {
+        context: 'Chat',
+        isActive: isEscapeActive,
+    });
+    // Shared kill path: stop all agents, suppress per-agent notifications,
+    // emit SDK events, enqueue a single aggregate model-facing notification.
+    // Returns true if anything was killed.
+    const killAllAgentsAndNotify = useCallback(() => {
+        const tasks = store.getState().tasks;
+        const running = Object.entries(tasks).filter(([, t]) => t.type === 'local_agent' && t.status === 'running');
+        if (running.length === 0)
+            return false;
+        killAllRunningAgentTasks(tasks, setAppState);
+        const descriptions = [];
+        for (const [taskId, task] of running) {
+            markAgentsNotified(taskId, setAppState);
+            descriptions.push(task.description);
+            emitTaskTerminatedSdk(taskId, 'stopped', {
+                toolUseId: task.toolUseId,
+                summary: task.description,
+            });
+        }
+        const summary = descriptions.length === 1
+            ? `Background agent "${descriptions[0]}" was stopped by the user.`
+            : `${descriptions.length} background agents were stopped by the user: ${descriptions.map(d => `"${d}"`).join(', ')}.`;
+        enqueuePendingNotification({ value: summary, mode: 'task-notification' });
+        onAgentsKilled();
+        return true;
+    }, [store, setAppState, onAgentsKilled]);
+    // Ctrl+C (app:interrupt). Scoped to teammate-view: killing agents from the
+    // main prompt stays a deliberate gesture (chat:killAgents), not a
+    // side-effect of cancelling a turn.
+    const handleInterrupt = useCallback(() => {
+        if (isViewingTeammate) {
+            killAllAgentsAndNotify();
+            exitTeammateView(setAppState);
+        }
+        if (canCancelRunningTask || hasQueuedCommands) {
+            handleCancel();
+        }
+    }, [
+        isViewingTeammate,
+        killAllAgentsAndNotify,
+        setAppState,
+        canCancelRunningTask,
+        hasQueuedCommands,
+        handleCancel,
+    ]);
+    useKeybinding('app:interrupt', handleInterrupt, {
+        context: 'Global',
+        isActive: isCtrlCActive,
+    });
+    // chat:killAgents uses a two-press pattern: first press shows a
+    // confirmation hint, second press within the window actually kills all
+    // agents. Reads tasks from the store directly to avoid stale closures.
+    const handleKillAgents = useCallback(() => {
+        const tasks = store.getState().tasks;
+        const hasRunningAgents = Object.values(tasks).some(t => t.type === 'local_agent' && t.status === 'running');
+        if (!hasRunningAgents) {
+            addNotification({
+                key: 'kill-agents-none',
+                text: 'No background agents running',
+                priority: 'immediate',
+                timeoutMs: 2000,
+            });
+            return;
+        }
+        const now = Date.now();
+        const elapsed = now - lastKillAgentsPressRef.current;
+        if (elapsed <= KILL_AGENTS_CONFIRM_WINDOW_MS) {
+            // Second press within window -- kill all background agents
+            lastKillAgentsPressRef.current = 0;
+            removeNotification('kill-agents-confirm');
+            logEvent('tengu_cancel', {
+                source: 'kill_agents',
+            });
+            clearCommandQueue();
+            killAllAgentsAndNotify();
+            return;
+        }
+        // First press -- show confirmation hint in status bar
+        lastKillAgentsPressRef.current = now;
+        const shortcut = getShortcutDisplay('chat:killAgents', 'Chat', 'ctrl+x ctrl+k');
+        addNotification({
+            key: 'kill-agents-confirm',
+            text: `Press ${shortcut} again to stop background agents`,
+            priority: 'immediate',
+            timeoutMs: KILL_AGENTS_CONFIRM_WINDOW_MS,
+        });
+    }, [store, addNotification, removeNotification, killAllAgentsAndNotify]);
+    // Must stay always-active: ctrl+x is consumed as a chord prefix regardless
+    // of isActive (because ctrl+x ctrl+e is always live), so an inactive handler
+    // here would leak ctrl+k to readline kill-line. Handler gates internally.
+    useKeybinding('chat:killAgents', handleKillAgents, {
+        context: 'Chat',
+    });
+    return null;
+}

package/dist/src/hooks/useChromeExtensionNotification.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from '../ink.js';
+import { isClaudeAISubscriber } from '../utils/auth.js';
+import { isChromeExtensionInstalled, shouldEnableClaudeInChrome } from '../utils/claudeInChrome/setup.js';
+import { isRunningOnHomespace } from '../utils/envUtils.js';
+import { useStartupNotification } from './notifs/useStartupNotification.js';
+function getChromeFlag() {
+    if (process.argv.includes('--chrome')) {
+        return true;
+    }
+    if (process.argv.includes('--no-chrome')) {
+        return false;
+    }
+    return undefined;
+}
+export function useChromeExtensionNotification() {
+    useStartupNotification(_temp);
+}
+async function _temp() {
+    const chromeFlag = getChromeFlag();
+    if (!shouldEnableClaudeInChrome(chromeFlag)) {
+        return null;
+    }
+    if (true && !isClaudeAISubscriber()) {
+        return {
+            key: "chrome-requires-subscription",
+            jsx: _jsx(Text, { color: "error", children: "Claude in Chrome requires a claude.ai subscription" }),
+            priority: "immediate",
+            timeoutMs: 5000
+        };
+    }
+    const installed = await isChromeExtensionInstalled();
+    if (!installed && !isRunningOnHomespace()) {
+        return {
+            key: "chrome-extension-not-detected",
+            jsx: _jsx(Text, { color: "warning", children: "Chrome extension not detected \u00B7 https://claude.ai/chrome to install" }),
+            priority: "immediate",
+            timeoutMs: 3000
+        };
+    }
+    if (chromeFlag === undefined) {
+        return {
+            key: "claude-in-chrome-default-enabled",
+            text: "Claude in Chrome enabled \xB7 /chrome",
+            priority: "low"
+        };
+    }
+    return null;
+}

package/dist/src/hooks/useClaudeCodeHintRecommendation.js

@@ -0,0 +1,117 @@
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Surfaces plugin-install prompts driven by `<claude-code-hint />` tags
+ * that CLIs/SDKs emit to stderr. See docs/claude-code-hints.md.
+ *
+ * Show-once semantics: each plugin is prompted for at most once ever,
+ * recorded in config regardless of yes/no. The pre-store gate in
+ * maybeRecordPluginHint already dropped installed/shown/capped hints, so
+ * anything that reaches this hook is worth resolving.
+ */
+import * as React from 'react';
+import { useNotifications } from '../context/notifications.js';
+import { logEvent } from '../services/analytics/index.js';
+import { clearPendingHint, getPendingHintSnapshot, markShownThisSession, subscribeToPendingHint } from '../utils/claudeCodeHints.js';
+import { logForDebugging } from '../utils/debug.js';
+import { disableHintRecommendations, markHintPluginShown, resolvePluginHint } from '../utils/plugins/hintRecommendation.js';
+import { installPluginFromMarketplace } from '../utils/plugins/pluginInstallationHelpers.js';
+import { installPluginAndNotify, usePluginRecommendationBase } from './usePluginRecommendationBase.js';
+export function useClaudeCodeHintRecommendation() {
+    const $ = _c(11);
+    const pendingHint = React.useSyncExternalStore(subscribeToPendingHint, getPendingHintSnapshot);
+    const { addNotification } = useNotifications();
+    const { recommendation, clearRecommendation, tryResolve } = usePluginRecommendationBase();
+    let t0;
+    let t1;
+    if ($[0] !== pendingHint || $[1] !== tryResolve) {
+        t0 = () => {
+            if (!pendingHint) {
+                return;
+            }
+            tryResolve(async () => {
+                const resolved = await resolvePluginHint(pendingHint);
+                if (resolved) {
+                    logForDebugging(`[useClaudeCodeHintRecommendation] surfacing ${resolved.pluginId} from ${resolved.sourceCommand}`);
+                    markShownThisSession();
+                }
+                if (getPendingHintSnapshot() === pendingHint) {
+                    clearPendingHint();
+                }
+                return resolved;
+            });
+        };
+        t1 = [pendingHint, tryResolve];
+        $[0] = pendingHint;
+        $[1] = tryResolve;
+        $[2] = t0;
+        $[3] = t1;
+    }
+    else {
+        t0 = $[2];
+        t1 = $[3];
+    }
+    React.useEffect(t0, t1);
+    let t2;
+    if ($[4] !== addNotification || $[5] !== clearRecommendation || $[6] !== recommendation) {
+        t2 = response => {
+            if (!recommendation) {
+                return;
+            }
+            markHintPluginShown(recommendation.pluginId);
+            logEvent("tengu_plugin_hint_response", {
+                _PROTO_plugin_name: recommendation.pluginName,
+                _PROTO_marketplace_name: recommendation.marketplaceName,
+                response: response
+            });
+            bb15: switch (response) {
+                case "yes":
+                    {
+                        const { pluginId, pluginName, marketplaceName } = recommendation;
+                        installPluginAndNotify(pluginId, pluginName, "hint-plugin", addNotification, async (pluginData) => {
+                            const result = await installPluginFromMarketplace({
+                                pluginId,
+                                entry: pluginData.entry,
+                                marketplaceName,
+                                scope: "user",
+                                trigger: "hint"
+                            });
+                            if (!result.success) {
+                                throw new Error(result.error);
+                            }
+                        });
+                        break bb15;
+                    }
+                case "disable":
+                    {
+                        disableHintRecommendations();
+                        break bb15;
+                    }
+                case "no":
+            }
+            clearRecommendation();
+        };
+        $[4] = addNotification;
+        $[5] = clearRecommendation;
+        $[6] = recommendation;
+        $[7] = t2;
+    }
+    else {
+        t2 = $[7];
+    }
+    const handleResponse = t2;
+    let t3;
+    if ($[8] !== handleResponse || $[9] !== recommendation) {
+        t3 = {
+            recommendation,
+            handleResponse
+        };
+        $[8] = handleResponse;
+        $[9] = recommendation;
+        $[10] = t3;
+    }
+    else {
+        t3 = $[10];
+    }
+    return t3;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useNotifications","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED","logEvent","clearPendingHint","getPendingHintSnapshot","markShownThisSession","subscribeToPendingHint","logForDebugging","disableHintRecommendations","markHintPluginShown","PluginHintRecommendation","resolvePluginHint","installPluginFromMarketplace","installPluginAndNotify","usePluginRecommendationBase","UseClaudeCodeHintRecommendationResult","recommendation","handleResponse","response","useClaudeCodeHintRecommendation","$","_c","pendingHint","useSyncExternalStore","addNotification","clearRecommendation","tryResolve","t0","t1","resolved","pluginId","sourceCommand","useEffect","t2","_PROTO_plugin_name","pluginName","_PROTO_marketplace_name","marketplaceName","bb15","pluginData","result","entry","scope","trigger","success","Error","error","t3"],"sources":["useClaudeCodeHintRecommendation.tsx"],"sourcesContent":["/**\n * Surfaces plugin-install prompts driven by `<claude-code-hint />` tags\n * that CLIs/SDKs emit to stderr. See docs/claude-code-hints.md.\n *\n * Show-once semantics: each plugin is prompted for at most once ever,\n * recorded in config regardless of yes/no. The pre-store gate in\n * maybeRecordPluginHint already dropped installed/shown/capped hints, so\n * anything that reaches this hook is worth resolving.\n */\n\nimport * as React from 'react'\nimport { useNotifications } from '../context/notifications.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED,\n  logEvent,\n} from '../services/analytics/index.js'\nimport {\n  clearPendingHint,\n  getPendingHintSnapshot,\n  markShownThisSession,\n  subscribeToPendingHint,\n} from '../utils/claudeCodeHints.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport {\n  disableHintRecommendations,\n  markHintPluginShown,\n  type PluginHintRecommendation,\n  resolvePluginHint,\n} from '../utils/plugins/hintRecommendation.js'\nimport { installPluginFromMarketplace } from '../utils/plugins/pluginInstallationHelpers.js'\nimport {\n  installPluginAndNotify,\n  usePluginRecommendationBase,\n} from './usePluginRecommendationBase.js'\n\ntype UseClaudeCodeHintRecommendationResult = {\n  recommendation: PluginHintRecommendation | null\n  handleResponse: (response: 'yes' | 'no' | 'disable') => void\n}\n\nexport function useClaudeCodeHintRecommendation(): UseClaudeCodeHintRecommendationResult {\n  const pendingHint = React.useSyncExternalStore(\n    subscribeToPendingHint,\n    getPendingHintSnapshot,\n  )\n  const { addNotification } = useNotifications()\n  const { recommendation, clearRecommendation, tryResolve } =\n    usePluginRecommendationBase<PluginHintRecommendation>()\n\n  React.useEffect(() => {\n    if (!pendingHint) return\n    tryResolve(async () => {\n      const resolved = await resolvePluginHint(pendingHint)\n      if (resolved) {\n        logForDebugging(\n          `[useClaudeCodeHintRecommendation] surfacing ${resolved.pluginId} from ${resolved.sourceCommand}`,\n        )\n        markShownThisSession()\n      }\n      // Drop the slot — but only if it still holds the hint we just\n      // resolved. A newer hint may have overwritten it during the async\n      // lookup; don't clobber that.\n      if (getPendingHintSnapshot() === pendingHint) {\n        clearPendingHint()\n      }\n      return resolved\n    })\n  }, [pendingHint, tryResolve])\n\n  const handleResponse = React.useCallback(\n    (response: 'yes' | 'no' | 'disable') => {\n      if (!recommendation) return\n\n      // Record show-once here, not at resolution-time — the dialog may have\n      // been blocked by a higher-priority focusedInputDialog and never\n      // rendered. Auto-dismiss reaches this via onResponse('no').\n      markHintPluginShown(recommendation.pluginId)\n      logEvent('tengu_plugin_hint_response', {\n        _PROTO_plugin_name:\n          recommendation.pluginName as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED,\n        _PROTO_marketplace_name:\n          recommendation.marketplaceName as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED,\n        response:\n          response as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      switch (response) {\n        case 'yes': {\n          const { pluginId, pluginName, marketplaceName } = recommendation\n          void installPluginAndNotify(\n            pluginId,\n            pluginName,\n            'hint-plugin',\n            addNotification,\n            async pluginData => {\n              const result = await installPluginFromMarketplace({\n                pluginId,\n                entry: pluginData.entry,\n                marketplaceName,\n                scope: 'user',\n                trigger: 'hint',\n              })\n              if (!result.success) {\n                throw new Error(result.error)\n              }\n            },\n          )\n          break\n        }\n        case 'disable':\n          disableHintRecommendations()\n          break\n        case 'no':\n          break\n      }\n\n      clearRecommendation()\n    },\n    [recommendation, addNotification, clearRecommendation],\n  )\n\n  return { recommendation, handleResponse }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/src/hooks/useClipboardImageHint.js

@@ -0,0 +1,59 @@
+import { useEffect, useRef } from 'react';
+import { useNotifications } from '../context/notifications.js';
+import { getShortcutDisplay } from '../keybindings/shortcutFormat.js';
+import { hasImageInClipboard } from '../utils/imagePaste.js';
+const NOTIFICATION_KEY = 'clipboard-image-hint';
+// Small debounce to batch rapid focus changes
+const FOCUS_CHECK_DEBOUNCE_MS = 1000;
+// Don't show the hint more than once per this interval
+const HINT_COOLDOWN_MS = 30000;
+/**
+ * Hook that shows a notification when the terminal regains focus
+ * and the clipboard contains an image.
+ *
+ * @param isFocused - Whether the terminal is currently focused
+ * @param enabled - Whether image paste is enabled (onImagePaste is defined)
+ */
+export function useClipboardImageHint(isFocused, enabled) {
+    const { addNotification } = useNotifications();
+    const lastFocusedRef = useRef(isFocused);
+    const lastHintTimeRef = useRef(0);
+    const checkTimeoutRef = useRef(null);
+    useEffect(() => {
+        // Only trigger on focus regain (was unfocused, now focused)
+        const wasFocused = lastFocusedRef.current;
+        lastFocusedRef.current = isFocused;
+        if (!enabled || !isFocused || wasFocused) {
+            return;
+        }
+        // Clear any pending check
+        if (checkTimeoutRef.current) {
+            clearTimeout(checkTimeoutRef.current);
+        }
+        // Small debounce to batch rapid focus changes
+        checkTimeoutRef.current = setTimeout(async (checkTimeoutRef, lastHintTimeRef, addNotification) => {
+            checkTimeoutRef.current = null;
+            // Check cooldown to avoid spamming the user
+            const now = Date.now();
+            if (now - lastHintTimeRef.current < HINT_COOLDOWN_MS) {
+                return;
+            }
+            // Check if clipboard has an image (async osascript call)
+            if (await hasImageInClipboard()) {
+                lastHintTimeRef.current = now;
+                addNotification({
+                    key: NOTIFICATION_KEY,
+                    text: `Image in clipboard · ${getShortcutDisplay('chat:imagePaste', 'Chat', 'ctrl+v')} to paste`,
+                    priority: 'immediate',
+                    timeoutMs: 8000,
+                });
+            }
+        }, FOCUS_CHECK_DEBOUNCE_MS, checkTimeoutRef, lastHintTimeRef, addNotification);
+        return () => {
+            if (checkTimeoutRef.current) {
+                clearTimeout(checkTimeoutRef.current);
+                checkTimeoutRef.current = null;
+            }
+        };
+    }, [isFocused, enabled, addNotification]);
+}

package/dist/src/hooks/useCommandKeybindings.js

@@ -0,0 +1,87 @@
+import { c as _c } from "react/compiler-runtime";
+import { useIsModalOverlayActive } from '../context/overlayContext.js';
+import { useOptionalKeybindingContext } from '../keybindings/KeybindingContext.js';
+import { useKeybindings } from '../keybindings/useKeybinding.js';
+const NOOP_HELPERS = {
+    setCursorOffset: () => { },
+    clearBuffer: () => { },
+    resetHistory: () => { }
+};
+/**
+ * Registers keybinding handlers for all "command:*" actions found in the
+ * user's keybinding configuration. When triggered, each handler submits
+ * the corresponding slash command (e.g., "command:commit" submits "/commit").
+ */
+export function CommandKeybindingHandlers(t0) {
+    const $ = _c(8);
+    const { onSubmit, isActive: t1 } = t0;
+    const isActive = t1 === undefined ? true : t1;
+    const keybindingContext = useOptionalKeybindingContext();
+    const isModalOverlayActive = useIsModalOverlayActive();
+    let t2;
+    bb0: {
+        if (!keybindingContext) {
+            let t3;
+            if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+                t3 = new Set();
+                $[0] = t3;
+            }
+            else {
+                t3 = $[0];
+            }
+            t2 = t3;
+            break bb0;
+        }
+        let actions;
+        if ($[1] !== keybindingContext.bindings) {
+            actions = new Set();
+            for (const binding of keybindingContext.bindings) {
+                if (binding.action?.startsWith("command:")) {
+                    actions.add(binding.action);
+                }
+            }
+            $[1] = keybindingContext.bindings;
+            $[2] = actions;
+        }
+        else {
+            actions = $[2];
+        }
+        t2 = actions;
+    }
+    const commandActions = t2;
+    let map;
+    if ($[3] !== commandActions || $[4] !== onSubmit) {
+        map = {};
+        for (const action of commandActions) {
+            const commandName = action.slice(8);
+            map[action] = () => {
+                onSubmit(`/${commandName}`, NOOP_HELPERS, undefined, {
+                    fromKeybinding: true
+                });
+            };
+        }
+        $[3] = commandActions;
+        $[4] = onSubmit;
+        $[5] = map;
+    }
+    else {
+        map = $[5];
+    }
+    const handlers = map;
+    const t3 = isActive && !isModalOverlayActive;
+    let t4;
+    if ($[6] !== t3) {
+        t4 = {
+            context: "Chat",
+            isActive: t3
+        };
+        $[6] = t3;
+        $[7] = t4;
+    }
+    else {
+        t4 = $[7];
+    }
+    useKeybindings(handlers, t4);
+    return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/hooks/useCommandQueue.js

@@ -0,0 +1,10 @@
+import { useSyncExternalStore } from 'react';
+import { getCommandQueueSnapshot, subscribeToCommandQueue, } from '../utils/messageQueueManager.js';
+/**
+ * React hook to subscribe to the unified command queue.
+ * Returns a frozen array that only changes reference on mutation.
+ * Components re-render only when the queue changes.
+ */
+export function useCommandQueue() {
+    return useSyncExternalStore(subscribeToCommandQueue, getCommandQueueSnapshot);
+}

package/dist/src/hooks/useCopyOnSelect.js

@@ -0,0 +1,88 @@
+import { useEffect, useRef } from 'react';
+import { useTheme } from '../components/design-system/ThemeProvider.js';
+import { getGlobalConfig } from '../utils/config.js';
+import { getTheme } from '../utils/theme.js';
+/**
+ * Auto-copy the selection to the clipboard when the user finishes dragging
+ * (mouse-up with a non-empty selection) or multi-clicks to select a word/line.
+ * Mirrors iTerm2's "Copy to pasteboard on selection" — the highlight is left
+ * intact so the user can see what was copied. Only fires in alt-screen mode
+ * (selection state is ink-instance-owned; outside alt-screen, the native
+ * terminal handles selection and this hook is a no-op via the ink stub).
+ *
+ * selection.subscribe fires on every mutation (start/update/finish/clear/
+ * multiclick). Both char drags and multi-clicks set isDragging=true while
+ * pressed, so a selection appearing with isDragging=false is always a
+ * drag-finish. copiedRef guards against double-firing on spurious notifies.
+ *
+ * onCopied is optional — when omitted, copy is silent (clipboard is written
+ * but no toast/notification fires). FleetView uses this silent mode; the
+ * fullscreen REPL passes showCopiedToast for user feedback.
+ */
+export function useCopyOnSelect(selection, isActive, onCopied) {
+    // Tracks whether the *previous* notification had a visible selection with
+    // isDragging=false (i.e., we already auto-copied it). Without this, the
+    // finish→clear transition would look like a fresh selection-gone-idle
+    // event and we'd toast twice for a single drag.
+    const copiedRef = useRef(false);
+    // onCopied is a fresh closure each render; read through a ref so the
+    // effect doesn't re-subscribe (which would reset copiedRef via unmount).
+    const onCopiedRef = useRef(onCopied);
+    onCopiedRef.current = onCopied;
+    useEffect(() => {
+        if (!isActive)
+            return;
+        const unsubscribe = selection.subscribe(() => {
+            const sel = selection.getState();
+            const has = selection.hasSelection();
+            // Drag in progress — wait for finish. Reset copied flag so a new drag
+            // that ends on the same range still triggers a fresh copy.
+            if (sel?.isDragging) {
+                copiedRef.current = false;
+                return;
+            }
+            // No selection (cleared, or click-without-drag) — reset.
+            if (!has) {
+                copiedRef.current = false;
+                return;
+            }
+            // Selection settled (drag finished OR multi-click). Already copied
+            // this one — the only way to get here again without going through
+            // isDragging or !has is a spurious notify (shouldn't happen, but safe).
+            if (copiedRef.current)
+                return;
+            // Default true: macOS users expect cmd+c to work. It can't — the
+            // terminal's Edit > Copy intercepts it before the pty sees it, and
+            // finds no native selection (mouse tracking disabled it). Auto-copy
+            // on mouse-up makes cmd+c a no-op that leaves the clipboard intact
+            // with the right content, so paste works as expected.
+            const enabled = getGlobalConfig().copyOnSelect ?? true;
+            if (!enabled)
+                return;
+            const text = selection.copySelectionNoClear();
+            // Whitespace-only (e.g., blank-line multi-click) — not worth a
+            // clipboard write or toast. Still set copiedRef so we don't retry.
+            if (!text || !text.trim()) {
+                copiedRef.current = true;
+                return;
+            }
+            copiedRef.current = true;
+            onCopiedRef.current?.(text);
+        });
+        return unsubscribe;
+    }, [isActive, selection]);
+}
+/**
+ * Pipe the theme's selectionBg color into the Ink StylePool so the
+ * selection overlay renders a solid blue bg instead of SGR-7 inverse.
+ * Ink is theme-agnostic (layering: colorize.ts "theme resolution happens
+ * at component layer, not here") — this is the bridge. Fires on mount
+ * (before any mouse input is possible) and again whenever /theme flips,
+ * so the selection color tracks the theme live.
+ */
+export function useSelectionBgColor(selection) {
+    const [themeName] = useTheme();
+    useEffect(() => {
+        selection.setSelectionBgColor(getTheme(themeName).selectionBg);
+    }, [selection, themeName]);
+}