@mcp-use/cli 1.0.0 → 1.0.1

package/dist/InputPrompt.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+interface InputPromptProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    onHistoryUp?: () => void;
+    onHistoryDown?: () => void;
+    placeholder?: string;
+    mask?: string;
+    focus?: boolean;
+}
+export declare const InputPrompt: React.FC<InputPromptProps>;
+export {};

package/dist/InputPrompt.js

@@ -0,0 +1,188 @@
+import React, { useState, useEffect, useCallback, useRef } from 'react';
+import { Box, Text, useInput } from 'ink';
+export const InputPrompt = ({ value, onChange, onSubmit, onHistoryUp, onHistoryDown, placeholder = 'Type your message...', mask, focus = true, }) => {
+    const [cursorPosition, setCursorPosition] = useState(value.length);
+    const [isMultiline, setIsMultiline] = useState(false);
+    const pasteBufferRef = useRef('');
+    const pasteTimeoutRef = useRef(null);
+    const lastInputTimeRef = useRef(Date.now());
+    // Track if we should allow multiline
+    useEffect(() => {
+        setIsMultiline(value.includes('\n'));
+    }, [value]);
+    // Update cursor position when value changes externally
+    useEffect(() => {
+        setCursorPosition(value.length);
+    }, [value]);
+    const handleSubmit = useCallback(() => {
+        const trimmedValue = value.trim();
+        if (trimmedValue) {
+            onSubmit(trimmedValue);
+            onChange('');
+            setCursorPosition(0);
+            setIsMultiline(false);
+        }
+    }, [value, onSubmit, onChange]);
+    const processPasteBuffer = useCallback(() => {
+        if (pasteBufferRef.current) {
+            const beforeCursor = value.slice(0, cursorPosition);
+            const afterCursor = value.slice(cursorPosition);
+            // Process the paste buffer to handle carriage returns
+            let processedPaste = pasteBufferRef.current
+                .replace(/\r\n/g, '\n')
+                .replace(/\r/g, '\n');
+            const newValue = beforeCursor + processedPaste + afterCursor;
+            onChange(newValue);
+            setCursorPosition(cursorPosition + processedPaste.length);
+            if (processedPaste.includes('\n')) {
+                setIsMultiline(true);
+            }
+            pasteBufferRef.current = '';
+        }
+    }, [value, cursorPosition, onChange]);
+    useInput((input, key) => {
+        if (!focus)
+            return;
+        const now = Date.now();
+        const timeSinceLastInput = now - lastInputTimeRef.current;
+        lastInputTimeRef.current = now;
+        // Detect paste by checking if we're getting rapid inputs or multi-character input
+        const isProbablyPaste = input &&
+            (timeSinceLastInput < 50 || input.length > 1) &&
+            !key.ctrl &&
+            !key.meta;
+        if (isProbablyPaste) {
+            // Accumulate paste buffer
+            pasteBufferRef.current += input;
+            // Clear existing timeout
+            if (pasteTimeoutRef.current) {
+                clearTimeout(pasteTimeoutRef.current);
+            }
+            // Set new timeout to process paste
+            pasteTimeoutRef.current = setTimeout(() => {
+                processPasteBuffer();
+                pasteTimeoutRef.current = null;
+            }, 100);
+            return;
+        }
+        // Process any pending paste buffer first
+        if (pasteBufferRef.current) {
+            processPasteBuffer();
+        }
+        // Submit on Enter (without modifiers)
+        if (key.return && !key.ctrl && !key.meta && !key.shift) {
+            handleSubmit();
+            return;
+        }
+        // New line on Ctrl+Enter, Meta+Enter, or Shift+Enter
+        if (key.return && (key.ctrl || key.meta || key.shift)) {
+            const beforeCursor = value.slice(0, cursorPosition);
+            const afterCursor = value.slice(cursorPosition);
+            onChange(beforeCursor + '\n' + afterCursor);
+            setCursorPosition(cursorPosition + 1);
+            setIsMultiline(true);
+            return;
+        }
+        // History navigation with up/down arrows (only in single-line mode)
+        if (!isMultiline) {
+            if (key.upArrow && onHistoryUp) {
+                onHistoryUp();
+                return;
+            }
+            if (key.downArrow && onHistoryDown) {
+                onHistoryDown();
+                return;
+            }
+        }
+        // Backspace
+        if (key.backspace || key.delete) {
+            if (cursorPosition > 0) {
+                const beforeCursor = value.slice(0, cursorPosition - 1);
+                const afterCursor = value.slice(cursorPosition);
+                onChange(beforeCursor + afterCursor);
+                setCursorPosition(cursorPosition - 1);
+            }
+            return;
+        }
+        // Navigation keys
+        if (key.leftArrow) {
+            setCursorPosition(Math.max(0, cursorPosition - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setCursorPosition(Math.min(value.length, cursorPosition + 1));
+            return;
+        }
+        // Home/End keys
+        if (key.ctrl && input === 'a') {
+            setCursorPosition(0);
+            return;
+        }
+        if (key.ctrl && input === 'e') {
+            setCursorPosition(value.length);
+            return;
+        }
+        // Regular character input (not paste)
+        if (input && !key.ctrl && !key.meta) {
+            const beforeCursor = value.slice(0, cursorPosition);
+            const afterCursor = value.slice(cursorPosition);
+            // Process input to handle carriage returns
+            const processedInput = input.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            const newValue = beforeCursor + processedInput + afterCursor;
+            onChange(newValue);
+            setCursorPosition(cursorPosition + processedInput.length);
+            if (processedInput.includes('\n')) {
+                setIsMultiline(true);
+            }
+        }
+    });
+    // Render the input
+    const renderContent = () => {
+        if (!value && placeholder && !focus) {
+            return React.createElement(Text, { dimColor: true }, placeholder);
+        }
+        let displayValue = mask ? value.replace(/./g, mask) : value;
+        if (!isMultiline) {
+            // Single line rendering with cursor
+            const beforeCursor = displayValue.slice(0, cursorPosition);
+            const atCursor = displayValue[cursorPosition] || ' ';
+            const afterCursor = displayValue.slice(cursorPosition + 1);
+            return (React.createElement(Text, null,
+                beforeCursor,
+                focus && React.createElement(Text, { inverse: true }, atCursor),
+                afterCursor));
+        }
+        // Multiline rendering
+        const lines = displayValue.split('\n');
+        let pos = 0;
+        let cursorRow = 0;
+        let cursorCol = 0;
+        for (let row = 0; row < lines.length; row++) {
+            const lineLength = lines[row]?.length || 0;
+            if (pos + lineLength >= cursorPosition) {
+                cursorRow = row;
+                cursorCol = cursorPosition - pos;
+                break;
+            }
+            pos += lineLength + 1; // +1 for newline
+        }
+        return lines.map((line, row) => {
+            if (row === cursorRow && focus) {
+                const before = line.slice(0, cursorCol);
+                const at = line[cursorCol] || ' ';
+                const after = line.slice(cursorCol + 1);
+                return (React.createElement(Box, { key: row },
+                    React.createElement(Text, null,
+                        before,
+                        React.createElement(Text, { inverse: true }, at),
+                        after)));
+            }
+            return (React.createElement(Box, { key: row },
+                React.createElement(Text, null, line || ' ')));
+        });
+    };
+    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+        renderContent(),
+        isMultiline && focus && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true, italic: true }, "Enter to submit \u2022 Ctrl/Shift+Enter for new line")))));
+};

