morpheus-cli 0.2.5 → 0.2.6

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