@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/hooks/useManagePlugins.js

@@ -1,261 +0,0 @@
-import { useCallback, useEffect } from 'react';
-import { useNotifications } from '../context/notifications.js';
-import { logEvent, } from '../services/analytics/index.js';
-import { reinitializeLspServerManager } from '../services/lsp/manager.js';
-import { useAppState, useSetAppState } from '../state/AppState.js';
-import { count } from '../utils/array.js';
-import { logForDebugging } from '../utils/debug.js';
-import { logForDiagnosticsNoPII } from '../utils/diagLogs.js';
-import { toError } from '../utils/errors.js';
-import { logError } from '../utils/log.js';
-import { loadPluginAgents } from '../utils/plugins/loadPluginAgents.js';
-import { getPluginCommands } from '../utils/plugins/loadPluginCommands.js';
-import { loadPluginHooks } from '../utils/plugins/loadPluginHooks.js';
-import { loadPluginLspServers } from '../utils/plugins/lspPluginIntegration.js';
-import { loadPluginMcpServers } from '../utils/plugins/mcpPluginIntegration.js';
-import { detectAndUninstallDelistedPlugins } from '../utils/plugins/pluginBlocklist.js';
-import { getFlaggedPlugins } from '../utils/plugins/pluginFlagging.js';
-import { loadAllPlugins } from '../utils/plugins/pluginLoader.js';
-/**
- * Hook to manage plugin state and synchronize with AppState.
- *
- * On mount: loads all plugins, runs delisting enforcement, surfaces flagged-
- * plugin notifications, populates AppState.plugins. This is the initial
- * Layer-3 load — subsequent refresh goes through /reload-plugins.
- *
- * On needsRefresh: shows a notification directing the user to /reload-plugins.
- * Does NOT auto-refresh. All Layer-3 swap (commands, agents, hooks, MCP)
- * goes through refreshActivePlugins() via /reload-plugins for one consistent
- * mental model. See Outline: declarative-settings-hXHBMDIf4b PR 5c.
- */
-export function useManagePlugins({ enabled = true, } = {}) {
-    const setAppState = useSetAppState();
-    const needsRefresh = useAppState(s => s.plugins.needsRefresh);
-    const { addNotification } = useNotifications();
-    // Initial plugin load. Runs once on mount. NOT used for refresh — all
-    // post-mount refresh goes through /reload-plugins → refreshActivePlugins().
-    // Unlike refreshActivePlugins, this also runs delisting enforcement and
-    // flagged-plugin notifications (session-start concerns), and does NOT bump
-    // mcp.pluginReconnectKey (MCP effects fire on their own mount).
-    const initialPluginLoad = useCallback(async () => {
-        try {
-            // Load all plugins - capture errors array
-            const { enabled, disabled, errors } = await loadAllPlugins();
-            // Detect delisted plugins, auto-uninstall them, and record as flagged.
-            await detectAndUninstallDelistedPlugins();
-            // Notify if there are flagged plugins pending dismissal
-            const flagged = getFlaggedPlugins();
-            if (Object.keys(flagged).length > 0) {
-                addNotification({
-                    key: 'plugin-delisted-flagged',
-                    text: 'Plugins flagged. Check /plugins',
-                    color: 'warning',
-                    priority: 'high',
-                });
-            }
-            // Load commands, agents, and hooks with individual error handling
-            // Errors are added to the errors array for user visibility in Doctor UI
-            let commands = [];
-            let agents = [];
-            try {
-                commands = await getPluginCommands();
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                errors.push({
-                    type: 'generic-error',
-                    source: 'plugin-commands',
-                    error: `Failed to load plugin commands: ${errorMessage}`,
-                });
-            }
-            try {
-                agents = await loadPluginAgents();
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                errors.push({
-                    type: 'generic-error',
-                    source: 'plugin-agents',
-                    error: `Failed to load plugin agents: ${errorMessage}`,
-                });
-            }
-            try {
-                await loadPluginHooks();
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                errors.push({
-                    type: 'generic-error',
-                    source: 'plugin-hooks',
-                    error: `Failed to load plugin hooks: ${errorMessage}`,
-                });
-            }
-            // Load MCP server configs per plugin to get an accurate count.
-            // LoadedPlugin.mcpServers is not populated by loadAllPlugins — it's a
-            // cache slot that extractMcpServersFromPlugins fills later, which races
-            // with this metric. Calling loadPluginMcpServers directly (as
-            // cli/handlers/plugins.ts does) gives the correct count and also
-            // warms the cache for the MCP connection manager.
-            //
-            // Runs BEFORE setAppState so any errors pushed by these loaders make it
-            // into AppState.plugins.errors (Doctor UI), not just telemetry.
-            const mcpServerCounts = await Promise.all(enabled.map(async (p) => {
-                if (p.mcpServers)
-                    return Object.keys(p.mcpServers).length;
-                const servers = await loadPluginMcpServers(p, errors);
-                if (servers)
-                    p.mcpServers = servers;
-                return servers ? Object.keys(servers).length : 0;
-            }));
-            const mcp_count = mcpServerCounts.reduce((sum, n) => sum + n, 0);
-            // LSP: the primary fix for issue #15521 is in refresh.ts (via
-            // performBackgroundPluginInstallations → refreshActivePlugins, which
-            // clears caches first). This reinit is defensive — it reads the same
-            // memoized loadAllPlugins() result as the original init unless a cache
-            // invalidation happened between main.tsx:3203 and REPL mount (e.g.
-            // seed marketplace registration or policySettings hot-reload).
-            const lspServerCounts = await Promise.all(enabled.map(async (p) => {
-                if (p.lspServers)
-                    return Object.keys(p.lspServers).length;
-                const servers = await loadPluginLspServers(p, errors);
-                if (servers)
-                    p.lspServers = servers;
-                return servers ? Object.keys(servers).length : 0;
-            }));
-            const lsp_count = lspServerCounts.reduce((sum, n) => sum + n, 0);
-            reinitializeLspServerManager();
-            // Update AppState - merge errors to preserve LSP errors
-            setAppState(prevState => {
-                // Keep existing LSP/non-plugin-loading errors (source 'lsp-manager' or 'plugin:*')
-                const existingLspErrors = prevState.plugins.errors.filter(e => e.source === 'lsp-manager' || e.source.startsWith('plugin:'));
-                // Deduplicate: remove existing LSP errors that are also in new errors
-                const newErrorKeys = new Set(errors.map(e => e.type === 'generic-error'
-                    ? `generic-error:${e.source}:${e.error}`
-                    : `${e.type}:${e.source}`));
-                const filteredExisting = existingLspErrors.filter(e => {
-                    const key = e.type === 'generic-error'
-                        ? `generic-error:${e.source}:${e.error}`
-                        : `${e.type}:${e.source}`;
-                    return !newErrorKeys.has(key);
-                });
-                const mergedErrors = [...filteredExisting, ...errors];
-                return {
-                    ...prevState,
-                    plugins: {
-                        ...prevState.plugins,
-                        enabled,
-                        disabled,
-                        commands,
-                        errors: mergedErrors,
-                    },
-                };
-            });
-            logForDebugging(`Loaded plugins - Enabled: ${enabled.length}, Disabled: ${disabled.length}, Commands: ${commands.length}, Agents: ${agents.length}, Errors: ${errors.length}`);
-            // Count component types across enabled plugins
-            const hook_count = enabled.reduce((sum, p) => {
-                if (!p.hooksConfig)
-                    return sum;
-                return (sum +
-                    Object.values(p.hooksConfig).reduce((s, matchers) => s + (matchers?.reduce((h, m) => h + m.hooks.length, 0) ?? 0), 0));
-            }, 0);
-            return {
-                enabled_count: enabled.length,
-                disabled_count: disabled.length,
-                inline_count: count(enabled, p => p.source.endsWith('@inline')),
-                marketplace_count: count(enabled, p => !p.source.endsWith('@inline')),
-                error_count: errors.length,
-                skill_count: commands.length,
-                agent_count: agents.length,
-                hook_count,
-                mcp_count,
-                lsp_count,
-                // Ant-only: which plugins are enabled, to correlate with RSS/FPS.
-                // Kept separate from base metrics so it doesn't flow into
-                // logForDiagnosticsNoPII.
-                ant_enabled_names: process.env.USER_TYPE === 'ant' && enabled.length > 0
-                    ? enabled
-                        .map(p => p.name)
-                        .sort()
-                        .join(',')
-                    : undefined,
-            };
-        }
-        catch (error) {
-            // Only plugin loading errors should reach here - log for monitoring
-            const errorObj = toError(error);
-            logError(errorObj);
-            logForDebugging(`Error loading plugins: ${error}`);
-            // Set empty state on error, but preserve LSP errors and add the new error
-            setAppState(prevState => {
-                // Keep existing LSP/non-plugin-loading errors
-                const existingLspErrors = prevState.plugins.errors.filter(e => e.source === 'lsp-manager' || e.source.startsWith('plugin:'));
-                const newError = {
-                    type: 'generic-error',
-                    source: 'plugin-system',
-                    error: errorObj.message,
-                };
-                return {
-                    ...prevState,
-                    plugins: {
-                        ...prevState.plugins,
-                        enabled: [],
-                        disabled: [],
-                        commands: [],
-                        errors: [...existingLspErrors, newError],
-                    },
-                };
-            });
-            return {
-                enabled_count: 0,
-                disabled_count: 0,
-                inline_count: 0,
-                marketplace_count: 0,
-                error_count: 1,
-                skill_count: 0,
-                agent_count: 0,
-                hook_count: 0,
-                mcp_count: 0,
-                lsp_count: 0,
-                load_failed: true,
-                ant_enabled_names: undefined,
-            };
-        }
-    }, [setAppState, addNotification]);
-    // Load plugins on mount and emit telemetry
-    useEffect(() => {
-        if (!enabled)
-            return;
-        void initialPluginLoad().then(metrics => {
-            const { ant_enabled_names, ...baseMetrics } = metrics;
-            const allMetrics = {
-                ...baseMetrics,
-                has_custom_plugin_cache_dir: !!process.env.CLAUDE_CODE_PLUGIN_CACHE_DIR,
-            };
-            logEvent('tengu_plugins_loaded', {
-                ...allMetrics,
-                ...(ant_enabled_names !== undefined && {
-                    enabled_names: ant_enabled_names,
-                }),
-            });
-            logForDiagnosticsNoPII('info', 'tengu_plugins_loaded', allMetrics);
-        });
-    }, [initialPluginLoad, enabled]);
-    // Plugin state changed on disk (background reconcile, /plugin menu,
-    // external settings edit). Show a notification; user runs /reload-plugins
-    // to apply. The previous auto-refresh here had a stale-cache bug (only
-    // cleared loadAllPlugins, downstream memoized loaders returned old data)
-    // and was incomplete (no MCP, no agentDefinitions). /reload-plugins
-    // handles all of that correctly via refreshActivePlugins().
-    useEffect(() => {
-        if (!enabled || !needsRefresh)
-            return;
-        addNotification({
-            key: 'plugin-reload-pending',
-            text: 'Plugins changed. Run /reload-plugins to activate.',
-            color: 'suggestion',
-            priority: 'low',
-        });
-        // Do NOT auto-refresh. Do NOT reset needsRefresh — /reload-plugins
-        // consumes it via refreshActivePlugins().
-    }, [enabled, needsRefresh, addNotification]);
-}