package/dist/MultilineInput.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+interface MultilineInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    onHistoryUp?: () => void;
+    onHistoryDown?: () => void;
+    placeholder?: string;
+    mask?: string;
+    focus?: boolean;
+}
+export declare const MultilineInput: React.FC<MultilineInputProps>;
+export {};

package/dist/MultilineInput.js

@@ -0,0 +1,154 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import { Box, Text, useInput } from 'ink';
+export const MultilineInput = ({ value, onChange, onSubmit, onHistoryUp, onHistoryDown, placeholder = 'Type your message...', mask, focus = true }) => {
+    const [cursorPosition, setCursorPosition] = useState(value.length);
+    const [isMultiline, setIsMultiline] = useState(false);
+    // Track if we should allow multiline
+    useEffect(() => {
+        setIsMultiline(value.includes('\n'));
+    }, [value]);
+    // Update cursor position when value changes externally (e.g., from history)
+    useEffect(() => {
+        setCursorPosition(value.length);
+    }, [value]);
+    const handleSubmit = useCallback(() => {
+        const trimmedValue = value.trim();
+        if (trimmedValue) {
+            onSubmit(trimmedValue);
+            onChange('');
+            setCursorPosition(0);
+            setIsMultiline(false);
+        }
+    }, [value, onSubmit, onChange]);
+    useInput((input, key) => {
+        if (!focus)
+            return;
+        // Submit on Enter (without modifiers)
+        if (key.return && !key.ctrl && !key.meta && !key.shift) {
+            handleSubmit();
+            return;
+        }
+        // New line on Ctrl+Enter, Meta+Enter, or Shift+Enter
+        if (key.return && (key.ctrl || key.meta || key.shift)) {
+            const beforeCursor = value.slice(0, cursorPosition);
+            const afterCursor = value.slice(cursorPosition);
+            onChange(beforeCursor + '\n' + afterCursor);
+            setCursorPosition(cursorPosition + 1);
+            setIsMultiline(true);
+            return;
+        }
+        // History navigation with up/down arrows (only in single-line mode)
+        if (!isMultiline) {
+            if (key.upArrow && onHistoryUp) {
+                onHistoryUp();
+                return;
+            }
+            if (key.downArrow && onHistoryDown) {
+                onHistoryDown();
+                return;
+            }
+        }
+        // Backspace
+        if (key.backspace || key.delete) {
+            if (cursorPosition > 0) {
+                const beforeCursor = value.slice(0, cursorPosition - 1);
+                const afterCursor = value.slice(cursorPosition);
+                onChange(beforeCursor + afterCursor);
+                setCursorPosition(cursorPosition - 1);
+            }
+            return;
+        }
+        // Navigation keys
+        if (key.leftArrow) {
+            setCursorPosition(Math.max(0, cursorPosition - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setCursorPosition(Math.min(value.length, cursorPosition + 1));
+            return;
+        }
+        // Home/End keys
+        if (key.ctrl && input === 'a') {
+            setCursorPosition(0);
+            return;
+        }
+        if (key.ctrl && input === 'e') {
+            setCursorPosition(value.length);
+            return;
+        }
+        // Regular character input (including paste)
+        if (input && !key.ctrl && !key.meta) {
+            // Handle potential paste operation (multi-character input)
+            const beforeCursor = value.slice(0, cursorPosition);
+            const afterCursor = value.slice(cursorPosition);
+            // Process the input character by character to handle special characters
+            let processedInput = '';
+            for (let i = 0; i < input.length; i++) {
+                const char = input[i];
+                // Convert carriage returns to newlines
+                if (char === '\r') {
+                    processedInput += '\n';
+                }
+                else {
+                    processedInput += char;
+                }
+            }
+            const newValue = beforeCursor + processedInput + afterCursor;
+            onChange(newValue);
+            setCursorPosition(cursorPosition + processedInput.length);
+            // Check if the input contains newlines (e.g., from paste)
+            if (processedInput.includes('\n')) {
+                setIsMultiline(true);
+            }
+        }
+    });
+    // Render the input
+    const renderContent = () => {
+        if (!value && placeholder && !focus) {
+            return React.createElement(Text, { dimColor: true }, placeholder);
+        }
+        let displayValue = mask ? value.replace(/./g, mask) : value;
+        if (!isMultiline) {
+            // Single line rendering with cursor
+            const beforeCursor = displayValue.slice(0, cursorPosition);
+            const atCursor = displayValue[cursorPosition] || ' ';
+            const afterCursor = displayValue.slice(cursorPosition + 1);
+            return (React.createElement(Text, null,
+                beforeCursor,
+                focus && React.createElement(Text, { inverse: true }, atCursor),
+                afterCursor));
+        }
+        // Multiline rendering
+        const lines = displayValue.split('\n');
+        let pos = 0;
+        let cursorRow = 0;
+        let cursorCol = 0;
+        for (let row = 0; row < lines.length; row++) {
+            const lineLength = lines[row]?.length || 0;
+            if (pos + lineLength >= cursorPosition) {
+                cursorRow = row;
+                cursorCol = cursorPosition - pos;
+                break;
+            }
+            pos += lineLength + 1; // +1 for newline
+        }
+        return lines.map((line, row) => {
+            if (row === cursorRow && focus) {
+                const before = line.slice(0, cursorCol);
+                const at = line[cursorCol] || ' ';
+                const after = line.slice(cursorCol + 1);
+                return (React.createElement(Box, { key: row },
+                    React.createElement(Text, null,
+                        before,
+                        React.createElement(Text, { inverse: true }, at),
+                        after)));
+            }
+            return React.createElement(Box, { key: row },
+                React.createElement(Text, null, line || ' '));
+        });
+    };
+    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+        renderContent(),
+        isMultiline && focus && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true, italic: true }, "Enter to submit \u2022 Ctrl/Shift+Enter for new line")))));
+};

