@mcp-use/cli 1.0.0 → 1.0.1

package/dist/components/AsciiLogo.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function AsciiLogo(): React.JSX.Element;

package/dist/components/AsciiLogo.js

@@ -0,0 +1,7 @@
+import React from 'react';
+import { Text } from 'ink';
+import BigText from 'ink-big-text';
+export default function AsciiLogo() {
+    return (React.createElement(Text, null,
+        React.createElement(BigText, { colors: ['white'], text: "mcp use cli" })));
+}

package/dist/components/Footer.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare const Footer: ({ servers, modelSlug }: {
+    servers: any;
+    modelSlug: string;
+}) => React.JSX.Element;

package/dist/components/Footer.js

@@ -0,0 +1,19 @@
+import { Box, Text } from 'ink';
+import React from 'react';
+export const Footer = ({ servers, modelSlug }) => {
+    return (React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", paddingX: 1, minWidth: 25 },
+        React.createElement(Box, { justifyContent: 'flex-start', paddingX: 1, minWidth: 25 }, servers.length > 0 ? (React.createElement(React.Fragment, null,
+            React.createElement(Text, { color: "green" },
+                "\u25CF ",
+                ' '),
+            React.createElement(Text, null,
+                servers.length,
+                " Server",
+                servers.length > 1 ? 's' : '',
+                " Connected"))) : (React.createElement(Text, null, "No servers connected"))),
+        React.createElement(Box, { justifyContent: 'flex-end', paddingX: 1, minWidth: 25 },
+            React.createElement(Text, { color: "blue", bold: true }, "Model:"),
+            React.createElement(Text, { color: "white" },
+                ' ',
+                modelSlug.replace('/', ' ')))));
+};

package/dist/components/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/components/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, null,
+            React.createElement(Text, { dimColor: true, italic: true }, "Enter to submit \u2022 Ctrl/Shift+Enter for new line")))));
+};

package/dist/components/Messages.d.ts

@@ -0,0 +1,21 @@
+import { CommandMessage, ToolCall } from '../types.js';
+import { Message } from '../types.js';
+import React from 'react';
+export declare const UserMessageRenderer: ({ message }: {
+    message: Message;
+}) => React.JSX.Element;
+export declare const AssistantMessageRenerer: ({ message }: {
+    message: Message;
+}) => React.JSX.Element;
+export declare const ThoughtMessageRenderer: ({ message }: {
+    message: Message;
+}) => React.JSX.Element;
+export declare const ToolCallRenderer: ({ message }: {
+    message: ToolCall;
+}) => React.JSX.Element;
+export declare const CommandMessageRenderer: ({ message, }: {
+    message: CommandMessage;
+}) => React.JSX.Element;
+export declare const MessageRenderer: ({ message, }: {
+    message: Message | ToolCall | CommandMessage;
+}) => React.JSX.Element | null;

package/dist/components/Messages.js