package/dist/src/hooks/useMemoryUsage.js

@@ -1,28 +0,0 @@
-import { useState } from 'react';
-import { useInterval } from 'usehooks-ts';
-const HIGH_MEMORY_THRESHOLD = 1.5 * 1024 * 1024 * 1024; // 1.5GB in bytes
-const CRITICAL_MEMORY_THRESHOLD = 2.5 * 1024 * 1024 * 1024; // 2.5GB in bytes
-/**
- * Hook to monitor Node.js process memory usage.
- * Polls every 10 seconds; returns null while status is 'normal'.
- */
-export function useMemoryUsage() {
-    const [memoryUsage, setMemoryUsage] = useState(null);
-    useInterval(() => {
-        const heapUsed = process.memoryUsage().heapUsed;
-        const status = heapUsed >= CRITICAL_MEMORY_THRESHOLD
-            ? 'critical'
-            : heapUsed >= HIGH_MEMORY_THRESHOLD
-                ? 'high'
-                : 'normal';
-        setMemoryUsage(prev => {
-            // Bail when status is 'normal' — nothing is shown, so heapUsed is
-            // irrelevant and we avoid re-rendering the whole Notifications subtree
-            // every 10 seconds for the 99%+ of users who never reach 1.5GB.
-            if (status === 'normal')
-                return prev === null ? prev : null;
-            return { heapUsed, status };
-        });
-    }, 10_000);
-    return memoryUsage;
-}

