protoagent 0.0.1

package/dist/config/commands.js

@@ -0,0 +1,208 @@
+/**
+ * Configuration management commands for ProtoAgent CLI
+ */
+import inquirer from 'inquirer';
+import { hasConfig, loadConfig, saveConfig, getConfigDirectory } from './manager.js';
+import { setupConfig } from './setup.js';
+import { openaiProvider, geminiProvider, cerebrasProvider } from './providers.js';
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Mask API key for display (show first 8 and last 4 characters)
+ */
+function maskApiKey(apiKey) {
+    if (apiKey.length <= 12) {
+        return '*'.repeat(apiKey.length);
+    }
+    const start = apiKey.substring(0, 8);
+    const end = apiKey.substring(apiKey.length - 4);
+    const middle = '*'.repeat(apiKey.length - 12);
+    return `${start}${middle}${end}`;
+}
+/**
+ * Show current configuration (without exposing sensitive data)
+ */
+export async function showCurrentConfig() {
+    try {
+        const configExists = await hasConfig();
+        if (!configExists) {
+            console.log('❌ No configuration found. Run ProtoAgent to set up.');
+            return;
+        }
+        const config = await loadConfig();
+        const configDir = getConfigDirectory();
+        console.log('\n📋 Current ProtoAgent Configuration:');
+        console.log('─'.repeat(40));
+        console.log(`Provider: ${config.provider}`);
+        console.log(`Model: ${config.model}`);
+        // Show the appropriate API key based on provider
+        if (config.provider === 'openai' && config.credentials.OPENAI_API_KEY) {
+            console.log(`API Key: ${maskApiKey(config.credentials.OPENAI_API_KEY)}`);
+        }
+        else if (config.provider === 'gemini' && config.credentials.GEMINI_API_KEY) {
+            console.log(`API Key: ${maskApiKey(config.credentials.GEMINI_API_KEY)}`);
+        }
+        else if (config.provider === 'cerebras' && config.credentials.CEREBRAS_API_KEY) {
+            console.log(`API Key: ${maskApiKey(config.credentials.CEREBRAS_API_KEY)}`);
+        }
+        console.log(`Config Location: ${configDir}/config.json`);
+        console.log('─'.repeat(40));
+    }
+    catch (error) {
+        console.error(`❌ Error reading configuration: ${error.message}`);
+    }
+}
+/**
+ * Update API key
+ */
+export async function updateApiKey() {
+    try {
+        const configExists = await hasConfig();
+        if (!configExists) {
+            console.log('❌ No configuration found. Run ProtoAgent to set up first.');
+            return;
+        }
+        const config = await loadConfig();
+        console.log(`\n🔑 Update ${config.provider.toUpperCase()} API Key`);
+        // Show current API key based on provider
+        let currentKey = '';
+        let helpUrl = '';
+        let keyPrefix = '';
+        if (config.provider === 'openai') {
+            currentKey = config.credentials.OPENAI_API_KEY || '';
+            helpUrl = 'https://platform.openai.com/api-keys';
+            keyPrefix = 'sk-';
+        }
+        else if (config.provider === 'gemini') {
+            currentKey = config.credentials.GEMINI_API_KEY || '';
+            helpUrl = 'https://aistudio.google.com/app/apikey';
+            keyPrefix = '';
+        }
+        else if (config.provider === 'cerebras') {
+            currentKey = config.credentials.CEREBRAS_API_KEY || '';
+            helpUrl = 'https://cloud.cerebras.ai/platform';
+            keyPrefix = '';
+        }
+        console.log(`Current API Key: ${maskApiKey(currentKey)}`);
+        console.log(`Get your API key from: ${helpUrl}\n`);
+        const { newApiKey } = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'newApiKey',
+                message: `Enter your new ${config.provider.toUpperCase()} API key:`,
+                mask: '*',
+                validate: (input) => {
+                    if (!input || input.trim().length === 0) {
+                        return 'API key is required';
+                    }
+                    if (keyPrefix && !input.trim().startsWith(keyPrefix)) {
+                        return `${config.provider.toUpperCase()} API keys should start with "${keyPrefix}"`;
+                    }
+                    return true;
+                }
+            }
+        ]);
+        // Update configuration based on provider
+        if (config.provider === 'openai') {
+            config.credentials.OPENAI_API_KEY = newApiKey.trim();
+        }
+        else if (config.provider === 'gemini') {
+            config.credentials.GEMINI_API_KEY = newApiKey.trim();
+        }
+        else if (config.provider === 'cerebras') {
+            config.credentials.CEREBRAS_API_KEY = newApiKey.trim();
+        }
+        await saveConfig(config);
+        console.log('\n✅ API key updated successfully!');
+        console.log(`New API Key: ${maskApiKey(newApiKey)}`);
+    }
+    catch (error) {
+        console.error(`❌ Error updating API key: ${error.message}`);
+    }
+}
+/**
+ * Update model
+ */
+export async function updateModel() {
+    try {
+        const configExists = await hasConfig();
+        if (!configExists) {
+            console.log('❌ No configuration found. Run ProtoAgent to set up first.');
+            return;
+        }
+        const config = await loadConfig();
+        console.log(`\n🤖 Update ${config.provider.toUpperCase()} Model`);
+        console.log(`Current Model: ${config.model}\n`);
+        // Get available models based on provider
+        let availableModels = [];
+        if (config.provider === 'openai') {
+            availableModels = openaiProvider.models;
+        }
+        else if (config.provider === 'gemini') {
+            availableModels = geminiProvider.models;
+        }
+        else if (config.provider === 'cerebras') {
+            availableModels = cerebrasProvider.models;
+        }
+        const { newModel } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'newModel',
+                message: `Select a new ${config.provider.toUpperCase()} model:`,
+                choices: availableModels.map(model => ({
+                    name: model === config.model ? `${model} (current)` : model,
+                    value: model
+                })),
+                default: config.model
+            }
+        ]);
+        if (newModel === config.model) {
+            console.log('✨ No change needed - same model selected.');
+            return;
+        }
+        // Update configuration
+        const previousModel = config.model;
+        config.model = newModel;
+        await saveConfig(config);
+        console.log('\n✅ Model updated successfully!');
+        console.log(`Previous Model: ${previousModel}`);
+        console.log(`New Model: ${newModel}`);
+    }
+    catch (error) {
+        console.error(`❌ Error updating model: ${error.message}`);
+    }
+}
+/**
+ * Reset configuration (full reconfiguration)
+ */
+export async function resetConfiguration() {
+    try {
+        const configExists = await hasConfig();
+        if (configExists) {
+            console.log('\n⚠️  Reset Configuration');
+            console.log('This will delete your current configuration and set up ProtoAgent from scratch.');
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Are you sure you want to reset your configuration?',
+                    default: false
+                }
+            ]);
+            if (!confirm) {
+                console.log('Configuration reset cancelled.');
+                return;
+            }
+            // Delete existing configuration
+            const configPath = path.join(getConfigDirectory(), 'config.json');
+            await fs.unlink(configPath);
+            console.log('✅ Existing configuration deleted.');
+        }
+        // Run setup again
+        console.log('\n🔄 Starting fresh configuration setup...');
+        await setupConfig();
+    }
+    catch (error) {
+        console.error(`❌ Error resetting configuration: ${error.message}`);
+    }
+}

