morpheus-cli 0.2.4 → 0.2.6

package/README.md

@@ -47,6 +47,9 @@ morpheus status
 # Stop the agent
 morpheus stop
 
+# Restart the agent
+morpheus restart
+
 # Diagnose issues
 morpheus doctor
 ```
@@ -93,17 +96,80 @@ Local React-based UI to manage recordings, chat history, and system status acros
 #### 🔒 UI Authentication
 To protect your Web UI, use the `THE_ARCHITECT_PASS` environment variable. This ensures only authorized users can access the dashboard and API.
 
+Additionally, you can use environment variables for API keys instead of storing them in the configuration file:
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| `OPENAI_API_KEY` | OpenAI API key (if using GPT) | No |
+| `ANTHROPIC_API_KEY` | Anthropic API key (if using Claude) | No |
+| `GOOGLE_API_KEY` | Google AI key (for Gemini and Audio) | Yes (for audio) |
+| `OPENROUTER_API_KEY` | OpenRouter API key (if using OpenRouter) | No |
+| `THE_ARCHITECT_PASS` | Web Dashboard access password | Recommended |
+| `TELEGRAM_BOT_TOKEN` | Telegram BotFather token | No |
+
+If these environment variables are set, they will take precedence over values stored in the configuration file.
+
+The system also supports generic environment variables that apply to all providers:
+
+| Variable | Description | Applies To |
+|----------|-------------|------------|
+| `MORPHEUS_AGENT_NAME` | Name of the agent | agent.name |
+| `MORPHEUS_AGENT_PERSONALITY` | Personality of the agent | agent.personality |
+| `MORPHEUS_LLM_PROVIDER` | LLM provider to use | llm.provider |
+| `MORPHEUS_LLM_MODEL` | Model name for LLM | llm.model |
+| `MORPHEUS_LLM_TEMPERATURE` | Temperature setting for LLM | llm.temperature |
+| `MORPHEUS_LLM_MAX_TOKENS` | Maximum tokens for LLM | llm.max_tokens |
+| `MORPHEUS_LLM_CONTEXT_WINDOW` | Context window size for LLM | llm.context_window |
+| `MORPHEUS_LLM_API_KEY` | Generic API key for LLM (lower precedence than provider-specific keys) | llm.api_key |
+| `MORPHEUS_SANTI_PROVIDER` | Sati provider to use | santi.provider |
+| `MORPHEUS_SANTI_MODEL` | Model name for Sati | santi.model |
+| `MORPHEUS_SANTI_TEMPERATURE` | Temperature setting for Sati | santi.temperature |
+| `MORPHEUS_SANTI_MAX_TOKENS` | Maximum tokens for Sati | santi.max_tokens |
+| `MORPHEUS_SANTI_CONTEXT_WINDOW` | Context window size for Sati | santi.context_window |
+| `MORPHEUS_SANTI_API_KEY` | Generic API key for Sati (lower precedence than provider-specific keys) | santi.api_key |
+| `MORPHEUS_SANTI_MEMORY_LIMIT` | Memory retrieval limit for Sati | santi.memory_limit |
+| `MORPHEUS_AUDIO_MODEL` | Model name for audio processing | audio.model |
+| `MORPHEUS_AUDIO_ENABLED` | Enable/disable audio processing | audio.enabled |
+| `MORPHEUS_AUDIO_API_KEY` | Generic API key for audio (lower precedence than provider-specific keys) | audio.apiKey |
+| `MORPHEUS_AUDIO_MAX_DURATION` | Max duration for audio processing | audio.maxDurationSeconds |
+| `MORPHEUS_TELEGRAM_ENABLED` | Enable/disable Telegram channel | channels.telegram.enabled |
+| `MORPHEUS_TELEGRAM_TOKEN` | Telegram bot token | channels.telegram.token |
+| `MORPHEUS_TELEGRAM_ALLOWED_USERS` | Comma-separated list of allowed Telegram user IDs | channels.telegram.allowedUsers |
+| `MORPHEUS_UI_ENABLED` | Enable/disable Web UI | ui.enabled |
+| `MORPHEUS_UI_PORT` | Port for Web UI | ui.port |
+| `MORPHEUS_LOGGING_ENABLED` | Enable/disable logging | logging.enabled |
+| `MORPHEUS_LOGGING_LEVEL` | Logging level | logging.level |
+| `MORPHEUS_LOGGING_RETENTION` | Log retention period | logging.retention |
+
+**Precedence Order**: The system follows this order of precedence when resolving configuration values:
+1. Provider-specific environment variable (e.g., `OPENAI_API_KEY`) - Highest priority
+2. Generic environment variable (e.g., `MORPHEUS_LLM_API_KEY`) - Medium priority
+3. Configuration file value (e.g., `config.llm.api_key`) - Lower priority
+4. Default value - Lowest priority
+
+> **Note**: If `THE_ARCHITECT_PASS` is not set, the system will use the default password `iamthearchitect`. This is less secure and it's recommended to set your own password in production environments.
+
 **Option 1: Using a `.env` file**
 Create a `.env` file in the root of your project:
 
 ```env
