morpheus-cli 0.2.5 → 0.2.7

package/dist/config/mcp-manager.js

@@ -0,0 +1,140 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { MCPConfigFileSchema, MCPServerConfigSchema } from './schemas.js';
+import { DEFAULT_MCP_TEMPLATE } from '../types/mcp.js';
+import { MORPHEUS_ROOT } from './paths.js';
+const MCP_FILE_NAME = 'mcps.json';
+const RESERVED_KEYS = new Set(['$schema']);
+const readConfigFile = async () => {
+    const configPath = path.join(MORPHEUS_ROOT, MCP_FILE_NAME);
+    try {
+        const raw = await fs.readFile(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return MCPConfigFileSchema.parse(parsed);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return DEFAULT_MCP_TEMPLATE;
+        }
+        throw error;
+    }
+};
+const writeConfigFile = async (config) => {
+    const configPath = path.join(MORPHEUS_ROOT, MCP_FILE_NAME);
+    const serialized = JSON.stringify(config, null, 2) + '\n';
+    await fs.writeFile(configPath, serialized, 'utf-8');
+};
+const isMetadataKey = (key) => key.startsWith('_') || RESERVED_KEYS.has(key);
+const normalizeName = (rawName) => rawName.replace(/^\$/, '');
+const findRawKey = (config, name) => {
+    const direct = name in config ? name : null;
+    if (direct)
+        return direct;
+    const prefixed = `$${name}`;
+    if (prefixed in config)
+        return prefixed;
+    return null;
+};
+const ensureValidName = (name) => {
+    if (!name || name.trim().length === 0) {
+        throw new Error('Name is required.');
+    }
+    if (name.startsWith('_') || name === '$schema') {
+        throw new Error('Reserved names cannot be used for MCP servers.');
+    }
+};
+export class MCPManager {
+    static async listServers() {
+        const config = await readConfigFile();
+        const servers = [];
+        for (const [rawName, value] of Object.entries(config)) {
+            if (isMetadataKey(rawName))
+                continue;
+            if (rawName === '$schema')
+                continue;
+            if (!value || typeof value !== 'object')
+                continue;
+            try {
+                const parsed = MCPServerConfigSchema.parse(value);
+                const enabled = !rawName.startsWith('$');
+                servers.push({
+                    name: normalizeName(rawName),
+                    enabled,
+                    config: parsed,
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+        return servers;
+    }
+    static async addServer(name, config) {
+        ensureValidName(name);
+        const parsedConfig = MCPServerConfigSchema.parse(config);
+        const file = await readConfigFile();
+        const existing = findRawKey(file, name);
+        if (existing) {
+            throw new Error(`Server "${name}" already exists.`);
+        }
+        const next = {};
+        for (const [key, value] of Object.entries(file)) {
+            next[key] = value;
+        }
+        next[name] = parsedConfig;
+        await writeConfigFile(next);
+    }
+    static async updateServer(name, config) {
+        ensureValidName(name);
+        const parsedConfig = MCPServerConfigSchema.parse(config);
+        const file = await readConfigFile();
+        const rawKey = findRawKey(file, name);
+        if (!rawKey) {
+            throw new Error(`Server "${name}" not found.`);
+        }
+        const next = {};
+        for (const [key, value] of Object.entries(file)) {
+            if (key === rawKey) {
+                next[key] = parsedConfig;
+            }
+            else {
+                next[key] = value;
+            }
+        }
+        await writeConfigFile(next);
+    }
+    static async deleteServer(name) {
+        ensureValidName(name);
+        const file = await readConfigFile();
+        const rawKey = findRawKey(file, name);
+        if (!rawKey) {
+            throw new Error(`Server "${name}" not found.`);
+        }
+        const next = {};
+        for (const [key, value] of Object.entries(file)) {
+            if (key === rawKey)
+                continue;
+            next[key] = value;
+        }
+        await writeConfigFile(next);
+    }
+    static async setServerEnabled(name, enabled) {
+        ensureValidName(name);
+        const file = await readConfigFile();
+        const rawKey = findRawKey(file, name);
+        if (!rawKey) {
+            throw new Error(`Server "${name}" not found.`);
+        }
+        const targetKey = enabled ? normalizeName(rawKey) : `$${normalizeName(rawKey)}`;
+        const next = {};
+        for (const [key, value] of Object.entries(file)) {
+            if (key === rawKey) {
+                next[targetKey] = value;
+            }
+            else {
+                next[key] = value;
+            }
+        }
+        await writeConfigFile(next);
+    }
+}

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) => {