morpheus-cli 0.2.4 → 0.2.6

package/dist/config/precedence.js

@@ -0,0 +1,138 @@
+/**
+ * Functions to resolve configuration values with precedence:
+ * 1. Provider-specific environment variable (e.g., OPENAI_API_KEY)
+ * 2. Generic environment variable (e.g., MORPHEUS_LLM_API_KEY)
+ * 3. Configuration file value
+ * 4. Default value
+ */
+/**
+ * Resolve an API key with provider-specific precedence
+ * @param provider The current provider
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @returns The resolved API key value
+ */
+export function resolveApiKey(provider, genericEnvVar, configFileValue) {
+    // Map provider to its specific environment variable
+    const providerSpecificVars = {
+        'openai': 'OPENAI_API_KEY',
+        'anthropic': 'ANTHROPIC_API_KEY',
+        'openrouter': 'OPENROUTER_API_KEY',
+        'ollama': '', // Ollama typically doesn't need an API key
+        'gemini': 'GOOGLE_API_KEY'
+    };
+    const providerSpecificVar = providerSpecificVars[provider];
+    // Check provider-specific variable first, then generic, then config file
+    if (providerSpecificVar && process.env[providerSpecificVar]) {
+        return process.env[providerSpecificVar];
+    }
+    if (process.env[genericEnvVar]) {
+        return process.env[genericEnvVar];
+    }
+    return configFileValue;
+}
+/**
+ * Resolve a model name with provider-specific precedence
+ * @param provider The current provider
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @returns The resolved model name value
+ */
+export function resolveModel(provider, genericEnvVar, configFileValue) {
+    // For now, we don't have provider-specific model variables, but we could add them later
+    // Check generic variable first, then config file
+    if (process.env[genericEnvVar]) {
+        return process.env[genericEnvVar];
+    }
+    return configFileValue;
+}
+/**
+ * Resolve a numeric configuration value
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @param defaultValue The default value to use if none is found
+ * @returns The resolved numeric value
+ */
+export function resolveNumeric(genericEnvVar, configFileValue, defaultValue) {
+    if (process.env[genericEnvVar] !== undefined && process.env[genericEnvVar] !== '') {
+        const envValue = Number(process.env[genericEnvVar]);
+        if (!isNaN(envValue)) {
+            return envValue;
+        }
+    }
+    if (configFileValue !== undefined) {
+        return configFileValue;
+    }
+    return defaultValue;
+}
+/**
+ * Resolve a string configuration value
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @param defaultValue The default value to use if none is found
+ * @returns The resolved string value
+ */
+export function resolveString(genericEnvVar, configFileValue, defaultValue) {
+    if (process.env[genericEnvVar]) {
+        return process.env[genericEnvVar];
+    }
+    if (configFileValue !== undefined) {
+        return configFileValue;
+    }
+    return defaultValue;
+}
+/**
+ * Resolve a boolean configuration value
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @param defaultValue The default value to use if none is found
+ * @returns The resolved boolean value
+ */
+export function resolveBoolean(genericEnvVar, configFileValue, defaultValue) {
+    if (process.env[genericEnvVar] !== undefined) {
+        const envValue = process.env[genericEnvVar]?.toLowerCase();
+        if (envValue === 'true' || envValue === '1') {
+            return true;
+        }
+        else if (envValue === 'false' || envValue === '0') {
+            return false;
+        }
+    }
+    if (configFileValue !== undefined) {
+        return configFileValue;
+    }
+    return defaultValue;
+}
+/**
+ * Resolve an array of string configuration value
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @param defaultValue The default value to use if none is found
+ * @returns The resolved array of strings value
+ */
+export function resolveStringArray(genericEnvVar, configFileValue, defaultValue) {
+    if (process.env[genericEnvVar]) {
+        // Split the environment variable by commas and trim whitespace
+        return process.env[genericEnvVar].split(',').map(item => item.trim()).filter(item => item.length > 0);
+    }
+    if (configFileValue !== undefined) {
+        return configFileValue;
+    }
+    return defaultValue;
+}
+/**
+ * Resolve a provider configuration value
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @param defaultValue The default value to use if none is found
+ * @returns The resolved provider value
+ */
+export function resolveProvider(genericEnvVar, configFileValue, defaultValue) {
+    if (process.env[genericEnvVar]) {
+        return process.env[genericEnvVar];
+    }
+    if (configFileValue !== undefined) {
+        return configFileValue;
+    }
+    return defaultValue;
+}

