@rawwee/interactive-mcp 1.1.0 → 1.3.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).
 
 ## Usage Scenarios
 
@@ -131,11 +132,10 @@ This section is primarily for developers looking to modify or contribute to the
 bun run start
 ```
 
-### Terminal UI backend status
+### UI backend status
 
-`interactive-mcp` now uses OpenTUI (`@opentui/core`, `@opentui/react`) for terminal UI rendering.
-
-OpenTUI is the terminal UI renderer backend.
+`interactive-mcp` currently runs with the OpenTUI terminal backend (`@opentui/core`, `@opentui/react`).
+The VS Code extension and bridge runtime have been removed from the active feature set for now, and may be reconsidered in a future iteration.
 
 #### Command-Line Options
 
@@ -143,7 +143,7 @@ The `interactive-mcp` server accepts the following command-line options. These s
 
 | Option            | Alias | Description                                                                                                                                                                                           |
 | ----------------- | ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `--timeout`       | `-t`  | Sets the default timeout (in seconds) for user input prompts. Defaults to 30 seconds.                                                                                                                 |
+| `--timeout`       | `-t`  | Sets the default timeout (in seconds) for user input prompts.                                                                                                                                         |
 | `--disable-tools` | `-d`  | Disables specific tools or groups (comma-separated list). Prevents the server from advertising or registering them. Options: `request_user_input`, `message_complete_notification`, `intensive_chat`. |
 
 **Example:** Setting multiple options in the client config `args` array:

package/dist/components/InteractiveInput.js

@@ -1,16 +1,143 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "@opentui/react/jsx-runtime";
 import * as OpenTuiReact from '@opentui/react';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
 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 { copyTextToClipboard, readFilePathsFromClipboard, readImageDataUrlFromClipboard, readTextFromClipboard, } from '../utils/clipboard.js';
 const { useKeyboard } = OpenTuiReact;
 const { useTerminalDimensions } = OpenTuiReact;
 const repositoryFileCache = new Map();
+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',
+};
+const IMAGE_EMBED_MAX_BYTES = 2 * 1024 * 1024;
+const TEXT_EMBED_MAX_BYTES = 512 * 1024;
+const TEXT_EMBED_MAX_CHARS = 20000;
+const COLLAPSE_TEXT_PASTE_CHARS = 800;
+const COLLAPSE_TEXT_PASTE_LINES = 12;
+const inferCodeFenceLanguage = (fileName) => {
+    const extension = path.extname(fileName).slice(1).toLowerCase();
+    const mapping = {
+        js: 'javascript',
+        jsx: 'jsx',
+        ts: 'typescript',
+        tsx: 'tsx',
+        json: 'json',
+        md: 'markdown',
+        py: 'python',
+        sh: 'bash',
+        yml: 'yaml',
+        yaml: 'yaml',
+        html: 'html',
+        css: 'css',
+        go: 'go',
+        rs: 'rust',
+        java: 'java',
+        cs: 'csharp',
+    };
+    return mapping[extension] ?? '';
+};
+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;
+};
+const shouldCollapsePastedText = (text) => text.length >= COLLAPSE_TEXT_PASTE_CHARS ||
+    text.split(/\r?\n/).length >= COLLAPSE_TEXT_PASTE_LINES;
+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];
+    if (imageMimeType) {
+        if (fileStats.size > IMAGE_EMBED_MAX_BYTES) {
+            return {
+                id: crypto.randomUUID(),
+                label: `Image: ${fileName} (${Math.round(fileStats.size / 1024)}KB, too large to embed)`,
+                payload: `[Image attachment: ${fileName}] (${imageMimeType}, ${fileStats.size} bytes, too large to embed)`,
+            };
+        }
+        const imageBuffer = await fs.readFile(absolutePath);
+        return {
+            id: crypto.randomUUID(),
+            label: `Image: ${fileName}`,
+            payload: `![${fileName}](data:${imageMimeType};base64,${imageBuffer.toString('base64')})`,
+        };
+    }
+    const fileBuffer = await fs.readFile(absolutePath);
+    if (fileStats.size <= TEXT_EMBED_MAX_BYTES &&
+        isLikelyTextBuffer(fileBuffer)) {
+        const fileText = fileBuffer.toString('utf8');
+        const truncatedText = fileText.length > TEXT_EMBED_MAX_CHARS
+            ? `${fileText.slice(0, TEXT_EMBED_MAX_CHARS)}\n\n...[truncated ${fileText.length - TEXT_EMBED_MAX_CHARS} chars]`
+            : fileText;
+        const language = inferCodeFenceLanguage(fileName);
+        return {
+            id: crypto.randomUUID(),
+            label: `File: ${fileName} (${truncatedText.length} chars)`,
+            payload: `Attached file: ${fileName}\n\`\`\`${language}\n${truncatedText}\n\`\`\``,
+        };
+    }
+    return {
+        id: crypto.randomUUID(),
+        label: `File: ${fileName} (${Math.round(fileStats.size / 1024)}KB binary)`,
+        payload: `[File attachment: ${fileName}] (${fileStats.size} bytes, binary content omitted)`,
+    };
+};
 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 +150,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);
