pokt-cli 1.0.0

package/dist/chat/loop.js

@@ -0,0 +1,162 @@
+import prompts from 'prompts';
+import ora from 'ora';
+import { ui } from '../ui.js';
+import { config } from '../config.js';
+import { getClient } from './client.js';
+import { tools, executeTool } from './tools.js';
+import { connectMcpServer, getAllMcpToolsOpenAI, callMcpTool, isMcpTool, disconnectAllMcp, } from '../mcp/client.js';
+const SYSTEM_PROMPT = `You are Pokt CLI, an elite AI Software Engineer.
+Your goal is to help the user build, fix, and maintain software projects with high quality.
+
+CORE CAPABILITIES:
+1.  **Project Understanding**: You can see the whole file structure and read any file.
+2.  **Autonomous Coding**: You can create new files, rewrite existing ones, and run terminal commands.
+3.  **Problem Solving**: You analyze errors and propose/apply fixes.
+
+GUIDELINES:
+- You will receive the user request first, then the current project structure. Use the project structure to understand the context before creating or editing anything.
+- When asked to fix something, first **read** the relevant files to understand the context.
+- When creating a project, start by planning the structure, then use \`write_file\` to create files.
+- **DO NOT repeat the generated code in your chat response** if you have already used the \`write_file\` tool. Simply state that the file has been updated or created.
+- You have full access to the current terminal. You can run \`npm install\`, \`tsc\`, or any other command.
+- Be extremely concise in your explanations.
+- The current working directory is: ${process.cwd()}
+`;
+async function loadProjectStructure() {
+    try {
+        const timeoutMs = 8000;
+        return await Promise.race([
+            executeTool('list_files', JSON.stringify({ path: '.' })),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), timeoutMs))
+        ]);
+    }
+    catch {
+        try {
+            return await executeTool('list_directory', JSON.stringify({ path: '.' }));
+        }
+        catch {
+            return 'Could not list files.';
+        }
+    }
+}
+export async function startChatLoop(modelConfig) {
+    const client = await getClient(modelConfig);
+    // Conectar servidores MCP configurados e montar lista de tools (nativas + MCP)
+    const mcpServers = config.get('mcpServers') ?? [];
+    for (const server of mcpServers) {
+        const session = await connectMcpServer(server);
+        if (session) {
+            console.log(ui.dim(`[MCP] Connected: ${session.serverName} (${session.tools.length} tools)`));
+        }
+    }
+    const allTools = [
+        ...tools,
+        ...getAllMcpToolsOpenAI(),
+    ];
+    const messages = [
+        { role: 'system', content: SYSTEM_PROMPT }
+    ];
+    while (true) {
+        console.log('');
+        console.log(ui.shortcutsLine('shift+tab to accept edits', '? for shortcuts'));
+        const response = await prompts({
+            type: 'text',
+            name: 'input',
+            message: '>',
+            initial: '',
+            style: 'default'
+        });
+        const userInput = response.input;
+        if (!userInput || userInput.toLowerCase() === 'exit' || userInput.trim().toLowerCase() === '/quit') {
+            await disconnectAllMcp();
+            console.log(ui.dim('Goodbye!'));
+            break;
+        }
+        messages.push({ role: 'user', content: userInput });
+        // Primeiro o modelo vê o pedido; depois carregamos a estrutura do projeto para ele entender e então criar/editar
+        const isFirstUserMessage = messages.filter(m => m.role === 'user').length === 1;
+        if (isFirstUserMessage) {
+            const loadSpinner = ora('Carregando estrutura do projeto...').start();
+            const projectStructure = await loadProjectStructure();
+            loadSpinner.stop();
+            messages.push({ role: 'system', content: `Current Project Structure:\n${projectStructure}` });
+        }
+        await processLLMResponse(client, modelConfig.id, messages, allTools);
+    }
+    await disconnectAllMcp();
+}
+const MAX_429_RETRIES = 3;
+const BASE_429_DELAY_MS = 5000;
+async function createCompletionWithRetry(client, modelId, messages, toolsList) {
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_429_RETRIES; attempt++) {
+        try {
+            return await client.chat.completions.create({
+                model: modelId,
+                messages,
+                tools: toolsList,
+                tool_choice: 'auto'
+            });
+        }
+        catch (err) {
+            lastError = err;
+            const is429 = err?.status === 429 || (err?.message && String(err.message).includes('429'));
+            if (is429 && attempt < MAX_429_RETRIES) {
+                const delayMs = BASE_429_DELAY_MS * (attempt + 1);
+                await new Promise(r => setTimeout(r, delayMs));
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw lastError;
+}
+async function processLLMResponse(client, modelId, messages, toolsList) {
+    const spinner = ora('Thinking...').start();
+    try {
+        let completion = await createCompletionWithRetry(client, modelId, messages, toolsList);
+        let message = completion.choices[0].message;
+        spinner.stop();
+        while (message.tool_calls && message.tool_calls.length > 0) {
+            messages.push(message);
+            for (const toolCall of message.tool_calls) {
+                const name = toolCall.function.name;
+                const args = toolCall.function.arguments ?? '{}';
+                console.log(ui.warn(`\n[Executing Tool: ${name}]`));
+                console.log(ui.dim(`Arguments: ${args}`));
+                const toolSpinner = ora('Running tool...').start();
+                const result = isMcpTool(name)
+                    ? await callMcpTool(name, args)
+                    : await executeTool(name, args);
+                toolSpinner.stop();
+                console.log(ui.dim(`Result: ${result.length} characters`));
+                messages.push({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: result,
+                });
+            }
+            spinner.start('Thinking...');
+            completion = await createCompletionWithRetry(client, modelId, messages, toolsList);
+            message = completion.choices[0].message;
+            spinner.stop();
+        }
+        if (message.content) {
+            console.log('\n' + ui.labelPokt());
+            console.log(message.content);
+            messages.push({ role: 'assistant', content: message.content });
+        }
+    }
+    catch (error) {
+        spinner.stop();
+        const is429 = error?.status === 429 || (error?.message && String(error.message).includes('429'));
+        if (is429) {
+            console.log(ui.error('\nLimite de taxa atingido (429). O provedor está recebendo muitas requisições.'));
+            console.log(ui.dim('Aguarde alguns segundos e tente novamente.'));
+        }
+        else {
+            console.log(ui.error(`\nError: ${error?.message ?? error}`));
+        }
+        messages.pop();
+    }
+}

package/dist/chat/tools.d.ts

@@ -0,0 +1,3 @@
+import type { ChatCompletionTool } from 'openai/resources/chat/completions/completions.js';
+export declare const tools: ChatCompletionTool[];
+export declare function executeTool(name: string, argsStr: string): Promise<string>;

package/dist/chat/tools.js

@@ -0,0 +1,215 @@
+import fs from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import chalk from 'chalk';
+import * as diff from 'diff';
+const execAsync = promisify(exec);
+/** Máximo de linhas de diff exibidas; além disso mostra resumo para não imprimir arquivo inteiro */
+const MAX_DIFF_LINES = 45;
+function showDiff(filePath, oldContent, newContent) {
+    const relativePath = path.relative(process.cwd(), filePath);
+    console.log(chalk.blue.bold(`\n📝 Edit ${relativePath}:`));
+    if (!oldContent) {
+        const lineCount = newContent.split('\n').length;
+        if (lineCount <= MAX_DIFF_LINES) {
+            newContent.split('\n').forEach((line, idx) => {
+                console.log(`${chalk.gray((idx + 1).toString().padStart(3))} ${chalk.green('+')} ${chalk.green(line)}`);
+            });
+        }
+        else {
+            newContent.split('\n').slice(0, MAX_DIFF_LINES).forEach((line, idx) => {
+                console.log(`${chalk.gray((idx + 1).toString().padStart(3))} ${chalk.green('+')} ${chalk.green(line)}`);
+            });
+            console.log(chalk.gray(`  ... (and ${lineCount - MAX_DIFF_LINES} more lines)`));
+        }
+        console.log('');
+        return;
+    }
+    const changes = diff.diffLines(oldContent, newContent);
+    const CONTEXT_LINES = 3;
+    let currentLine = 1;
+    let linesPrinted = 0;
+    for (let i = 0; i < changes.length && linesPrinted < MAX_DIFF_LINES; i++) {
+        const part = changes[i];
+        const lines = part.value.split('\n');
+        if (lines[lines.length - 1] === '')
+            lines.pop();
+        if (part.added || part.removed) {
+            // Show some context from previous part if it was unchanged
+            if (i > 0 && !changes[i - 1].added && !changes[i - 1].removed && linesPrinted < MAX_DIFF_LINES) {
+                const prevLines = changes[i - 1].value.split('\n');
+                if (prevLines[prevLines.length - 1] === '')
+                    prevLines.pop();
+                const contextToShow = prevLines.slice(-CONTEXT_LINES);
+                const startLine = currentLine - contextToShow.length;
+                contextToShow.forEach((l, idx) => {
+                    if (linesPrinted >= MAX_DIFF_LINES)
+                        return;
+                    console.log(`${chalk.gray((startLine + idx).toString().padStart(3))}   ${chalk.gray(l)}`);
+                    linesPrinted++;
+                });
+            }
+            // Show the actual change (só até MAX_DIFF_LINES)
+            for (const line of lines) {
+                if (linesPrinted >= MAX_DIFF_LINES)
+                    break;
+                const lineDisplay = part.added ? chalk.green(line) : chalk.red(line);
+                const symbolDisplay = part.added ? chalk.green('+') : chalk.red('-');
+                console.log(`${chalk.gray(currentLine.toString().padStart(3))} ${symbolDisplay} ${lineDisplay}`);
+                if (!part.removed)
+                    currentLine++;
+                linesPrinted++;
+            }
+            // Show some context from next part if it is unchanged
+            if (i < changes.length - 1 && !changes[i + 1].added && !changes[i + 1].removed && linesPrinted < MAX_DIFF_LINES) {
+                const nextLines = changes[i + 1].value.split('\n');
+                if (nextLines[nextLines.length - 1] === '')
+                    nextLines.pop();
+                const contextToShow = nextLines.slice(0, CONTEXT_LINES);
+                contextToShow.forEach((l, idx) => {
+                    if (linesPrinted >= MAX_DIFF_LINES)
+                        return;
+                    console.log(`${chalk.gray((currentLine + idx).toString().padStart(3))}   ${chalk.gray(l)}`);
+                    linesPrinted++;
+                });
+                if (linesPrinted < MAX_DIFF_LINES)
+                    console.log(chalk.gray('  ...'));
+                linesPrinted++;
+            }
+        }
+        else {
+            currentLine += lines.length;
+        }
+    }
+    if (linesPrinted >= MAX_DIFF_LINES) {
+        console.log(chalk.gray(`  ... (diff truncated, more changes in file)`));
+    }
+    console.log('');
+}
+export const tools = [
+    {
+        type: 'function',
+        function: {
+            name: 'read_file',
+            description: 'Reads the contents of a file.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'The path to the file' }
+                },
+                required: ['path']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'write_file',
+            description: 'Writes content to a file. Overwrites if exists, creates if not.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'The path to the file' },
+                    content: { type: 'string', description: 'The full content to write to the file' }
+                },
+                required: ['path', 'content']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'run_command',
+            description: 'Runs a shell command in the current directory.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'The shell command to run' }
+                },
+                required: ['command']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'list_directory',
+            description: 'Lists files and folders in a single directory.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Directory path to list' }
+                },
+                required: ['path']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'list_files',
+            description: 'Lists ALL files in the project recursively (ignores node_modules, .git, dist).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Root directory to start from (default ".")' }
+                }
+            }
+        }
+    }
+];
+export async function executeTool(name, argsStr) {
+    try {
+        const args = JSON.parse(argsStr);
+        if (name === 'read_file') {
+            return fs.readFileSync(path.resolve(process.cwd(), args.path), 'utf8');
+        }
+        if (name === 'write_file') {
+            const filePath = path.resolve(process.cwd(), args.path);
+            const oldContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.writeFileSync(filePath, args.content, 'utf8');
+            showDiff(filePath, oldContent, args.content);
+            return `Successfully wrote to ${args.path}`;
+        }
+        if (name === 'run_command') {
+            const { stdout, stderr } = await execAsync(args.command, { cwd: process.cwd() });
+            let out = '';
+            if (stdout)
+                out += `STDOUT:\n${stdout}\n`;
+            if (stderr)
+                out += `STDERR:\n${stderr}\n`;
+            return out || 'Command executed successfully with no output.';
+        }
+        if (name === 'list_directory') {
+            const dirPath = path.resolve(process.cwd(), args.path);
+            const items = fs.readdirSync(dirPath);
+            return items.join('\n');
+        }
+        if (name === 'list_files') {
+            const root = path.resolve(process.cwd(), args.path || '.');
+            const files = [];
+            const walk = (dir) => {
+                const items = fs.readdirSync(dir);
+                for (const item of items) {
+                    const fullPath = path.join(dir, item);
+                    if (item === 'node_modules' || item === '.git' || item === 'dist')
+                        continue;
+                    if (fs.statSync(fullPath).isDirectory()) {
+                        walk(fullPath);
+                    }
+                    else {
+                        files.push(path.relative(process.cwd(), fullPath));
+                    }
+                }
+            };
+            walk(root);
+            return files.join('\n') || 'No files found.';
+        }
+        return `Unknown tool: ${name}`;
+    }
+    catch (error) {
+        return `Error executing tool ${name}: ${error.message}`;
+    }
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const authCommand: CommandModule;

package/dist/commands/auth.js

@@ -0,0 +1,16 @@
+import { loginWithGoogle } from '../auth/google.js';
+export const authCommand = {
+    command: 'auth <action>',
+    describe: 'Manage authentication',
+    builder: (yargs) => yargs
+        .positional('action', {
+        describe: 'Action to perform',
+        type: 'string',
+        choices: ['login-google']
+    }),
+    handler: async (argv) => {
+        if (argv.action === 'login-google') {
+            await loginWithGoogle();
+        }
+    }
+};

package/dist/commands/chat.d.ts

@@ -0,0 +1,2 @@
+import type * as Yargs from 'yargs';
+export declare const chatCommand: Yargs.CommandModule;

package/dist/commands/chat.js

@@ -0,0 +1,41 @@
+import { config, getEffectiveActiveModel } from '../config.js';
+import { startChatLoop } from '../chat/loop.js';
+import { ui } from '../ui.js';
+export const chatCommand = {
+    command: 'chat',
+    describe: 'Start a Vibe Coding chat session',
+    handler: async (argv) => {
+        const fromMenu = argv?.fromMenu;
+        const activeModel = getEffectiveActiveModel();
+        if (!activeModel) {
+            console.log(ui.error('No active model selected. Run: pokt models list then pokt models use -p <provider> -i <id>'));
+            return;
+        }
+        if (activeModel.provider === 'openrouter' && !config.get('openrouterToken')) {
+            console.log(ui.error('OpenRouter token not set. Use: pokt config set-openrouter -v <token>'));
+            return;
+        }
+        if (activeModel.provider === 'gemini' && !config.get('geminiApiKey')) {
+            console.log(ui.error('Gemini API key not set. Use: pokt config set-gemini -v <key>'));
+            return;
+        }
+        if (activeModel.provider === 'controller') {
+            if (!config.get('poktToken')) {
+                console.log(ui.error('Pokt token not set. Generate one at the panel and: pokt config set-pokt-token -v <token>'));
+                return;
+            }
+        }
+        // Se veio do menu interativo, não repetir banner/tips (já foram exibidos)
+        if (!fromMenu) {
+            console.log(ui.banner());
+            console.log(ui.statusLine(`[${activeModel.provider}] ${activeModel.id}`));
+            console.log('');
+            console.log(ui.tips());
+            console.log('');
+        }
+        console.log(ui.dim('Type "exit" or /quit to end the session.'));
+        console.log(ui.statusBar({ model: `/model ${activeModel.provider} (${activeModel.id})` }));
+        console.log('');
+        await startChatLoop(activeModel);
+    }
+};

package/dist/commands/config.d.ts

@@ -0,0 +1,7 @@
+import type * as Yargs from 'yargs';
+interface ConfigArgs {
+    action?: string;
+    value?: string | string[];
+}
+export declare const configCommand: Yargs.CommandModule<{}, ConfigArgs>;
+export {};

package/dist/commands/config.js

@@ -0,0 +1,76 @@
+import { config, getControllerBaseUrl } from '../config.js';
+import chalk from 'chalk';
+import { ui } from '../ui.js';
+export const configCommand = {
+    command: 'config <action>',
+    describe: 'Configure Pokt CLI settings',
+    builder: (yargs) => yargs
+        .positional('action', {
+        describe: 'Action to perform',
+        type: 'string',
+        choices: ['set-openrouter', 'set-ollama', 'set-ollama-cloud', 'set-gemini', 'set-pokt-token', 'clear-openrouter', 'show']
+    })
+        .option('value', {
+        describe: 'The value to set',
+        type: 'string',
+        alias: 'v'
+    }),
+    handler: (argv) => {
+        const { action, value } = argv;
+        if (action === 'show') {
+            const openrouter = config.get('openrouterToken');
+            const gemini = config.get('geminiApiKey');
+            const ollama = config.get('ollamaBaseUrl');
+            const ollamaCloud = config.get('ollamaCloudApiKey');
+            const poktToken = config.get('poktToken');
+            console.log(chalk.blue('\nCurrent config (tokens masked):'));
+            console.log(ui.dim('  OpenRouter Token:'), openrouter ? openrouter.slice(0, 8) + '****' : '(not set)');
+            console.log(ui.dim('  Gemini API Key:'), gemini ? gemini.slice(0, 8) + '****' : '(not set)');
+            console.log(ui.dim('  Ollama Base URL (local):'), ollama || '(not set)');
+            console.log(ui.dim('  Ollama Cloud API Key:'), ollamaCloud ? ollamaCloud.slice(0, 8) + '****' : '(not set) — https://ollama.com/settings/keys');
+            console.log(ui.dim('  Controller URL:'), getControllerBaseUrl(), ui.dim('(já configurado)'));
+            console.log(ui.dim('  Pokt Token:'), poktToken ? poktToken.slice(0, 10) + '****' : '(not set) — use: pokt config set-pokt-token -v <token>');
+            console.log(ui.warn('\nTokens are stored in your user config directory. Do not share it.\n'));
+            return;
+        }
+        if (action === 'clear-openrouter') {
+            config.set('openrouterToken', '');
+            console.log(ui.success('OpenRouter token cleared.'));
+            return;
+        }
+        if (action !== 'set-openrouter' && action !== 'set-ollama' && action !== 'set-ollama-cloud' && action !== 'set-gemini' && action !== 'set-pokt-token')
+            return;
+        const raw = Array.isArray(value) ? value[0] : value;
+        const strValue = typeof raw === 'string' ? raw : (raw != null ? String(raw) : '');
+        if (strValue === '') {
+            console.log(ui.error('Error: --value is required. Use: pokt config ' + action + ' -v <value>'));
+            return;
+        }
+        if (action === 'set-openrouter') {
+            config.set('openrouterToken', strValue);
+            console.log(ui.success('OpenRouter token saved successfully.'));
+        }
+        else if (action === 'set-ollama') {
+            config.set('ollamaBaseUrl', strValue);
+            console.log(ui.success(`Ollama base URL set to: ${strValue}`));
+        }
+        else if (action === 'set-ollama-cloud') {
+            config.set('ollamaCloudApiKey', strValue);
+            console.log(ui.success('Ollama Cloud API key saved. Create keys at: https://ollama.com/settings/keys'));
+        }
+        else if (action === 'set-gemini') {
+            config.set('geminiApiKey', strValue);
+            console.log(ui.success('Gemini API key saved successfully.'));
+        }
+        else if (action === 'set-pokt-token') {
+            config.set('poktToken', strValue);
+            const controllerModel = { provider: 'controller', id: 'default' };
+            const models = config.get('registeredModels');
+            if (!models.some((m) => m.provider === 'controller' && m.id === 'default')) {
+                config.set('registeredModels', [controllerModel, ...models]);
+            }
+            config.set('activeModel', controllerModel);
+            console.log(ui.success('Pokt token salvo. Controller é seu provedor principal. Gere tokens em: https://pokt-cli-controller.vercel.app'));
+        }
+    }
+};

package/dist/commands/mcp.d.ts

@@ -0,0 +1,11 @@
+import type * as Yargs from 'yargs';
+interface McpArgs {
+    action?: string;
+    name?: string;
+    type?: string;
+    command?: string;
+    args?: string;
+    url?: string;
+}
+export declare const mcpCommand: Yargs.CommandModule<{}, McpArgs>;
+export {};

package/dist/commands/mcp.js

@@ -0,0 +1,127 @@
+import { config } from '../config.js';
+import { ui } from '../ui.js';
+import { connectMcpServer, getAllMcpToolsOpenAI, disconnectAllMcp } from '../mcp/client.js';
+export const mcpCommand = {
+    command: 'mcp [action]',
+    describe: 'Manage MCP (Model Context Protocol) servers',
+    builder: (yargs) => yargs
+        .positional('action', {
+        describe: 'Action: list, add, remove, test',
+        type: 'string',
+        choices: ['list', 'add', 'remove', 'test'],
+    })
+        .option('name', { describe: 'Server name (for add/remove)', type: 'string', alias: 'n' })
+        .option('type', { describe: 'Server type: stdio or http', type: 'string', choices: ['stdio', 'http'] })
+        .option('command', { describe: 'Command for stdio (e.g. npx)', type: 'string', alias: 'c' })
+        .option('args', { describe: 'JSON array of args for stdio (e.g. \'["-y","mcp-server"]\')', type: 'string', alias: 'a' })
+        .option('url', { describe: 'URL for http server', type: 'string', alias: 'u' }),
+    handler: async (argv) => {
+        const action = argv.action || 'list';
+        const servers = config.get('mcpServers') ?? [];
+        if (action === 'list') {
+            if (servers.length === 0) {
+                console.log(ui.dim('No MCP servers configured. Add one with: pokt mcp add -n <name> -t stdio -c npx -a \'["-y","mcp-server-name"]\''));
+                return;
+            }
+            console.log(ui.title('\nMCP Servers:\n'));
+            for (const s of servers) {
+                const typeInfo = s.type === 'stdio'
+                    ? `${s.command} ${(s.args ?? []).join(' ')}`
+                    : (s.url ?? '');
+                console.log(ui.dim(`  ${s.name}`), typeInfo);
+            }
+            console.log('');
+            return;
+        }
+        if (action === 'add') {
+            const name = argv.name;
+            const type = argv.type ?? 'stdio';
+            if (!name?.trim()) {
+                console.log(ui.error('--name is required. Example: pokt mcp add -n filesystem -t stdio -c npx -a \'["-y","@modelcontextprotocol/server-filesystem"]\''));
+                return;
+            }
+            if (servers.some(s => s.name === name)) {
+                console.log(ui.error(`Server "${name}" already exists. Use "pokt mcp remove -n ${name}" first.`));
+                return;
+            }
+            if (type === 'stdio') {
+                const command = argv.command;
+                if (!command?.trim()) {
+                    console.log(ui.error('For stdio, --command is required (e.g. npx).'));
+                    return;
+                }
+                let args = [];
+                if (argv.args) {
+                    try {
+                        args = JSON.parse(argv.args);
+                    }
+                    catch {
+                        console.log(ui.error('--args must be a JSON array, e.g. \'["-y","mcp-server"]\''));
+                        return;
+                    }
+                }
+                config.set('mcpServers', [...servers, { name, type: 'stdio', command, args }]);
+            }
+            else {
+                const url = argv.url;
+                if (!url?.trim()) {
+                    console.log(ui.error('For http, --url is required.'));
+                    return;
+                }
+                config.set('mcpServers', [...servers, { name, type: 'http', url }]);
+            }
+            console.log(ui.success(`MCP server "${name}" added. Use "pokt chat" to use its tools.`));
+            return;
+        }
+        if (action === 'remove') {
+            const name = argv.name;
+            if (!name?.trim()) {
+                console.log(ui.error('--name is required. Example: pokt mcp remove -n filesystem'));
+                return;
+            }
+            const next = servers.filter(s => s.name !== name);
+            if (next.length === servers.length) {
+                console.log(ui.warn(`No server named "${name}" found.`));
+                return;
+            }
+            config.set('mcpServers', next);
+            console.log(ui.success(`MCP server "${name}" removed.`));
+            return;
+        }
+        if (action === 'test') {
+            const name = argv.name;
+            const toTest = name ? servers.filter(s => s.name === name) : servers;
+            if (toTest.length === 0) {
+                console.log(ui.warn(name ? `No server named "${name}".` : 'No MCP servers configured.'));
+                return;
+            }
+            console.log(ui.dim('\nConnecting to MCP server(s)...\n'));
+            for (const server of toTest) {
+                if (server.type !== 'stdio') {
+                    console.log(ui.warn(`  ${server.name}: HTTP not yet supported in test.`));
+                    continue;
+                }
+                try {
+                    const session = await connectMcpServer(server);
+                    if (session) {
+                        const openaiTools = getAllMcpToolsOpenAI();
+                        const count = session.tools.length;
+                        console.log(ui.success(`  ${server.name}: OK (${count} tools)`));
+                        for (const t of session.tools) {
+                            console.log(ui.dim(`    - ${t.exposedName}`));
+                        }
+                    }
+                    else {
+                        console.log(ui.error(`  ${server.name}: Connection failed.`));
+                    }
+                }
+                catch (e) {
+                    console.log(ui.error(`  ${server.name}: ${e.message}`));
+                }
+            }
+            await disconnectAllMcp();
+            console.log('');
+            return;
+        }
+    },
+};