package/dist/config/schemas.js

@@ -2,17 +2,19 @@ import { z } from 'zod';
 import { DEFAULT_CONFIG } from '../types/config.js';
 export const AudioConfigSchema = z.object({
     provider: z.enum(['google']).default(DEFAULT_CONFIG.audio.provider),
+    model: z.string().min(1).default(DEFAULT_CONFIG.audio.model),
     enabled: z.boolean().default(DEFAULT_CONFIG.audio.enabled),
     apiKey: z.string().optional(),
     maxDurationSeconds: z.number().default(DEFAULT_CONFIG.audio.maxDurationSeconds),
     supportedMimeTypes: z.array(z.string()).default(DEFAULT_CONFIG.audio.supportedMimeTypes),
 });
 export const LLMConfigSchema = z.object({
-    provider: z.enum(['openai', 'anthropic', 'ollama', 'gemini']).default(DEFAULT_CONFIG.llm.provider),
+    provider: z.enum(['openai', 'anthropic', 'openrouter', 'ollama', 'gemini']).default(DEFAULT_CONFIG.llm.provider),
     model: z.string().min(1).default(DEFAULT_CONFIG.llm.model),
     temperature: z.number().min(0).max(1).default(DEFAULT_CONFIG.llm.temperature),
     max_tokens: z.number().int().positive().optional(),
     api_key: z.string().optional(),
+    base_url: z.string().optional(),
     context_window: z.number().int().positive().optional(),
 });
 export const SatiConfigSchema = LLMConfigSchema.extend({

package/dist/http/__tests__/status_api.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+import bodyParser from 'body-parser';
+import { createApiRouter } from '../api.js';
+import { ConfigManager } from '../../config/manager.js';
+import fs from 'fs-extra';
+// Mock dependencies
+vi.mock('../../config/manager.js');
+vi.mock('fs-extra');
+describe('Status API', () => {
+    let app;
+    let mockConfigManager;
+    beforeEach(() => {
+        // Reset mocks
+        vi.clearAllMocks();
+        // Mock ConfigManager instance
+        mockConfigManager = {
+            get: vi.fn(),
+        };
+        ConfigManager.getInstance.mockReturnValue(mockConfigManager);
+        // Setup App
+        app = express();
+        app.use(bodyParser.json());
+        // Create router without server instance to test fallback
+        app.use('/api', createApiRouter());
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('GET /api/status', () => {
+        it('should return status information including server port', async () => {
+            const mockConfig = {
+                agent: { name: 'TestAgent' },
+                llm: { provider: 'openai', model: 'gpt-4' },
+                ui: { port: 3333 }
+            };
+            mockConfigManager.get.mockReturnValue(mockConfig);
+            // Mock fs.readJson to return a version
+            fs.readJson.mockResolvedValue({ version: '1.0.0' });
+            const res = await request(app).get('/api/status');
+            expect(res.status).toBe(200);
+            expect(res.body).toHaveProperty('status');
+            expect(res.body).toHaveProperty('uptimeSeconds');
+            expect(res.body).toHaveProperty('pid');
+            expect(res.body).toHaveProperty('projectVersion');
+            expect(res.body).toHaveProperty('nodeVersion');
+            expect(res.body).toHaveProperty('agentName');
+            expect(res.body).toHaveProperty('llmProvider');
+            expect(res.body).toHaveProperty('llmModel');
+            expect(res.body).toHaveProperty('serverPort');
+            expect(res.body.serverPort).toBe(3333);
+        });
+    });
+});

package/dist/http/__tests__/status_with_server_api.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+import bodyParser from 'body-parser';
+import { createApiRouter } from '../api.js';
+import { ConfigManager } from '../../config/manager.js';
+import fs from 'fs-extra';
+// Mock dependencies
+vi.mock('../../config/manager.js');
+vi.mock('fs-extra');
+describe('Status API with Server Instance', () => {
+    let app;
+    let mockConfigManager;
+    let mockServerInstance;
+    beforeEach(() => {
+        // Reset mocks
+        vi.clearAllMocks();
+        // Mock ConfigManager instance
+        mockConfigManager = {
+            get: vi.fn(),
+        };
+        ConfigManager.getInstance.mockReturnValue(mockConfigManager);
+        // Mock server instance with getPort method
+        mockServerInstance = {
+            getPort: vi.fn().mockReturnValue(4567),
+        };
+        // Setup App
+        app = express();
+        app.use(bodyParser.json());
+        // Create router with server instance
+        app.use('/api', createApiRouter(mockServerInstance));
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('GET /api/status', () => {
+        it('should return status information with server instance port', async () => {
+            const mockConfig = {
+                agent: { name: 'TestAgent' },
+                llm: { provider: 'openai', model: 'gpt-4' },
+                ui: { port: 3333 } // This should be overridden by server instance
+            };
+            mockConfigManager.get.mockReturnValue(mockConfig);
+            // Mock fs.readJson to return a version
+            fs.readJson.mockResolvedValue({ version: '1.0.0' });
+            const res = await request(app).get('/api/status');
+            expect(res.status).toBe(200);
+            expect(res.body).toHaveProperty('status');
+            expect(res.body).toHaveProperty('uptimeSeconds');
+            expect(res.body).toHaveProperty('pid');
+            expect(res.body).toHaveProperty('projectVersion');
+            expect(res.body).toHaveProperty('nodeVersion');
+            expect(res.body).toHaveProperty('agentName');
+            expect(res.body).toHaveProperty('llmProvider');
+            expect(res.body).toHaveProperty('llmModel');
+            expect(res.body).toHaveProperty('serverPort');
+            expect(res.body.serverPort).toBe(4567); // Should come from server instance
+        });
+    });
+});

package/dist/http/api.js

@@ -6,6 +6,10 @@ import fs from 'fs-extra';
 import path from 'path';
 import { SQLiteChatMessageHistory } from '../runtime/memory/sqlite.js';
 import { SatiRepository } from '../runtime/memory/sati/repository.js';
+import { spawn } from 'child_process';
+import { z } from 'zod';
+import { MCPManager } from '../config/mcp-manager.js';
+import { MCPServerConfigSchema } from '../config/schemas.js';
 async function readLastLines(filePath, n) {
     try {
         const content = await fs.readFile(filePath, 'utf8');
@@ -38,6 +42,29 @@ export function createApiRouter() {
             llmModel: config.llm.model
         });
     });
+    router.post('/restart', async (req, res) => {
+        try {
+            // Send response immediately before restarting
+            res.json({
+                success: true,
+                message: 'Restart initiated. Process will shut down and restart shortly.'
+            });
+            // Delay the actual restart to allow response to be sent
+            setTimeout(() => {
+                // 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);
+            }, 100);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
     router.get('/config', (req, res) => {
         res.json(configManager.get());
     });
@@ -224,6 +251,64 @@ export function createApiRouter() {
             res.status(500).json({ error: error.message });
         }
     });
+    const MCPUpsertSchema = z.object({
+        name: z.string().min(1),
+        config: MCPServerConfigSchema,
+    });
+    const MCPToggleSchema = z.object({
+        enabled: z.boolean(),
+    });
+    router.get('/mcp/servers', async (_req, res) => {
+        try {
+            const servers = await MCPManager.listServers();
+            res.json({ servers });
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to load MCP servers.', details: String(error) });
+        }
+    });
+    router.post('/mcp/servers', async (req, res) => {
+        try {
+            const body = MCPUpsertSchema.parse(req.body);
+            await MCPManager.addServer(body.name, body.config);
+            res.status(201).json({ ok: true });
+        }
+        catch (error) {
+            const status = error instanceof z.ZodError ? 400 : 500;
+            res.status(status).json({ error: 'Failed to create MCP server.', details: error });
+        }
+    });
+    router.put('/mcp/servers/:name', async (req, res) => {
+        try {
+            const body = MCPUpsertSchema.parse({ name: req.params.name, config: req.body?.config ?? req.body });
+            await MCPManager.updateServer(body.name, body.config);
+            res.json({ ok: true });
+        }
+        catch (error) {
+            const status = error instanceof z.ZodError ? 400 : 500;
+            res.status(status).json({ error: 'Failed to update MCP server.', details: error });
+        }
+    });
+    router.delete('/mcp/servers/:name', async (req, res) => {
+        try {
+            await MCPManager.deleteServer(req.params.name);
+            res.json({ ok: true });
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to delete MCP server.', details: String(error) });
+        }
+    });
+    router.patch('/mcp/servers/:name/toggle', async (req, res) => {
+        try {
+            const body = MCPToggleSchema.parse(req.body);
+            await MCPManager.setServerEnabled(req.params.name, body.enabled);
+            res.json({ ok: true });
+        }
+        catch (error) {
+            const status = error instanceof z.ZodError ? 400 : 500;
+            res.status(status).json({ error: 'Failed to toggle MCP server.', details: error });
+        }
+    });
     // Keep PUT for backward compatibility if needed, or remove. 
     // Tasks says Implement POST. I'll remove PUT to avoid confusion or redirect it.
     router.put('/config', async (req, res) => {

package/dist/http/middleware/auth.js

@@ -2,13 +2,15 @@ import { AUTH_HEADER } from '../../types/auth.js';
 import { DisplayManager } from '../../runtime/display.js';
 /**
  * Middleware to protect API routes with a password from THE_ARCHITECT_PASS env var.
- * If the env var is not set, authentication is skipped (open mode).
+ * If the env var is not set, uses default password 'iamthearchitect'.
  */
 export const authMiddleware = (req, res, next) => {
-    const architectPass = process.env.THE_ARCHITECT_PASS;
-    // If password is not configured, allow all requests
-    if (!architectPass || architectPass.trim() === '') {
-        return next();
+    // Use environment variable if set, otherwise use default password
+    const architectPass = process.env.THE_ARCHITECT_PASS || 'iamthearchitect';
+    // If password is not configured (using default), log a warning
+    if (!process.env.THE_ARCHITECT_PASS) {
+        const display = DisplayManager.getInstance();
+        display.log('Using default password for dashboard access. For security, set THE_ARCHITECT_PASS environment variable.', { source: 'http', level: 'warning' });
     }
     const providedPass = req.headers[AUTH_HEADER];
     if (providedPass === architectPass) {

package/dist/http/server.js

@@ -20,8 +20,29 @@ export class HttpServer {
     setupMiddleware() {
         this.app.use(cors());
         this.app.use(bodyParser.json());
+        // Adicionar cabeçalhos para evitar indexação por motores de busca
+        this.app.use((req, res, next) => {
+            res.setHeader('X-Robots-Tag', 'noindex, nofollow');
+            next();
+        });
     }
     setupRoutes() {
+        // Rota de health check pública (sem autenticação)
+        this.app.get('/health', (req, res) => {
+            res.status(200).json({
+                status: 'healthy',
+                timestamp: new Date().toISOString(),
+                uptime: process.uptime()
+            });
+        });
+        // Rota de health check para o Docker (padrão)
+        this.app.get('/api/health', (req, res) => {
+            res.status(200).json({
+                status: 'healthy',
+                timestamp: new Date().toISOString(),
+                uptime: process.uptime()
+            });
+        });
         this.app.use('/api', authMiddleware, createApiRouter());
         // Serve static frontend from compiled output
         const uiPath = path.resolve(__dirname, '../ui');

package/dist/runtime/__tests__/manual_start_verify.js

@@ -13,6 +13,7 @@ const mockConfig = {
     logging: { enabled: false, level: 'info', retention: '1d' },
     audio: {
         provider: 'google',
+        model: 'gemini-2.5-flash-lite',
         enabled: false,
         maxDurationSeconds: 60,
         supportedMimeTypes: ['audio/ogg']

package/dist/runtime/oracle.js

@@ -49,7 +49,7 @@ export class Oracle {
             throw new ProviderError(this.config.llm.provider || 'unknown', err, "Oracle initialization failed");
         }
     }
-    async chat(message, extraUsage) {
+    async chat(message, extraUsage, isTelephonist) {
         if (!this.provider) {
             throw new Error("Oracle not initialized. Call initialize() first.");
         }
@@ -61,8 +61,8 @@ export class Oracle {
             const userMessage = new HumanMessage(message);
             // Inject provider/model metadata for persistence
             userMessage.provider_metadata = {
-                provider: this.config.llm.provider,
-                model: this.config.llm.model
+                provider: isTelephonist ? this.config.audio?.provider : this.config.llm.provider,
+                model: isTelephonist ? this.config.audio?.model : this.config.llm.model
             };
             // Attach extra usage (e.g. from Audio) to the user message to be persisted
             if (extraUsage) {

package/dist/runtime/providers/factory.js

@@ -38,14 +38,24 @@ export class ProviderFactory {
                     model = new ChatOpenAI({
                         modelName: config.model,
                         temperature: config.temperature,
-                        apiKey: config.api_key, // LangChain will also check process.env.OPENAI_API_KEY
+                        apiKey: process.env.OPENAI_API_KEY || config.api_key, // Check env var first, then config
                     });
                     break;
                 case 'anthropic':
                     model = new ChatAnthropic({
                         modelName: config.model,
                         temperature: config.temperature,
-                        apiKey: config.api_key,
+                        apiKey: process.env.ANTHROPIC_API_KEY || config.api_key, // Check env var first, then config
+                    });
+                    break;
+                case 'openrouter':
+                    model = new ChatOpenAI({
+                        modelName: config.model,
+                        temperature: config.temperature,
+                        apiKey: process.env.OPENROUTER_API_KEY || config.api_key, // Check env var first, then config
+                        configuration: {
+                            baseURL: config.base_url || 'https://openrouter.ai/api/v1'
+                        }
                     });
                     break;
                 case 'ollama':
@@ -60,7 +70,7 @@ export class ProviderFactory {
                     model = new ChatGoogleGenerativeAI({
                         model: config.model,
                         temperature: config.temperature,
-                        apiKey: config.api_key
+                        apiKey: process.env.GOOGLE_API_KEY || config.api_key // Check env var first, then config
                     });
                     break;
                 default:
@@ -99,7 +109,7 @@ export class ProviderFactory {
                 suggestion = `Model '${config.model}' may not be available. Check provider docs.`;
             }
             else if (msg.includes("unsupported provider")) {
-                suggestion = "Edit your config file to use a supported provider (openai, anthropic, ollama, gemini).";
+                suggestion = "Edit your config file to use a supported provider (openai, anthropic, openrouter, ollama, gemini).";
             }
             throw new ProviderError(config.provider, error, suggestion);
         }

package/dist/runtime/tools/config-tools.js

@@ -5,66 +5,60 @@ import { ConfigManager } from "../../config/manager.js";
 export const ConfigQueryTool = tool(async ({ key }) => {
     try {
         const configManager = ConfigManager.getInstance();
-        // Load config if not already loaded
         await configManager.load();
         const config = configManager.get();
         if (key) {
-            // Return specific configuration value
-            const value = config[key];
+            // Suporta busca por chave aninhada, ex: 'llm.model' ou 'channels.telegram.enabled'
+            const value = key.split('.').reduce((obj, k) => (obj ? obj[k] : undefined), config);
             return JSON.stringify({ [key]: value });
         }
         else {
-            // Return all configuration values
             return JSON.stringify(config);
         }
     }
     catch (error) {
-        console.error("Error in ConfigQueryTool:", error);
+        // Nunca usar console.log, mas manter para debug local
         return JSON.stringify({ error: "Failed to query configuration" });
     }
 }, {
-    name: "config_query",
-    description: "Queries current configuration values. Accepts an optional 'key' parameter to get a specific configuration value, or no parameter to get all configuration values.",
+    name: "morpheus_config_query",
+    description: "Queries current configuration values. Accepts an optional 'key' parameter (dot notation supported, e.g. 'llm.model') to get a specific configuration value, or no parameter to get all configuration values.",
     schema: z.object({
         key: z.string().optional(),
     }),
 });
-// Tool for updating configuration values
+// Tool for updating configuration values (suporta objetos aninhados via dot notation)
+function setNestedValue(obj, path, value) {
+    const keys = path.split('.');
+    let curr = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        if (!curr[keys[i]] || typeof curr[keys[i]] !== 'object') {
+            curr[keys[i]] = {};
+        }
+        curr = curr[keys[i]];
+    }
+    curr[keys[keys.length - 1]] = value;
+}
 export const ConfigUpdateTool = tool(async ({ updates }) => {
     try {
         const configManager = ConfigManager.getInstance();
-        // Load current config
         await configManager.load();
         const currentConfig = configManager.get();
-        // Create new config with updates
-        const newConfig = { ...currentConfig, ...updates };
-        // Save the updated config
+        // Suporta updates com dot notation para campos aninhados
+        const newConfig = { ...currentConfig };
+        for (const key in updates) {
+            setNestedValue(newConfig, key, updates[key]);
+        }
         await configManager.save(newConfig);
         return JSON.stringify({ success: true, message: "Configuration updated successfully" });
     }
     catch (error) {
-        console.error("Error in ConfigUpdateTool:", error);
         return JSON.stringify({ error: `Failed to update configuration: ${error.message}` });
     }
 }, {
-    name: "config_update",
-    description: "Updates configuration values with validation. Accepts an 'updates' object containing key-value pairs to update.",
+    name: "morpheus_config_update",
+    description: "Updates configuration values with validation. Accepts an 'updates' object containing key-value pairs to update. Supports dot notation for nested fields (e.g. 'llm.model').",
     schema: z.object({
-        updates: z.object({
-            // Define common config properties that might be updated
-            // Using optional fields to allow flexible updates
-            "llm.provider": z.string().optional(),
-            "llm.model": z.string().optional(),
-            "llm.temperature": z.number().optional(),
-            "llm.api_key": z.string().optional(),
-            "ui.enabled": z.boolean().optional(),
-            "ui.port": z.number().optional(),
-            "logging.enabled": z.boolean().optional(),
-            "logging.level": z.enum(['debug', 'info', 'warn', 'error']).optional(),
-            "audio.enabled": z.boolean().optional(),
-            "audio.provider": z.string().optional(),
-            "memory.limit": z.number().optional(),
-            // Add more specific fields as needed, or use a catch-all for other properties
-        }).passthrough(), // Allow additional properties not explicitly defined
+        updates: z.object({}).passthrough(),
     }),
 });

package/dist/types/config.js

@@ -10,6 +10,7 @@ export const DEFAULT_CONFIG = {
     },
     audio: {
         provider: 'google',
+        model: 'gemini-2.5-flash-lite',
         enabled: true,
         maxDurationSeconds: 300,
         supportedMimeTypes: ['audio/ogg', 'audio/mp3', 'audio/mpeg', 'audio/wav'],