@@ -176,6 +304,7 @@ export function InteractiveInput({ question, questionId, predefinedOptions = [],
         setSelectedIndex(0);
         setInputValue('');
         setCaretPosition(0);
+        setQueuedAttachments([]);
         latestInputValueRef.current = '';
         latestCaretPositionRef.current = 0;
         setFileSuggestions([]);
@@ -301,18 +430,123 @@ export function InteractiveInput({ question, questionId, predefinedOptions = [],
         });
         onInputActivity?.();
     }, [inputValue, mode, onInputActivity]);
-    const submitCurrentSelection = useCallback(() => {
-        if (mode === 'option' && predefinedOptions.length > 0) {
-            onSubmit(questionId, predefinedOptions[selectedIndex]);
+    const insertTextAtCaret = useCallback((text) => {
+        if (!text) {
+            return;
+        }
+        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) => [...previous, attachment]);
+    }, []);
+    const handlePastedText = useCallback((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;
         }
-        const textareaValue = safeReadTextarea()?.value ?? inputValue;
-        onSubmit(questionId, textareaValue);
+        pasteAsPlainText();
+    }, [insertTextAtCaret, onInputActivity, queueAttachment, searchRoot]);
+    const pasteClipboardIntoInput = useCallback(() => {
+        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) {
+                queueAttachment({
+                    id: crypto.randomUUID(),
+                    label: 'Image: pasted-image.png',
+                    payload: `![pasted-image.png](${imageDataUrl})`,
+                });
+                setClipboardStatus('Queued clipboard image');
+                onInputActivity?.();
+                return;
+            }
+            setClipboardStatus('Paste failed: clipboard is empty');
+        })
+            .catch((error) => {
+            const errorMessage = error instanceof Error ? error.message : 'unknown error';
+            setClipboardStatus(`Paste failed: ${errorMessage}`);
+        });
+    }, [handlePastedText, onInputActivity, queueAttachment, requestInputFocus]);
+    const submitCurrentSelection = useCallback(() => {
+        const baseValue = mode === 'option' && predefinedOptions.length > 0
+            ? predefinedOptions[selectedIndex]
+            : (safeReadTextarea()?.value ?? inputValue);
+        const attachmentPayload = queuedAttachments
+            .map((attachment) => attachment.payload)
+            .join('\n\n');
+        const finalValue = attachmentPayload
+            ? baseValue.trim().length > 0
+                ? `${baseValue}\n\n${attachmentPayload}`
+                : attachmentPayload
+            : baseValue;
+        onSubmit(questionId, finalValue);
+        setQueuedAttachments([]);
     }, [
         inputValue,
         mode,
         onSubmit,
         predefinedOptions,
+        queuedAttachments,
         questionId,
         safeReadTextarea,
         selectedIndex,
@@ -383,6 +617,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 +708,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%", children: [_jsx("text", { fg: "yellow", children: _jsx("strong", { children: "QUEUED ATTACHMENTS" }) }), queuedAttachments.map((attachment) => (_jsxs("text", { fg: "gray", wrapMode: "word", children: ["- ", attachment.label] }, attachment.id)))] })), 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 • 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/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/index.js

@@ -4,8 +4,8 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import notifier from 'node-notifier';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import { askQuestionInSession, startIntensiveChatSession, stopIntensiveChatSession, } from './commands/intensive-chat/index.js';
 import { getCmdWindowInput } from './commands/input/index.js';
-import { startIntensiveChatSession, askQuestionInSession, stopIntensiveChatSession, } from './commands/intensive-chat/index.js';
 import { USER_INPUT_TIMEOUT_SECONDS, USER_INPUT_TIMEOUT_SENTINEL, } from './constants.js';
 import logger from './utils/logger.js';
 import { validateRepositoryBaseDirectory } from './utils/base-directory.js';
@@ -158,10 +158,11 @@ if (isToolEnabled('start_intensive_chat')) {
         const { sessionTitle, baseDirectory } = args;
         try {
             const validatedBaseDirectory = await validateRepositoryBaseDirectory(baseDirectory);
-            // Start a new intensive chat session, passing global timeout
             const sessionId = await startIntensiveChatSession(sessionTitle, validatedBaseDirectory, globalTimeoutSeconds);
             // Track this session for the client
-            activeChatSessions.set(sessionId, sessionTitle);
+            activeChatSessions.set(sessionId, {
+                title: sessionTitle,
+            });
             return {
                 content: [
                     {
@@ -200,8 +201,8 @@ if (isToolEnabled('ask_intensive_chat')) {
     async (args) => {
         // Use inferred args type
         const { sessionId, question, predefinedOptions, baseDirectory } = args;
-        // Check if session exists
-        if (!activeChatSessions.has(sessionId)) {
+        const activeSession = activeChatSessions.get(sessionId);
+        if (!activeSession) {
             return {
                 content: [
                     { type: 'text', text: 'Error: Invalid or expired session ID.' },
@@ -210,7 +211,6 @@ if (isToolEnabled('ask_intensive_chat')) {
         }
         try {
             const validatedBaseDirectory = await validateRepositoryBaseDirectory(baseDirectory);
-            // Ask the question in the session
             const answer = await askQuestionInSession(sessionId, question, validatedBaseDirectory, predefinedOptions);
             // Check for the specific timeout indicator
             if (answer === USER_INPUT_TIMEOUT_SENTINEL) {
@@ -279,8 +279,8 @@ if (isToolEnabled('stop_intensive_chat')) {
     async (args) => {
         // Use inferred args type
         const { sessionId } = args;
-        // Check if session exists
-        if (!activeChatSessions.has(sessionId)) {
+        const activeSession = activeChatSessions.get(sessionId);
+        if (!activeSession) {
             return {
                 content: [
                     { type: 'text', text: 'Error: Invalid or expired session ID.' },
@@ -288,7 +288,6 @@ if (isToolEnabled('stop_intensive_chat')) {
             };
         }
         try {
-            // Stop the session
             const success = await stopIntensiveChatSession(sessionId);
             // Remove session from map if successful
             if (success) {

package/dist/tool-definitions/intensive-chat.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 // === Start Intensive Chat Definition ===
 const startCapability = {
-    description: 'Start a persistent OpenTUI intensive chat session for gathering multiple answers quickly with markdown-friendly prompts.',
+    description: 'Start a persistent intensive chat session for gathering multiple answers quickly with markdown-friendly prompts.',
     parameters: {
         type: 'object',
         properties: {
@@ -18,17 +18,18 @@ const startCapability = {
     },
 };
 const startDescription = (globalTimeoutSeconds) => `<description>
-Start an intensive chat session (OpenTUI terminal UI) for gathering multiple answers quickly from the user.
+Start an intensive chat session for gathering multiple answers quickly from the user.
 **Highly recommended** for scenarios requiring a sequence of related inputs or confirmations.
 Very useful for gathering multiple answers from the user in a short period of time.
 Especially useful for brainstorming ideas or discussing complex topics with the user.
 </description>
 
 <importantNotes>
-- (!important!) Opens a persistent console window that stays open for multiple questions.
+- (!important!) Opens a persistent interaction session that stays active for multiple questions.
 - (!important!) Returns a session ID that **must** be used for subsequent questions via 'ask_intensive_chat'.
 - (!important!) **Must** be closed with 'stop_intensive_chat' when finished gathering all inputs.
 - (!important!) After starting a session, **immediately** continue asking all necessary questions using 'ask_intensive_chat' within the **same response message**. Do not end the response until the chat is closed with 'stop_intensive_chat'. This creates a seamless conversational flow for the user.
+- (!important!) Continue the prompt loop until the user explicitly says one of: "Stop prompting", "End session", or "Don't ask anymore".
 </importantNotes>
 
 <whenToUseThisTool>
@@ -41,7 +42,7 @@ Especially useful for brainstorming ideas or discussing complex topics with the
 </whenToUseThisTool>
 
 <features>
-- Opens a persistent OpenTUI window for continuous interaction
+- Opens a persistent interactive prompt surface for continuous interaction
 - Renders markdown prompts, including code/diff snippets, for richer question context
 - Preserves markdown links, including VS Code file links (for example: "vscode://file/<abs-path>:<line>:<column>") in prompt content
 - Supports option mode + free-text mode while asking follow-up questions
@@ -49,6 +50,7 @@ Especially useful for brainstorming ideas or discussing complex topics with the
 - Returns a session ID for subsequent interactions
 - Keeps full chat history visible to the user
 - Maintains state between questions
+- Backend-agnostic contract: start/ask/stop behavior is consistent across available UI backends
 - Requires baseDirectory and pins autocomplete/search scope to the repository root
 </features>
 
@@ -85,7 +87,7 @@ const startToolDefinition = {
 };
 // === Ask Intensive Chat Definition ===
 const askCapability = {
-    description: 'Ask a markdown-friendly question in an active OpenTUI intensive chat session.',
+    description: 'Ask a markdown-friendly question in an active intensive chat session.',
     parameters: {
         type: 'object',
         properties: {
@@ -120,6 +122,8 @@ Ask a new question in an active intensive chat session previously started with '
 - (!important!) Supports predefined options for quick selection.
 - (!important!) Returns the user's answer or indicates if they didn't respond.
 - (!important!) **Use this repeatedly within the same response message** after 'start_intensive_chat' until all questions are asked.
+- (!important!) If response is empty or times out for required input, re-prompt and do not proceed with assumptions.
+- (!important!) Keep the loop active until the user explicitly says one of: "Stop prompting", "End session", or "Don't ask anymore".
 </importantNotes>
 
 <whenToUseThisTool>
@@ -193,9 +197,10 @@ const stopDescription = `<description>
 </description>
 
 <importantNotes>
-- (!important!) Closes the console window for the intensive chat.
+- (!important!) Closes the active intensive chat session.
 - (!important!) Frees up system resources.
 - (!important!) **Should always be called** as the final step when finished with an intensive chat session, typically at the end of the response message where 'start_intensive_chat' was called.
+- (!important!) Only stop the session when the user explicitly wants to end prompting, such as with "Stop prompting", "End session", or "Don't ask anymore".
 </importantNotes>
 
 <whenToUseThisTool>
@@ -207,7 +212,7 @@ const stopDescription = `<description>
 </whenToUseThisTool>
 
 <features>
-- Gracefully closes the console window
+- Gracefully closes the active session in the current backend
 - Cleans up system resources
 - Marks the session as complete
 </features>

package/dist/tool-definitions/request-user-input.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 // Define capability conforming to ToolCapabilityInfo
 const capabilityInfo = {
-    description: 'Ask the user a question in an OpenTUI terminal prompt with markdown-friendly rendering and await their reply.',
+    description: 'Ask the user a question in an interactive prompt surface and await their reply.',
     parameters: {
         type: 'object',
         properties: {
@@ -29,7 +29,7 @@ const capabilityInfo = {
 };
 // Define description conforming to ToolRegistrationDescription
 const registrationDescription = (globalTimeoutSeconds) => `<description>
-Send a question to the user via the OpenTUI terminal prompt. **Crucial for clarifying requirements, confirming plans, or resolving ambiguity.**
+Send a question to the user via an interactive prompt surface. **Crucial for clarifying requirements, confirming plans, or resolving ambiguity.**
 You should call this tool whenever it has **any** uncertainty or needs clarification or confirmation, even for trivial or silly questions.
 Feel free to ask anything! **Proactive questioning is preferred over making assumptions.**
 </description>
@@ -39,9 +39,15 @@ Feel free to ask anything! **Proactive questioning is preferred over making assu
 - (!important!) Continue to generate existing messages after user answers.
 - (!important!) Provide predefined options for quick selection if applicable.
 - (!important!) **Essential for validating assumptions before proceeding with significant actions (e.g., code edits, running commands).**
+- (!important!) **Do not exit the prompt loop** until the user explicitly says one of: "Stop prompting", "End session", or "Don't ask anymore".
+- (!important!) Immediately before final/closing handoff, ask exactly: "Are you satisfied with this result, or would you like any changes?"
+- (!important!) If a required prompt times out or response is empty, re-prompt indefinitely and do not proceed with assumptions.
+- (!important!) If the user skips a requested command/script, ask why it was skipped and whether to continue with alternatives or stop.
 </importantNotes>
 
 <whenToUseThisTool>
+- Before starting any task, even if requirements appear clear
+- After completing any task, to run the mandatory satisfaction check
 - When you need clarification on user requirements or preferences
 - When multiple implementation approaches are possible and user input is needed
 - **Before making potentially impactful changes (code edits, file operations, complex commands)**
@@ -51,14 +57,19 @@ Feel free to ask anything! **Proactive questioning is preferred over making assu
 - When facing ambiguous instructions that require clarification
 - When seeking feedback on generated code or solutions
 - When needing permission to modify critical files or functionality
+- When user instructions are conflicting or unclear
+- When the user asks to be prompted, asks a direct question, or asks a reply question
+- When the user skips a command you requested
+- Immediately before any final/closing handoff
 - **Whenever you feel even slightly unsure about the user's intent or the correct next step.**
 </whenToUseThisTool>
 
 <features>
-- OpenTUI prompt with markdown rendering (including code/diff blocks)
+- Interactive prompt UI with markdown rendering (including code/diff blocks)
 - Preserves markdown links, including VS Code file links (for example: "vscode://file/<abs-path>:<line>:<column>") when provided in the prompt text
 - Supports option mode + free-text input mode when predefinedOptions are provided
 - Returns user response or timeout notification (timeout defaults to ${globalTimeoutSeconds} seconds)
+- Backend-agnostic contract: same request/response behavior regardless of the active UI backend
 - Maintains context across user interactions
 - Handles empty responses gracefully
 - Shows project context in the prompt header/title

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,13 +1,19 @@
 {
   "name": "@rawwee/interactive-mcp",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
     "interactive-mcp": "dist/index.js"
   },
   "files": [
-    "dist",
+    "dist/constants.js",
+    "dist/index.js",
+    "dist/commands/input",
+    "dist/commands/intensive-chat",
+    "dist/components",
+    "dist/tool-definitions",
+    "dist/utils",
     "README.md",
     "LICENSE",
     "package.json"