package/dist/config/manager.js

@@ -0,0 +1,117 @@
+/**
+ * Configuration manager for ProtoAgent
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { geminiProvider, openaiProvider, cerebrasProvider } from './providers.js';
+/**
+ * Get the config directory path
+ */
+function getConfigDir() {
+    const homeDir = os.homedir();
+    // Use XDG Base Directory specification on Unix-like systems
+    if (process.platform === 'win32') {
+        return path.join(homeDir, 'AppData', 'Local', 'protoagent');
+    }
+    else {
+        return path.join(homeDir, '.local', 'share', 'protoagent');
+    }
+}
+/**
+ * Get the config file path
+ */
+function getConfigPath() {
+    return path.join(getConfigDir(), 'config.json');
+}
+/**
+ * Ensure config directory exists
+ */
+async function ensureConfigDir() {
+    const configDir = getConfigDir();
+    try {
+        await fs.access(configDir);
+    }
+    catch {
+        await fs.mkdir(configDir, { recursive: true });
+    }
+}
+/**
+ * Check if configuration exists
+ */
+export async function hasConfig() {
+    try {
+        await fs.access(getConfigPath());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Load user configuration
+ */
+export async function loadConfig() {
+    try {
+        const configPath = getConfigPath();
+        const configData = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(configData);
+    }
+    catch (error) {
+        throw new Error(`Failed to load configuration: ${error.message}`);
+    }
+}
+/**
+ * Save user configuration
+ */
+export async function saveConfig(config) {
+    try {
+        await ensureConfigDir();
+        const configPath = getConfigPath();
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+    }
+    catch (error) {
+        throw new Error(`Failed to save configuration: ${error.message}`);
+    }
+}
+/**
+ * Validate configuration
+ */
+export function validateConfig(config) {
+    if (!config || typeof config !== 'object') {
+        return false;
+    }
+    const { provider, model, credentials } = config;
+    if (!model || !credentials || !(credentials.OPENAI_API_KEY || credentials.GEMINI_API_KEY || credentials.CEREBRAS_API_KEY)) {
+        return false;
+    }
+    if (provider === 'gemini') {
+        // Check if model is available for Gemini
+        if (!geminiProvider.models.includes(model)) {
+            return false;
+        }
+        // Additional model validation for Gemini can be added here
+        return true;
+    }
+    if (provider === 'openai') {
+        // Check if model is available for OpenAI
+        if (!openaiProvider.models.includes(model)) {
+            return false;
+        }
+        return true;
+    }
+    if (provider === 'cerebras') {
+        // Check if model is available for Cerebras
+        if (!cerebrasProvider.models.includes(model)) {
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Get configuration directory path for display
+ */
+export function getConfigDirectory() {
+    return getConfigDir();
+}

package/dist/config/mcp-commands.js

@@ -0,0 +1,266 @@
+/**
+ * MCP management commands for ProtoAgent CLI
+ */
+import inquirer from 'inquirer';
+import { MCPManager } from './mcp-manager.js';
+const mcpManager = new MCPManager();
+/**
+ * Show current MCP configuration and status
+ */
+export async function showMCPStatus() {
+    try {
+        await mcpManager.loadConfig();
+        console.log('\n🔌 MCP Configuration & Status:');
+        console.log('─'.repeat(50));
+        const servers = mcpManager.listServers();
+        const connectionStatus = mcpManager.getConnectionStatus();
+        if (Object.keys(servers).length === 0) {
+            console.log('No MCP servers configured');
+            return;
+        }
+        for (const [name, config] of Object.entries(servers)) {
+            const status = connectionStatus[name];
+            const statusIcon = status === true ? '🟢' : status === false ? '🔴' : '⚪';
+            const typeLabel = config.isBuiltIn ? '(built-in)' : '(custom)';
+            console.log(`${statusIcon} ${name} ${typeLabel}`);
+            console.log(`   Description: ${config.description}`);
+            console.log(`   Command: ${config.command} ${(config.args || []).join(' ')}`);
+            console.log(`   Enabled: ${config.enabled ? 'Yes' : 'No'}`);
+            console.log('');
+        }
+        // Show available tools if connected
+        const tools = await mcpManager.getAllTools();
+        if (tools.length > 0) {
+            console.log('🛠️  Available Tools:');
+            for (const tool of tools) {
+                console.log(`   • ${tool.server}:${tool.name} - ${tool.description || 'No description'}`);
+            }
+        }
+        console.log('─'.repeat(50));
+    }
+    catch (error) {
+        console.error(`❌ Error showing MCP status: ${error.message}`);
+    }
+}
+/**
+ * Connect to MCP servers
+ */
+export async function connectMCPServers() {
+    try {
+        await mcpManager.loadConfig();
+        await mcpManager.connectToAllServers();
+    }
+    catch (error) {
+        console.error(`❌ Error connecting to MCP servers: ${error.message}`);
+    }
+}
+/**
+ * Add a custom MCP server
+ */
+export async function addCustomMCPServer() {
+    try {
+        console.log('\n🔧 Add Custom MCP Server');
+        console.log('Configure a new MCP server for ProtoAgent\n');
+        const serverConfig = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Server name (unique identifier):',
+                validate: (input) => {
+                    if (!input || input.trim().length === 0) {
+                        return 'Server name is required';
+                    }
+                    if (!/^[a-zA-Z0-9\-_]+$/.test(input.trim())) {
+                        return 'Server name can only contain letters, numbers, hyphens, and underscores';
+                    }
+                    return true;
+                }
+            },
+            {
+                type: 'input',
+                name: 'description',
+                message: 'Description:',
+                validate: (input) => input.trim().length > 0 ? true : 'Description is required'
+            },
+            {
+                type: 'input',
+                name: 'command',
+                message: 'Command to run the server:',
+                validate: (input) => input.trim().length > 0 ? true : 'Command is required'
+            },
+            {
+                type: 'input',
+                name: 'args',
+                message: 'Arguments (space-separated, optional):',
+                default: ''
+            },
+            {
+                type: 'confirm',
+                name: 'enabled',
+                message: 'Enable this server?',
+                default: true
+            }
+        ]);
+        const newServer = {
+            name: serverConfig.name.trim(),
+            description: serverConfig.description.trim(),
+            command: serverConfig.command.trim(),
+            args: serverConfig.args.trim() ? serverConfig.args.trim().split(' ') : [],
+            enabled: serverConfig.enabled,
+            isBuiltIn: false
+        };
+        await mcpManager.loadConfig();
+        await mcpManager.addCustomServer(newServer);
+        console.log(`\n✅ Custom MCP server '${newServer.name}' added successfully!`);
+        if (newServer.enabled) {
+            const { connectNow } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'connectNow',
+                    message: 'Connect to this server now?',
+                    default: true
+                }
+            ]);
+            if (connectNow) {
+                const connection = await mcpManager.connectToServer(newServer.name);
+                if (connection) {
+                    console.log(`🎉 Successfully connected to ${newServer.name}!`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error adding custom MCP server: ${error.message}`);
+    }
+}
+/**
+ * Remove a custom MCP server
+ */
+export async function removeCustomMCPServer() {
+    try {
+        await mcpManager.loadConfig();
+        const servers = mcpManager.listServers();
+        const customServers = Object.entries(servers).filter(([_, config]) => !config.isBuiltIn);
+        if (customServers.length === 0) {
+            console.log('📭 No custom MCP servers configured');
+            return;
+        }
+        const { serverToRemove } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'serverToRemove',
+                message: 'Select server to remove:',
+                choices: customServers.map(([name, config]) => ({
+                    name: `${name} - ${config.description}`,
+                    value: name
+                }))
+            }
+        ]);
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Are you sure you want to remove '${serverToRemove}'?`,
+                default: false
+            }
+        ]);
+        if (confirm) {
+            await mcpManager.removeCustomServer(serverToRemove);
+            console.log(`✅ Custom MCP server '${serverToRemove}' removed successfully!`);
+        }
+        else {
+            console.log('Operation cancelled.');
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error removing custom MCP server: ${error.message}`);
+    }
+}
+/**
+ * Toggle MCP server enabled/disabled status
+ */
+export async function toggleMCPServer() {
+    try {
+        await mcpManager.loadConfig();
+        const servers = mcpManager.listServers();
+        if (Object.keys(servers).length === 0) {
+            console.log('📭 No MCP servers configured');
+            return;
+        }
+        const { serverToToggle } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'serverToToggle',
+                message: 'Select server to enable/disable:',
+                choices: Object.entries(servers).map(([name, config]) => ({
+                    name: `${name} - ${config.enabled ? '🟢 Enabled' : '🔴 Disabled'} - ${config.description}`,
+                    value: name
+                }))
+            }
+        ]);
+        const currentConfig = servers[serverToToggle];
+        const newStatus = !currentConfig.enabled;
+        // Update the configuration
+        await mcpManager.loadConfig();
+        const updatedServers = mcpManager.listServers();
+        updatedServers[serverToToggle].enabled = newStatus;
+        // Save the updated configuration
+        const updatedConfig = {
+            servers: updatedServers,
+            globalTimeout: 30000,
+            maxConcurrentConnections: 5,
+            retryAttempts: 3
+        };
+        const mcpManagerForSave = new MCPManager(updatedConfig);
+        await mcpManagerForSave.saveConfig();
+        console.log(`✅ Server '${serverToToggle}' ${newStatus ? 'enabled' : 'disabled'}`);
+    }
+    catch (error) {
+        console.error(`❌ Error toggling MCP server: ${error.message}`);
+    }
+}
+/**
+ * Test connection to a specific MCP server
+ */
+export async function testMCPServer() {
+    try {
+        await mcpManager.loadConfig();
+        const servers = mcpManager.listServers();
+        const enabledServers = Object.entries(servers).filter(([_, config]) => config.enabled);
+        if (enabledServers.length === 0) {
+            console.log('📭 No enabled MCP servers to test');
+            return;
+        }
+        const { serverToTest } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'serverToTest',
+                message: 'Select server to test:',
+                choices: enabledServers.map(([name, config]) => ({
+                    name: `${name} - ${config.description}`,
+                    value: name
+                }))
+            }
+        ]);
+        console.log(`🧪 Testing connection to ${serverToTest}...`);
+        const connection = await mcpManager.connectToServer(serverToTest);
+        if (connection) {
+            console.log(`✅ Successfully connected to ${serverToTest}!`);
+            console.log(`🛠️  Available tools: ${connection.capabilities.join(', ')}`);
+            // Clean up test connection
+            await mcpManager.disconnectServer(serverToTest);
+        }
+        else {
+            console.log(`❌ Failed to connect to ${serverToTest}`);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error testing MCP server: ${error.message}`);
+    }
+}
+/**
+ * Get the MCP manager instance (for use in main application)
+ */
+export function getMCPManager() {
+    return mcpManager;
+}