@rawwee/interactive-mcp 1.2.0 → 1.4.0

package/README.md

@@ -19,6 +19,7 @@ This server exposes the following tools via the Model Context Protocol (MCP):
 - `stop_intensive_chat`: Closes an active intensive chat session.
 
 Prompt UIs support markdown-friendly question text (including multiline prompts, fenced code blocks, and diff snippets). When useful, you can also include VS Code-style file links in prompt text (for example, `vscode://file/<absolute-path>:<line>:<column>`).
+In TUI input mode, `Cmd/Ctrl+V` supports clipboard text plus file/image includes from pasted paths, copied file objects, and copied images (platform support varies). Files are sent as path references rather than full contents to optimize token usage—the AI can then read files directly using its available tools.
 
 ## Usage Scenarios
 

package/dist/commands/intensive-chat/ui.js

@@ -282,11 +282,11 @@ const App = ({ sessionId, title, outputDir, searchRoot, timeoutSeconds, onCloseS
         : 0;
     return (_jsxs("box", { flexDirection: "column", width: "100%", height: "100%", backgroundColor: "black", paddingLeft: isNarrow ? 0 : 1, paddingRight: isNarrow ? 0 : 1, children: [_jsxs("box", { marginBottom: 1, flexDirection: "column", width: "100%", paddingLeft: 1, paddingRight: 1, gap: 0, children: [_jsx("text", { fg: "magenta", children: _jsx("strong", { children: title }) }), _jsxs("text", { fg: "gray", wrapMode: "word", children: ["Session ", sessionId] }), !isNarrow && _jsx("text", { fg: "gray", children: "Waiting for prompts\u2026" })] }), _jsx("scrollbox", { ref: scrollRef, flexGrow: 1, width: "100%", scrollY: true, stickyScroll: followInput, stickyStart: followInput ? 'bottom' : undefined, viewportCulling: false, scrollbarOptions: {
                     showArrows: false,
-                }, children: _jsxs("box", { flexDirection: "column", width: "100%", paddingBottom: 1, children: [_jsx("box", { flexDirection: "column", width: "100%", gap: 2, children: chatHistory.map((msg, i) => (_jsxs("box", { flexDirection: "column", width: "100%", paddingLeft: 1, paddingRight: 1, gap: 1, children: [msg.isQuestion ? (_jsxs("box", { flexDirection: "column", width: "100%", gap: 0, children: [_jsx("text", { fg: "cyan", children: _jsx("strong", { children: "QUESTION" }) }), _jsx("box", { paddingLeft: isNarrow ? 1 : 2, children: _jsx(MarkdownText, { content: msg.text, showCodeCopyControls: true }) })] })) : null, msg.answer ? (_jsxs("box", { flexDirection: "column", width: "100%", marginTop: 0, children: [_jsx("text", { fg: "green", children: _jsx("strong", { children: "ANSWER" }) }), _jsx("box", { paddingLeft: isNarrow ? 1 : 2, children: _jsx(MarkdownText, { content: msg.answer, showCodeCopyControls: true }) })] })) : null] }, `msg-${i}`))) }), currentQuestionId && (_jsxs("box", { flexDirection: "column", marginTop: 1, paddingLeft: 1, paddingRight: 1, gap: 1, children: [_jsx(InteractiveInput, { question: chatHistory
-                                        .slice()
-                                        .reverse()
-                                        .find((m) => m.isQuestion && !m.answer)
-                                        ?.text || '', questionId: currentQuestionId, predefinedOptions: currentPredefinedOptions, searchRoot: currentSearchRoot, onSubmit: handleSubmit, onInputActivity: keepInputVisible }), timeLeft !== null && (_jsx("box", { marginTop: 0, children: _jsx(PromptStatus, { value: percentage, timeLeftSeconds: timeLeft, critical: timeLeft <= 10 }) }))] }))] }) })] }));
+                }, children: _jsxs("box", { flexDirection: "column", width: "100%", paddingBottom: 1, children: [_jsx("box", { flexDirection: "column", width: "100%", gap: 2, children: chatHistory.map((msg, i) => (_jsxs("box", { flexDirection: "column", width: "100%", paddingLeft: 1, paddingRight: 1, gap: 1, children: [msg.isQuestion ? (_jsxs("box", { flexDirection: "column", width: "100%", gap: 0, children: [_jsx("text", { fg: "cyan", children: _jsx("strong", { children: "QUESTION" }) }), _jsx("box", { paddingLeft: isNarrow ? 1 : 2, children: _jsx(MarkdownText, { content: msg.text, showCodeCopyControls: true }) })] })) : null, msg.answer ? (_jsxs("box", { flexDirection: "column", width: "100%", marginTop: 0, children: [_jsx("text", { fg: "green", children: _jsx("strong", { children: "ANSWER" }) }), _jsx("box", { paddingLeft: isNarrow ? 1 : 2, children: _jsx(MarkdownText, { content: msg.answer, showCodeCopyControls: true }) })] })) : null] }, `msg-${i}`))) }), currentQuestionId && (_jsx("box", { flexDirection: "column", marginTop: 1, paddingLeft: 1, paddingRight: 1, gap: 1, children: _jsx(InteractiveInput, { question: chatHistory
+                                    .slice()
+                                    .reverse()
+                                    .find((m) => m.isQuestion && !m.answer)
+                                    ?.text || '', questionId: currentQuestionId, predefinedOptions: currentPredefinedOptions, searchRoot: currentSearchRoot, onSubmit: handleSubmit, onInputActivity: keepInputVisible }) }))] }) }), currentQuestionId && timeLeft !== null && (_jsx("box", { paddingLeft: 1, paddingRight: 1, paddingTop: 1, children: _jsx(PromptStatus, { value: percentage, timeLeftSeconds: timeLeft, critical: timeLeft <= 10 }) }))] }));
 };
 async function startUi() {
     const renderer = await createCliRenderer({

package/dist/components/InteractiveInput.js

@@ -3,14 +3,14 @@ import * as OpenTuiReact from '@opentui/react';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import path from 'node:path';
 import { getAutocompleteTarget, rankFileSuggestions, readRepositoryFiles, } from './interactive-input/autocomplete.js';
-import { isPrintableCharacter, isCopyShortcut, isReverseTabShortcut, isSubmitShortcut, textareaKeyBindings, } from './interactive-input/keyboard.js';
+import { extractPastedText, isPrintableCharacter, isCopyShortcut, isPasteShortcut, isReverseTabShortcut, isSubmitShortcut, textareaKeyBindings, } from './interactive-input/keyboard.js';
 import { InputEditor, ModeTabs, OptionList, SuggestionsPanel, } from './interactive-input/sections.js';
 import { getTextareaDimensions } from './interactive-input/textarea-height.js';
 import { MarkdownText } from './MarkdownText.js';
-import { copyTextToClipboard } from '../utils/clipboard.js';
+import { repositoryFileCache, } from './interactive-input/constants.js';
+import { createClipboardHandlers } from './interactive-input/clipboard-handlers.js';
 const { useKeyboard } = OpenTuiReact;
 const { useTerminalDimensions } = OpenTuiReact;
-const repositoryFileCache = new Map();
 export function InteractiveInput({ question, questionId, predefinedOptions = [], onSubmit, onInputActivity, searchRoot, }) {
     const [mode, setMode] = useState(predefinedOptions.length > 0 ? 'option' : 'input');
     const [selectedIndex, setSelectedIndex] = useState(0);
@@ -23,6 +23,7 @@ export function InteractiveInput({ question, questionId, predefinedOptions = [],
     const [textareaRenderVersion, setTextareaRenderVersion] = useState(0);
     const [focusRequestToken, setFocusRequestToken] = useState(0);
     const [clipboardStatus, setClipboardStatus] = useState(null);
+    const [queuedAttachments, setQueuedAttachments] = useState([]);
     const textareaRef = useRef(null);
     const latestInputValueRef = useRef(inputValue);
     const latestCaretPositionRef = useRef(caretPosition);
@@ -128,6 +129,30 @@ export function InteractiveInput({ question, questionId, predefinedOptions = [],
             clearTimeout(clearStatusTimeout);
         };
     }, [clipboardStatus]);
+    // Detect when placeholders are manually removed from input
+    const previousInputValueRef = useRef('');
+    useEffect(() => {
+        if (queuedAttachments.length === 0) {
+            previousInputValueRef.current = inputValue;
+            return;
+        }
+        // Only check if input actually changed
+        if (inputValue === previousInputValueRef.current) {
+            return;
+        }
+        previousInputValueRef.current = inputValue;
+        const currentText = inputValue;
+        const missingAttachmentIds = [];
+        queuedAttachments.forEach((attachment, index) => {
+            const placeholder = `[Attached file ${index + 1}]`;
+            if (!currentText.includes(placeholder)) {
+                missingAttachmentIds.push(attachment.id);
+            }
+        });
+        if (missingAttachmentIds.length > 0) {
+            setQueuedAttachments((prev) => prev.filter((a) => !missingAttachmentIds.includes(a.id)));
+        }
+    }, [inputValue, queuedAttachments.length]);
     useEffect(() => {
         let active = true;
         const repositoryRoot = searchRoot;
@@ -176,6 +201,7 @@ export function InteractiveInput({ question, questionId, predefinedOptions = [],
         setSelectedIndex(0);
         setInputValue('');
         setCaretPosition(0);
+        setQueuedAttachments([]);
         latestInputValueRef.current = '';
         latestCaretPositionRef.current = 0;
         setFileSuggestions([]);
@@ -275,44 +301,66 @@ export function InteractiveInput({ question, questionId, predefinedOptions = [],
         setMode('option');
         onInputActivity?.();
     }, [onInputActivity, predefinedOptions.length]);
-    const copyInputToClipboard = useCallback(() => {
-        if (mode !== 'input') {
+    const insertTextAtCaret = useCallback((text) => {
+        if (!text) {
             return;
         }
-        const textarea = textareaRef.current;
-        const selectedText = typeof textarea?.hasSelection === 'function' &&
-            textarea.hasSelection() &&
-            typeof textarea.getSelectedText === 'function'
-            ? textarea.getSelectedText()
-            : '';
-        const fallbackText = textarea?.plainText ?? inputValue;
-        const textToCopy = selectedText.length > 0 ? selectedText : fallbackText;
-        if (textToCopy.length === 0) {
-            setClipboardStatus('Nothing to copy');
-            return;
-        }
-        void copyTextToClipboard(textToCopy)
-            .then(() => {
-            setClipboardStatus('Copied input to clipboard');
-        })
-            .catch((error) => {
-            const errorMessage = error instanceof Error ? error.message : 'unknown error';
-            setClipboardStatus(`Copy failed: ${errorMessage}`);
+        const textareaState = safeReadTextarea();
+        const currentValue = textareaState?.value ?? inputValue;
+        const currentCaret = Math.max(0, Math.min(textareaState?.caret ?? caretPosition, currentValue.length));
+        const nextValue = currentValue.slice(0, currentCaret) +
+            text +
+            currentValue.slice(currentCaret);
+        setTextareaValue(nextValue, currentCaret + text.length);
+    }, [caretPosition, inputValue, safeReadTextarea, setTextareaValue]);
+    const queueAttachment = useCallback((attachment) => {
+        setQueuedAttachments((previous) => {
+            const nextAttachments = [...previous, attachment];
+            const attachmentIndex = nextAttachments.length;
+            const placeholderText = `[Attached file ${attachmentIndex}]`;
+            // Insert placeholder at current caret position
+            insertTextAtCaret(placeholderText);
+            return nextAttachments;
         });
-        onInputActivity?.();
-    }, [inputValue, mode, onInputActivity]);
+    }, [insertTextAtCaret]);
+    const clipboardHandlers = useMemo(() => createClipboardHandlers({
+        insertTextAtCaret,
+        queueAttachment,
+        setClipboardStatus,
+        onInputActivity,
+        searchRoot,
+        requestInputFocus,
+        textareaRef,
+        inputValue,
+        mode,
+    }), [
+        insertTextAtCaret,
+        queueAttachment,
+        onInputActivity,
+        searchRoot,
+        requestInputFocus,
+        inputValue,
+        mode,
+    ]);
+    const { copyInputToClipboard, handlePastedText, pasteClipboardIntoInput } = clipboardHandlers;
     const submitCurrentSelection = useCallback(() => {
-        if (mode === 'option' && predefinedOptions.length > 0) {
-            onSubmit(questionId, predefinedOptions[selectedIndex]);
-            return;
-        }
-        const textareaValue = safeReadTextarea()?.value ?? inputValue;
-        onSubmit(questionId, textareaValue);
+        let finalValue = mode === 'option' && predefinedOptions.length > 0
+            ? predefinedOptions[selectedIndex]
+            : (safeReadTextarea()?.value ?? inputValue);
+        // Replace [Attached file N] placeholders with actual payloads
+        queuedAttachments.forEach((attachment, index) => {
+            const placeholder = `[Attached file ${index + 1}]`;
+            const regex = new RegExp(placeholder.replace(/[[\]]/g, '\\$&'), 'g');
+            finalValue = finalValue.replace(regex, attachment.payload);
+        });
+        onSubmit(questionId, finalValue);
+        setQueuedAttachments([]);
     }, [
         inputValue,
         mode,
         onSubmit,
         predefinedOptions,
+        queuedAttachments,
         questionId,
         safeReadTextarea,
         selectedIndex,
@@ -383,6 +431,18 @@ export function InteractiveInput({ question, questionId, predefinedOptions = [],
             submitCurrentSelection();
             return;
         }
+        const pastedText = extractPastedText(key);
+        if (pastedText !== null) {
+            if (mode === 'option' && hasOptions) {
+                setModeToInput();
+            }
+            handlePastedText(pastedText);
+            return;
+        }
+        if (isPasteShortcut(key)) {
+            pasteClipboardIntoInput();
+            return;
+        }
         if (isCopyShortcut(key)) {
             copyInputToClipboard();
             return;
@@ -462,7 +522,9 @@ export function InteractiveInput({ question, questionId, predefinedOptions = [],
                             ? `#search root: ${searchRoot}`
                             : '#search root: no search root' }), _jsx("text", { fg: "gray", children: isIndexingFiles
                             ? '#search index: indexing...'
-                            : `#search index: ${repositoryFiles.length} files indexed` })] })), _jsxs("box", { flexDirection: isNarrow ? 'column' : 'row', justifyContent: "space-between", marginBottom: 0, gap: isNarrow ? 0 : undefined, children: [_jsx("text", { fg: "gray", children: mode === 'input' ? 'Custom input' : 'Option selection' }), _jsxs("text", { fg: "gray", children: [inputValue.length, " chars"] })] }), mode === 'input' && clipboardStatus && (_jsx("text", { fg: clipboardStatus.startsWith('Copy failed:') ? 'red' : 'green', children: clipboardStatus })), mode === 'input' && (_jsx("box", { backgroundColor: "cyan", paddingLeft: 1, paddingRight: 1, alignSelf: "flex-start", marginBottom: 0, onClick: submitCurrentSelection, children: _jsxs("text", { fg: "black", children: [_jsx("strong", { children: "Send" }), " \u2303S"] }) })), mode === 'input' && (_jsx("text", { fg: "gray", wrapMode: "word", children: hasOptions
-                    ? 'Enter/Ctrl+J newline (or #search apply) • #search nav: ↑/↓ or Ctrl+N/P • Tab mode switch • #path for repo file autocomplete • Cmd/Ctrl+C copy'
-                    : 'Enter/Ctrl+J newline • #search nav: ↑/↓ or Ctrl+N/P • Enter/Tab #search apply • #path for repo file autocomplete • Cmd/Ctrl+C copy' }))] }));
+                            : `#search index: ${repositoryFiles.length} files indexed` })] })), _jsxs("box", { flexDirection: isNarrow ? 'column' : 'row', justifyContent: "space-between", marginBottom: 0, gap: isNarrow ? 0 : undefined, children: [_jsx("text", { fg: "gray", children: mode === 'input' ? 'Custom input' : 'Option selection' }), _jsx("text", { fg: "gray", children: mode === 'input' && queuedAttachments.length > 0
+                            ? `${inputValue.length} chars + ${queuedAttachments.length} queued`
+                            : `${inputValue.length} chars` })] }), mode === 'input' && clipboardStatus && (_jsx("text", { fg: clipboardStatus.startsWith('Copy failed:') ? 'red' : 'green', children: clipboardStatus })), mode === 'input' && queuedAttachments.length > 0 && (_jsxs("box", { flexDirection: "column", width: "100%", gap: 0, children: [_jsxs("text", { fg: "yellow", children: [_jsx("strong", { children: "QUEUED ATTACHMENTS" }), " (Delete placeholder text to remove)"] }), queuedAttachments.map((attachment, index) => (_jsxs("text", { fg: "gray", wrapMode: "word", children: ["[File ", index + 1, "] ", attachment.label] }, attachment.id)))] })), mode === 'input' && (_jsx("box", { backgroundColor: "cyan", paddingLeft: 1, paddingRight: 1, alignSelf: "flex-start", marginBottom: 0, children: _jsxs("text", { fg: "black", children: [_jsx("strong", { children: "Send" }), " \u2303S"] }) })), mode === 'input' && (_jsx("text", { fg: "gray", wrapMode: "word", children: hasOptions
+                    ? 'Enter/Ctrl+J newline (or #search apply) • #search nav: ↑/↓ or Ctrl+N/P • Tab mode switch • #path for repo file autocomplete • Cmd/Ctrl+C copy • Cmd/Ctrl+V paste/attach'
+                    : 'Enter/Ctrl+J newline • #search nav: ↑/↓ or Ctrl+N/P • Enter/Tab #search apply • #path for repo file autocomplete • Cmd/Ctrl+C copy • Cmd/Ctrl+V paste/attach' }))] }));
 }