package/dist/MultilineTextInput.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface MultilineTextInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    placeholder?: string;
+    mask?: string;
+    focus?: boolean;
+}
+export declare const MultilineTextInput: React.FC<MultilineTextInputProps>;
+export {};

package/dist/MultilineTextInput.js

@@ -0,0 +1,97 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+export const MultilineTextInput = ({ value, onChange, onSubmit, placeholder = '', mask, focus = true }) => {
+    const [cursorPosition, setCursorPosition] = useState(value.length);
+    useEffect(() => {
+        setCursorPosition(value.length);
+    }, [value]);
+    useInput((input, key) => {
+        if (!focus)
+            return;
+        if (key.return && !key.shift) {
+            // Submit on Enter (without Shift)
+            onSubmit(value);
+            return;
+        }
+        if (key.return && key.shift) {
+            // New line on Shift+Enter
+            const beforeCursor = value.slice(0, cursorPosition);
+            const afterCursor = value.slice(cursorPosition);
+            const newValue = beforeCursor + '\n' + afterCursor;
+            onChange(newValue);
+            setCursorPosition(cursorPosition + 1);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (cursorPosition > 0) {
+                const beforeCursor = value.slice(0, cursorPosition - 1);
+                const afterCursor = value.slice(cursorPosition);
+                onChange(beforeCursor + afterCursor);
+                setCursorPosition(Math.max(0, cursorPosition - 1));
+            }
+            return;
+        }
+        if (key.leftArrow) {
+            setCursorPosition(Math.max(0, cursorPosition - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setCursorPosition(Math.min(value.length, cursorPosition + 1));
+            return;
+        }
+        // Handle paste (Ctrl+V or Cmd+V)
+        if ((key.ctrl || key.meta) && input === 'v') {
+            // Unfortunately, Ink doesn't provide clipboard content directly
+            // This is a limitation of terminal-based input
+            return;
+        }
+        // Regular character input (including multi-character pastes)
+        if (input && !key.ctrl && !key.meta) {
+            const beforeCursor = value.slice(0, cursorPosition);
+            const afterCursor = value.slice(cursorPosition);
+            const newValue = beforeCursor + input + afterCursor;
+            onChange(newValue);
+            setCursorPosition(cursorPosition + input.length);
+        }
+    });
+    // Render the input with cursor
+    const renderContent = () => {
+        let displayValue = value;
+        if (mask) {
+            displayValue = value.replace(/./g, mask);
+        }
+        if (!displayValue && placeholder && !focus) {
+            return React.createElement(Text, { dimColor: true }, placeholder);
+        }
+        // Add cursor to the display value
+        const beforeCursor = displayValue.slice(0, cursorPosition);
+        const atCursor = displayValue[cursorPosition] || ' ';
+        const afterCursor = displayValue.slice(cursorPosition + 1);
+        // Split by newlines and render each line
+        const beforeLines = beforeCursor.split('\n');
+        const afterLines = (atCursor + afterCursor).split('\n');
+        return (React.createElement(React.Fragment, null,
+            beforeLines.map((line, index) => {
+                const isLastBeforeLine = index === beforeLines.length - 1;
+                if (isLastBeforeLine && afterLines.length > 0) {
+                    // This line contains the cursor
+                    const firstAfterLine = afterLines[0] || '';
+                    const cursorChar = firstAfterLine[0] || ' ';
+                    const restOfLine = firstAfterLine.slice(1);
+                    return (React.createElement(Box, { key: `line-${index}` },
+                        React.createElement(Text, null,
+                            line,
+                            React.createElement(Text, { inverse: true }, cursorChar),
+                            restOfLine)));
+                }
+                return React.createElement(Box, { key: `line-${index}` },
+                    React.createElement(Text, null, line));
+            }),
+            afterLines.slice(1).map((line, index) => (React.createElement(Box, { key: `after-line-${index}` },
+                React.createElement(Text, null, line))))));
+    };
+    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+        renderContent(),
+        focus && value.includes('\n') && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true, italic: true }, "(Shift+Enter for new line, Enter to submit)")))));
+};