@@ -0,0 +1,80 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { ServerStatus } from './ServerStatus.js';
+import { ToolStatus } from './ToolStatus.js';
+export const UserMessageRenderer = ({ message }) => {
+    return (React.createElement(Box, { key: message.id, marginBottom: 1, flexDirection: "row" },
+        React.createElement(Box, { marginRight: 1 },
+            React.createElement(Text, { color: "white", bold: true }, "\u25CF")),
+        React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+            React.createElement(Text, { wrap: "wrap" }, message.content))));
+};
+export const AssistantMessageRenerer = ({ message }) => {
+    return (React.createElement(Box, { key: message.id, marginBottom: 1, flexDirection: "row" },
+        React.createElement(Box, { marginRight: 1 },
+            React.createElement(Text, { color: "blue", bold: true }, "\u25CF")),
+        React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+            React.createElement(Text, { wrap: "wrap" }, message.content))));
+};
+export const ThoughtMessageRenderer = ({ message }) => {
+    return (React.createElement(Box, { key: message.id, flexDirection: "row" },
+        React.createElement(Box, { flexDirection: "column", marginRight: 1, flexGrow: 1 },
+            React.createElement(Text, { color: "gray", italic: true }, message.content))));
+};
+export const ToolCallRenderer = ({ message }) => {
+    const input = JSON.stringify(message.tool_input);
+    const output = JSON.stringify(message.tool_output);
+    return (React.createElement(Box, { key: message.id, flexDirection: "row" },
+        React.createElement(Box, { marginRight: 1 },
+            React.createElement(Text, { color: "white", bold: true }, "\u25CF")),
+        React.createElement(Box, { flexGrow: 1, paddingX: 1, borderStyle: "round", borderColor: "white", flexDirection: "column" },
+            React.createElement(Text, { color: "white", bold: true },
+                "Tool: ",
+                message.tool_name),
+            React.createElement(Text, null,
+                "Input: ",
+                input.length > 100 ? `${input.slice(0, 97)}...` : input),
+            React.createElement(Text, null,
+                "Output: ",
+                output.length > 100 ? `${output.slice(0, 97)}...` : output))));
+};
+export const CommandMessageRenderer = ({ message, }) => {
+    const { commandResult } = message;
+    let color = 'magenta'; // Default for info/system
+    if (commandResult.type === 'error')
+        color = 'red';
+    if (commandResult.type === 'success')
+        color = 'green';
+    if (commandResult.type === 'prompt_key' ||
+        commandResult.type === 'prompt_server_config') {
+        color = 'yellow';
+    }
+    if (commandResult.type === 'list_servers')
+        color = 'magenta';
+    if (commandResult.type === 'list_tools')
+        color = 'cyan';
+    return (React.createElement(Box, { key: message.id, marginBottom: 1, flexDirection: "row" },
+        React.createElement(Box, { marginRight: 1 },
+            React.createElement(Text, { color: color, bold: true }, "\u25CF")),
+        React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+            React.createElement(Text, null, message.content),
+            commandResult.type === 'list_servers' &&
+                commandResult.data?.servers && (React.createElement(ServerStatus, { servers: commandResult.data.servers })),
+            commandResult.type === 'list_tools' && commandResult.data && (React.createElement(ToolStatus, { tools: commandResult.data.tools, error: commandResult.data.error })))));
+};
+export const MessageRenderer = ({ message, }) => {
+    switch (message.role) {
+        case 'tool':
+            return React.createElement(ToolCallRenderer, { message: message });
+        case 'user':
+            return React.createElement(UserMessageRenderer, { message: message });
+        case 'assistant':
+            return React.createElement(AssistantMessageRenerer, { message: message });
+        case 'thought':
+            return React.createElement(ThoughtMessageRenderer, { message: message });
+        case 'command':
+            return React.createElement(CommandMessageRenderer, { message: message });
+        default:
+            return null;
+    }
+};

package/dist/components/ServerStatus.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { ServerStatus as ServerStatusData } from '../types.js';
+interface ServerStatusProps {
+    servers: ServerStatusData[];
+}
+export declare function ServerStatus({ servers }: ServerStatusProps): React.JSX.Element;
+export {};

package/dist/components/ServerStatus.js

