morpheus-cli 0.2.4 → 0.2.6

package/dist/cli/commands/init.js

@@ -30,6 +30,7 @@ export const initCommand = new Command('init')
             choices: [
                 { name: 'OpenAI', value: 'openai' },
                 { name: 'Anthropic', value: 'anthropic' },
+                { name: 'OpenRouter', value: 'openrouter' },
                 { name: 'Ollama', value: 'ollama' },
                 { name: 'Google Gemini', value: 'gemini' },
             ],
@@ -43,6 +44,9 @@ export const initCommand = new Command('init')
             case 'anthropic':
                 defaultModel = 'claude-3-5-sonnet-20240620';
                 break;
+            case 'openrouter':
+                defaultModel = 'openrouter/auto';
+                break;
             case 'ollama':
                 defaultModel = 'llama3';
                 break;
@@ -59,10 +63,23 @@ export const initCommand = new Command('init')
         });
         let apiKey;
         const hasExistingKey = !!currentConfig.llm.api_key;
-        const apiKeyMessage = hasExistingKey
+        let apiKeyMessage = hasExistingKey
             ? 'Enter API Key (leave empty to preserve existing, or if using env vars):'
             : 'Enter API Key (leave empty if using env vars):';
-        if (provider !== 'ollama') {
+        // Add info about environment variables to the message
+        if (provider === 'openai') {
+            apiKeyMessage = `${apiKeyMessage} (Env var: OPENAI_API_KEY)`;
+        }
+        else if (provider === 'anthropic') {
+            apiKeyMessage = `${apiKeyMessage} (Env var: ANTHROPIC_API_KEY)`;
+        }
+        else if (provider === 'gemini') {
+            apiKeyMessage = `${apiKeyMessage} (Env var: GOOGLE_API_KEY)`;
+        }
+        else if (provider === 'openrouter') {
+            apiKeyMessage = `${apiKeyMessage} (Env var: OPENROUTER_API_KEY)`;
+        }
+        if (provider !== 'ollama' && provider !== 'openrouter') {
             apiKey = await password({
                 message: apiKeyMessage,
             });
@@ -75,6 +92,14 @@ export const initCommand = new Command('init')
         if (apiKey) {
             await configManager.set('llm.api_key', apiKey);
         }
+        // Base URL Configuration for OpenRouter
+        if (provider === 'openrouter') {
+            const baseUrl = await input({
+                message: 'Enter OpenRouter Base URL:',
+                default: currentConfig.llm.base_url || 'https://openrouter.ai/api/v1',
+            });
+            await configManager.set('llm.base_url', baseUrl);
+        }
         // Context Window Configuration
         const contextWindow = await input({
             message: 'Context Window Size (number of messages to send to LLM):',
@@ -105,6 +130,7 @@ export const initCommand = new Command('init')
                 choices: [
                     { name: 'OpenAI', value: 'openai' },
                     { name: 'Anthropic', value: 'anthropic' },
+                    { name: 'OpenRouter', value: 'openrouter' },
                     { name: 'Ollama', value: 'ollama' },
                     { name: 'Google Gemini', value: 'gemini' },
                 ],
@@ -118,6 +144,9 @@ export const initCommand = new Command('init')
                 case 'anthropic':
                     defaultSatiModel = 'claude-3-5-sonnet-20240620';
                     break;
+                case 'openrouter':
+                    defaultSatiModel = 'openrouter/auto';
+                    break;
                 case 'ollama':
                     defaultSatiModel = 'llama3';
                     break;
@@ -133,9 +162,22 @@ export const initCommand = new Command('init')
                 default: defaultSatiModel,
             });
             const hasExistingSatiKey = !!currentConfig.santi?.api_key;
-            const santiKeyMsg = hasExistingSatiKey
-                ? 'Enter Sati API Key (leave empty to preserve existing):'
-                : 'Enter Sati API Key:';
+            let santiKeyMsg = hasExistingSatiKey
+                ? 'Enter Sati API Key (leave empty to preserve existing, or if using env vars):'
+                : 'Enter Sati API Key (leave empty if using env vars):';
+            // Add info about environment variables to the message
+            if (santiProvider === 'openai') {
+                santiKeyMsg = `${santiKeyMsg} (Env var: OPENAI_API_KEY)`;
+            }
+            else if (santiProvider === 'anthropic') {
+                santiKeyMsg = `${santiKeyMsg} (Env var: ANTHROPIC_API_KEY)`;
+            }
+            else if (santiProvider === 'gemini') {
+                santiKeyMsg = `${santiKeyMsg} (Env var: GOOGLE_API_KEY)`;
+            }
+            else if (santiProvider === 'openrouter') {
+                santiKeyMsg = `${santiKeyMsg} (Env var: OPENROUTER_API_KEY)`;
+            }
             const keyInput = await password({ message: santiKeyMsg });
             if (keyInput) {
                 santiApiKey = keyInput;
@@ -146,6 +188,14 @@ export const initCommand = new Command('init')
             else {
                 santiApiKey = undefined; // Ensure we don't accidentally carry over invalid state
             }
+            // Base URL Configuration for Sati OpenRouter
+            if (santiProvider === 'openrouter') {
+                const satiBaseUrl = await input({
+                    message: 'Enter Sati OpenRouter Base URL:',
+                    default: currentConfig.santi?.base_url || 'https://openrouter.ai/api/v1',
+                });
+                await configManager.set('santi.base_url', satiBaseUrl);
+            }
         }
         const memoryLimit = await input({
             message: 'Sati Memory Retrieval Limit (messages):',
@@ -171,9 +221,11 @@ export const initCommand = new Command('init')
             }
             else {
                 const hasExistingAudioKey = !!currentConfig.audio?.apiKey;
-                const audioKeyMessage = hasExistingAudioKey
-                    ? 'Enter Gemini API Key for Audio (leave empty to preserve existing):'
-                    : 'Enter Gemini API Key for Audio:';
+                let audioKeyMessage = hasExistingAudioKey
+                    ? 'Enter Gemini API Key for Audio (leave empty to preserve existing, or if using env vars):'
+                    : 'Enter Gemini API Key for Audio (leave empty if using env vars):';
+                // Add info about environment variables to the message
+                audioKeyMessage = `${audioKeyMessage} (Env var: GOOGLE_API_KEY)`;
                 audioKey = await password({
                     message: audioKeyMessage,
                 });
@@ -210,10 +262,13 @@ export const initCommand = new Command('init')
                 display.log(chalk.gray('1. Create a bot via @BotFather to get your token.'));
                 display.log(chalk.gray('2. Get your User ID via @userinfobot.\n'));
                 const hasExistingToken = !!currentConfig.channels.telegram?.token;
+                let telegramTokenMessage = hasExistingToken
+                    ? 'Enter Telegram Bot Token (leave empty to preserve existing, or if using env vars):'
+                    : 'Enter Telegram Bot Token (leave empty if using env vars):';
+                // Add info about environment variables to the message
+                telegramTokenMessage = `${telegramTokenMessage} (Env var: TELEGRAM_BOT_TOKEN)`;
                 const token = await password({
-                    message: hasExistingToken
-                        ? 'Enter Telegram Bot Token (leave empty to preserve existing):'
-                        : 'Enter Telegram Bot Token:',
+                    message: telegramTokenMessage,
                     validate: (value) => {
                         if (value.length > 0)
                             return true;

package/dist/cli/commands/restart.js

@@ -0,0 +1,167 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import { scaffold } from '../../runtime/scaffold.js';
+import { DisplayManager } from '../../runtime/display.js';
+import { writePid, readPid, isProcessRunning, clearPid, checkStalePid } from '../../runtime/lifecycle.js';
+import { ConfigManager } from '../../config/manager.js';
+import { renderBanner } from '../utils/render.js';
+import { TelegramAdapter } from '../../channels/telegram.js';
+import { PATHS } from '../../config/paths.js';
+import { Oracle } from '../../runtime/oracle.js';
+import { ProviderError } from '../../runtime/errors.js';
+import { HttpServer } from '../../http/server.js';
+import { getVersion } from '../utils/version.js';
+export const restartCommand = new Command('restart')
+    .description('Restart the Morpheus agent')
+    .option('--ui', 'Enable web UI', true)
+    .option('--no-ui', 'Disable web UI')
+    .option('-p, --port <number>', 'Port for web UI', '3333')
+    .action(async (options) => {
+    const display = DisplayManager.getInstance();
+    try {
+        // First, try to stop the current process
+        display.log(chalk.blue('Stopping current Morpheus process...'));
+        await checkStalePid();
+        const pid = await readPid();
+        if (pid) {
+            if (isProcessRunning(pid)) {
+                process.kill(pid, 'SIGTERM');
+                display.log(chalk.green(`Sent stop signal to Morpheus (PID: ${pid}).`));
+                // Wait a bit for the process to terminate
+                await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+            else {
+                display.log(chalk.yellow('Current process not running, continuing with restart...'));
+                await clearPid();
+            }
+        }
+        else {
+            display.log(chalk.yellow('No running process found, continuing with restart...'));
+        }
+        // Now start a new process
+        display.log(chalk.blue('Starting new Morpheus process...'));
+        renderBanner(getVersion());
+        await scaffold(); // Ensure env exists
+        // Cleanup stale PID first
+        await checkStalePid();
+        const existingPid = await readPid();
+        if (existingPid !== null && isProcessRunning(existingPid)) {
+            display.log(chalk.red(`Morpheus is already running (PID: ${existingPid})`));
+            process.exit(1);
+        }
+        // Check config existence
+        if (!await fs.pathExists(PATHS.config)) {
+            display.log(chalk.yellow("Configuration not found."));
+            display.log(chalk.cyan("Please run 'morpheus init' first to set up your agent."));
+            process.exit(1);
+        }
+        // Write current PID
+        await writePid(process.pid);
+        const configManager = ConfigManager.getInstance();
+        const config = await configManager.load();
+        // Initialize persistent logging
+        await display.initialize(config.logging);
+        display.log(chalk.green(`Morpheus Agent (${config.agent.name}) starting...`));
+        display.log(chalk.gray(`PID: ${process.pid}`));
+        if (options.ui) {
+            display.log(chalk.blue(`Web UI enabled to port ${options.port}`));
+        }
+        // Initialize Oracle
+        const oracle = new Oracle(config);
+        try {
+            display.startSpinner(`Initializing ${config.llm.provider} oracle...`);
+            await oracle.initialize();
+            display.stopSpinner();
+            display.log(chalk.green('✓ Oracle initialized'), { source: 'Oracle' });
+        }
+        catch (err) {
+            display.stopSpinner();
+            if (err instanceof ProviderError) {
+                display.log(chalk.red(`\nProvider Error (${err.provider}):`));
+                display.log(chalk.white(err.message));
+                if (err.suggestion) {
+                    display.log(chalk.yellow(`Tip: ${err.suggestion}`));
+                }
+            }
+            else {
+                display.log(chalk.red('\nOracle initialization failed:'));
+                display.log(chalk.white(err.message));
+                if (err.message.includes('API Key')) {
+                    display.log(chalk.yellow('Tip: Check your API key in configuration or environment variables.'));
+                }
+            }
+            await clearPid();
+            process.exit(1);
+        }
+        const adapters = [];
+        let httpServer;
+        // Initialize Web UI
+        if (options.ui && config.ui.enabled) {
+            try {
+                httpServer = new HttpServer();
+                // Use CLI port if provided and valid, otherwise fallback to config or default
+                const port = parseInt(options.port) || config.ui.port || 3333;
+                httpServer.start(port);
+            }
+            catch (e) {
+                display.log(chalk.red(`Failed to start Web UI: ${e.message}`));
+            }
+        }
+        // Initialize Telegram
+        if (config.channels.telegram.enabled) {
+            if (config.channels.telegram.token) {
+                const telegram = new TelegramAdapter(oracle);
+                try {
+                    await telegram.connect(config.channels.telegram.token, config.channels.telegram.allowedUsers || []);
+                    adapters.push(telegram);
+                }
+                catch (e) {
+                    display.log(chalk.red('Failed to initialize Telegram adapter. Continuing...'));
+                }
+            }
+            else {
+                display.log(chalk.yellow('Telegram enabled but no token provided. Skipping.'));
+            }
+        }
+        // Handle graceful shutdown
+        const shutdown = async (signal) => {
+            display.stopSpinner();
+            display.log(`\n${signal} received. Shutting down...`);
+            if (httpServer) {
+                httpServer.stop();
+            }
+            for (const adapter of adapters) {
+                await adapter.disconnect();
+            }
+            await clearPid();
+            process.exit(0);
+        };
+        process.on('SIGINT', () => shutdown('SIGINT'));
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
+        // Allow ESC to exit
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+            process.stdin.on('data', (key) => {
+                // ESC or Ctrl+C
+                if (key === '\u001B' || key === '\u0003') {
+                    shutdown('User Quit');
+                }
+            });
+        }
+        // Keep process alive (Mock Agent Loop)
+        display.startSpinner('Agent active and listening... (Press ctrl+c to stop)');
+        // Prevent node from exiting
+        setInterval(() => {
+            // Heartbeat or background tasks would go here
+        }, 5000);
+    }
+    catch (error) {
+        display.stopSpinner();
+        console.error(chalk.red('Failed to restart Morpheus:'), error.message);
+        await clearPid();
+        process.exit(1);
+    }
+});

package/dist/cli/index.js

@@ -5,6 +5,7 @@ import { statusCommand } from './commands/status.js';
 import { configCommand } from './commands/config.js';
 import { doctorCommand } from './commands/doctor.js';
 import { initCommand } from './commands/init.js';
+import { restartCommand } from './commands/restart.js';
 import { scaffold } from '../runtime/scaffold.js';
 import { getVersion } from './utils/version.js';
 export async function cli() {
@@ -19,6 +20,7 @@ export async function cli() {
     program.addCommand(initCommand);
     program.addCommand(startCommand);
     program.addCommand(stopCommand);
+    program.addCommand(restartCommand);
     program.addCommand(statusCommand);
     program.addCommand(configCommand);
     program.addCommand(doctorCommand);

package/dist/config/manager.js

@@ -5,6 +5,7 @@ import { PATHS } from './paths.js';
 import { setByPath } from './utils.js';
 import { ConfigSchema } from './schemas.js';
 import { migrateConfigFile } from '../runtime/migration.js';
+import { resolveApiKey, resolveModel, resolveNumeric, resolveString, resolveBoolean, resolveProvider, resolveStringArray } from './precedence.js';
 export class ConfigManager {
     static instance;
     config = DEFAULT_CONFIG;
@@ -18,16 +19,15 @@ export class ConfigManager {
     async load() {
         try {
             await migrateConfigFile();
+            let rawConfig = DEFAULT_CONFIG;
             if (await fs.pathExists(PATHS.config)) {
                 const raw = await fs.readFile(PATHS.config, 'utf8');
                 const parsed = yaml.load(raw);
                 // Validate and merge with defaults via Zod
-                this.config = ConfigSchema.parse(parsed);
-            }
-            else {
-                // File doesn't exist, use defaults
-                this.config = DEFAULT_CONFIG;
+                rawConfig = ConfigSchema.parse(parsed);
             }
+            // Apply environment variable precedence to the loaded config
+            this.config = this.applyEnvironmentVariablePrecedence(rawConfig);
         }
         catch (error) {
             console.error('Failed to load configuration:', error);
@@ -36,6 +36,85 @@ export class ConfigManager {
         }
         return this.config;
     }
+    applyEnvironmentVariablePrecedence(config) {
+        // Apply precedence to agent config
+        const agentConfig = {
+            name: resolveString('MORPHEUS_AGENT_NAME', config.agent.name, DEFAULT_CONFIG.agent.name),
+            personality: resolveString('MORPHEUS_AGENT_PERSONALITY', config.agent.personality, DEFAULT_CONFIG.agent.personality)
+        };
+        // Apply precedence to LLM config
+        const llmProvider = resolveProvider('MORPHEUS_LLM_PROVIDER', config.llm.provider, DEFAULT_CONFIG.llm.provider);
+        const llmConfig = {
+            provider: llmProvider,
+            model: resolveModel(llmProvider, 'MORPHEUS_LLM_MODEL', config.llm.model),
+            temperature: resolveNumeric('MORPHEUS_LLM_TEMPERATURE', config.llm.temperature, DEFAULT_CONFIG.llm.temperature),
+            max_tokens: config.llm.max_tokens !== undefined ? resolveNumeric('MORPHEUS_LLM_MAX_TOKENS', config.llm.max_tokens, config.llm.max_tokens) : undefined,
+            api_key: resolveApiKey(llmProvider, 'MORPHEUS_LLM_API_KEY', config.llm.api_key),
+            base_url: config.llm.base_url, // base_url doesn't have environment variable precedence for now
+            context_window: config.llm.context_window !== undefined ? resolveNumeric('MORPHEUS_LLM_CONTEXT_WINDOW', config.llm.context_window, DEFAULT_CONFIG.llm.context_window) : undefined
+        };
+        // Apply precedence to Sati config
+        let santiConfig;
+        if (config.santi) {
+            const santiProvider = resolveProvider('MORPHEUS_SANTI_PROVIDER', config.santi.provider, llmConfig.provider);
+            santiConfig = {
+                provider: santiProvider,
+                model: resolveModel(santiProvider, 'MORPHEUS_SANTI_MODEL', config.santi.model || llmConfig.model),
+                temperature: resolveNumeric('MORPHEUS_SANTI_TEMPERATURE', config.santi.temperature, llmConfig.temperature),
+                max_tokens: config.santi.max_tokens !== undefined ? resolveNumeric('MORPHEUS_SANTI_MAX_TOKENS', config.santi.max_tokens, config.santi.max_tokens) : llmConfig.max_tokens,
+                api_key: resolveApiKey(santiProvider, 'MORPHEUS_SANTI_API_KEY', config.santi.api_key || llmConfig.api_key),
+                base_url: config.santi.base_url || config.llm.base_url,
+                context_window: config.santi.context_window !== undefined ? resolveNumeric('MORPHEUS_SANTI_CONTEXT_WINDOW', config.santi.context_window, config.santi.context_window) : llmConfig.context_window,
+                memory_limit: config.santi.memory_limit !== undefined ? resolveNumeric('MORPHEUS_SANTI_MEMORY_LIMIT', config.santi.memory_limit, config.santi.memory_limit) : undefined
+            };
+        }
+        // Apply precedence to audio config
+        const audioConfig = {
+            provider: config.audio.provider, // Audio provider is fixed as 'google'
+            model: resolveString('MORPHEUS_AUDIO_MODEL', config.audio.model, DEFAULT_CONFIG.audio.model),
+            enabled: resolveBoolean('MORPHEUS_AUDIO_ENABLED', config.audio.enabled, DEFAULT_CONFIG.audio.enabled),
+            apiKey: resolveApiKey('gemini', 'MORPHEUS_AUDIO_API_KEY', config.audio.apiKey),
+            maxDurationSeconds: resolveNumeric('MORPHEUS_AUDIO_MAX_DURATION', config.audio.maxDurationSeconds, DEFAULT_CONFIG.audio.maxDurationSeconds),
+            supportedMimeTypes: config.audio.supportedMimeTypes
+        };
+        // Apply precedence to channel configs
+        const channelsConfig = {
+            telegram: {
+                enabled: resolveBoolean('MORPHEUS_TELEGRAM_ENABLED', config.channels.telegram.enabled, DEFAULT_CONFIG.channels.telegram.enabled),
+                token: resolveString('MORPHEUS_TELEGRAM_TOKEN', config.channels.telegram.token, config.channels.telegram.token || ''),
+                allowedUsers: resolveStringArray('MORPHEUS_TELEGRAM_ALLOWED_USERS', config.channels.telegram.allowedUsers, DEFAULT_CONFIG.channels.telegram.allowedUsers)
+            },
+            discord: {
+                enabled: config.channels.discord.enabled, // Discord doesn't have env var precedence for now
+                token: config.channels.discord.token
+            }
+        };
+        // Apply precedence to UI config
+        const uiConfig = {
+            enabled: resolveBoolean('MORPHEUS_UI_ENABLED', config.ui.enabled, DEFAULT_CONFIG.ui.enabled),
+            port: resolveNumeric('MORPHEUS_UI_PORT', config.ui.port, DEFAULT_CONFIG.ui.port)
+        };
+        // Apply precedence to logging config
+        const loggingConfig = {
+            enabled: resolveBoolean('MORPHEUS_LOGGING_ENABLED', config.logging.enabled, DEFAULT_CONFIG.logging.enabled),
+            level: resolveString('MORPHEUS_LOGGING_LEVEL', config.logging.level, DEFAULT_CONFIG.logging.level),
+            retention: resolveString('MORPHEUS_LOGGING_RETENTION', config.logging.retention, DEFAULT_CONFIG.logging.retention)
+        };
+        // Memory config (deprecated, but keeping for backward compatibility)
+        const memoryConfig = {
+            limit: config.memory.limit // Not applying env var precedence to deprecated field
+        };
+        return {
+            agent: agentConfig,
+            llm: llmConfig,
+            santi: santiConfig,
+            audio: audioConfig,
+            channels: channelsConfig,
+            ui: uiConfig,
+            logging: loggingConfig,
+            memory: memoryConfig
+        };
+    }
     get() {
         return this.config;
     }

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);
+    }
+}