package/dist/src/hooks/useMergedClients.js

@@ -1,11 +0,0 @@
-import uniqBy from 'lodash-es/uniqBy.js';
-import { useMemo } from 'react';
-export function mergeClients(initialClients, mcpClients) {
-    if (initialClients && mcpClients && mcpClients.length > 0) {
-        return uniqBy([...initialClients, ...mcpClients], 'name');
-    }
-    return initialClients || [];
-}
-export function useMergedClients(initialClients, mcpClients) {
-    return useMemo(() => mergeClients(initialClients, mcpClients), [initialClients, mcpClients]);
-}

package/dist/src/hooks/useMergedCommands.js

@@ -1,10 +0,0 @@
-import uniqBy from 'lodash-es/uniqBy.js';
-import { useMemo } from 'react';
-export function useMergedCommands(initialCommands, mcpCommands) {
-    return useMemo(() => {
-        if (mcpCommands.length > 0) {
-            return uniqBy([...initialCommands, ...mcpCommands], 'name');
-        }
-        return initialCommands;
-    }, [initialCommands, mcpCommands]);
-}

package/dist/src/hooks/useMergedTools.js

@@ -1,32 +0,0 @@
-// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
-import { useMemo } from 'react';
-import { assembleToolPool } from '../tools.js';
-import { mergeAndFilterTools } from '../utils/toolPool.js';
-/**
- * React hook that assembles the full tool pool for the REPL.
- *
- * Uses assembleToolPool() (the shared pure function used by both REPL and runAgent)
- * to combine built-in tools with MCP tools, applying deny rules and deduplication.
- * Any extra initialTools are merged on top.
- *
- * @param initialTools - Extra tools to include (built-in + startup MCP from props).
- *   These are merged with the assembled pool and take precedence in deduplication.
- * @param mcpTools - MCP tools discovered dynamically (from mcp state)
- * @param toolPermissionContext - Permission context for filtering
- */
-export function useMergedTools(initialTools, mcpTools, toolPermissionContext) {
-    let replBridgeEnabled = false;
-    let replBridgeOutboundOnly = false;
-    return useMemo(() => {
-        // assembleToolPool is the shared function that both REPL and runAgent use.
-        // It handles: getTools() + MCP deny-rule filtering + dedup + MCP CLI exclusion.
-        const assembled = assembleToolPool(toolPermissionContext, mcpTools);
-        return mergeAndFilterTools(initialTools, assembled, toolPermissionContext.mode);
-    }, [
-        initialTools,
-        mcpTools,
-        toolPermissionContext,
-        replBridgeEnabled,
-        replBridgeOutboundOnly,
-    ]);
-}