@@ -0,0 +1,36 @@
+import { Box, Text } from 'ink';
+import React from 'react';
+export function ServerStatus({ servers }) {
+    return (React.createElement(Box, { flexDirection: "column" }, servers.map(server => (React.createElement(Box, { key: server.name, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1 },
+        React.createElement(Box, null, server.isConnected ? (React.createElement(Text, { bold: true },
+            " \uD83D\uDD39",
+            server.name)) : (React.createElement(Text, { bold: true },
+            " \uD83D\uDD38 ",
+            server.name))),
+        React.createElement(Box, null,
+            React.createElement(Text, null,
+                "Status:",
+                ' ',
+                server.isConnected ? (React.createElement(Text, { color: "green" }, "Connected")) : (React.createElement(Text, { color: "red" }, "Disconnected")))),
+        React.createElement(Box, null,
+            React.createElement(Text, null,
+                "Command: ",
+                server.config.command)),
+        server.config.args && server.config.args.length > 0 && (React.createElement(Box, null,
+            React.createElement(Text, null,
+                "Args: ",
+                server.config.args.join(' ')))),
+        server.config.env && Object.keys(server.config.env).length > 0 && (React.createElement(Box, null,
+            React.createElement(Text, null,
+                "Env:",
+                ' ',
+                Object.entries(server.config.env)
+                    .map(([k, v]) => `${k}=${v}`)
+                    .join(', ')))),
+        React.createElement(Box, null,
+            React.createElement(Text, null,
+                "Action: /server ",
+                server.isConnected ? 'disconnect' : 'connect',
+                ' ',
+                server.name)))))));
+}

package/dist/components/Spinner.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { SpinnerName } from 'cli-spinners';
+type SpinnerProps = {
+    /**
+     * Type of a spinner.
+     * See [cli-spinners](https://github.com/sindresorhus/cli-spinners) for available spinners.
+     *
+     * @default dots
+     */
+    type?: SpinnerName | 'mcpuse';
+};
+/**
+ * Spinner.
+ */
+declare function Spinner({ type }: SpinnerProps): React.JSX.Element;
+export default Spinner;

package/dist/components/Spinner.js

@@ -0,0 +1,63 @@
+import React, { useState, useEffect } from 'react';
+import { Text } from 'ink';
+import spinners from 'cli-spinners';
+const mcpuseSpinner = {
+    interval: 80,
+    frames: [
+        "⠋",
+        "⠙",
+        "⠹",
+        "⠸",
+        "m", // 5
+        "⠼",
+        "⠴",
+        "⠦",
+        "c", // 9
+        "⠧",
+        "⠇",
+        "⠏",
+        "p", // 13
+        "⠋",
+        "⠙",
+        "⠹",
+        "-", // 17
+        "⠸",
+        "⠼",
+        "⠴",
+        "u", // 21
+        "⠦",
+        "⠧",
+        "⠇",
+        "s", // 25
+        "⠏",
+        "⠋",
+        "⠙",
+        "e" // 29
+    ]
+};
+/**
+ * Spinner.
+ */
+function Spinner({ type = 'mcpuse' }) {
+    const [frame, setFrame] = useState(0);
+    let spinner;
+    if (type === 'mcpuse') {
+        spinner = mcpuseSpinner;
+    }
+    else {
+        spinner = spinners[type];
+    }
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame(previousFrame => {
+                const isLastFrame = previousFrame === spinner.frames.length - 1;
+                return isLastFrame ? 0 : previousFrame + 1;
+            });
+        }, spinner.interval);
+        return () => {
+            clearInterval(timer);
+        };
+    }, [spinner]);
+    return React.createElement(Text, null, spinner.frames[frame]);
+}
+export default Spinner;

package/dist/components/ToolStatus.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+interface ToolStatusProps {
+    tools: Tool[];
+    error?: string;
+}
+export declare function ToolStatus({ tools, error }: ToolStatusProps): React.JSX.Element;
+export {};

package/dist/components/ToolStatus.js