package/dist/components/MarkdownText.js

@@ -283,14 +283,14 @@ export function MarkdownText({ content, streaming = false, showContentCopyContro
                                     return (_jsx("box", { height: 1 }, `segment-${index}-line-${lineIndex}`));
                                 }
                                 const inlineSegments = parseMarkdownInlineLinks(line);
-                                return (_jsx("box", { flexDirection: "row", width: "100%", children: inlineSegments.flatMap((inlineSegment, inlineSegmentIndex) => {
+                                return (_jsx("box", { flexDirection: "row", flexWrap: "wrap", width: "100%", children: inlineSegments.flatMap((inlineSegment, inlineSegmentIndex) => {
                                         const baseKey = `segment-${index}-line-${lineIndex}-part-${inlineSegmentIndex}`;
                                         if (inlineSegment.type !== 'link' ||
                                             !inlineSegment.href) {
                                             return (_jsx("text", { wrapMode: "word", children: inlineSegment.value }, baseKey));
                                         }
                                         if (!isVscodeFileLink(inlineSegment.href)) {
-                                            return (_jsx("text", { fg: "cyan", wrapMode: "word", onMouseUp: () => {
+                                            return (_jsx("text", { fg: "cyan", wrapMode: "char", onMouseUp: () => {
                                                     void openLinkWithHint(inlineSegment.href ?? '', 'default');
                                                 }, children: inlineSegment.value }, baseKey));
                                         }

package/dist/components/PromptStatus.js

@@ -1,46 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
 import * as OpenTuiReact from '@opentui/react';
-import { useEffect, useState } from 'react';
 import { TextProgressBar } from './TextProgressBar.js';
 const { useTerminalDimensions } = OpenTuiReact;
-const { useTimeline } = OpenTuiReact;
 export function PromptStatus({ value, timeLeftSeconds, critical, }) {
     const { width } = useTerminalDimensions();
-    const [pulseLevel, setPulseLevel] = useState(0);
-    const timeline = useTimeline({ duration: 900, loop: true, autoplay: false });
     const suffixLength = ` • ${timeLeftSeconds}s left`.length;
     const availableWidth = Math.max(16, width - 4);
     const reservedWidth = 2 + 1 + 4 + suffixLength;
     const computedBarWidth = availableWidth - reservedWidth;
     const barWidth = Math.max(6, Math.min(28, computedBarWidth));
     const shortcutHint = width < 80 ? '⌃S send • ⇧↹ mode' : '⌃S send • ⇥ mode • ⇧↹ reverse';
-    useEffect(() => {
-        if (!critical) {
-            timeline.pause();
-            timeline.resetItems();
-            setPulseLevel(0);
-            return;
-        }
-        const pulseTarget = { level: 0 };
-        timeline.resetItems();
-        timeline.add(pulseTarget, {
-            level: 1,
-            duration: 900,
-            ease: 'inOutSine',
-            loop: true,
-            alternate: true,
-            onUpdate: (animation) => {
-                const nextValue = animation.targets[0]?.level;
-                if (typeof nextValue === 'number') {
-                    setPulseLevel(nextValue);
-                }
-            },
-        });
-        timeline.play();
-        return () => {
-            timeline.pause();
-            timeline.resetItems();
-        };
-    }, [critical, timeline]);
-    return (_jsxs("box", { flexDirection: "column", alignItems: "flex-start", width: "100%", gap: 0, children: [_jsx("text", { fg: "gray", wrapMode: "word", children: shortcutHint }), _jsxs("text", { fg: critical && pulseLevel > 0.5 ? 'red' : 'gray', children: [critical ? '●' : '○', " ", timeLeftSeconds, "s remaining"] }), _jsx(TextProgressBar, { value: value, width: barWidth, timeLeftSeconds: timeLeftSeconds, critical: critical })] }));
+    return (_jsxs("box", { flexDirection: "column", alignItems: "flex-start", width: "100%", children: [_jsx("text", { fg: "gray", wrapMode: "word", children: shortcutHint }), _jsx(TextProgressBar, { value: value, width: barWidth, timeLeftSeconds: timeLeftSeconds, critical: critical })] }));
 }

package/dist/components/interactive-input/attachments.js

@@ -0,0 +1,79 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { IMAGE_MIME_BY_EXTENSION, TEXT_EMBED_MAX_BYTES, } from './constants.js';
+export const normalizeClipboardPath = (clipboardText, searchRoot) => {
+    const trimmed = clipboardText.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const lines = trimmed
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    let candidate = lines[0] ?? '';
+    if (!candidate) {
+        return null;
+    }
+    if ((candidate.startsWith('"') && candidate.endsWith('"')) ||
+        (candidate.startsWith("'") && candidate.endsWith("'"))) {
+        candidate = candidate.slice(1, -1);
+    }
+    if (candidate.startsWith('file://')) {
+        candidate = decodeURIComponent(candidate.replace(/^file:\/\//, ''));
+    }
+    if (path.isAbsolute(candidate)) {
+        return candidate;
+    }
+    if (!searchRoot) {
+        return null;
+    }
+    return path.resolve(searchRoot, candidate);
+};
+const isLikelyTextBuffer = (buffer) => {
+    if (buffer.includes(0)) {
+        return false;
+    }
+    const sample = buffer.subarray(0, Math.min(buffer.length, 2048));
+    let suspiciousBytes = 0;
+    for (const byte of sample) {
+        const isPrintableAscii = byte >= 32 && byte <= 126;
+        const isWhitespace = byte === 9 || byte === 10 || byte === 13;
+        const isExtendedUtf8Byte = byte >= 128;
+        if (!isPrintableAscii && !isWhitespace && !isExtendedUtf8Byte) {
+            suspiciousBytes += 1;
+        }
+    }
+    return suspiciousBytes < 8;
+};
+export const buildAttachmentFromPath = async (absolutePath) => {
+    const fileStats = await fs.stat(absolutePath);
+    if (!fileStats.isFile()) {
+        throw new Error('Clipboard path is not a file');
+    }
+    const fileName = path.basename(absolutePath);
+    const extension = path.extname(fileName).toLowerCase();
+    const imageMimeType = IMAGE_MIME_BY_EXTENSION[extension];
+    const sizeKB = Math.round(fileStats.size / 1024);
+    if (imageMimeType) {
+        return {
+            id: crypto.randomUUID(),
+            label: `Image: ${fileName} (${sizeKB}KB)`,
+            payload: `[Image file: ${absolutePath}]`,
+        };
+    }
+    const fileBuffer = await fs.readFile(absolutePath);
+    const isTextFile = fileStats.size <= TEXT_EMBED_MAX_BYTES && isLikelyTextBuffer(fileBuffer);
+    if (isTextFile) {
+        return {
+            id: crypto.randomUUID(),
+            label: `File: ${fileName} (${sizeKB}KB text)`,
+            payload: `[Text file: ${absolutePath}]`,
+        };
+    }
+    return {
+        id: crypto.randomUUID(),
+        label: `File: ${fileName} (${sizeKB}KB binary)`,
+        payload: `[Binary file: ${absolutePath}]`,
+    };
+};

package/dist/components/interactive-input/clipboard-handlers.js

@@ -0,0 +1,134 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { copyTextToClipboard as copyToSystemClipboard, readFilePathsFromClipboard, readImageDataUrlFromClipboard, readTextFromClipboard, } from '../../utils/clipboard.js';
+import { buildAttachmentFromPath, normalizeClipboardPath, } from './attachments.js';
+import { shouldCollapsePastedText, } from './constants.js';
+export function createClipboardHandlers(deps) {
+    const { insertTextAtCaret, queueAttachment, setClipboardStatus, onInputActivity, searchRoot, requestInputFocus, textareaRef, inputValue, mode, } = deps;
+    const handlePastedText = (pastedText) => {
+        if (!pastedText) {
+            return;
+        }
+        const pasteAsPlainText = () => {
+            insertTextAtCaret(pastedText);
+            setClipboardStatus('Pasted text');
+            onInputActivity?.();
+        };
+        const normalizedPath = normalizeClipboardPath(pastedText, searchRoot);
+        if (normalizedPath) {
+            void buildAttachmentFromPath(normalizedPath)
+                .then((attachment) => {
+                queueAttachment(attachment);
+                setClipboardStatus(`Queued ${attachment.label}`);
+                onInputActivity?.();
+            })
+                .catch(() => {
+                pasteAsPlainText();
+            });
+            return;
+        }
+        if (shouldCollapsePastedText(pastedText)) {
+            queueAttachment({
+                id: crypto.randomUUID(),
+                label: `Pasted text block (${pastedText.length} chars)`,
+                payload: pastedText,
+            });
+            setClipboardStatus('Queued pasted text block');
+            onInputActivity?.();
+            return;
+        }
+        pasteAsPlainText();
+    };
+    const pasteClipboardIntoInput = () => {
+        requestInputFocus();
+        void readTextFromClipboard()
+            .then(async (clipboardText) => {
+            if (clipboardText.trim()) {
+                handlePastedText(clipboardText);
+                return;
+            }
+            const clipboardPaths = await readFilePathsFromClipboard();
+            if (clipboardPaths.length > 0) {
+                const attachments = await Promise.all(clipboardPaths.map(async (clipboardPath) => {
+                    try {
+                        return await buildAttachmentFromPath(clipboardPath);
+                    }
+                    catch {
+                        return null;
+                    }
+                }));
+                const validAttachments = attachments.filter((value) => value !== null);
+                if (validAttachments.length > 0) {
+                    validAttachments.forEach((attachment) => {
+                        queueAttachment(attachment);
+                    });
+                    setClipboardStatus(validAttachments.length === 1
+                        ? `Queued ${validAttachments[0].label}`
+                        : `Queued ${validAttachments.length} clipboard files`);
+                    onInputActivity?.();
+                    return;
+                }
+            }
+            const imageDataUrl = await readImageDataUrlFromClipboard();
+            if (imageDataUrl) {
+                try {
+                    // Extract base64 data and save to temp file
+                    const base64Data = imageDataUrl.replace(/^data:image\/\w+;base64,/, '');
+                    const imageBuffer = Buffer.from(base64Data, 'base64');
+                    const tempDir = os.tmpdir();
+                    const tempFileName = `pasted-image-${crypto.randomUUID()}.png`;
+                    const tempFilePath = path.join(tempDir, tempFileName);
+                    await fs.writeFile(tempFilePath, imageBuffer);
+                    // Now queue it as a file attachment
+                    const attachment = await buildAttachmentFromPath(tempFilePath);
+                    queueAttachment(attachment);
+                    setClipboardStatus('Queued clipboard image');
+                    onInputActivity?.();
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'unknown error';
+                    setClipboardStatus(`Failed to save clipboard image: ${errorMessage}`);
+                }
+                return;
+            }
+            setClipboardStatus('Paste failed: clipboard is empty');
+        })
+            .catch((error) => {
+            const errorMessage = error instanceof Error ? error.message : 'unknown error';
+            setClipboardStatus(`Paste failed: ${errorMessage}`);
+        });
+    };
+    const copyInputToClipboard = () => {
+        if (mode !== 'input') {
+            return;
+        }
+        const textarea = textareaRef.current;
+        const selectedText = typeof textarea?.hasSelection === 'function' &&
+            textarea.hasSelection() &&
+            typeof textarea?.getSelectedText === 'function'
+            ? textarea.getSelectedText()
+            : '';
+        const fallbackText = textarea?.plainText ?? inputValue;
+        const textToCopy = selectedText.length > 0 ? selectedText : fallbackText;
+        if (textToCopy.length === 0) {
+            setClipboardStatus('Nothing to copy');
+            return;
+        }
+        void copyToSystemClipboard(textToCopy)
+            .then(() => {
+            setClipboardStatus('Copied input to clipboard');
+        })
+            .catch((error) => {
+            const errorMessage = error instanceof Error ? error.message : 'unknown error';
+            setClipboardStatus(`Copy failed: ${errorMessage}`);
+        });
+        onInputActivity?.();
+    };
+    return {
+        handlePastedText,
+        pasteClipboardIntoInput,
+        copyInputToClipboard,
+    };
+}

package/dist/components/interactive-input/constants.js

@@ -0,0 +1,15 @@
+export const repositoryFileCache = new Map();
+export const IMAGE_MIME_BY_EXTENSION = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.bmp': 'image/bmp',
+    '.svg': 'image/svg+xml',
+};
+export const TEXT_EMBED_MAX_BYTES = 512 * 1024;
+export const COLLAPSE_TEXT_PASTE_CHARS = 800;
+export const COLLAPSE_TEXT_PASTE_LINES = 12;
+export const shouldCollapsePastedText = (text) => text.length >= COLLAPSE_TEXT_PASTE_CHARS ||
+    text.split(/\r?\n/).length >= COLLAPSE_TEXT_PASTE_LINES;

package/dist/components/interactive-input/keyboard.js

@@ -24,6 +24,8 @@ export const isControlKeyShortcut = (key, letter) => {
 export const isSubmitShortcut = (key) => isControlKeyShortcut(key, 's');
 export const isCopyShortcut = (key) => isControlKeyShortcut(key, 'c') ||
     (key.ctrl && key.shift && key.name.toLowerCase() === 'c');
+export const isPasteShortcut = (key) => isControlKeyShortcut(key, 'v') ||
+    (key.ctrl && key.shift && key.name.toLowerCase() === 'v');
 export const isReverseTabShortcut = (key) => key.name === 'backtab' ||
     (key.name === 'tab' && key.shift) ||
     key.sequence === '\u001b[Z';
@@ -42,6 +44,19 @@ export const isPrintableCharacter = (key) => {
     }
     return null;
 };
+export const extractPastedText = (key) => {
+    if (key.ctrl || key.meta || key.option || key.sequence.length <= 1) {
+        return null;
+    }
+    for (const character of key.sequence) {
+        const code = character.charCodeAt(0);
+        const isAllowedControl = code === 9 || code === 10 || code === 13;
+        if (!isAllowedControl && code < 32) {
+            return null;
+        }
+    }
+    return key.sequence;
+};
 export const textareaKeyBindings = [
     { name: 's', ctrl: true, action: 'submit' },
     { name: 's', meta: true, action: 'submit' },

package/dist/utils/clipboard.js

@@ -1,5 +1,40 @@
 import os from 'os';
 import { spawn } from 'child_process';
+function decodeFileUri(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('file://')) {
+        return trimmed;
+    }
+    return decodeURIComponent(trimmed.replace(/^file:\/\//, ''));
+}
+function normalizePathCandidate(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const decoded = decodeFileUri(trimmed);
+    if (decoded.startsWith('/')) {
+        return decoded;
+    }
+    if (/^[a-zA-Z]:[\\/]/.test(decoded)) {
+        return decoded;
+    }
+    return null;
+}
+function parseNonEmptyLines(value) {
+    return value
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => Boolean(line) && !line.startsWith('#'));
+}
+function parseFilePaths(value) {
+    return parseNonEmptyLines(value)
+        .map((line) => normalizePathCandidate(line))
+        .filter((line) => typeof line === 'string');
+}
+function uniquePaths(values) {
+    return Array.from(new Set(values));
+}
 function runCommand(command, args, input) {
     return new Promise((resolve, reject) => {
         const child = spawn(command, args, {
@@ -65,3 +100,152 @@ export async function readTextFromClipboard() {
     }
     throw new Error(`Clipboard paste is not supported on platform: ${platform}`);
 }
+export async function readFilePathsFromClipboard() {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        const aliasResult = await runCommand('osascript', [
+            '-e',
+            'try',
+            '-e',
+            'POSIX path of (the clipboard as alias)',
+            '-e',
+            'on error',
+            '-e',
+            'return ""',
+            '-e',
+            'end try',
+        ]);
+        const aliasPaths = parseFilePaths(aliasResult.stdout);
+        if (aliasPaths.length > 0) {
+            return aliasPaths;
+        }
+        const listResult = await runCommand('osascript', [
+            '-e',
+            'try',
+            '-e',
+            'set L to the clipboard as list',
+            '-e',
+            'set out to {}',
+            '-e',
+            'repeat with i in L',
+            '-e',
+            'set end of out to POSIX path of i',
+            '-e',
+            'end repeat',
+            '-e',
+            'set text item delimiters of AppleScript to linefeed',
+            '-e',
+            'return out as text',
+            '-e',
+            'on error',
+            '-e',
+            'return ""',
+            '-e',
+            'end try',
+        ]);
+        const listPaths = parseFilePaths(listResult.stdout);
+        if (listPaths.length > 0) {
+            return listPaths;
+        }
+        const jxaResult = await runCommand('osascript', [
+            '-l',
+            'JavaScript',
+            '-e',
+            'ObjC.import("AppKit")',
+            '-e',
+            'ObjC.import("Foundation")',
+            '-e',
+            'const pb = $.NSPasteboard.generalPasteboard',
+            '-e',
+            'const classes = $.NSArray.arrayWithObject($.NSURL)',
+            '-e',
+            'const urls = pb.readObjectsForClassesOptions(classes, $())',
+            '-e',
+            'if (!urls || urls.count === 0) { "" } else { const out = []; for (let i = 0; i < urls.count; i += 1) { out.push(ObjC.unwrap(urls.objectAtIndex(i).path)); } out.join("\\n"); }',
+        ]);
+        const jxaPaths = parseFilePaths(jxaResult.stdout);
+        if (jxaPaths.length > 0) {
+            return uniquePaths(jxaPaths);
+        }
+        const jxaTypeProbeResult = await runCommand('osascript', [
+            '-l',
+            'JavaScript',
+            '-e',
+            'ObjC.import("AppKit")',
+            '-e',
+            'ObjC.import("Foundation")',
+            '-e',
+            'const pb = $.NSPasteboard.generalPasteboard',
+            '-e',
+            'const out = []',
+            '-e',
+            'const pushLine = (value) => { if (!value) { return; } const text = String(value).trim(); if (!text) { return; } out.push(text); }',
+            '-e',
+            'const types = ObjC.deepUnwrap(pb.types) || []',
+            '-e',
+            'for (const type of types) { const data = pb.dataForType(type); if (!data || data.isNil()) { continue; } let text = ""; const utf8 = $.NSString.alloc.initWithDataEncoding(data, $.NSUTF8StringEncoding); if (utf8 && !utf8.isNil()) { text = ObjC.unwrap(utf8); } if (!text) { const utf16 = $.NSString.alloc.initWithDataEncoding(data, $.NSUTF16StringEncoding); if (utf16 && !utf16.isNil()) { text = ObjC.unwrap(utf16); } } if (!text) { continue; } const lines = String(text).split(/\\r?\\n/); for (const line of lines) { const trimmed = line.trim(); if (!trimmed || trimmed.startsWith("#")) { continue; } pushLine(trimmed); } }',
+            '-e',
+            'out.join("\\n")',
+        ]);
+        return uniquePaths(parseFilePaths(jxaTypeProbeResult.stdout));
+    }
+    if (platform === 'linux') {
+        try {
+            const uriListResult = await runCommand('xclip', [
+                '-selection',
+                'clipboard',
+                '-o',
+                '-t',
+                'text/uri-list',
+            ]);
+            return parseFilePaths(uriListResult.stdout);
+        }
+        catch {
+            return [];
+        }
+    }
+    if (platform === 'win32') {
+        try {
+            const fileDropResult = await runCommand('powershell', [
+                '-NoProfile',
+                '-Command',
+                '$paths = Get-Clipboard -Format FileDropList; if ($paths) { $paths | ForEach-Object { $_.FullName } }',
+            ]);
+            return parseFilePaths(fileDropResult.stdout);
+        }
+        catch {
+            return [];
+        }
+    }
+    return [];
+}
+export async function readImageDataUrlFromClipboard() {
+    const platform = os.platform();
+    if (platform !== 'darwin') {
+        return null;
+    }
+    try {
+        const imageResult = await runCommand('osascript', [
+            '-l',
+            'JavaScript',
+            '-e',
+            'ObjC.import("AppKit")',
+            '-e',
+            'ObjC.import("Foundation")',
+            '-e',
+            'const pb = $.NSPasteboard.generalPasteboard',
+            '-e',
+            'const image = $.NSImage.alloc.initWithPasteboard(pb)',
+            '-e',
+            'if (!image || image.isNil()) { "" } else { const tiff = image.TIFFRepresentation; if (!tiff || tiff.isNil()) { "" } else { const rep = $.NSBitmapImageRep.imageRepWithData(tiff); if (!rep || rep.isNil()) { "" } else { const pngData = rep.representationUsingTypeProperties($.NSBitmapImageFileTypePNG, $()); if (!pngData || pngData.isNil()) { "" } else { ObjC.unwrap(pngData.base64EncodedStringWithOptions(0)); } } } }',
+        ]);
+        const base64Payload = imageResult.stdout.trim();
+        if (!base64Payload) {
+            return null;
+        }
+        return `data:image/png;base64,${base64Payload}`;
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rawwee/interactive-mcp",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "main": "dist/index.js",
   "type": "module",
   "bin": {