dr-claw 1.1.2

package/server/utils/mcp-detector.js

@@ -0,0 +1,198 @@
+/**
+ * MCP SERVER DETECTION UTILITY
+ * ============================
+ * 
+ * Centralized utility for detecting MCP server configurations.
+ * Used across TaskMaster integration and other MCP-dependent features.
+ */
+
+import { promises as fsPromises } from 'fs';
+import path from 'path';
+import os from 'os';
+
+/**
+ * Check if task-master-ai MCP server is configured
+ * Reads directly from Claude configuration files like claude-cli.js does
+ * @returns {Promise<Object>} MCP detection result
+ */
+export async function detectTaskMasterMCPServer() {
+    try {
+        // Read Claude configuration files directly (same logic as mcp.js)
+        const homeDir = os.homedir();
+        const configPaths = [
+            path.join(homeDir, '.claude.json'),
+            path.join(homeDir, '.claude', 'settings.json')
+        ];
+        
+        let configData = null;
+        let configPath = null;
+        
+        // Try to read from either config file
+        for (const filepath of configPaths) {
+            try {
+                const fileContent = await fsPromises.readFile(filepath, 'utf8');
+                configData = JSON.parse(fileContent);
+                configPath = filepath;
+                break;
+            } catch (error) {
+                // File doesn't exist or is not valid JSON, try next
+                continue;
+            }
+        }
+        
+        if (!configData) {
+            return {
+                hasMCPServer: false,
+                reason: 'No Claude configuration file found',
+                hasConfig: false
+            };
+        }
+
+        // Look for task-master-ai in user-scoped MCP servers
+        let taskMasterServer = null;
+        if (configData.mcpServers && typeof configData.mcpServers === 'object') {
+            const serverEntry = Object.entries(configData.mcpServers).find(([name, config]) => 
+                name === 'task-master-ai' || 
+                name.includes('task-master') ||
+                (config && config.command && config.command.includes('task-master'))
+            );
+            
+            if (serverEntry) {
+                const [name, config] = serverEntry;
+                taskMasterServer = {
+                    name,
+                    scope: 'user',
+                    config,
+                    type: config.command ? 'stdio' : (config.url ? 'http' : 'unknown')
+                };
+            }
+        }
+
+        // Also check project-specific MCP servers if not found globally
+        if (!taskMasterServer && configData.projects) {
+            for (const [projectPath, projectConfig] of Object.entries(configData.projects)) {
+                if (projectConfig.mcpServers && typeof projectConfig.mcpServers === 'object') {
+                    const serverEntry = Object.entries(projectConfig.mcpServers).find(([name, config]) => 
+                        name === 'task-master-ai' || 
+                        name.includes('task-master') ||
+                        (config && config.command && config.command.includes('task-master'))
+                    );
+                    
+                    if (serverEntry) {
+                        const [name, config] = serverEntry;
+                        taskMasterServer = {
+                            name,
+                            scope: 'local',
+                            projectPath,
+                            config,
+                            type: config.command ? 'stdio' : (config.url ? 'http' : 'unknown')
+                        };
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (taskMasterServer) {
+            const isValid = !!(taskMasterServer.config && 
+                             (taskMasterServer.config.command || taskMasterServer.config.url));
+            const hasEnvVars = !!(taskMasterServer.config && 
+                                taskMasterServer.config.env && 
+                                Object.keys(taskMasterServer.config.env).length > 0);
+
+            return {
+                hasMCPServer: true,
+                isConfigured: isValid,
+                hasApiKeys: hasEnvVars,
+                scope: taskMasterServer.scope,
+                config: {
+                    command: taskMasterServer.config?.command,
+                    args: taskMasterServer.config?.args || [],
+                    url: taskMasterServer.config?.url,
+                    envVars: hasEnvVars ? Object.keys(taskMasterServer.config.env) : [],
+                    type: taskMasterServer.type
+                }
+            };
+        } else {
+            // Get list of available servers for debugging
+            const availableServers = [];
+            if (configData.mcpServers) {
+                availableServers.push(...Object.keys(configData.mcpServers));
+            }
+            if (configData.projects) {
+                for (const projectConfig of Object.values(configData.projects)) {
+                    if (projectConfig.mcpServers) {
+                        availableServers.push(...Object.keys(projectConfig.mcpServers).map(name => `local:${name}`));
+                    }
+                }
+            }
+
+            return {
+                hasMCPServer: false,
+                reason: 'task-master-ai not found in configured MCP servers',
+                hasConfig: true,
+                configPath,
+                availableServers
+            };
+        }
+    } catch (error) {
+        console.error('Error detecting MCP server config:', error);
+        return {
+            hasMCPServer: false,
+            reason: `Error checking MCP config: ${error.message}`,
+            hasConfig: false
+        };
+    }
+}
+
+/**
+ * Get all configured MCP servers (not just TaskMaster)
+ * @returns {Promise<Object>} All MCP servers configuration
+ */
+export async function getAllMCPServers() {
+    try {
+        const homeDir = os.homedir();
+        const configPaths = [
+            path.join(homeDir, '.claude.json'),
+            path.join(homeDir, '.claude', 'settings.json')
+        ];
+        
+        let configData = null;
+        let configPath = null;
+        
+        // Try to read from either config file
+        for (const filepath of configPaths) {
+            try {
+                const fileContent = await fsPromises.readFile(filepath, 'utf8');
+                configData = JSON.parse(fileContent);
+                configPath = filepath;
+                break;
+            } catch (error) {
+                continue;
+            }
+        }
+        
+        if (!configData) {
+            return {
+                hasConfig: false,
+                servers: {},
+                projectServers: {}
+            };
+        }
+
+        return {
+            hasConfig: true,
+            configPath,
+            servers: configData.mcpServers || {},
+            projectServers: configData.projects || {}
+        };
+    } catch (error) {
+        console.error('Error getting all MCP servers:', error);
+        return {
+            hasConfig: false,
+            error: error.message,
+            servers: {},
+            projectServers: {}
+        };
+    }
+}

package/server/utils/parsers/bibtex-parser.js

@@ -0,0 +1,207 @@
+/**
+ * Lightweight BibTeX parser — no external dependencies.
+ *
+ * Handles:
+ *  - @type{key, field = {value}, ...}
+ *  - @type{key, field = "value", ...}
+ *  - Nested braces in values
+ *  - Basic LaTeX accent commands (\'{e} → é, etc.)
+ *  - Concatenated string fields (field = {a} # {b})
+ */
+
+// Common LaTeX accent → unicode mappings
+const LATEX_ACCENTS = {
+  "`a": "à", "'a": "á", "^a": "â", "~a": "ã", '"a': "ä",
+  "`e": "è", "'e": "é", "^e": "ê", '"e': "ë",
+  "`i": "ì", "'i": "í", "^i": "î", '"i': "ï",
+  "`o": "ò", "'o": "ó", "^o": "ô", "~o": "õ", '"o': "ö",
+  "`u": "ù", "'u": "ú", "^u": "û", '"u': "ü",
+  "`A": "À", "'A": "Á", "^A": "Â", "~A": "Ã", '"A': "Ä",
+  "`E": "È", "'E": "É", "^E": "Ê", '"E': "Ë",
+  "`I": "Ì", "'I": "Í", "^I": "Î", '"I': "Ï",
+  "`O": "Ò", "'O": "Ó", "^O": "Ô", "~O": "Õ", '"O': "Ö",
+  "`U": "Ù", "'U": "Ú", "^U": "Û", '"U': "Ü",
+  "~n": "ñ", "~N": "Ñ", "cc": "ç", "cC": "Ç",
+};
+
+function cleanLatex(str) {
+  if (!str) return str;
+  // \'{e}  or  \'e  →  lookup
+  let result = str.replace(/\\([`'^"~c])\{([a-zA-Z])\}/g, (_, accent, char) => {
+    return LATEX_ACCENTS[accent + char] || char;
+  });
+  result = result.replace(/\\([`'^"~c])([a-zA-Z])/g, (_, accent, char) => {
+    return LATEX_ACCENTS[accent + char] || char;
+  });
+  // Strip remaining braces
+  result = result.replace(/[{}]/g, '');
+  // Common TeX commands
+  result = result.replace(/\\textit\s*/g, '');
+  result = result.replace(/\\textbf\s*/g, '');
+  result = result.replace(/\\emph\s*/g, '');
+  result = result.replace(/\\\\/g, ' ');
+  result = result.replace(/\\&/g, '&');
+  result = result.replace(/\\%/g, '%');
+  result = result.replace(/~/g, ' ');
+  return result.trim();
+}
+
+/**
+ * Parse a BibTeX string and return an array of entry objects.
+ */
+export function parseBibtex(bibtexString) {
+  const entries = [];
+  // Match each @type{...} block
+  const entryRegex = /@(\w+)\s*\{/g;
+  let match;
+
+  while ((match = entryRegex.exec(bibtexString)) !== null) {
+    const entryType = match[1].toLowerCase();
+    if (entryType === 'comment' || entryType === 'preamble' || entryType === 'string') continue;
+
+    const startIdx = match.index + match[0].length;
+    // Find the matching closing brace (handle nesting)
+    let depth = 1;
+    let i = startIdx;
+    while (i < bibtexString.length && depth > 0) {
+      if (bibtexString[i] === '{') depth++;
+      else if (bibtexString[i] === '}') depth--;
+      i++;
+    }
+    const body = bibtexString.slice(startIdx, i - 1);
+
+    // First token is the citation key
+    const commaIdx = body.indexOf(',');
+    if (commaIdx === -1) continue;
+    const citationKey = body.slice(0, commaIdx).trim();
+    const fieldsStr = body.slice(commaIdx + 1);
+
+    const fields = parseFields(fieldsStr);
+    entries.push({ entryType, citationKey, fields });
+  }
+
+  return entries.map(mapToReference);
+}
+
+function parseFields(str) {
+  const fields = {};
+  // State machine to parse: fieldname = {value} or "value"
+  let i = 0;
+  const len = str.length;
+
+  while (i < len) {
+    // Skip whitespace and commas
+    while (i < len && /[\s,]/.test(str[i])) i++;
+    if (i >= len) break;
+
+    // Read field name
+    let nameStart = i;
+    while (i < len && str[i] !== '=' && !/[\s,{}]/.test(str[i])) i++;
+    const fieldName = str.slice(nameStart, i).trim().toLowerCase();
+    if (!fieldName) { i++; continue; }
+
+    // Skip to =
+    while (i < len && str[i] !== '=') i++;
+    if (i >= len) break;
+    i++; // skip =
+
+    // Skip whitespace
+    while (i < len && /\s/.test(str[i])) i++;
+    if (i >= len) break;
+
+    // Read value — braced, quoted, or bare number
+    let value = '';
+    if (str[i] === '{') {
+      i++; // skip opening brace
+      let depth = 1;
+      let vStart = i;
+      while (i < len && depth > 0) {
+        if (str[i] === '{') depth++;
+        else if (str[i] === '}') depth--;
+        if (depth > 0) i++;
+      }
+      value = str.slice(vStart, i);
+      i++; // skip closing brace
+    } else if (str[i] === '"') {
+      i++; // skip opening quote
+      let vStart = i;
+      while (i < len && !(str[i] === '"' && str[i - 1] !== '\\')) i++;
+      value = str.slice(vStart, i).replace(/\\"/g, '"');
+      i++; // skip closing quote
+    } else {
+      // Bare value (number or string reference)
+      let vStart = i;
+      while (i < len && str[i] !== ',' && str[i] !== '}' && !/\s/.test(str[i])) i++;
+      value = str.slice(vStart, i);
+    }
+
+    // Handle # concatenation
+    while (i < len) {
+      // skip whitespace
+      let j = i;
+      while (j < len && /\s/.test(str[j])) j++;
+      if (str[j] !== '#') break;
+      j++; // skip #
+      while (j < len && /\s/.test(str[j])) j++;
+      i = j;
+      // Read next part
+      if (str[i] === '{') {
+        i++;
+        let depth = 1;
+        let vStart = i;
+        while (i < len && depth > 0) {
+          if (str[i] === '{') depth++;
+          else if (str[i] === '}') depth--;
+          if (depth > 0) i++;
+        }
+        value += str.slice(vStart, i);
+        i++;
+      } else if (str[i] === '"') {
+        i++;
+        let vStart = i;
+        while (i < len && !(str[i] === '"' && str[i - 1] !== '\\')) i++;
+        value += str.slice(vStart, i).replace(/\\"/g, '"');
+        i++;
+      }
+    }
+
+    if (fieldName) {
+      fields[fieldName] = cleanLatex(value);
+    }
+  }
+
+  return fields;
+}
+
+function parseAuthors(authorStr) {
+  if (!authorStr) return [];
+  return authorStr.split(/\s+and\s+/i).map((a) => {
+    const parts = a.trim().split(',').map((s) => s.trim());
+    if (parts.length >= 2) {
+      return { family: parts[0], given: parts.slice(1).join(' ') };
+    }
+    const words = a.trim().split(/\s+/);
+    if (words.length === 1) return { family: words[0], given: '' };
+    return { family: words[words.length - 1], given: words.slice(0, -1).join(' ') };
+  });
+}
+
+function mapToReference(entry) {
+  const f = entry.fields;
+  const yearStr = f.year || '';
+  const year = parseInt(yearStr, 10) || null;
+
+  return {
+    citationKey: entry.citationKey,
+    title: f.title || 'Untitled',
+    authors: parseAuthors(f.author),
+    year,
+    abstract: f.abstract || null,
+    doi: f.doi || null,
+    url: f.url || null,
+    journal: f.journal || f.journalname || f.booktitle || null,
+    itemType: entry.entryType || 'article',
+    keywords: f.keywords ? f.keywords.split(/[,;]/).map((k) => k.trim()).filter(Boolean) : [],
+    source: 'bibtex',
+  };
+}

package/server/utils/permissions.js

@@ -0,0 +1,100 @@
+import crypto from 'crypto';
+
+const pendingToolApprovals = new Map();
+const TOOL_APPROVAL_TIMEOUT_MS = parseInt(process.env.TOOL_APPROVAL_TIMEOUT_MS, 10) || 55000;
+
+export function createRequestId() {
+  if (typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  return crypto.randomBytes(16).toString('hex');
+}
+
+export function waitForToolApproval(requestId, options = {}) {
+  const { timeoutMs = TOOL_APPROVAL_TIMEOUT_MS, signal, onCancel } = options;
+
+  return new Promise(resolve => {
+    let settled = false;
+
+    const finalize = (decision) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(decision);
+    };
+
+    let timeout;
+
+    const cleanup = () => {
+      pendingToolApprovals.delete(requestId);
+      if (timeout) clearTimeout(timeout);
+      if (signal && abortHandler) {
+        signal.removeEventListener('abort', abortHandler);
+      }
+    };
+
+    // timeoutMs 0 = wait indefinitely (interactive tools)
+    if (timeoutMs > 0) {
+      timeout = setTimeout(() => {
+        onCancel?.('timeout');
+        finalize(null);
+      }, timeoutMs);
+    }
+
+    const abortHandler = () => {
+      onCancel?.('cancelled');
+      finalize({ cancelled: true });
+    };
+
+    if (signal) {
+      if (signal.aborted) {
+        onCancel?.('cancelled');
+        finalize({ cancelled: true });
+        return;
+      }
+      signal.addEventListener('abort', abortHandler, { once: true });
+    }
+
+    pendingToolApprovals.set(requestId, (decision) => {
+      finalize(decision);
+    });
+  });
+}
+
+export function resolveToolApproval(requestId, decision) {
+  const resolver = pendingToolApprovals.get(requestId);
+  if (resolver) {
+    resolver(decision);
+  }
+}
+
+// Match stored permission entries against a tool + input combo.
+export function matchesToolPermission(entry, toolName, input) {
+  if (!entry || !toolName) {
+    return false;
+  }
+
+  if (entry === toolName) {
+    return true;
+  }
+
+  const bashMatch = entry.match(/^Bash\((.+):\*\)$/);
+  if (toolName === 'Bash' && bashMatch) {
+    const allowedPrefix = bashMatch[1];
+    let command = '';
+
+    if (typeof input === 'string') {
+      command = input.trim();
+    } else if (input && typeof input === 'object' && typeof input.command === 'string') {
+      command = input.command.trim();
+    }
+
+    if (!command) {
+      return false;
+    }
+
+    return command.startsWith(allowedPrefix);
+  }
+
+  return false;
+}