package/dist/src/hooks/useMinDisplayTime.js

@@ -1,26 +0,0 @@
-import { useEffect, useRef, useState } from 'react';
-/**
- * Throttles a value so each distinct value stays visible for at least `minMs`.
- * Prevents fast-cycling progress text from flickering past before it's readable.
- *
- * Unlike debounce (wait for quiet) or throttle (limit rate), this guarantees
- * each value gets its minimum screen time before being replaced.
- */
-export function useMinDisplayTime(value, minMs) {
-    const [displayed, setDisplayed] = useState(value);
-    const lastShownAtRef = useRef(0);
-    useEffect(() => {
-        const elapsed = Date.now() - lastShownAtRef.current;
-        if (elapsed >= minMs) {
-            lastShownAtRef.current = Date.now();
-            setDisplayed(value);
-            return;
-        }
-        const timer = setTimeout((shownAtRef, setFn, v) => {
-            shownAtRef.current = Date.now();
-            setFn(v);
-        }, minMs - elapsed, lastShownAtRef, setDisplayed, value);
-        return () => clearTimeout(timer);
-    }, [value, minMs]);
-    return displayed;
-}

package/dist/src/hooks/useNotifyAfterTimeout.js

@@ -1,51 +0,0 @@
-import { useEffect } from 'react';
-import { getLastInteractionTime, updateLastInteractionTime, } from '../bootstrap/state.js';
-import { useTerminalNotification } from '../ink/useTerminalNotification.js';
-import { sendNotification } from '../services/notifier.js';
-// The time threshold in milliseconds for considering an interaction "recent" (6 seconds)
-export const DEFAULT_INTERACTION_THRESHOLD_MS = 6000;
-function getTimeSinceLastInteraction() {
-    return Date.now() - getLastInteractionTime();
-}
-function hasRecentInteraction(threshold) {
-    return getTimeSinceLastInteraction() < threshold;
-}
-function shouldNotify(threshold) {
-    return process.env.NODE_ENV !== 'test' && !hasRecentInteraction(threshold);
-}
-// NOTE: User interaction tracking is now done in App.tsx's processKeysInBatch
-// function, which calls updateLastInteractionTime() when any input is received.
-// This avoids having a separate stdin 'data' listener that would compete with
-// the main 'readable' listener and cause dropped input characters.
-/**
- * Hook that manages desktop notifications after a timeout period.
- *
- * Shows a notification in two cases:
- * 1. Immediately if the app has been idle for longer than the threshold
- * 2. After the specified timeout if the user doesn't interact within that time
- *
- * @param message - The notification message to display
- * @param timeout - The timeout in milliseconds (defaults to 6000ms)
- */
-export function useNotifyAfterTimeout(message, notificationType) {
-    const terminal = useTerminalNotification();
-    // Reset interaction time when hook is called to make sure that requests
-    // that took a long time to complete don't pop up a notification right away.
-    // Must be immediate because useEffect runs after Ink's render cycle has
-    // already flushed; without it the timestamp stays stale and a premature
-    // notification fires if the user is idle (no subsequent renders to flush).
-    useEffect(() => {
-        updateLastInteractionTime(true);
-    }, []);
-    useEffect(() => {
-        let hasNotified = false;
-        const timer = setInterval(() => {
-            if (shouldNotify(DEFAULT_INTERACTION_THRESHOLD_MS) && !hasNotified) {
-                hasNotified = true;
-                clearInterval(timer);
-                void sendNotification({ message, notificationType }, terminal);
-            }
-        }, DEFAULT_INTERACTION_THRESHOLD_MS);
-        return () => clearInterval(timer);
-    }, [message, notificationType, terminal]);
-}