+OPENAI_API_KEY="your-openai-api-key"
+ANTHROPIC_API_KEY="your-anthropic-api-key"
+GOOGLE_API_KEY="your-google-api-key"
 THE_ARCHITECT_PASS="your-secure-password"
+TELEGRAM_BOT_TOKEN="your-telegram-bot-token"
+OPENROUTER_API_KEY="your-openrouter-api-key"
 ```
 
 **Option 2: Using Shell export**
 
 ```bash
+export OPENAI_API_KEY="your-openai-api-key"
+export ANTHROPIC_API_KEY="your-anthropic-api-key"
+export GOOGLE_API_KEY="your-google-api-key"
+export OPENROUTER_API_KEY="your-openrouter-api-key"
 export THE_ARCHITECT_PASS="your-secure-password"
+export TELEGRAM_BOT_TOKEN="your-telegram-bot-token"
 morpheus start
 ```
 
@@ -133,6 +199,18 @@ Send voice messages directly to the Telegram bot. Morpheus will:
 
 *Requires a Google Gemini API Key.*
 
+### 🤖 Telegram Commands
+The Morpheus Telegram bot supports several commands for interacting with the agent:
+
+- `/start` - Show welcome message and available commands
+- `/status` - Check the status of the Morpheus agent
+- `/doctor` - Diagnose environment and configuration issues
+- `/stats` - Show token usage statistics
+- `/help` - Show available commands
+- `/zaion` - Show system configurations
+- `/sati <qnt>` - Show specific memories
+- `/restart` - **New!** Restart the Morpheus agent
+
 ## Development Setup
 
 This guide is for developers contributing to the Morpheus codebase.
@@ -333,6 +411,131 @@ npm run test:watch
 - [ ] **Discord Adapter**: Support for Discord interactions.
 - [ ] **Plugin System**: Extend functionality via external modules.
 
+## 🕵️ Privacy Protection
+
+The Web UI includes privacy protection headers to prevent indexing by search engines:
+- HTML meta tags: `<meta name="robots" content="noindex, nofollow">`
+- HTTP header: `X-Robots-Tag: noindex, nofollow`
+
+This ensures that your private agent dashboard remains private and is not discoverable by search engines.
+
+## 🐳 Running with Docker
+
+Morpheus can be easily deployed using Docker and Docker Compose. The container supports all environment variables for configuration.
+The Docker image is publicly available at [Docker Hub](https://hub.docker.com/r/marcosnunesmbs/morpheus).
+
+### Prerequisites
+
+- Docker Engine
+- Docker Compose
+
+### Quick Start
+
+1. Create a `.env` file with your configuration:
+
+```bash
+cp .env.example .env
+# Edit .env with your actual API keys and settings
+```
+
+2. Build and start the container:
+
+```bash
+docker-compose up -d
+```
+
+3. Access the Web UI at `http://localhost:3333`
+
+### Docker Compose Example
+
+Here's a complete example of how to run Morpheus using Docker Compose:
+
+```yaml
+version: '3.8'
+
+services:
+  morpheus:
+    image: morpheus/morpheus-agent:latest
+    container_name: morpheus-agent
+    ports:
+      - "3333:3333"
+    volumes:
+      - morpheus_data:/root/.morpheus
+    environment:
+      # LLM Configuration
+      - MORPHEUS_LLM_PROVIDER=openai
+      - MORPHEUS_LLM_MODEL=gpt-4o
+      - MORPHEUS_LLM_TEMPERATURE=0.7
+      
+      # API Keys
+      - OPENAI_API_KEY=your-openai-api-key
+      - ANTHROPIC_API_KEY=your-anthropic-api-key
+      - GOOGLE_API_KEY=your-google-api-key
+      - OPENROUTER_API_KEY=your-openrouter-api-key
+      
+      # Security
+      - THE_ARCHITECT_PASS=your-secure-password
+      
+      # Agent Configuration
+      - MORPHEUS_AGENT_NAME=morpheus
+      - MORPHEUS_AGENT_PERSONALITY=helpful_dev
+      
+      # UI Configuration
+      - MORPHEUS_UI_ENABLED=true
+      - MORPHEUS_UI_PORT=3333
+    restart: unless-stopped
+```
+
+### Using Docker Directly
+
+```bash
+# Build the image
+docker build -t morpheus .
+
+# Run with environment variables
+docker run -d \
+  --name morpheus-agent \
+  -p 3333:3333 \
+  -v morpheus_data:/root/.morpheus \
+  -e MORPHEUS_LLM_PROVIDER=openai \
+  -e OPENAI_API_KEY=your-api-key-here \
+  -e THE_ARCHITECT_PASS=your-password \
+  morpheus
+```
+
+### Environment Variables in Docker
+
+All environment variables described above work in Docker. The precedence order remains the same:
+1. Container environment variables
+2. Configuration file values
+3. Default values
+
+### Persistent Data
+
+The container stores configuration and data in `/root/.morpheus`. Mount a volume to persist data between container restarts:
+
+```yaml
+volumes:
+  - morpheus_data:/root/.morpheus  # Recommended for persistence
+```
+
+### Health Check
+
+The container includes a health check that verifies the health endpoint is accessible. The application exposes a public `/health` endpoint that doesn't require authentication:
+
+```bash
+curl http://localhost:3333/health
+```
+
+Response:
+```json
+{
+  "status": "healthy",
+  "timestamp": "2026-02-05T21:30:00.000Z",
+  "uptime": 123.45
+}
+```
+
 ## Contributing
 
 1.  Fork the repository.

