mcp-config-manager 2.1.1 → 2.3.0

package/src/skills-manager.js

@@ -0,0 +1,555 @@
+import * as fs from 'fs/promises';
+import path from 'path';
+import { CLIENT_SKILLS, getClientSkillTabs, getClientSkillTab, clientHasSkills } from './skills-scopes.js';
+
+// Mock support for testing
+const USE_MOCK_SKILLS = process.env.MCP_USE_MOCK_SKILLS === 'true';
+
+/**
+ * Parse YAML frontmatter from a markdown file
+ */
+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 = {};
+
+  const lines = yamlPart.split('\n');
+  for (const line of lines) {
+    const match = line.match(/^(\w+):\s*(.*)$/);
+    if (match) {
+      const [, key, value] = match;
+      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 item name to prevent path traversal attacks
+ */
+function validateItemName(name) {
+  if (!name || name.includes('..') || name.includes('/') || name.includes('\\') || name.includes('\0')) {
+    throw new Error(`Invalid item name: '${name}'`);
+  }
+}
+
+/**
+ * SkillsManager handles CRUD operations for client-specific skills/prompts/rules
+ */
+export class SkillsManager {
+  constructor() {
+    this.mockSkillsInitialized = false;
+    this.clientSkills = { ...CLIENT_SKILLS };
+  }
+
+  async initializeMockSkills() {
+    if (USE_MOCK_SKILLS && !this.mockSkillsInitialized) {
+      try {
+        const mockModule = await import('../test/mock-skills.js');
+        if (mockModule.MOCK_CLIENT_SKILLS) {
+          this.clientSkills = mockModule.MOCK_CLIENT_SKILLS;
+        }
+        this.mockSkillsInitialized = true;
+      } catch (error) {
+        console.warn('Mock skills not available, using production paths');
+      }
+    }
+  }
+
+  /**
+   * Get skill tabs for a client
+   */
+  async getClientTabs(clientId) {
+    await this.initializeMockSkills();
+    const config = this.clientSkills[clientId];
+    return config ? config.tabs : [];
+  }
+
+  /**
+   * Get a specific tab for a client
+   */
+  async getClientTab(clientId, tabId) {
+    const tabs = await this.getClientTabs(clientId);
+    return tabs.find(t => t.id === tabId);
+  }
+
+  /**
+   * Check if client has skill support
+   */
+  async clientHasSkills(clientId) {
+    const tabs = await this.getClientTabs(clientId);
+    return tabs && tabs.length > 0;
+  }
+
+  /**
+   * List all items in a client's skill tab
+   */
+  async listItems(clientId, tabId) {
+    const tab = await this.getClientTab(clientId, tabId);
+    if (!tab) {
+      throw new Error(`Tab '${tabId}' not found for client '${clientId}'`);
+    }
+
+    const items = [];
+
+    try {
+      await fs.access(tab.path);
+    } catch {
+      return items; // Directory doesn't exist
+    }
+
+    // Handle single-file tabs (like GEMINI.md, AGENTS.md)
+    if (tab.singleFile) {
+      const filePath = path.join(tab.path, tab.filePattern);
+      try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const { metadata } = parseFrontmatter(content);
+        items.push({
+          name: tab.filePattern.replace('.md', ''),
+          type: 'single',
+          path: filePath,
+          metadata,
+          exists: true
+        });
+      } catch {
+        items.push({
+          name: tab.filePattern.replace('.md', ''),
+          type: 'single',
+          path: filePath,
+          metadata: {},
+          exists: false
+        });
+      }
+      return items;
+    }
+
+    // Handle directory-based tabs
+    const entries = await fs.readdir(tab.path, { withFileTypes: true });
+    const ext = tab.filePattern.replace('*', '');
+
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+
+      const entryPath = path.join(tab.path, entry.name);
+
+      try {
+        if (entry.isDirectory() && tab.supportsDirectories) {
+          // Complex item - directory with main file
+          const mainFile = path.join(entryPath, 'SKILL.md');
+          try {
+            const content = await fs.readFile(mainFile, 'utf-8');
+            const { metadata } = parseFrontmatter(content);
+
+            const subEntries = await fs.readdir(entryPath, { withFileTypes: true });
+            const hasWorkflows = subEntries.some(e => e.name === 'workflows' && e.isDirectory());
+            const hasReferences = subEntries.some(e => e.name === 'references' && e.isDirectory());
+
+            items.push({
+              name: entry.name,
+              type: 'complex',
+              path: entryPath,
+              metadata: {
+                name: metadata.name || entry.name,
+                description: metadata.description || '',
+                ...metadata
+              },
+              structure: { hasWorkflows, hasReferences }
+            });
+          } catch {
+            // Directory doesn't have SKILL.md, skip
+          }
+        } else if (entry.isFile() && entry.name.endsWith(ext) && entry.name !== 'README.md') {
+          // Simple item - single file
+          const itemName = entry.name.replace(ext, '');
+          const content = await fs.readFile(entryPath, 'utf-8');
+          const { metadata } = parseFrontmatter(content);
+
+          items.push({
+            name: itemName,
+            type: 'simple',
+            path: entryPath,
+            metadata: {
+              name: metadata.name || itemName,
+              description: metadata.description || '',
+              ...metadata
+            }
+          });
+        }
+      } catch (error) {
+        console.warn(`Error reading item ${entry.name}:`, error.message);
+      }
+    }
+
+    return items.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  /**
+   * Read a single item's content
+   */
+  async readItem(clientId, tabId, itemName) {
+    validateItemName(itemName);
+    const tab = await this.getClientTab(clientId, tabId);
+    if (!tab) {
+      throw new Error(`Tab '${tabId}' not found for client '${clientId}'`);
+    }
+
+    // Handle single-file tabs
+    if (tab.singleFile) {
+      const filePath = path.join(tab.path, tab.filePattern);
+      try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const { metadata, content: bodyContent } = parseFrontmatter(content);
+        return {
+          name: itemName,
+          type: 'single',
+          path: filePath,
+          metadata,
+          content: bodyContent,
+          fullContent: content
+        };
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          return {
+            name: itemName,
+            type: 'single',
+            path: filePath,
+            metadata: {},
+            content: '',
+            fullContent: '',
+            exists: false
+          };
+        }
+        throw error;
+      }
+    }
+
+    const ext = tab.filePattern.replace('*', '');
+
+    // Try complex item first (directory)
+    if (tab.supportsDirectories) {
+      const dirPath = path.join(tab.path, itemName);
+      try {
+        const stat = await fs.stat(dirPath);
+        if (stat.isDirectory()) {
+          const mainFile = path.join(dirPath, 'SKILL.md');
+          const content = await fs.readFile(mainFile, 'utf-8');
+          const { metadata, content: bodyContent } = parseFrontmatter(content);
+
+          return {
+            name: itemName,
+            type: 'complex',
+            path: dirPath,
+            metadata,
+            content: bodyContent,
+            fullContent: content
+          };
+        }
+      } catch {
+        // Not a directory or doesn't exist
+      }
+    }
+
+    // Try simple item (file)
+    const filePath = path.join(tab.path, `${itemName}${ext}`);
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const { metadata, content: bodyContent } = parseFrontmatter(content);
+
+      return {
+        name: itemName,
+        type: 'simple',
+        path: filePath,
+        metadata,
+        content: bodyContent,
+        fullContent: content
+      };
+    } catch (error) {
+      throw new Error(`Item '${itemName}' not found in ${clientId}/${tabId}`);
+    }
+  }
+
+  /**
+   * Write/create an item
+   */
+  async writeItem(clientId, tabId, itemName, data) {
+    validateItemName(itemName);
+    const tab = await this.getClientTab(clientId, tabId);
+    if (!tab) {
+      throw new Error(`Tab '${tabId}' not found for client '${clientId}'`);
+    }
+
+    // Ensure directory exists
+    await fs.mkdir(tab.path, { recursive: true });
+
+    const { type = 'simple', metadata = {}, content = '' } = data;
+    const frontmatter = generateFrontmatter(metadata);
+    const fullContent = frontmatter + content;
+
+    // Handle single-file tabs
+    if (tab.singleFile) {
+      const filePath = path.join(tab.path, tab.filePattern);
+      await fs.writeFile(filePath, fullContent, 'utf-8');
+      return { path: filePath, type: 'single' };
+    }
+
+    const ext = tab.filePattern.replace('*', '');
+
+    if (type === 'simple') {
+      const filePath = path.join(tab.path, `${itemName}${ext}`);
+      await fs.writeFile(filePath, fullContent, 'utf-8');
+      return { path: filePath, type: 'simple' };
+    } else if (type === 'complex' && tab.supportsDirectories) {
+      const dirPath = path.join(tab.path, itemName);
+      await fs.mkdir(dirPath, { recursive: true });
+
+      const mainFile = path.join(dirPath, 'SKILL.md');
+      await fs.writeFile(mainFile, fullContent, 'utf-8');
+
+      if (data.createWorkflows) {
+        await fs.mkdir(path.join(dirPath, 'workflows'), { recursive: true });
+      }
+      if (data.createReferences) {
+        await fs.mkdir(path.join(dirPath, 'references'), { recursive: true });
+      }
+
+      return { path: dirPath, type: 'complex' };
+    }
+
+    throw new Error(`Invalid item type '${type}' for tab '${tabId}'`);
+  }
+
+  /**
+   * Delete an item
+   */
+  async deleteItem(clientId, tabId, itemName) {
+    validateItemName(itemName);
+    const tab = await this.getClientTab(clientId, tabId);
+    if (!tab) {
+      throw new Error(`Tab '${tabId}' not found for client '${clientId}'`);
+    }
+
+    // Cannot delete single-file items, only clear content
+    if (tab.singleFile) {
+      const filePath = path.join(tab.path, tab.filePattern);
+      await fs.writeFile(filePath, '', 'utf-8');
+      return { deleted: false, cleared: true, path: filePath };
+    }
+
+    const ext = tab.filePattern.replace('*', '');
+
+    // Try complex item first (directory)
+    if (tab.supportsDirectories) {
+      const dirPath = path.join(tab.path, itemName);
+      try {
+        const stat = await fs.stat(dirPath);
+        if (stat.isDirectory()) {
+          await fs.rm(dirPath, { recursive: true });
+          return { deleted: true, type: 'complex', path: dirPath };
+        }
+      } catch {
+        // Not a directory
+      }
+    }
+
+    // Try simple item (file)
+    const filePath = path.join(tab.path, `${itemName}${ext}`);
+    try {
+      await fs.unlink(filePath);
+      return { deleted: true, type: 'simple', path: filePath };
+    } catch (error) {
+      throw new Error(`Item '${itemName}' not found in ${clientId}/${tabId}`);
+    }
+  }
+
+  /**
+   * List files in a complex item
+   */
+  async listItemFiles(clientId, tabId, itemName) {
+    validateItemName(itemName);
+    const tab = await this.getClientTab(clientId, tabId);
+    if (!tab || !tab.supportsDirectories) {
+      throw new Error(`Tab '${tabId}' does not support directories`);
+    }
+
+    const itemPath = path.join(tab.path, itemName);
+    const stat = await fs.stat(itemPath);
+    if (!stat.isDirectory()) {
+      throw new Error(`Item '${itemName}' is not a complex item`);
+    }
+
+    const files = [];
+
+    async function walkDir(dir, relativePath = '') {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.name.startsWith('.')) continue;
+
+        const fullPath = path.join(dir, entry.name);
+        const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+
+        if (entry.isDirectory()) {
+          files.push({ name: entry.name, path: relPath, type: 'directory' });
+          await walkDir(fullPath, relPath);
+        } else {
+          const fileStat = await fs.stat(fullPath);
+          files.push({
+            name: entry.name,
+            path: relPath,
+            type: 'file',
+            size: fileStat.size,
+            modified: fileStat.mtime
+          });
+        }
+      }
+    }
+
+    await walkDir(itemPath);
+    return files;
+  }
+
+  /**
+   * Read a file from a complex item
+   */
+  async readItemFile(clientId, tabId, itemName, filePath) {
+    validateItemName(itemName);
+    const tab = await this.getClientTab(clientId, tabId);
+    if (!tab) {
+      throw new Error(`Tab '${tabId}' not found`);
+    }
+
+    const fullPath = path.join(tab.path, itemName, filePath);
+    const realItemDir = await fs.realpath(path.join(tab.path, itemName));
+    const realPath = await fs.realpath(fullPath);
+
+    if (!realPath.startsWith(realItemDir + path.sep) && realPath !== realItemDir) {
+      throw new Error('Invalid file path');
+    }
+
+    const content = await fs.readFile(fullPath, 'utf-8');
+    const stat = await fs.stat(fullPath);
+
+    return { path: filePath, content, size: stat.size, modified: stat.mtime };
+  }
+
+  /**
+   * Write a file in a complex item
+   */
+  async writeItemFile(clientId, tabId, itemName, filePath, content) {
+    validateItemName(itemName);
+    const tab = await this.getClientTab(clientId, tabId);
+    if (!tab) {
+      throw new Error(`Tab '${tabId}' not found`);
+    }
+
+    const fullPath = path.join(tab.path, itemName, filePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+
+    const realItemDir = await fs.realpath(path.join(tab.path, itemName));
+    const realPath = await fs.realpath(fullPath);
+
+    if (!realPath.startsWith(realItemDir + path.sep) && realPath !== realItemDir) {
+      throw new Error('Invalid file path');
+    }
+
+    await fs.writeFile(fullPath, content, 'utf-8');
+
+    return { path: filePath, written: true };
+  }
+
+  /**
+   * Copy an item within the same tab
+   */
+  async copyItem(clientId, tabId, itemName, newName) {
+    validateItemName(itemName);
+    validateItemName(newName);
+    const item = await this.readItem(clientId, tabId, itemName);
+
+    await this.writeItem(clientId, tabId, newName, {
+      type: item.type,
+      metadata: item.metadata,
+      content: item.content
+    });
+
+    return { copied: true, from: itemName, to: newName };
+  }
+
+  // Legacy compatibility methods
+  async listScopes() {
+    return [];
+  }
+
+  async listSkills(scopeId) {
+    return [];
+  }
+
+  async listAllSkills() {
+    return [];
+  }
+
+  async readSkill(scopeId, skillName) {
+    return null;
+  }
+
+  async writeSkill(scopeId, skillName, data) {
+    throw new Error('Use writeItem instead');
+  }
+
+  async deleteSkill(scopeId, skillName) {
+    throw new Error('Use deleteItem instead');
+  }
+
+  async readRegistry() {
+    return { skills: [] };
+  }
+
+  async importFromGitHub(url, toScope) {
+    return { imported: false, message: 'GitHub import not supported in per-client mode' };
+  }
+
+  async getClientsWithScopes() {
+    return [];
+  }
+
+  async listScopesByClient(clientId) {
+    return [];
+  }
+}