coder-config 0.40.1

package/ui/routes/mcp-discovery.js

@@ -0,0 +1,235 @@
+/**
+ * MCP Server Discovery Routes
+ *
+ * Connects to MCP servers and discovers their available tools.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const os = require('os');
+
+// Cache for discovered tools (serverName -> { tools, timestamp })
+const toolsCache = new Map();
+const CACHE_TTL = 60000; // 1 minute cache
+
+/**
+ * Send a JSON-RPC message to an MCP server via stdio
+ */
+function sendMessage(proc, method, params = {}, id = 1) {
+  const message = {
+    jsonrpc: '2.0',
+    id,
+    method,
+    params
+  };
+  proc.stdin.write(JSON.stringify(message) + '\n');
+}
+
+/**
+ * Parse JSON-RPC responses from stdout
+ */
+function parseResponses(data) {
+  const responses = [];
+  const lines = data.toString().split('\n').filter(l => l.trim());
+
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed.jsonrpc === '2.0') {
+        responses.push(parsed);
+      }
+    } catch (e) {
+      // Skip non-JSON lines (could be server logs)
+    }
+  }
+
+  return responses;
+}
+
+/**
+ * Expand environment variables in a string
+ */
+function expandEnv(str, env = {}) {
+  if (typeof str !== 'string') return str;
+
+  // Combine process env with custom env
+  const fullEnv = { ...process.env, ...env };
+
+  return str.replace(/\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (match, p1, p2) => {
+    const varName = p1 || p2;
+    return fullEnv[varName] || match;
+  });
+}
+
+/**
+ * Discover tools from a stdio-based MCP server
+ */
+async function discoverStdioTools(serverName, config) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      proc.kill();
+      reject(new Error('Timeout waiting for server response'));
+    }, 10000); // 10 second timeout
+
+    // Expand environment variables in command and args
+    const command = expandEnv(config.command, config.env);
+    const args = (config.args || []).map(arg => expandEnv(arg, config.env));
+
+    // Prepare environment
+    const env = { ...process.env };
+    if (config.env) {
+      for (const [key, value] of Object.entries(config.env)) {
+        env[key] = expandEnv(value, config.env);
+      }
+    }
+
+    const proc = spawn(command, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env,
+      cwd: config.cwd || os.homedir(),
+      shell: process.platform === 'win32'
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let initialized = false;
+    let toolsReceived = false;
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+      const responses = parseResponses(data);
+
+      for (const response of responses) {
+        if (response.id === 1 && !initialized) {
+          // Initialize response received, now request tools
+          initialized = true;
+          sendMessage(proc, 'tools/list', {}, 2);
+        } else if (response.id === 2 && !toolsReceived) {
+          // Tools list response
+          toolsReceived = true;
+          clearTimeout(timeout);
+          proc.kill();
+
+          const tools = response.result?.tools || [];
+          resolve(tools.map(t => ({
+            name: t.name,
+            description: t.description || '',
+            inputSchema: t.inputSchema
+          })));
+        }
+      }
+    });
+
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timeout);
+      reject(new Error(`Failed to spawn server: ${err.message}`));
+    });
+
+    proc.on('close', (code) => {
+      if (!toolsReceived) {
+        clearTimeout(timeout);
+        reject(new Error(`Server exited with code ${code}. stderr: ${stderr.slice(0, 200)}`));
+      }
+    });
+
+    // Send initialize request
+    sendMessage(proc, 'initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: {
+        name: 'claude-config-ui',
+        version: '1.0.0'
+      }
+    }, 1);
+  });
+}
+
+/**
+ * Discover tools from an SSE-based MCP server
+ */
+async function discoverSseTools(serverName, config) {
+  // SSE servers are more complex - they require establishing an event stream
+  // For now, return empty and note that SSE discovery is not yet supported
+  return [];
+}
+
+/**
+ * Get tools for a specific MCP server
+ */
+async function getServerTools(manager, serverName) {
+  // Check cache first
+  const cached = toolsCache.get(serverName);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return { serverName, tools: cached.tools, cached: true };
+  }
+
+  // Get registry
+  const registry = manager.loadJson(manager.registryPath) || { mcpServers: {} };
+  const config = registry.mcpServers?.[serverName];
+
+  if (!config) {
+    return { serverName, error: 'Server not found in registry' };
+  }
+
+  try {
+    let tools;
+
+    if (config.command) {
+      // stdio server
+      tools = await discoverStdioTools(serverName, config);
+    } else if (config.url) {
+      // SSE server
+      tools = await discoverSseTools(serverName, config);
+    } else {
+      return { serverName, error: 'Unknown server type' };
+    }
+
+    // Cache the result
+    toolsCache.set(serverName, { tools, timestamp: Date.now() });
+
+    return { serverName, tools, cached: false };
+  } catch (err) {
+    return { serverName, error: err.message };
+  }
+}
+
+/**
+ * Get tools for all MCP servers
+ */
+async function getAllServerTools(manager) {
+  const registry = manager.loadJson(manager.registryPath) || { mcpServers: {} };
+  const serverNames = Object.keys(registry.mcpServers || {});
+
+  const results = await Promise.all(
+    serverNames.map(name => getServerTools(manager, name))
+  );
+
+  return results.reduce((acc, result) => {
+    acc[result.serverName] = result.error
+      ? { error: result.error }
+      : { tools: result.tools, cached: result.cached };
+    return acc;
+  }, {});
+}
+
+/**
+ * Clear the tools cache
+ */
+function clearCache(serverName = null) {
+  if (serverName) {
+    toolsCache.delete(serverName);
+  } else {
+    toolsCache.clear();
+  }
+  return { success: true };
+}
+
+module.exports = {
+  getServerTools,
+  getAllServerTools,
+  clearCache
+};