package/dist/channels/telegram.js

@@ -4,9 +4,13 @@ import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
+import { spawn } from 'child_process';
 import { ConfigManager } from '../config/manager.js';
 import { DisplayManager } from '../runtime/display.js';
 import { Telephonist } from '../runtime/telephonist.js';
+import { readPid, isProcessRunning, checkStalePid } from '../runtime/lifecycle.js';
+import { SQLiteChatMessageHistory } from '../runtime/memory/sqlite.js';
+import { SatiRepository } from '../runtime/memory/sati/repository.js';
 export class TelegramAdapter {
     bot = null;
     isConnected = false;
@@ -40,13 +44,18 @@ export class TelegramAdapter {
                     return; // Silent fail for security
                 }
                 this.display.log(`@${user}: ${text}`, { source: 'Telegram' });
+                // Handle system commands
+                if (text.startsWith('/')) {
+                    await this.handleSystemCommand(ctx, text, user);
+                    return;
+                }
                 try {
                     // Send "typing" status
                     await ctx.sendChatAction('typing');
                     // Process with Agent
                     const response = await this.oracle.chat(text);
                     if (response) {
-                        await ctx.reply(response);
+                        await ctx.reply(response, { parse_mode: 'Markdown' });
                         this.display.log(`Responded to @${user}`, { source: 'Telegram' });
                     }
                 }
@@ -105,7 +114,7 @@ export class TelegramAdapter {
                     await ctx.reply(`🎤 *Transcription*: _"${text}"_`, { parse_mode: 'Markdown' });
                     await ctx.sendChatAction('typing');
                     // Process with Agent
-                    const response = await this.oracle.chat(text, usage);
+                    const response = await this.oracle.chat(text, usage, true);
                     // if (listeningMsg) {
                     //   try {
                     //     await ctx.telegram.deleteMessage(ctx.chat.id, listeningMsg.message_id);
@@ -135,6 +144,10 @@ export class TelegramAdapter {
                 }
             });
             this.isConnected = true;
