@mcp-use/cli 1.0.0

package/dist/app.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+type Props = {
+    name?: string;
+};
+export default function App({ name }: Props): React.JSX.Element;
+export {};

package/dist/app.js

@@ -0,0 +1,343 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import TextInput from 'ink-text-input';
+import BigText from 'ink-big-text';
+import { mcpService } from './mcp-service.js';
+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 "command":
+            return React.createElement(CommandMessageRenderer, { message: message });
+        default:
+            return null;
+    }
+};
+const UserMessageRenderer = ({ message }) => {
+    return React.createElement(React.Fragment, null,
+        React.createElement(Box, { key: message.id, marginBottom: 1 },
+            React.createElement(Box, { marginRight: 1 },
+                React.createElement(Text, { color: 'green', bold: true }, "'\u276F'")),
+            React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+                React.createElement(Text, { wrap: "wrap" }, message.content))));
+};
+const AssistantMessageRenerer = ({ message }) => {
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Box, { key: message.id, marginBottom: 1 },
+            React.createElement(Box, { marginRight: 1 },
+                React.createElement(Text, { color: 'blue', bold: true }, "'\u25E6'")),
+            React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+                React.createElement(Text, { wrap: "wrap" }, message.content)))));
+};
+const ToolCallRenderer = ({ message }) => {
+    return React.createElement(React.Fragment, null,
+        React.createElement(Box, { key: message.id, marginBottom: 1, borderStyle: "round", flexDirection: 'column', gap: 1 },
+            React.createElement(Box, { marginRight: 1 },
+                React.createElement(Text, { color: 'white', bold: true },
+                    "\uD83D\uDD28 Tool: ",
+                    message.tool_name)),
+            React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+                React.createElement(Text, { wrap: "wrap" },
+                    " Input: ",
+                    message.tool_input.toString(),
+                    " "),
+                React.createElement(Text, { wrap: "wrap" },
+                    " Output:",
+                    message.tool_output.toString(),
+                    " "))));
+};
+const CommandMessageRenderer = ({ message }) => {
+    const { commandResult } = message;
+    let icon = '💻';
+    let color = 'cyan';
+    if (commandResult.type === 'error') {
+        icon = '❌';
+        color = 'red';
+    }
+    else if (commandResult.type === 'success') {
+        icon = '✅';
+        color = 'green';
+    }
+    else if (commandResult.type === 'prompt_key') {
+        icon = '🔑';
+        color = 'yellow';
+    }
+    else if (commandResult.type === 'prompt_server_config') {
+        icon = '🔧';
+        color = 'blue';
+    }
+    return React.createElement(React.Fragment, null,
+        React.createElement(Box, { key: message.id, marginBottom: 1 },
+            React.createElement(Box, { marginRight: 1 },
+                React.createElement(Text, { color: color, bold: true }, icon)),
+            React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+                React.createElement(Text, { wrap: "wrap", color: color }, message.content))));
+};
+export default function App({ name }) {
+    const [messages, setMessages] = useState([]);
+    const [input, setInput] = useState('');
+    const [isLoading, setIsLoading] = useState(false);
+    const [showInput, setShowInput] = useState(false);
+    const [initializationError, setInitializationError] = useState('');
+    const [currentModel, setCurrentModel] = useState('openai/gpt-4o-mini');
+    const [connectedServers, setConnectedServers] = useState([]);
+    const [isWaitingForApiKey, setIsWaitingForApiKey] = useState(false);
+    const [pendingProvider, setPendingProvider] = useState('');
+    const [pendingModel, setPendingModel] = useState('');
+    const [isWaitingForServerConfig, setIsWaitingForServerConfig] = useState(false);
+    const [serverConfigStep, setServerConfigStep] = useState('');
+    const [currentServerConfig, setCurrentServerConfig] = useState(null);
+    const { stdout } = useStdout();
+    // Initialize MCP service on component mount
+    useEffect(() => {
+        const initializeMCP = async () => {
+            try {
+                setIsLoading(true);
+                await mcpService.initialize();
+                setCurrentModel(mcpService.getCurrentModel());
+                setConnectedServers(mcpService.getConnectedServers());
+                setShowInput(true);
+            }
+            catch (error) {
+                setInitializationError(error instanceof Error ? error.message : 'Failed to initialize MCP service');
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        initializeMCP();
+    }, []);
+    useInput((input, key) => {
+        if (key.ctrl && input === 'c') {
+            process.exit(0);
+        }
+        if (key.ctrl && input === 'd') {
+            process.exit(0);
+        }
+    });
+    const handleSubmit = async (userInput) => {
+        if (!userInput.trim())
+            return;
+        // Check if we're waiting for server configuration input
+        if (isWaitingForServerConfig) {
+            const userMessage = {
+                id: Date.now().toString(),
+                role: 'user',
+                content: userInput.trim(),
+                timestamp: new Date(),
+            };
+            setMessages(prev => [...prev, userMessage]);
+            setInput('');
+            setIsLoading(true);
+            try {
+                // Import CommandHandler to access handleServerConfigInput
+                const result = await mcpService.sendMessage(userInput.trim(), false, '', '', true, serverConfigStep, currentServerConfig);
+                if (result.commandResult) {
+                    const commandMessage = {
+                        id: (Date.now() + 1).toString(),
+                        role: 'command',
+                        content: result.response,
+                        commandResult: result.commandResult,
+                        timestamp: new Date(),
+                    };
+                    setMessages(prev => [...prev, commandMessage]);
+                    // Check if we're continuing server config or done
+                    if (result.commandResult.type === 'prompt_server_config' && result.commandResult.data) {
+                        setServerConfigStep(result.commandResult.data.step);
+                        setCurrentServerConfig(result.commandResult.data.config);
+                    }
+                    else {
+                        // Server config is done
+                        setIsWaitingForServerConfig(false);
+                        setServerConfigStep('');
+                        setCurrentServerConfig(null);
+                        // Update connected servers if servers were connected or disconnected
+                        if (result.commandResult.data?.serverConnected || result.commandResult.data?.serverDisconnected) {
+                            setConnectedServers(mcpService.getConnectedServers());
+                        }
+                    }
+                }
+                setIsLoading(false);
+            }
+            catch (error) {
+                const errorMessage = {
+                    id: (Date.now() + 1).toString(),
+                    role: 'assistant',
+                    content: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    timestamp: new Date(),
+                };
+                setMessages(prev => [...prev, errorMessage]);
+                setIsLoading(false);
+                // Reset server config state on error
+                setIsWaitingForServerConfig(false);
+                setServerConfigStep('');
+                setCurrentServerConfig(null);
+            }
+            return;
+        }
+        // Check if we're waiting for an API key
+        if (isWaitingForApiKey) {
+            const maskedInput = userInput.replace(/./g, '*');
+            const userMessage = {
+                id: Date.now().toString(),
+                role: 'user',
+                content: maskedInput,
+                timestamp: new Date(),
+            };
+            setMessages(prev => [...prev, userMessage]);
+            setInput('');
+            setIsLoading(true);
+            try {
+                const result = await mcpService.sendMessage(userInput.trim(), true, pendingProvider, pendingModel);
+                if (result.commandResult) {
+                    const commandMessage = {
+                        id: (Date.now() + 1).toString(),
+                        role: 'command',
+                        content: result.response,
+                        commandResult: result.commandResult,
+                        timestamp: new Date(),
+                    };
+                    setMessages(prev => [...prev, commandMessage]);
+                    // Update current model if successful
+                    if (result.commandResult.data?.llmConfig) {
+                        setCurrentModel(mcpService.getCurrentModel());
+                    }
+                    // Reset API key input state
+                    setIsWaitingForApiKey(false);
+                    setPendingProvider('');
+                    setPendingModel('');
+                }
+                setIsLoading(false);
+            }
+            catch (error) {
+                const errorMessage = {
+                    id: (Date.now() + 1).toString(),
+                    role: 'assistant',
+                    content: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    timestamp: new Date(),
+                };
+                setMessages(prev => [...prev, errorMessage]);
+                setIsLoading(false);
+                // Reset API key input state on error
+                setIsWaitingForApiKey(false);
+                setPendingProvider('');
+                setPendingModel('');
+            }
+            return;
+        }
+        const userMessage = {
+            id: Date.now().toString(),
+            role: 'user',
+            content: userInput.trim(),
+            timestamp: new Date(),
+        };
+        setMessages(prev => [...prev, userMessage]);
+        setInput('');
+        setIsLoading(true);
+        try {
+            const result = await mcpService.sendMessage(userInput.trim());
+            if (result.isCommand && result.commandResult) {
+                // Handle command response
+                const commandMessage = {
+                    id: (Date.now() + 1).toString(),
+                    role: 'command',
+                    content: result.response,
+                    commandResult: result.commandResult,
+                    timestamp: new Date(),
+                };
+                setMessages(prev => [...prev, commandMessage]);
+                // Check if we need to prompt for API key
+                if (result.commandResult.type === 'prompt_key' && result.commandResult.data) {
+                    setIsWaitingForApiKey(true);
+                    setPendingProvider(result.commandResult.data.provider);
+                    setPendingModel(result.commandResult.data.model);
+                }
+                else if (result.commandResult.type === 'prompt_server_config' && result.commandResult.data) {
+                    setIsWaitingForServerConfig(true);
+                    setServerConfigStep(result.commandResult.data.step);
+                    setCurrentServerConfig(result.commandResult.data.config || null);
+                }
+                else if (result.commandResult.data?.serverConnected || result.commandResult.data?.serverDisconnected) {
+                    // Update connected servers if servers were connected or disconnected
+                    setConnectedServers(mcpService.getConnectedServers());
+                }
+                else if (result.commandResult.data?.hasOwnProperty('llmConfig')) {
+                    // Update current model if it changed (including null for clearkeys)
+                    setCurrentModel(mcpService.getCurrentModel());
+                }
+            }
+            else {
+                // Handle regular assistant response
+                const assistantMessage = {
+                    id: (Date.now() + 1).toString(),
+                    role: 'assistant',
+                    content: result.response,
+                    timestamp: new Date(),
+                };
+                // Add assistant message and any tool calls
+                setMessages(prev => [...prev, assistantMessage, ...result.toolCalls]);
+            }
+            setIsLoading(false);
+        }
+        catch (error) {
+            const errorMessage = {
+                id: (Date.now() + 1).toString(),
+                role: 'assistant',
+                content: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                timestamp: new Date(),
+            };
+            setMessages(prev => [...prev, errorMessage]);
+            setIsLoading(false);
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", minHeight: stdout.rows || 24 },
+        React.createElement(Box, { borderStyle: "round", borderColor: "blue", paddingX: 1, marginBottom: 1 },
+            React.createElement(Box, { flexDirection: "column", width: "100%" },
+                React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%" },
+                    React.createElement(Text, { color: "blue", bold: true },
+                        "MCP-Use CLI ",
+                        name ? `- ${name}` : ' '),
+                    React.createElement(Text, { color: "gray" },
+                        "Model: ",
+                        currentModel)),
+                React.createElement(Box, { flexDirection: "row", justifyContent: "flex-start", width: "100%" },
+                    React.createElement(Text, { color: "gray" },
+                        "Connected servers: ",
+                        connectedServers.length > 0 ? connectedServers.join(', ') : 'none')))),
+        React.createElement(Box, { flexDirection: "column", flexGrow: 1, paddingX: 1 },
+            initializationError && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "red" },
+                    "\u274C ",
+                    initializationError))),
+            !initializationError && messages.length === 0 && !isLoading && (React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+                React.createElement(BigText, { text: "MCP USE CLI", colors: ['white'] }),
+                React.createElement(Text, { color: "gray" }, "Welcome to MCP-Use CLI!"),
+                currentModel.includes('No') ? (React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: "yellow" },
+                        "\u26A0\uFE0F ",
+                        currentModel),
+                    React.createElement(Text, { color: "gray" }, "Choose a model to get started - the CLI will help you set up the API key."),
+                    React.createElement(Text, { color: "cyan" }, "\uD83D\uDCA1 Try: /model openai gpt-4o-mini"),
+                    React.createElement(Text, { color: "gray" }, "Or use /models to see all options, /help for commands."))) : (React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: "gray" }, "Type your message and press Enter to start chatting."),
+                    React.createElement(Text, { color: "gray" }, "Use slash commands like /help, /model, or /status for configuration."))))),
+            !initializationError && messages.length === 0 && isLoading && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "blue" }, "\uD83D\uDD04 Initializing MCP service..."))),
+            messages.map(message => React.createElement(MessageRenderer, { message: message })),
+            isLoading && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Box, { marginRight: 1 },
+                    React.createElement(Text, { color: "blue", bold: true }, "\u25E6")),
+                React.createElement(Text, { color: "gray" }, "Thinking...")))),
+        showInput && !initializationError && (React.createElement(Box, { borderStyle: "round", borderColor: isWaitingForApiKey ? "yellow" : isWaitingForServerConfig ? "blue" : "gray", paddingX: 1 },
+            React.createElement(Box, { marginRight: 1 },
+                React.createElement(Text, { color: isWaitingForApiKey ? "yellow" : isWaitingForServerConfig ? "blue" : "green", bold: true }, isWaitingForApiKey ? "🔑" : isWaitingForServerConfig ? "🔧" : "❯")),
+            React.createElement(TextInput, { value: input, onChange: setInput, onSubmit: handleSubmit, placeholder: isWaitingForApiKey
+                    ? `Enter ${pendingProvider.toUpperCase()} API key...`
+                    : isWaitingForServerConfig
+                        ? "Enter server configuration..."
+                        : "Type your message...", mask: isWaitingForApiKey ? "*" : undefined })))));
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import meow from 'meow';
+import App from './app.js';
+const cli = meow(`
+	Usage
+	  $ mcp-use-cli
+
+	Options
+		--name        Your name (optional)
+		--config      Path to MCP configuration file (optional)
+
+	Examples
+	  $ mcp-use-cli
+	  $ mcp-use-cli --name=Jane
+	  $ mcp-use-cli --config=./mcp-config.json
+
+	Environment Variables
+	  OPENAI_API_KEY    Required - Your OpenAI API key
+
+	Setup
+	  1. Set your OpenAI API key: export OPENAI_API_KEY=your_key_here
+	  2. Run: mcp-use-cli
+	  3. Start chatting with MCP servers!
+`, {
+    importMeta: import.meta,
+    flags: {
+        name: {
+            type: 'string',
+        },
+        config: {
+            type: 'string',
+        },
+    },
+});
+render(React.createElement(App, { name: cli.flags.name }));