package/ui/routes/memory.js

@@ -0,0 +1,385 @@
+/**
+ * Memory Routes
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Get all memory files (global + project + sync)
+ */
+function getMemory(projectDir) {
+  const home = os.homedir();
+  const globalMemoryDir = path.join(home, '.claude', 'memory');
+  const projectMemoryDir = path.join(projectDir, '.claude', 'memory');
+  const syncDir = path.join(home, '.claude', 'sync');
+  const templatesDir = path.join(home, '.claude', 'templates', 'project-memory');
+
+  const result = {
+    global: {
+      dir: globalMemoryDir,
+      files: []
+    },
+    project: {
+      dir: projectMemoryDir,
+      files: [],
+      initialized: false
+    },
+    sync: {
+      dir: syncDir,
+      state: null,
+      history: []
+    },
+    templates: {
+      dir: templatesDir,
+      available: fs.existsSync(templatesDir)
+    }
+  };
+
+  // Global memory files
+  const globalFiles = ['index.md', 'preferences.md', 'corrections.md', 'facts.md'];
+  for (const file of globalFiles) {
+    const filePath = path.join(globalMemoryDir, file);
+    result.global.files.push({
+      name: file,
+      path: filePath,
+      exists: fs.existsSync(filePath),
+      type: file.replace('.md', '')
+    });
+  }
+
+  // Project memory files
+  const projectFiles = ['context.md', 'patterns.md', 'decisions.md', 'issues.md', 'history.md'];
+  result.project.initialized = fs.existsSync(projectMemoryDir);
+  for (const file of projectFiles) {
+    const filePath = path.join(projectMemoryDir, file);
+    result.project.files.push({
+      name: file,
+      path: filePath,
+      exists: fs.existsSync(filePath),
+      type: file.replace('.md', '')
+    });
+  }
+
+  // Sync state
+  const stateJsonPath = path.join(syncDir, 'state.json');
+  const stateMdPath = path.join(syncDir, 'state.md');
+  if (fs.existsSync(stateJsonPath)) {
+    try {
+      result.sync.state = JSON.parse(fs.readFileSync(stateJsonPath, 'utf8'));
+      result.sync.stateMd = fs.existsSync(stateMdPath) ? fs.readFileSync(stateMdPath, 'utf8') : null;
+    } catch (e) {
+      result.sync.state = null;
+    }
+  }
+
+  // Sync history
+  const historyDir = path.join(syncDir, 'history');
+  if (fs.existsSync(historyDir)) {
+    try {
+      const files = fs.readdirSync(historyDir)
+        .filter(f => f.endsWith('.json'))
+        .sort()
+        .reverse()
+        .slice(0, 10);
+      result.sync.history = files.map(f => ({
+        name: f,
+        path: path.join(historyDir, f)
+      }));
+    } catch (e) {}
+  }
+
+  return result;
+}
+
+/**
+ * Get a specific memory file content
+ */
+function getMemoryFile(filePath, projectDir) {
+  if (!filePath) {
+    return { error: 'Path required' };
+  }
+
+  const home = os.homedir();
+  const normalizedPath = path.resolve(filePath);
+  const isGlobalMemory = normalizedPath.startsWith(path.join(home, '.claude'));
+  const isProjectMemory = normalizedPath.startsWith(path.join(projectDir, '.claude'));
+
+  if (!isGlobalMemory && !isProjectMemory) {
+    return { error: 'Access denied: path must be within .claude directory' };
+  }
+
+  if (!fs.existsSync(normalizedPath)) {
+    return { content: '', exists: false };
+  }
+
+  try {
+    const content = fs.readFileSync(normalizedPath, 'utf8');
+    return { content, exists: true, path: normalizedPath };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+/**
+ * Save a memory file
+ */
+function saveMemoryFile(body, projectDir) {
+  const { path: filePath, content } = body;
+
+  if (!filePath) {
+    return { error: 'Path required' };
+  }
+
+  const home = os.homedir();
+  const normalizedPath = path.resolve(filePath);
+  const isGlobalMemory = normalizedPath.startsWith(path.join(home, '.claude'));
+  const isProjectMemory = normalizedPath.startsWith(path.join(projectDir, '.claude'));
+
+  if (!isGlobalMemory && !isProjectMemory) {
+    return { error: 'Access denied: path must be within .claude directory' };
+  }
+
+  try {
+    const dir = path.dirname(normalizedPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    fs.writeFileSync(normalizedPath, content, 'utf8');
+    return { success: true, path: normalizedPath };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+/**
+ * Add a memory entry to the appropriate file
+ */
+function addMemoryEntry(body, projectDir) {
+  const { type, content, scope = 'global' } = body;
+
+  if (!type || !content) {
+    return { error: 'Type and content required' };
+  }
+
+  const typeToFile = {
+    preference: { file: 'preferences.md', dir: 'global' },
+    correction: { file: 'corrections.md', dir: 'global' },
+    fact: { file: 'facts.md', dir: 'global' },
+    pattern: { file: 'patterns.md', dir: 'project' },
+    decision: { file: 'decisions.md', dir: 'project' },
+    issue: { file: 'issues.md', dir: 'project' },
+    history: { file: 'history.md', dir: 'project' },
+    context: { file: 'context.md', dir: 'project' }
+  };
+
+  const mapping = typeToFile[type];
+  if (!mapping) {
+    return { error: `Unknown type: ${type}. Valid types: ${Object.keys(typeToFile).join(', ')}` };
+  }
+
+  const home = os.homedir();
+  let targetDir;
+  if (mapping.dir === 'global' || scope === 'global') {
+    targetDir = path.join(home, '.claude', 'memory');
+  } else {
+    targetDir = path.join(projectDir, '.claude', 'memory');
+  }
+
+  const targetPath = path.join(targetDir, mapping.file);
+
+  try {
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+
+    let existing = '';
+    if (fs.existsSync(targetPath)) {
+      existing = fs.readFileSync(targetPath, 'utf8');
+    } else {
+      existing = `# ${type.charAt(0).toUpperCase() + type.slice(1)}s\n\n`;
+    }
+
+    const timestamp = new Date().toISOString().split('T')[0];
+    const entry = `\n## [${timestamp}]\n${content}\n`;
+
+    fs.writeFileSync(targetPath, existing + entry, 'utf8');
+
+    return { success: true, path: targetPath, type };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+/**
+ * Initialize project memory from templates
+ */
+function initProjectMemory(dir, projectDir) {
+  const targetDir = dir || projectDir;
+  const home = os.homedir();
+  const templatesDir = path.join(home, '.claude', 'templates', 'project-memory');
+  const memoryDir = path.join(targetDir, '.claude', 'memory');
+
+  if (!fs.existsSync(templatesDir)) {
+    const defaultTemplates = {
+      'context.md': `# Project Context\n\n## Overview\n[Describe what this project does]\n\n## Tech Stack\n- \n\n## Key Conventions\n- \n`,
+      'patterns.md': `# Code Patterns\n\n## Common Patterns\n[Document recurring patterns in this codebase]\n`,
+      'decisions.md': `# Architecture Decisions\n\n## ADRs\n[Record important decisions and their rationale]\n`,
+      'issues.md': `# Known Issues\n\n## Current Issues\n[Track bugs, limitations, and workarounds]\n`,
+      'history.md': `# Session History\n\n[Chronological log of significant work]\n`
+    };
+
+    try {
+      fs.mkdirSync(templatesDir, { recursive: true });
+      for (const [file, content] of Object.entries(defaultTemplates)) {
+        fs.writeFileSync(path.join(templatesDir, file), content, 'utf8');
+      }
+    } catch (e) {
+      return { error: `Failed to create templates: ${e.message}` };
+    }
+  }
+
+  if (fs.existsSync(memoryDir)) {
+    return { error: 'Project memory already exists', dir: memoryDir };
+  }
+
+  try {
+    fs.mkdirSync(memoryDir, { recursive: true });
+    const templateFiles = fs.readdirSync(templatesDir);
+
+    for (const file of templateFiles) {
+      const src = path.join(templatesDir, file);
+      const dest = path.join(memoryDir, file);
+      if (fs.statSync(src).isFile()) {
+        fs.copyFileSync(src, dest);
+      }
+    }
+
+    return { success: true, dir: memoryDir, files: templateFiles };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+/**
+ * Search memory files
+ */
+function searchMemory(query, projectDir) {
+  if (!query) {
+    return { results: [] };
+  }
+
+  const home = os.homedir();
+  const searchDirs = [
+    path.join(home, '.claude', 'memory'),
+    path.join(projectDir, '.claude', 'memory')
+  ];
+
+  const results = [];
+  const queryLower = query.toLowerCase();
+
+  for (const dir of searchDirs) {
+    if (!fs.existsSync(dir)) continue;
+
+    try {
+      const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+
+      for (const file of files) {
+        const filePath = path.join(dir, file);
+        const content = fs.readFileSync(filePath, 'utf8');
+
+        if (content.toLowerCase().includes(queryLower)) {
+          const lines = content.split('\n');
+          const matches = [];
+
+          for (let i = 0; i < lines.length; i++) {
+            if (lines[i].toLowerCase().includes(queryLower)) {
+              matches.push({
+                line: i + 1,
+                text: lines[i].trim().substring(0, 200)
+              });
+            }
+          }
+
+          if (matches.length > 0) {
+            results.push({
+              file,
+              path: filePath,
+              scope: dir.includes(projectDir) ? 'project' : 'global',
+              matches: matches.slice(0, 5)
+            });
+          }
+        }
+      }
+    } catch (e) {}
+  }
+
+  return { query, results };
+}
+
+/**
+ * Get sync state
+ */
+function getSyncState() {
+  const home = os.homedir();
+  const syncDir = path.join(home, '.claude', 'sync');
+
+  const result = {
+    dir: syncDir,
+    state: null,
+    stateMd: null,
+    history: []
+  };
+
+  const stateJsonPath = path.join(syncDir, 'state.json');
+  if (fs.existsSync(stateJsonPath)) {
+    try {
+      result.state = JSON.parse(fs.readFileSync(stateJsonPath, 'utf8'));
+    } catch (e) {}
+  }
+
+  const stateMdPath = path.join(syncDir, 'state.md');
+  if (fs.existsSync(stateMdPath)) {
+    try {
+      result.stateMd = fs.readFileSync(stateMdPath, 'utf8');
+    } catch (e) {}
+  }
+
+  const historyDir = path.join(syncDir, 'history');
+  if (fs.existsSync(historyDir)) {
+    try {
+      const files = fs.readdirSync(historyDir)
+        .filter(f => f.endsWith('.json'))
+        .sort()
+        .reverse()
+        .slice(0, 10);
+
+      result.history = files.map(f => {
+        const filePath = path.join(historyDir, f);
+        try {
+          return {
+            name: f,
+            path: filePath,
+            data: JSON.parse(fs.readFileSync(filePath, 'utf8'))
+          };
+        } catch (e) {
+          return { name: f, path: filePath, error: e.message };
+        }
+      });
+    } catch (e) {}
+  }
+
+  return result;
+}
+
+module.exports = {
+  getMemory,
+  getMemoryFile,
+  saveMemoryFile,
+  addMemoryEntry,
+  initProjectMemory,
+  searchMemory,
+  getSyncState,
+};

package/ui/routes/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}