mcp-config-manager 2.1.0 → 2.3.0

package/src/commands-manager.js

@@ -0,0 +1,268 @@
+import * as fs from 'fs/promises';
+import path from 'path';
+import { COMMANDS_PATH } from './skills-scopes.js';
+
+// Mock support for testing
+const USE_MOCK_COMMANDS = process.env.MCP_USE_MOCK_SKILLS === 'true';
+
+/**
+ * Parse YAML frontmatter from a command file
+ * Format:
+ * ---
+ * description: Command description
+ * tools: tool1, tool2
+ * ...other metadata
+ * ---
+ * Prompt content here
+ */
+function parseFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+
+  if (!frontmatterMatch) {
+    return { metadata: {}, content: content.trim() };
+  }
+
+  const [, yamlPart, bodyPart] = frontmatterMatch;
+  const metadata = {};
+
+  // Simple YAML parsing for key: value pairs
+  const lines = yamlPart.split('\n');
+  for (const line of lines) {
+    const match = line.match(/^(\w+):\s*(.*)$/);
+    if (match) {
+      const [, key, value] = match;
+      // Handle arrays (comma-separated values)
+      if (value.includes(',')) {
+        metadata[key] = value.split(',').map(v => v.trim());
+      } else if (value.startsWith('"') && value.endsWith('"')) {
+        metadata[key] = value.slice(1, -1);
+      } else if (value.startsWith("'") && value.endsWith("'")) {
+        metadata[key] = value.slice(1, -1);
+      } else {
+        metadata[key] = value;
+      }
+    }
+  }
+
+  return { metadata, content: bodyPart.trim() };
+}
+
+/**
+ * Generate YAML frontmatter string from metadata object
+ */
+function generateFrontmatter(metadata) {
+  if (!metadata || Object.keys(metadata).length === 0) {
+    return '';
+  }
+
+  const lines = ['---'];
+  for (const [key, value] of Object.entries(metadata)) {
+    if (Array.isArray(value)) {
+      lines.push(`${key}: ${value.join(', ')}`);
+    } else if (typeof value === 'string' && (value.includes(':') || value.includes('#') || value.includes('\n'))) {
+      lines.push(`${key}: "${value.replace(/"/g, '\\"')}"`);
+    } else {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  lines.push('---');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Validate command name to prevent path traversal attacks
+ */
+function validateCommandName(name) {
+  if (!name || name.includes('..') || name.includes('/') || name.includes('\\') || name.includes('\0')) {
+    throw new Error(`Invalid command name: '${name}'`);
+  }
+}
+
+/**
+ * CommandsManager handles CRUD operations for Claude Code slash commands
+ */
+export class CommandsManager {
+  constructor() {
+    this.mockCommandsInitialized = false;
+    this.commandsPath = COMMANDS_PATH;
+  }
+
+  async initializeMockCommands() {
+    if (USE_MOCK_COMMANDS && !this.mockCommandsInitialized) {
+      try {
+        const mockModule = await import('../test/mock-skills.js');
+        this.commandsPath = mockModule.MOCK_COMMANDS_PATH;
+        this.mockCommandsInitialized = true;
+      } catch (error) {
+        console.warn('Mock commands not available, using production path');
+      }
+    }
+  }
+
+  async getCommandsPath() {
+    await this.initializeMockCommands();
+    return this.commandsPath;
+  }
+
+  /**
+   * List all commands
+   */
+  async listCommands() {
+    const commandsPath = await this.getCommandsPath();
+    const commands = [];
+
+    try {
+      await fs.access(commandsPath);
+    } catch {
+      return commands; // Commands directory doesn't exist
+    }
+
+    const entries = await fs.readdir(commandsPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+      if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+
+      try {
+        const filePath = path.join(commandsPath, entry.name);
+        const content = await fs.readFile(filePath, 'utf-8');
+        const { metadata } = parseFrontmatter(content);
+
+        // Command name is the filename without .md extension
+        const name = entry.name.replace(/\.md$/, '');
+
+        commands.push({
+          name,
+          path: filePath,
+          description: metadata.description || '',
+          tools: Array.isArray(metadata.tools) ? metadata.tools : (metadata.tools ? [metadata.tools] : []),
+          metadata
+        });
+      } catch (error) {
+        console.warn(`Error reading command ${entry.name}:`, error.message);
+      }
+    }
+
+    return commands.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  /**
+   * Read a single command
+   */
+  async readCommand(commandName) {
+    validateCommandName(commandName);
+    const commandsPath = await this.getCommandsPath();
+    const filePath = path.join(commandsPath, `${commandName}.md`);
+
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const { metadata, content: promptContent } = parseFrontmatter(content);
+
+      return {
+        name: commandName,
+        path: filePath,
+        description: metadata.description || '',
+        tools: Array.isArray(metadata.tools) ? metadata.tools : (metadata.tools ? [metadata.tools] : []),
+        metadata,
+        content: promptContent,
+        fullContent: content
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`Command '${commandName}' not found`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Create or update a command
+   */
+  async writeCommand(commandName, data) {
+    validateCommandName(commandName);
+    const commandsPath = await this.getCommandsPath();
+
+    // Ensure commands directory exists
+    await fs.mkdir(commandsPath, { recursive: true });
+
+    const { metadata = {}, content = '' } = data;
+
+    // Generate full content with frontmatter
+    const frontmatter = generateFrontmatter(metadata);
+    const fullContent = frontmatter + content;
+
+    const filePath = path.join(commandsPath, `${commandName}.md`);
+    await fs.writeFile(filePath, fullContent, 'utf-8');
+
+    return { path: filePath, written: true };
+  }
+
+  /**
+   * Delete a command
+   */
+  async deleteCommand(commandName) {
+    validateCommandName(commandName);
+    const commandsPath = await this.getCommandsPath();
+    const filePath = path.join(commandsPath, `${commandName}.md`);
+
+    try {
+      await fs.unlink(filePath);
+      return { deleted: true, path: filePath };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`Command '${commandName}' not found`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Rename a command
+   */
+  async renameCommand(oldName, newName) {
+    validateCommandName(oldName);
+    validateCommandName(newName);
+    const commandsPath = await this.getCommandsPath();
+    const oldPath = path.join(commandsPath, `${oldName}.md`);
+    const newPath = path.join(commandsPath, `${newName}.md`);
+
+    try {
+      await fs.access(oldPath);
+    } catch {
+      throw new Error(`Command '${oldName}' not found`);
+    }
+
+    try {
+      await fs.access(newPath);
+      throw new Error(`Command '${newName}' already exists`);
+    } catch (error) {
+      if (error.code !== 'ENOENT' && !error.message.includes('already exists')) {
+        throw error;
+      }
+      if (error.message.includes('already exists')) {
+        throw error;
+      }
+    }
+
+    await fs.rename(oldPath, newPath);
+    return { renamed: true, from: oldName, to: newName };
+  }
+
+  /**
+   * Duplicate a command
+   */
+  async duplicateCommand(commandName, newName) {
+    validateCommandName(commandName);
+    validateCommandName(newName);
+    const command = await this.readCommand(commandName);
+
+    await this.writeCommand(newName, {
+      metadata: command.metadata,
+      content: command.content
+    });
+
+    return { duplicated: true, from: commandName, to: newName };
+  }
+}

package/src/config-manager.js

@@ -316,13 +316,11 @@ export class MCPConfigManager {
         }
       };
     } else if (format === 'codex') {
-      // Preserve other Codex settings and update only the mcp_servers table
+      // Preserve other Codex settings and replace the mcp_servers table entirely
+      // (don't merge with original, otherwise deleted servers get reintroduced)
       return {
         ...originalConfig,
-        mcp_servers: {
-          ...(originalConfig.mcp_servers || {}),
-          ...normalizedConfig.servers
-        }
+        mcp_servers: normalizedConfig.servers
       };
     }
     return originalConfig;

package/src/server.js

@@ -3,11 +3,15 @@ import cors from 'cors';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { MCPConfigManager } from './config-manager.js';
+import { SkillsManager } from './skills-manager.js';
+import { CommandsManager } from './commands-manager.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const manager = new MCPConfigManager();
+const skillsManager = new SkillsManager();
+const commandsManager = new CommandsManager();
 
 export function startServer(port = 3456) {
   const app = express();
@@ -193,6 +197,302 @@ export function startServer(port = 3456) {
     }
   });
 
+  // Skills API Routes - Per-Client Architecture
+
+  // Get skill tabs for a specific client
+  app.get('/api/clients/:client/tabs', async (req, res) => {
+    try {
+      const tabs = await skillsManager.getClientTabs(req.params.client);
+      res.json({ tabs });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Check if client has skills support
+  app.get('/api/clients/:client/has-skills', async (req, res) => {
+    try {
+      const hasSkills = await skillsManager.clientHasSkills(req.params.client);
+      res.json({ hasSkills });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // List items in a client's tab
+  app.get('/api/clients/:client/tabs/:tab/items', async (req, res) => {
+    try {
+      const items = await skillsManager.listItems(req.params.client, req.params.tab);
+      res.json({ items });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Get single item
+  app.get('/api/clients/:client/tabs/:tab/items/:name', async (req, res) => {
+    try {
+      const item = await skillsManager.readItem(req.params.client, req.params.tab, req.params.name);
+      res.json(item);
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Create item
+  app.post('/api/clients/:client/tabs/:tab/items/:name', async (req, res) => {
+    try {
+      const result = await skillsManager.writeItem(req.params.client, req.params.tab, req.params.name, req.body);
+      res.json({ success: true, ...result });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Update item
+  app.put('/api/clients/:client/tabs/:tab/items/:name', async (req, res) => {
+    try {
+      const result = await skillsManager.writeItem(req.params.client, req.params.tab, req.params.name, req.body);
+      res.json({ success: true, ...result });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Delete item
+  app.delete('/api/clients/:client/tabs/:tab/items/:name', async (req, res) => {
+    try {
+      const result = await skillsManager.deleteItem(req.params.client, req.params.tab, req.params.name);
+      res.json({ success: true, ...result });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // List files in a complex item
+  app.get('/api/clients/:client/tabs/:tab/items/:name/files', async (req, res) => {
+    try {
+      const files = await skillsManager.listItemFiles(req.params.client, req.params.tab, req.params.name);
+      res.json({ files });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Read file from complex item - Express 5 syntax: /*paramName for wildcard
+  app.get('/api/clients/:client/tabs/:tab/items/:name/files/*filePath', async (req, res) => {
+    try {
+      // filePath is an array of path segments in Express 5, join them
+      const filePath = Array.isArray(req.params.filePath)
+        ? req.params.filePath.join('/')
+        : req.params.filePath;
+      const file = await skillsManager.readItemFile(req.params.client, req.params.tab, req.params.name, filePath);
+      res.json(file);
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Write file in complex item - Express 5 syntax: /*paramName for wildcard
+  app.put('/api/clients/:client/tabs/:tab/items/:name/files/*filePath', async (req, res) => {
+    try {
+      // filePath will be an array of path segments, join them
+      const filePath = Array.isArray(req.params.filePath)
+        ? req.params.filePath.join('/')
+        : req.params.filePath;
+      const { content } = req.body;
+      const result = await skillsManager.writeItemFile(req.params.client, req.params.tab, req.params.name, filePath, content);
+      res.json({ success: true, ...result });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Copy item within same tab
+  app.post('/api/clients/:client/tabs/:tab/items/:name/copy', async (req, res) => {
+    try {
+      const { newName } = req.body;
+      const result = await skillsManager.copyItem(req.params.client, req.params.tab, req.params.name, newName);
+      res.json({ success: true, ...result });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Commands API Routes
+  app.get('/api/commands', async (req, res) => {
+    try {
+      const commands = await commandsManager.listCommands();
+      res.json({ commands });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.get('/api/commands/:name', async (req, res) => {
+    try {
+      const command = await commandsManager.readCommand(req.params.name);
+      res.json(command);
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post('/api/commands/:name', async (req, res) => {
+    try {
+      await commandsManager.writeCommand(req.params.name, req.body);
+      res.json({ success: true });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.put('/api/commands/:name', async (req, res) => {
+    try {
+      await commandsManager.writeCommand(req.params.name, req.body);
+      res.json({ success: true });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.delete('/api/commands/:name', async (req, res) => {
+    try {
+      await commandsManager.deleteCommand(req.params.name);
+      res.json({ success: true });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post('/api/commands/:name/rename', async (req, res) => {
+    try {
+      const { newName } = req.body;
+      await commandsManager.renameCommand(req.params.name, newName);
+      res.json({ success: true });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post('/api/commands/:name/duplicate', async (req, res) => {
+    try {
+      const { newName } = req.body;
+      await commandsManager.duplicateCommand(req.params.name, newName);
+      res.json({ success: true });
+    } catch (error) {
+      if (error.message.includes('not found')) {
+        return res.status(404).json({ error: error.message });
+      }
+      if (error.message.includes('Invalid') || error.message.includes('already exists')) {
+        return res.status(400).json({ error: error.message });
+      }
+      res.status(500).json({ error: error.message });
+    }
+  });
+
   app.listen(port, () => {
     console.log(`MCP Config Manager server running on http://localhost:${port}`);
   });