package/dist/PasteAwareInput.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+interface PasteAwareInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    onHistoryUp?: () => void;
+    onHistoryDown?: () => void;
+    placeholder?: string;
+    mask?: string;
+    focus?: boolean;
+}
+export declare const PasteAwareInput: React.FC<PasteAwareInputProps>;
+export {};

package/dist/PasteAwareInput.js

@@ -0,0 +1,183 @@
+import React, { useState, useEffect, useCallback, useRef } from 'react';
+import { Box, Text, useInput } from 'ink';
+export const PasteAwareInput = ({ value, onChange, onSubmit, onHistoryUp, onHistoryDown, placeholder = 'Type your message...', mask, focus = true }) => {
+    const [cursorPosition, setCursorPosition] = useState(value.length);
+    const [isMultiline, setIsMultiline] = useState(false);
+    const pasteBufferRef = useRef('');
+    const pasteTimeoutRef = useRef(null);
+    const lastInputTimeRef = useRef(Date.now());
+    // Track if we should allow multiline
+    useEffect(() => {
+        setIsMultiline(value.includes('\n'));
+    }, [value]);
+    // Update cursor position when value changes externally
+    useEffect(() => {
+        setCursorPosition(value.length);
+    }, [value]);
+    const handleSubmit = useCallback(() => {
+        const trimmedValue = value.trim();
+        if (trimmedValue) {
+            onSubmit(trimmedValue);
+            onChange('');
+            setCursorPosition(0);
+            setIsMultiline(false);
+        }
+    }, [value, onSubmit, onChange]);
+    const processPasteBuffer = useCallback(() => {
+        if (pasteBufferRef.current) {
+            const beforeCursor = value.slice(0, cursorPosition);
+            const afterCursor = value.slice(cursorPosition);
+            // Process the paste buffer to handle carriage returns
+            let processedPaste = pasteBufferRef.current.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            const newValue = beforeCursor + processedPaste + afterCursor;
+            onChange(newValue);
+            setCursorPosition(cursorPosition + processedPaste.length);
+            if (processedPaste.includes('\n')) {
+                setIsMultiline(true);
+            }
+            pasteBufferRef.current = '';
+        }
+    }, [value, cursorPosition, onChange]);
+    useInput((input, key) => {
+        if (!focus)
+            return;
+        const now = Date.now();
+        const timeSinceLastInput = now - lastInputTimeRef.current;
+        lastInputTimeRef.current = now;
+        // Detect paste by checking if we're getting rapid inputs or multi-character input
+        const isProbablyPaste = input && (timeSinceLastInput < 50 || input.length > 1) && !key.ctrl && !key.meta;
+        if (isProbablyPaste) {
+            // Accumulate paste buffer
+            pasteBufferRef.current += input;
+            // Clear existing timeout
+            if (pasteTimeoutRef.current) {
+                clearTimeout(pasteTimeoutRef.current);
+            }
+            // Set new timeout to process paste
+            pasteTimeoutRef.current = setTimeout(() => {
+                processPasteBuffer();
+                pasteTimeoutRef.current = null;
+            }, 100);
+            return;
+        }
+        // Process any pending paste buffer first
+        if (pasteBufferRef.current) {
+            processPasteBuffer();
+        }
+        // Submit on Enter (without modifiers)
+        if (key.return && !key.ctrl && !key.meta && !key.shift) {
+            handleSubmit();
+            return;
+        }
+        // New line on Ctrl+Enter, Meta+Enter, or Shift+Enter
+        if (key.return && (key.ctrl || key.meta || key.shift)) {
+            const beforeCursor = value.slice(0, cursorPosition);
+            const afterCursor = value.slice(cursorPosition);
+            onChange(beforeCursor + '\n' + afterCursor);
+            setCursorPosition(cursorPosition + 1);
+            setIsMultiline(true);
+            return;
+        }
+        // History navigation with up/down arrows (only in single-line mode)
+        if (!isMultiline) {
+            if (key.upArrow && onHistoryUp) {
+                onHistoryUp();
+                return;
+            }
+            if (key.downArrow && onHistoryDown) {
+                onHistoryDown();
+                return;
+            }
+        }
+        // Backspace
+        if (key.backspace || key.delete) {
+            if (cursorPosition > 0) {
+                const beforeCursor = value.slice(0, cursorPosition - 1);
+                const afterCursor = value.slice(cursorPosition);
+                onChange(beforeCursor + afterCursor);
+                setCursorPosition(cursorPosition - 1);
+            }
+            return;
+        }
+        // Navigation keys
+        if (key.leftArrow) {
+            setCursorPosition(Math.max(0, cursorPosition - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setCursorPosition(Math.min(value.length, cursorPosition + 1));
+            return;
+        }
+        // Home/End keys
+        if (key.ctrl && input === 'a') {
+            setCursorPosition(0);
+            return;
+        }
+        if (key.ctrl && input === 'e') {
+            setCursorPosition(value.length);
+            return;
+        }
+        // Regular character input (not paste)
+        if (input && !key.ctrl && !key.meta) {
+            const beforeCursor = value.slice(0, cursorPosition);
+            const afterCursor = value.slice(cursorPosition);
+            // Process input to handle carriage returns
+            const processedInput = input.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            const newValue = beforeCursor + processedInput + afterCursor;
+            onChange(newValue);
+            setCursorPosition(cursorPosition + processedInput.length);
+            if (processedInput.includes('\n')) {
+                setIsMultiline(true);
+            }
+        }
+    });
+    // Render the input
+    const renderContent = () => {
+        if (!value && placeholder && !focus) {
+            return React.createElement(Text, { dimColor: true }, placeholder);
+        }
+        let displayValue = mask ? value.replace(/./g, mask) : value;
+        if (!isMultiline) {
+            // Single line rendering with cursor
+            const beforeCursor = displayValue.slice(0, cursorPosition);
+            const atCursor = displayValue[cursorPosition] || ' ';
+            const afterCursor = displayValue.slice(cursorPosition + 1);
+            return (React.createElement(Text, null,
+                beforeCursor,
+                focus && React.createElement(Text, { inverse: true }, atCursor),
+                afterCursor));
+        }
+        // Multiline rendering
+        const lines = displayValue.split('\n');
+        let pos = 0;
+        let cursorRow = 0;
+        let cursorCol = 0;
+        for (let row = 0; row < lines.length; row++) {
+            const lineLength = lines[row]?.length || 0;
+            if (pos + lineLength >= cursorPosition) {
+                cursorRow = row;
+                cursorCol = cursorPosition - pos;
+                break;
+            }
+            pos += lineLength + 1; // +1 for newline
+        }
+        return lines.map((line, row) => {
+            if (row === cursorRow && focus) {
+                const before = line.slice(0, cursorCol);
+                const at = line[cursorCol] || ' ';
+                const after = line.slice(cursorCol + 1);
+                return (React.createElement(Box, { key: row },
+                    React.createElement(Text, null,
+                        before,
+                        React.createElement(Text, { inverse: true }, at),
+                        after)));
+            }
+            return React.createElement(Box, { key: row },
+                React.createElement(Text, null, line || ' '));
+        });
+    };
+    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+        renderContent(),
+        isMultiline && focus && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true, italic: true }, "Enter to submit \u2022 Ctrl/Shift+Enter for new line")))));
+};