package/dist/src/hooks/useOfficialMarketplaceNotification.js

@@ -1,46 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Text } from '../ink.js';
-import { logForDebugging } from '../utils/debug.js';
-import { checkAndInstallOfficialMarketplace } from '../utils/plugins/officialMarketplaceStartupCheck.js';
-import { useStartupNotification } from './notifs/useStartupNotification.js';
-/**
- * Hook that handles official marketplace auto-installation and shows
- * notifications for success/failure in the bottom right of the REPL.
- */
-export function useOfficialMarketplaceNotification() {
-    useStartupNotification(_temp);
-}
-async function _temp() {
-    const result = await checkAndInstallOfficialMarketplace();
-    const notifs = [];
-    if (result.configSaveFailed) {
-        logForDebugging("Showing marketplace config save failure notification");
-        notifs.push({
-            key: "marketplace-config-save-failed",
-            jsx: _jsx(Text, { color: "error", children: "Failed to save marketplace retry info \u00B7 Check ~/.claude.json permissions" }),
-            priority: "immediate",
-            timeoutMs: 10000
-        });
-    }
-    if (result.installed) {
-        logForDebugging("Showing marketplace installation success notification");
-        notifs.push({
-            key: "marketplace-installed",
-            jsx: _jsx(Text, { color: "success", children: "\u2713 Anthropic marketplace installed \u00B7 /plugin to see available plugins" }),
-            priority: "immediate",
-            timeoutMs: 7000
-        });
-    }
-    else {
-        if (result.skipped && result.reason === "unknown") {
-            logForDebugging("Showing marketplace installation failure notification");
-            notifs.push({
-                key: "marketplace-install-failed",
-                jsx: _jsx(Text, { color: "warning", children: "Failed to install Anthropic marketplace \u00B7 Will retry on next startup" }),
-                priority: "immediate",
-                timeoutMs: 8000
-            });
-        }
-    }
-    return notifs;
-}

package/dist/src/hooks/usePasteHandler.js

