@mcp-use/cli 1.0.0 → 1.0.1

package/dist/app.js

@@ -1,83 +1,13 @@
-import React, { useState, useEffect } from 'react';
+import React, { useState, useEffect, useCallback } 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 }) {
+import { cliService } from './services/cli-service.js';
+import { Logger } from './logger.js';
+import { InputPrompt } from './components/InputPrompt.js';
+import Spinner from './components/Spinner.js';
+import AsciiLogo from './components/AsciiLogo.js';
+import { MessageRenderer } from './components/Messages.js';
+import { Footer } from './components/Footer.js';
+export default function App() {
     const [messages, setMessages] = useState([]);
     const [input, setInput] = useState('');
     const [isLoading, setIsLoading] = useState(false);
@@ -91,19 +21,36 @@ export default function App({ name }) {
     const [isWaitingForServerConfig, setIsWaitingForServerConfig] = useState(false);
     const [serverConfigStep, setServerConfigStep] = useState('');
     const [currentServerConfig, setCurrentServerConfig] = useState(null);
+    const [inputHistory, setInputHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const [tempInput, setTempInput] = useState('');
     const { stdout } = useStdout();
     // Initialize MCP service on component mount
     useEffect(() => {
         const initializeMCP = async () => {
             try {
+                Logger.info('Initializing MCP service...');
                 setIsLoading(true);
-                await mcpService.initialize();
-                setCurrentModel(mcpService.getCurrentModel());
-                setConnectedServers(mcpService.getConnectedServers());
+                await cliService.initialize();
+                const model = cliService.getCurrentModel();
+                const servers = cliService.getConnectedServers();
+                Logger.info('MCP service initialized successfully', {
+                    model,
+                    connectedServers: servers,
+                });
+                setCurrentModel(model);
+                setConnectedServers(servers);
                 setShowInput(true);
             }
             catch (error) {
-                setInitializationError(error instanceof Error ? error.message : 'Failed to initialize MCP service');
+                const errorMsg = error instanceof Error
+                    ? error.message
+                    : 'Failed to initialize MCP service';
+                Logger.error('MCP initialization failed', {
+                    error: errorMsg,
+                    stack: error instanceof Error ? error.stack : undefined,
+                });
+                setInitializationError(errorMsg);
             }
             finally {
                 setIsLoading(false);
@@ -111,23 +58,93 @@ export default function App({ name }) {
         };
         initializeMCP();
     }, []);
-    useInput((input, key) => {
-        if (key.ctrl && input === 'c') {
+    // Handle keyboard shortcuts
+    useInput((inputChar, key) => {
+        if (key.ctrl && inputChar === 'c') {
             process.exit(0);
         }
-        if (key.ctrl && input === 'd') {
+        if (key.ctrl && inputChar === 'd') {
             process.exit(0);
         }
     });
+    // History navigation callbacks
+    const handleHistoryUp = useCallback(() => {
+        Logger.debug('History up requested', {
+            historyIndex,
+            historyLength: inputHistory.length,
+        });
+        if (inputHistory.length === 0)
+            return;
+        // If we're at the bottom of history, save current input
+        if (historyIndex === -1) {
+            setTempInput(input);
+        }
+        // Move up in history
+        const newIndex = Math.min(historyIndex + 1, inputHistory.length - 1);
+        if (newIndex !== historyIndex) {
+            setHistoryIndex(newIndex);
+            const historyItem = inputHistory[inputHistory.length - 1 - newIndex];
+            if (historyItem !== undefined) {
+                setInput(historyItem);
+            }
+        }
+    }, [
+        historyIndex,
+        inputHistory,
+        input,
+        setInput,
+        setHistoryIndex,
+        setTempInput,
+    ]);
+    const handleHistoryDown = useCallback(() => {
+        Logger.debug('History down requested', {
+            historyIndex,
+            historyLength: inputHistory.length,
+        });
+        if (historyIndex === -1)
+            return;
+        // Move down in history
+        const newIndex = historyIndex - 1;
+        if (newIndex === -1) {
+            // Back to current input
+            setHistoryIndex(-1);
+            setInput(tempInput);
+        }
+        else {
+            setHistoryIndex(newIndex);
+            const historyItem = inputHistory[inputHistory.length - 1 - newIndex];
+            if (historyItem !== undefined) {
+                setInput(historyItem);
+            }
+        }
+    }, [historyIndex, inputHistory, tempInput, setInput, setHistoryIndex]);
+    // Handle submit of commands
     const handleSubmit = async (userInput) => {
         if (!userInput.trim())
             return;
+        // Add input to history (avoid duplicates and empty strings)
+        const trimmedInput = userInput.trim();
+        if (trimmedInput &&
+            (inputHistory.length === 0 ||
+                inputHistory[inputHistory.length - 1] !== trimmedInput)) {
+            setInputHistory(prev => [...prev, trimmedInput]);
+        }
+        // Reset history navigation
+        setHistoryIndex(-1);
+        setTempInput('');
+        Logger.debug('User input received', {
+            input: trimmedInput,
+            isWaitingForApiKey,
+            isWaitingForServerConfig,
+            historyLength: inputHistory.length + 1,
+        });
         // Check if we're waiting for server configuration input
         if (isWaitingForServerConfig) {
+            Logger.debug('Processing server config input', { step: serverConfigStep });
             const userMessage = {
                 id: Date.now().toString(),
                 role: 'user',
-                content: userInput.trim(),
+                content: trimmedInput,
                 timestamp: new Date(),
             };
             setMessages(prev => [...prev, userMessage]);
@@ -135,35 +152,46 @@ export default function App({ name }) {
             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());
+                const stream = cliService.sendMessage(trimmedInput, false, '', '', true, serverConfigStep, currentServerConfig);
+                for await (const result of stream) {
+                    Logger.debug('Server config result received', { result });
+                    if (result.commandResult) {
+                        // 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?.reinitializeAgent) {
+                                await cliService.initializeAgent();
+                                setConnectedServers([...cliService.getConnectedServers()]);
+                            }
+                        }
+                        const commandMessage = {
+                            id: (Date.now() + 1).toString(),
+                            role: 'command',
+                            content: result.response || '',
+                            commandResult: result.commandResult,
+                            timestamp: new Date(),
+                        };
+                        setMessages(prev => [...prev, commandMessage]);
+                    }
+                    if (result.done) {
+                        setIsLoading(false);
                     }
                 }
-                setIsLoading(false);
             }
             catch (error) {
+                Logger.error('Server config error', {
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                    stack: error instanceof Error ? error.stack : undefined,
+                });
                 const errorMessage = {
                     id: (Date.now() + 1).toString(),
                     role: 'assistant',
@@ -181,7 +209,11 @@ export default function App({ name }) {
         }
         // Check if we're waiting for an API key
         if (isWaitingForApiKey) {
-            const maskedInput = userInput.replace(/./g, '*');
+            Logger.debug('Processing API key input', {
+                provider: pendingProvider,
+                model: pendingModel,
+            });
+            const maskedInput = trimmedInput.replace(/./g, '*');
             const userMessage = {
                 id: Date.now().toString(),
                 role: 'user',
@@ -192,28 +224,39 @@ export default function App({ name }) {
             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());
+                const stream = cliService.sendMessage(trimmedInput.trim(), true, pendingProvider, pendingModel);
+                for await (const result of stream) {
+                    Logger.debug('API key result received', {
+                        success: !!result.commandResult?.data?.llmConfig,
+                    });
+                    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(cliService.getCurrentModel());
+                        }
+                        // Reset API key input state
+                        setIsWaitingForApiKey(false);
+                        setPendingProvider('');
+                        setPendingModel('');
+                    }
+                    if (result.done) {
+                        setIsLoading(false);
                     }
-                    // Reset API key input state
-                    setIsWaitingForApiKey(false);
-                    setPendingProvider('');
-                    setPendingModel('');
                 }
-                setIsLoading(false);
             }
             catch (error) {
+                Logger.error('API key error', {
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                    stack: error instanceof Error ? error.stack : undefined,
+                });
                 const errorMessage = {
                     id: (Date.now() + 1).toString(),
                     role: 'assistant',
@@ -229,61 +272,107 @@ export default function App({ name }) {
             }
             return;
         }
+        Logger.debug('Processing regular message');
         const userMessage = {
             id: Date.now().toString(),
             role: 'user',
-            content: userInput.trim(),
+            content: trimmedInput,
             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);
+            const stream = cliService.sendMessage(trimmedInput);
+            let assistantMessageId = null;
+            for await (const chunk of stream) {
+                Logger.debug('Message chunk received', {
+                    isCommand: chunk.isCommand,
+                    hasContent: !!chunk.response,
+                    toolCallsCount: chunk.toolCalls?.length || 0,
+                });
+                if (chunk.isCommand && chunk.commandResult) {
+                    // Check if we need to prompt for API key
+                    if (chunk.commandResult.data?.reinitializeAgent) {
+                        await cliService.initializeAgent();
+                        setConnectedServers([...cliService.getConnectedServers()]);
+                    }
+                    // Check if we need to prompt for API key
+                    if (chunk.commandResult.type === 'prompt_key' &&
+                        chunk.commandResult.data) {
+                        setIsWaitingForApiKey(true);
+                        setPendingProvider(chunk.commandResult.data.provider);
+                        setPendingModel(chunk.commandResult.data.model);
+                    }
+                    else if (chunk.commandResult.type === 'prompt_server_config' &&
+                        chunk.commandResult.data) {
+                        setIsWaitingForServerConfig(true);
+                        setServerConfigStep(chunk.commandResult.data.step);
+                        setCurrentServerConfig(chunk.commandResult.data.config || null);
+                    }
+                    else if (chunk.commandResult.data?.hasOwnProperty('llmConfig')) {
+                        // Update current model if it changed (including null for clearkeys)
+                        setCurrentModel(cliService.getCurrentModel());
+                    }
+                    const commandMessage = {
+                        id: (Date.now() + 1).toString(),
+                        role: 'command',
+                        content: chunk.response || '',
+                        commandResult: chunk.commandResult,
+                        timestamp: new Date(),
+                    };
+                    setMessages(prev => [...prev, commandMessage]);
                 }
-                else if (result.commandResult.data?.serverConnected || result.commandResult.data?.serverDisconnected) {
-                    // Update connected servers if servers were connected or disconnected
-                    setConnectedServers(mcpService.getConnectedServers());
+                else {
+                    // Handle streaming agent response
+                    if (chunk.toolCalls && chunk.toolCalls.length > 0) {
+                        setMessages(prev => [...prev, ...chunk.toolCalls]);
+                    }
+                    if (chunk.thought) {
+                        const thoughtMessage = {
+                            id: (Date.now() + Math.random()).toString(),
+                            role: 'thought',
+                            content: chunk.thought,
+                            timestamp: new Date(),
+                        };
+                        setMessages(prev => [...prev, thoughtMessage]);
+                    }
+                    if (chunk.response) {
+                        if (assistantMessageId === null) {
+                            // First chunk of an assistant message
+                            const assistantMessage = {
+                                id: (Date.now() + 1).toString(),
+                                role: 'assistant',
+                                content: chunk.response,
+                                timestamp: new Date(),
+                            };
+                            assistantMessageId = assistantMessage.id;
+                            setMessages(prev => [...prev, assistantMessage]);
+                        }
+                        else {
+                            // Subsequent chunks: find and update the message
+                            setMessages(prev => prev.map(msg => {
+                                if (msg.id === assistantMessageId && msg.role === 'assistant') {
+                                    return {
+                                        ...msg,
+                                        content: msg.content + chunk.response,
+                                    };
+                                }
+                                return msg;
+                            }));
+                        }
+                    }
                 }
-                else if (result.commandResult.data?.hasOwnProperty('llmConfig')) {
-                    // Update current model if it changed (including null for clearkeys)
-                    setCurrentModel(mcpService.getCurrentModel());
+                if (chunk.done) {
+                    setIsLoading(false);
                 }
             }
-            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) {
+            Logger.error('Message processing error', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                stack: error instanceof Error ? error.stack : undefined,
+            });
             const errorMessage = {
                 id: (Date.now() + 1).toString(),
                 role: 'assistant',
@@ -298,23 +387,24 @@ export default function App({ name }) {
         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: "blue" }, "mcp use"),
                     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')))),
+                        "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(AsciiLogo, null),
                 React.createElement(Text, { color: "gray" }, "Welcome to MCP-Use CLI!"),
                 currentModel.includes('No') ? (React.createElement(Box, { flexDirection: "column" },
                     React.createElement(Text, { color: "yellow" },
@@ -327,17 +417,32 @@ export default function App({ name }) {
                     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 })),
+            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...`
+                    React.createElement(Text, { color: "blue" },
+                        React.createElement(Spinner, { type: "mcpuse" })))))),
+        showInput && !initializationError && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Box, { borderStyle: "round", borderColor: isWaitingForApiKey
+                    ? 'yellow'
                     : isWaitingForServerConfig
-                        ? "Enter server configuration..."
-                        : "Type your message...", mask: isWaitingForApiKey ? "*" : undefined })))));
+                        ? 'blue'
+                        : 'gray', minHeight: 3 },
+                React.createElement(Box, { flexDirection: "row", width: "100%" },
+                    React.createElement(Box, { marginRight: 1, alignSelf: "flex-start", flexShrink: 0 },
+                        React.createElement(Text, { color: isWaitingForApiKey
+                                ? 'yellow'
+                                : isWaitingForServerConfig
+                                    ? 'blue'
+                                    : 'green', bold: true }, isWaitingForApiKey
+                            ? '🔑'
+                            : isWaitingForServerConfig
+                                ? '🔧'
+                                : '❯')),
+                    React.createElement(InputPrompt, { value: input, onChange: setInput, onSubmit: handleSubmit, onHistoryUp: handleHistoryUp, onHistoryDown: handleHistoryDown, placeholder: isWaitingForApiKey
+                            ? `Enter ${pendingProvider.toUpperCase()} API key...`
+                            : isWaitingForServerConfig
+                                ? 'Enter server configuration...'
+                                : 'Type your message...', mask: isWaitingForApiKey ? '*' : undefined }))))),
+        React.createElement(Footer, { servers: connectedServers, modelSlug: currentModel })));
 }

package/dist/cli.js

@@ -3,7 +3,7 @@ import React from 'react';
 import { render } from 'ink';
 import meow from 'meow';
 import App from './app.js';
-const cli = meow(`
+meow(`
 	Usage
 	  $ mcp-use-cli
 
@@ -26,12 +26,9 @@ const cli = meow(`
 `, {
     importMeta: import.meta,
     flags: {
-        name: {
-            type: 'string',
-        },
         config: {
             type: 'string',
         },
     },
 });
-render(React.createElement(App, { name: cli.flags.name }));
+render(React.createElement(App, null));