package/dist/commands.d.ts

@@ -0,0 +1,51 @@
+import { StoredConfig } from './storage.js';
+export interface LLMConfig {
+    provider: 'openai' | 'anthropic' | 'google' | 'mistral';
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+export interface CommandResult {
+    type: 'success' | 'error' | 'info' | 'prompt_key' | 'prompt_server_config';
+    message: string;
+    data?: any;
+}
+export declare class CommandHandler {
+    private currentLLMConfig;
+    private sessionApiKeys;
+    private persistentConfig;
+    private sessionServers;
+    private availableModels;
+    constructor();
+    private initializeDefaultProvider;
+    getAvailableProviders(): string[];
+    private getApiKey;
+    isAnyProviderAvailable(): boolean;
+    handleCommand(input: string): Promise<CommandResult>;
+    private handleHelp;
+    private handleModel;
+    private handleListModels;
+    private handleStatus;
+    private handleConfig;
+    private handleSetKey;
+    private validateApiKey;
+    private maskApiKey;
+    createLLM(): any;
+    getCurrentConfig(): LLMConfig | null;
+    getCurrentStoredConfig(): StoredConfig;
+    getSessionServers(): Record<string, {
+        command: string;
+        args?: string[];
+        env?: Record<string, string>;
+    }>;
+    private handleListTools;
+    private handleTestServer;
+    isCommand(input: string): boolean;
+    private handleClearKeys;
+    handleServerConfigInput(input: string, step: string, serverConfig?: any): CommandResult;
+    private handleServer;
+    private handleListServers;
+    private handleConnectServer;
+    private handleDisconnectServer;
+    handleApiKeyInput(apiKey: string, provider: string, model: string): CommandResult;
+}