@@ -0,0 +1,33 @@
+import { Box, Text } from 'ink';
+import React from 'react';
+export function ToolStatus({ tools, error }) {
+    if (error) {
+        return (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { color: "red" },
+                "\u274C Error: ",
+                error),
+            React.createElement(Text, null, "\uD83D\uDCA1 This might indicate:"),
+            React.createElement(Box, { marginLeft: 2, flexDirection: "column" },
+                React.createElement(Text, null, "\u2022 MCP servers failed to start"),
+                React.createElement(Text, null, "\u2022 Connection issues with configured servers")),
+            React.createElement(Text, null, "Check console logs for more details.")));
+    }
+    if (tools.length === 0) {
+        return (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { color: "white" }, " No MCP tools found"),
+            React.createElement(Text, null,
+                ' ',
+                "Add tools from a server by running /server connect <name>")));
+    }
+    return (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+        React.createElement(Text, { color: "green" },
+            "Found ",
+            tools.length,
+            " MCP tools:"),
+        tools.map((tool, index) => (React.createElement(Box, { key: tool.name, flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, null,
+                index + 1,
+                ". ",
+                React.createElement(Text, { bold: true }, tool.name || 'Unknown'),
+                tool.description && `: ${tool.description}`))))));
+}

package/dist/components/textInput.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/textInput.js

@@ -0,0 +1 @@
+export {};

package/dist/logger.d.ts

@@ -0,0 +1,10 @@
+export declare class Logger {
+    private static formatMessage;
+    private static writeToFile;
+    static debug(message: string, data?: any): void;
+    static info(message: string, data?: any): void;
+    static warn(message: string, data?: any): void;
+    static error(message: string, data?: any): void;
+    static getLogPath(): string;
+    static clearLogs(): void;
+}

package/dist/logger.js

@@ -0,0 +1,48 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const LOG_DIR = path.join(os.homedir(), '.mcp-use-cli');
+const LOG_FILE = path.join(LOG_DIR, 'debug.log');
+// Ensure log directory exists
+if (!fs.existsSync(LOG_DIR)) {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+}
+export class Logger {
+    static formatMessage(level, message, data) {
+        const timestamp = new Date().toISOString();
+        const dataStr = data ? ` | Data: ${JSON.stringify(data, null, 2)}` : '';
+        return `[${timestamp}] ${level.toUpperCase()}: ${message}${dataStr}\n`;
+    }
+    static writeToFile(content) {
+        try {
+            fs.appendFileSync(LOG_FILE, content);
+        }
+        catch (error) {
+            // Fallback to console if file write fails
+            console.error('Failed to write to log file:', error);
+        }
+    }
+    static debug(message, data) {
+        this.writeToFile(this.formatMessage('debug', message, data));
+    }
+    static info(message, data) {
+        this.writeToFile(this.formatMessage('info', message, data));
+    }
+    static warn(message, data) {
+        this.writeToFile(this.formatMessage('warn', message, data));
+    }
+    static error(message, data) {
+        this.writeToFile(this.formatMessage('error', message, data));
+    }
+    static getLogPath() {
+        return LOG_FILE;
+    }
+    static clearLogs() {
+        try {
+            fs.writeFileSync(LOG_FILE, '');
+        }
+        catch (error) {
+            console.error('Failed to clear log file:', error);
+        }
+    }
+}

package/dist/mcp-service.d.ts

@@ -1,4 +1,5 @@
 import { CommandResult } from './commands.js';
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 export interface MCPMessage {
     id: string;
     role: 'user' | 'assistant';
@@ -17,9 +18,9 @@ export declare class MCPService {
     private isInitialized;
     private commandHandler;
     private client;
-    initialize(config?: any): Promise<void>;
-    private initializeAgent;
-    private reinitializeWithNewServers;
+    initialize(): Promise<void>;
+    initializeAgent(): Promise<void>;
+    refreshAgent(): Promise<void>;
     sendMessage(message: string, isApiKeyInput?: boolean, pendingProvider?: string, pendingModel?: string, isServerConfigInput?: boolean, serverConfigStep?: string, serverConfig?: any): Promise<{
         response: string;
         toolCalls: MCPToolCall[];
@@ -37,7 +38,7 @@ export declare class MCPService {
     getConfiguredServers(): string[];
     getConnectedServers(): string[];
     getAvailableTools(): Promise<{
-        tools: any[];
+        tools: Tool[];
         error?: string;
     }>;
 }