+            // Check if there's a restart notification to send
+            this.checkAndSendRestartNotification().catch((err) => {
+                this.display.log(`Failed to send restart notification: ${err.message}`, { source: 'Telegram', level: 'error' });
+            });
             process.once('SIGINT', () => this.disconnect());
             process.once('SIGTERM', () => this.disconnect());
         }
@@ -174,4 +187,290 @@ export class TelegramAdapter {
         this.bot = null;
         this.display.log(chalk.gray('Telegram disconnected.'), { source: 'Telegram' });
     }
+    async handleSystemCommand(ctx, text, user) {
+        const command = text.split(' ')[0];
+        const args = text.split(' ').slice(1);
+        switch (command) {
+            case '/start':
+                await this.handleStartCommand(ctx, user);
+                break;
+            case '/status':
+                await this.handleStatusCommand(ctx, user);
+                break;
+            case '/doctor':
+                await this.handleDoctorCommand(ctx, user);
+                break;
+            case '/stats':
+                await this.handleStatsCommand(ctx, user);
+                break;
+            case '/help':
+                await this.handleHelpCommand(ctx, user);
+                break;
+            case '/zaion':
+                await this.handleZaionCommand(ctx, user);
+                break;
+            case '/sati':
+                await this.handleSatiCommand(ctx, user, args);
+                break;
+            case '/restart':
+                await this.handleRestartCommand(ctx, user);
+                break;
+            default:
+                await this.handleDefaultCommand(ctx, user, command);
+        }
+    }
+    async handleStartCommand(ctx, user) {
+        const welcomeMessage = `
+Hello, @${user}! I am ${this.config.get().agent.name}, ${this.config.get().agent.personality}.
+
+I am your local AI operator/agent. Here are the commands you can use:
+
+/start - Show this welcome message and available commands
+/status - Check the status of the Morpheus agent
+/doctor - Diagnose environment and configuration issues
+/stats - Show token usage statistics
+/help - Show available commands
+/zaion - Show system configurations
+/sati <qnt> - Show specific memories
+/restart - Restart the Morpheus agent
+
+How can I assist you today?`;
+        await ctx.reply(welcomeMessage);
+    }
+    async handleStatusCommand(ctx, user) {
+        try {
+            await checkStalePid();
+            const pid = await readPid();
+            if (pid && isProcessRunning(pid)) {
+                await ctx.reply(`Morpheus is running (PID: ${pid})`);
+            }
+            else {
+                await ctx.reply('Morpheus is stopped.');
+            }
+        }
+        catch (error) {
+            await ctx.reply(`Failed to check status: ${error.message}`);
+        }
+    }
+    async handleDoctorCommand(ctx, user) {
+        // Implementação simplificada do diagnóstico
+        const config = this.config.get();
+        let response = '*Morpheus Doctor*\n\n';
+        // Verificar versão do Node.js
+        const nodeVersion = process.version;
+        const majorVersion = parseInt(nodeVersion.replace('v', '').split('.')[0], 10);
+        if (majorVersion >= 18) {
+            response += '✅ Node.js Version: ' + nodeVersion + ' (Satisfied)\n';
+        }
+        else {
+            response += '❌ Node.js Version: ' + nodeVersion + ' (Required: >=18)\n';
+        }
+        // Verificar configuração
+        if (config) {
+            response += '✅ Configuration: Valid\n';
+            // Verificar se há chave de API disponível para o provedor ativo
+            const llmProvider = config.llm?.provider;
+            if (llmProvider && llmProvider !== 'ollama') {
+                const hasLlmApiKey = config.llm?.api_key ||
+                    (llmProvider === 'openai' && process.env.OPENAI_API_KEY) ||
+                    (llmProvider === 'anthropic' && process.env.ANTHROPIC_API_KEY) ||
+                    (llmProvider === 'gemini' && process.env.GOOGLE_API_KEY) ||
+                    (llmProvider === 'openrouter' && process.env.OPENROUTER_API_KEY);
+                if (hasLlmApiKey) {
+                    response += `✅ LLM API key available for ${llmProvider}\n`;
+                }
+                else {
+                    response += `❌ LLM API key missing for ${llmProvider}. Either set in config or define environment variable.\n`;
+                }
+            }
+            // Verificar token do Telegram se ativado
+            if (config.channels?.telegram?.enabled) {
+                const hasTelegramToken = config.channels.telegram?.token || process.env.TELEGRAM_BOT_TOKEN;
+                if (hasTelegramToken) {
+                    response += '✅ Telegram bot token available\n';
+                }
+                else {
+                    response += '❌ Telegram bot token missing. Either set in config or define TELEGRAM_BOT_TOKEN environment variable.\n';
+                }
+            }
+        }
+        else {
+            response += '⚠️ Configuration: Missing\n';
+        }
+        await ctx.reply(response, { parse_mode: 'Markdown' });
+    }
+    async handleStatsCommand(ctx, user) {
+        try {
+            // Criar instância temporária do histórico para obter estatísticas
+            const history = new SQLiteChatMessageHistory({
+                sessionId: "default",
+                databasePath: undefined, // Usará o caminho padrão
+                limit: 100, // Limite arbitrário para esta operação
+            });
+            const stats = await history.getGlobalUsageStats();
+            const groupedStats = await history.getUsageStatsByProviderAndModel();
+            let response = '*Token Usage Statistics*\n\n';
+            response += `Total Input Tokens: ${stats.totalInputTokens}\n`;
+            response += `Total Output Tokens: ${stats.totalOutputTokens}\n`;
+            response += `Total Tokens: ${stats.totalInputTokens + stats.totalOutputTokens}\n\n`;
+            if (groupedStats.length > 0) {
+                response += '*Breakdown by Provider and Model:*\n';
+                for (const stat of groupedStats) {
+                    response += `- ${stat.provider}/${stat.model}: ${stat.totalTokens} tokens (${stat.messageCount} messages)\n`;
+                }
+            }
+            else {
+                response += 'No detailed usage statistics available.';
+            }
+            await ctx.reply(response, { parse_mode: 'Markdown' });
+            // Fechar conexão com o banco de dados
+            history.close();
+        }
+        catch (error) {
+            await ctx.reply(`Failed to retrieve statistics: ${error.message}`);
+        }
+    }
+    async handleDefaultCommand(ctx, user, command) {
+        const prompt = `O usuário envio o comando: ${command},
+    Não entendemos o comando
+    temos os seguintes comandos disponíveis: /start, /status, /doctor, /stats, /help, /zaion, /sati <qnt>, /restart
+    Identifique se ele talvez tenha errado o comando e pergunte se ele não quis executar outro comando.
+    Só faça isso agora.`;
+        let response = await this.oracle.chat(prompt);
+        if (response) {
+            await ctx.reply(response, { parse_mode: 'Markdown' });
+        }
+        // await ctx.reply(`Command not recognized. Type /help to see available commands.`);
+    }
+    async handleHelpCommand(ctx, user) {
+        const helpMessage = `
+*Available Commands:*
+
+/start - Show welcome message and available commands
+/status - Check the status of the Morpheus agent
+/doctor - Diagnose environment and configuration issues
+/stats - Show token usage statistics
+/help - Show this help message
+/zaion - Show system configurations
+/sati <qnt> - Show specific memories
+/restart - Restart the Morpheus agent
+
+How can I assist you today?`;
+        await ctx.reply(helpMessage, { parse_mode: 'Markdown' });
+    }
+    async handleZaionCommand(ctx, user) {
+        const config = this.config.get();
+        let response = '*System Configuration*\n\n';
+        response += `*Agent:*\n`;
+        response += `- Name: ${config.agent.name}\n`;
+        response += `- Personality: ${config.agent.personality}\n\n`;
+        response += `*LLM:*\n`;
+        response += `- Provider: ${config.llm.provider}\n`;
+        response += `- Model: ${config.llm.model}\n`;
+        response += `- Temperature: ${config.llm.temperature}\n`;
+        response += `- Context Window: ${config.llm.context_window || 100}\n\n`;
+        response += `*Channels:*\n`;
+        response += `- Telegram Enabled: ${config.channels.telegram.enabled}\n`;
+        response += `- Discord Enabled: ${config.channels.discord.enabled}\n\n`;
+        response += `*UI:*\n`;
+        response += `- Enabled: ${config.ui.enabled}\n`;
+        response += `- Port: ${config.ui.port}\n\n`;
+        response += `*Audio:*\n`;
+        response += `- Enabled: ${config.audio.enabled}\n`;
+        response += `- Max Duration: ${config.audio.maxDurationSeconds}s\n`;
+        await ctx.reply(response, { parse_mode: 'Markdown' });
+    }
+    async handleSatiCommand(ctx, user, args) {
+        let limit = null;
+        if (args.length > 0) {
+            limit = parseInt(args[0], 10);
+            if (isNaN(limit) || limit <= 0) {
+                await ctx.reply('Invalid quantity. Please specify a positive number. Usage: /sati <qnt>');
+                return;
+            }
+        }
+        try {
+            // Usar o repositório SATI para obter memórias de longo prazo
+            const repository = SatiRepository.getInstance();
+            const memories = repository.getAllMemories();
+            if (memories.length === 0) {
+                await ctx.reply(`No memories found.`);
+                return;
+            }
+            // Se nenhum limite for especificado, usar todas as memórias
+            let selectedMemories = memories;
+            if (limit !== null) {
+                selectedMemories = memories.slice(0, Math.min(limit, memories.length));
+            }
+            let response = `*${selectedMemories.length} SATI Memories${limit !== null ? ` (Showing first ${selectedMemories.length})` : ''}:*\n\n`;
+            for (const memory of selectedMemories) {
+                // Limitar o tamanho do resumo para evitar mensagens muito longas
+                const truncatedSummary = memory.summary.length > 200 ? memory.summary.substring(0, 200) + '...' : memory.summary;
+                response += `*${memory.category} (${memory.importance}):* ${truncatedSummary}\n\n`;
+            }
+            await ctx.reply(response, { parse_mode: 'Markdown' });
+        }
+        catch (error) {
+            await ctx.reply(`Failed to retrieve memories: ${error.message}`);
+        }
+    }
+    async handleRestartCommand(ctx, user) {
+        // Store the user ID who requested the restart
+        const userId = ctx.from.id;
+        // Save the user ID to a temporary file so the restarted process can notify them
+        const restartNotificationFile = path.join(os.tmpdir(), 'morpheus_restart_notification.json');
+        try {
+            await fs.writeJson(restartNotificationFile, { userId: userId, username: user }, { encoding: 'utf8' });
+        }
+        catch (error) {
+            this.display.log(`Failed to save restart notification info: ${error.message}`, { source: 'Telegram', level: 'error' });
+        }
+        // Respond to the user first
+        await ctx.reply('🔄 Restart initiated. The Morpheus agent will restart shortly.');
+        // Schedule the restart after a short delay to ensure the response is sent
+        setTimeout(() => {
+            // Stop the bot to prevent processing more messages
+            if (this.bot) {
+                try {
+                    this.bot.stop();
+                }
+                catch (e) {
+                    // Ignore stop errors
+                }
+            }
+            // Execute the restart command using the CLI
+            const restartProcess = spawn(process.execPath, [process.argv[1], 'restart'], {
+                detached: true,
+                stdio: 'ignore'
+            });
+            restartProcess.unref();
+            // Exit the current process
+            process.exit(0);
+        }, 500); // Shorter delay to minimize chance of processing more messages
+    }
+    async checkAndSendRestartNotification() {
+        const restartNotificationFile = path.join(os.tmpdir(), 'morpheus_restart_notification.json');
+        try {
+            // Check if the notification file exists
+            if (await fs.pathExists(restartNotificationFile)) {
+                const notificationData = await fs.readJson(restartNotificationFile);
+                // Send a message to the user who requested the restart
+                if (this.bot && notificationData.userId) {
+                    try {
+                        await this.bot.telegram.sendMessage(notificationData.userId, '✅ Morpheus agent has been successfully restarted!');
+                        // Optionally, also send to the display
+                        this.display.log(`Restart notification sent to user ${notificationData.username} (ID: ${notificationData.userId})`, { source: 'Telegram', level: 'info' });
+                    }
+                    catch (error) {
+                        this.display.log(`Failed to send restart notification to user ${notificationData.username}: ${error.message}`, { source: 'Telegram', level: 'error' });
+                    }
+                }
+                // Remove the notification file after sending the message
+                await fs.remove(restartNotificationFile);
+            }
+        }
+        catch (error) {
+            this.display.log(`Error checking restart notification: ${error.message}`, { source: 'Telegram', level: 'error' });
+        }
+    }
 }