@@ -1,188 +0,0 @@
-import { basename } from 'path';
-import React from 'react';
-import { logError } from '../utils/log.js';
-import { useDebounceCallback } from 'usehooks-ts';
-import { getImageFromClipboard, isImageFilePath, PASTE_THRESHOLD, tryReadImageFromPath, } from '../utils/imagePaste.js';
-import { getPlatform } from '../utils/platform.js';
-const CLIPBOARD_CHECK_DEBOUNCE_MS = 50;
-const PASTE_COMPLETION_TIMEOUT_MS = 100;
-export function usePasteHandler({ onPaste, onInput, onImagePaste, }) {
-    const [pasteState, setPasteState] = React.useState({ chunks: [], timeoutId: null });
-    const [isPasting, setIsPasting] = React.useState(false);
-    const isMountedRef = React.useRef(true);
-    // Mirrors pasteState.timeoutId but updated synchronously. When paste + a
-    // keystroke arrive in the same stdin chunk, both wrappedOnInput calls run
-    // in the same discreteUpdates batch before React commits — the second call
-    // reads stale pasteState.timeoutId (null) and takes the onInput path. If
-    // that key is Enter, it submits the old input and the paste is lost.
-    const pastePendingRef = React.useRef(false);
-    const isMacOS = React.useMemo(() => getPlatform() === 'macos', []);
-    React.useEffect(() => {
-        return () => {
-            isMountedRef.current = false;
-        };
-    }, []);
-    const checkClipboardForImageImpl = React.useCallback(() => {
-        if (!onImagePaste || !isMountedRef.current)
-            return;
-        void getImageFromClipboard()
-            .then(imageData => {
-            if (imageData && isMountedRef.current) {
-                onImagePaste(imageData.base64, imageData.mediaType, undefined, // no filename for clipboard images
-                imageData.dimensions);
-            }
-        })
-            .catch(error => {
-            if (isMountedRef.current) {
-                logError(error);
-            }
-        })
-            .finally(() => {
-            if (isMountedRef.current) {
-                setIsPasting(false);
-            }
-        });
-    }, [onImagePaste]);
-    const checkClipboardForImage = useDebounceCallback(checkClipboardForImageImpl, CLIPBOARD_CHECK_DEBOUNCE_MS);
-    const resetPasteTimeout = React.useCallback((currentTimeoutId) => {
-        if (currentTimeoutId) {
-            clearTimeout(currentTimeoutId);
-        }
-        return setTimeout((setPasteState, onImagePaste, onPaste, setIsPasting, checkClipboardForImage, isMacOS, pastePendingRef) => {
-            pastePendingRef.current = false;
-            setPasteState(({ chunks }) => {
-                // Join chunks and filter out orphaned focus sequences
-                // These can appear when focus events split during paste
-                const pastedText = chunks
-                    .join('')
-                    .replace(/\[I$/, '')
-                    .replace(/\[O$/, '');
-                // Check if the pasted text contains image file paths
-                // When dragging multiple images, they may come as:
-                // 1. Newline-separated paths (common in some terminals)
-                // 2. Space-separated paths (common when dragging from Finder)
-                // For space-separated paths, we split on spaces that precede absolute paths:
-                // - Unix: space followed by `/` (e.g., `/Users/...`)
-                // - Windows: space followed by drive letter and `:\` (e.g., `C:\Users\...`)
-                // This works because spaces within paths are escaped (e.g., `file\ name.png`)
-                const lines = pastedText
-                    .split(/ (?=\/|[A-Za-z]:\\)/)
-                    .flatMap(part => part.split('\n'))
-                    .filter(line => line.trim());
-                const imagePaths = lines.filter(line => isImageFilePath(line));
-                if (onImagePaste && imagePaths.length > 0) {
-                    const isTempScreenshot = /\/TemporaryItems\/.*screencaptureui.*\/Screenshot/i.test(pastedText);
-                    // Process all image paths
-                    void Promise.all(imagePaths.map(imagePath => tryReadImageFromPath(imagePath))).then(results => {
-                        const validImages = results.filter((r) => r !== null);
-                        if (validImages.length > 0) {
-                            // Successfully read at least one image
-                            for (const imageData of validImages) {
-                                const filename = basename(imageData.path);
-                                onImagePaste(imageData.base64, imageData.mediaType, filename, imageData.dimensions, imageData.path);
-                            }
-                            // If some paths weren't images, paste them as text
-                            const nonImageLines = lines.filter(line => !isImageFilePath(line));
-                            if (nonImageLines.length > 0 && onPaste) {
-                                onPaste(nonImageLines.join('\n'));
-                            }
-                            setIsPasting(false);
-                        }
-                        else if (isTempScreenshot && isMacOS) {
-                            // For temporary screenshot files that no longer exist, try clipboard
-                            checkClipboardForImage();
-                        }
-                        else {
-                            if (onPaste) {
-                                onPaste(pastedText);
-                            }
-                            setIsPasting(false);
-                        }
-                    });
-                    return { chunks: [], timeoutId: null };
-                }
-                // If paste is empty (common when trying to paste images with Cmd+V),
-                // check if clipboard has an image (macOS only)
-                if (isMacOS && onImagePaste && pastedText.length === 0) {
-                    checkClipboardForImage();
-                    return { chunks: [], timeoutId: null };
-                }
-                // Handle regular paste
-                if (onPaste) {
-                    onPaste(pastedText);
-                }
-                // Reset isPasting state after paste is complete
-                setIsPasting(false);
-                return { chunks: [], timeoutId: null };
-            });
-        }, PASTE_COMPLETION_TIMEOUT_MS, setPasteState, onImagePaste, onPaste, setIsPasting, checkClipboardForImage, isMacOS, pastePendingRef);
-    }, [checkClipboardForImage, isMacOS, onImagePaste, onPaste]);
-    // Paste detection is now done via the InputEvent's keypress.isPasted flag,
-    // which is set by the keypress parser when it detects bracketed paste mode.
-    // This avoids the race condition caused by having multiple listeners on stdin.
-    // Previously, we had a stdin.on('data') listener here which competed with
-    // the 'readable' listener in App.tsx, causing dropped characters.
-    const wrappedOnInput = (input, key, event) => {
-        // Detect paste from the parsed keypress event.
-        // The keypress parser sets isPasted=true for content within bracketed paste.
-        const isFromPaste = event.keypress.isPasted;
-        // If this is pasted content, set isPasting state for UI feedback
-        if (isFromPaste) {
-            setIsPasting(true);
-        }
-        // Handle large pastes (>PASTE_THRESHOLD chars)
-        // Usually we get one or two input characters at a time. If we
-        // get more than the threshold, the user has probably pasted.
-        // Unfortunately node batches long pastes, so it's possible
-        // that we would see e.g. 1024 characters and then just a few
-        // more in the next frame that belong with the original paste.
-        // This batching number is not consistent.
-        // Handle potential image filenames (even if they're shorter than paste threshold)
-        // When dragging multiple images, they may come as newline-separated or
-        // space-separated paths. Split on spaces preceding absolute paths:
-        // - Unix: ` /` - Windows: ` C:\` etc.
-        const hasImageFilePath = input
-            .split(/ (?=\/|[A-Za-z]:\\)/)
-            .flatMap(part => part.split('\n'))
-            .some(line => isImageFilePath(line.trim()));
-        // Handle empty paste (clipboard image on macOS)
-        // When the user pastes an image with Cmd+V, the terminal sends an empty
-        // bracketed paste sequence. The keypress parser emits this as isPasted=true
-        // with empty input.
-        if (isFromPaste && input.length === 0 && isMacOS && onImagePaste) {
-            checkClipboardForImage();
-            // Reset isPasting since there's no text content to process
-            setIsPasting(false);
-            return;
-        }
-        // Check if we should handle as paste (from bracketed paste, large input, or continuation)
-        const shouldHandleAsPaste = onPaste &&
-            (input.length > PASTE_THRESHOLD ||
-                pastePendingRef.current ||
-                hasImageFilePath ||
-                isFromPaste);
-        if (shouldHandleAsPaste) {
-            pastePendingRef.current = true;
-            setPasteState(({ chunks, timeoutId }) => {
-                return {
-                    chunks: [...chunks, input],
-                    timeoutId: resetPasteTimeout(timeoutId),
-                };
-            });
-            return;
-        }
-        onInput(input, key);
-        if (input.length > 10) {
-            // Ensure that setIsPasting is turned off on any other multicharacter
-            // input, because the stdin buffer may chunk at arbitrary points and split
-            // the closing escape sequence if the input length is too long for the
-            // stdin buffer.
-            setIsPasting(false);
-        }
-    };
-    return {
-        wrappedOnInput,
-        pasteState,
-        isPasting,
-    };
-}