package/dist/cli/commands/doctor.js

@@ -47,6 +47,68 @@ export const doctorCommand = new Command('doctor')
             else if (deprecatedLimit !== undefined && contextWindow !== undefined) {
                 console.log(chalk.yellow('⚠') + ' Found both \'memory.limit\' and \'llm.context_window\'. Remove \'memory.limit\' from config.');
             }
+            // Check API keys availability for active providers
+            const llmProvider = config.llm?.provider;
+            const santiProvider = config.santi?.provider;
+            // Check LLM provider API key
+            if (llmProvider && llmProvider !== 'ollama') {
+                const hasLlmApiKey = config.llm?.api_key ||
+                    (llmProvider === 'openai' && process.env.OPENAI_API_KEY) ||
+                    (llmProvider === 'anthropic' && process.env.ANTHROPIC_API_KEY) ||
+                    (llmProvider === 'gemini' && process.env.GOOGLE_API_KEY) ||
+                    (llmProvider === 'openrouter' && process.env.OPENROUTER_API_KEY);
+                if (hasLlmApiKey) {
+                    console.log(chalk.green('✓') + ` LLM API key available for ${llmProvider}`);
+                }
+                else {
+                    console.log(chalk.red('✗') + ` LLM API key missing for ${llmProvider}. Either set in config or define environment variable.`);
+                    allPassed = false;
+                }
+            }
+            // Check Santi provider API key
+            if (santiProvider && santiProvider !== 'ollama') {
+                const hasSantiApiKey = config.santi?.api_key ||
+                    (santiProvider === 'openai' && process.env.OPENAI_API_KEY) ||
+                    (santiProvider === 'anthropic' && process.env.ANTHROPIC_API_KEY) ||
+                    (santiProvider === 'gemini' && process.env.GOOGLE_API_KEY) ||
+                    (santiProvider === 'openrouter' && process.env.OPENROUTER_API_KEY);
+                if (hasSantiApiKey) {
+                    console.log(chalk.green('✓') + ` Santi API key available for ${santiProvider}`);
+                }
+                else {
+                    console.log(chalk.red('✗') + ` Santi API key missing for ${santiProvider}. Either set in config or define environment variable.`);
+                    allPassed = false;
+                }
+            }
+            // Check audio API key if enabled
+            if (config.audio?.enabled && config.llm?.provider !== 'gemini') {
+                const hasAudioApiKey = config.audio?.apiKey || process.env.GOOGLE_API_KEY;
+                if (hasAudioApiKey) {
+                    console.log(chalk.green('✓') + ' Audio API key available for transcription');
+                }
+                else {
+                    console.log(chalk.red('✗') + ' Audio API key missing. Either set in config or define GOOGLE_API_KEY environment variable.');
+                    allPassed = false;
+                }
+            }
+            // Check Telegram token if enabled
+            if (config.channels?.telegram?.enabled) {
+                const hasTelegramToken = config.channels.telegram?.token || process.env.TELEGRAM_BOT_TOKEN;
+                if (hasTelegramToken) {
+                    console.log(chalk.green('✓') + ' Telegram bot token available');
+                }
+                else {
+                    console.log(chalk.red('✗') + ' Telegram bot token missing. Either set in config or define TELEGRAM_BOT_TOKEN environment variable.');
+                    allPassed = false;
+                }
+            }
+            // Check if default password is being used for dashboard
+            if (!process.env.THE_ARCHITECT_PASS) {
+                console.log(chalk.yellow('⚠') + ' Using default password for dashboard (iamthearchitect). For security, set THE_ARCHITECT_PASS environment variable.');
+            }
+            else {
+                console.log(chalk.green('✓') + ' Custom dashboard password set');
+            }
         }
         else {
             console.log(chalk.yellow('!') + ' Configuration: Missing (will be created on start)');