Function handleMCPToolCall

bin/smallcode.js:2884–2955

(id, params)

}

async function handleMCPToolCall(id, params) {
  const { name, arguments: args } = params;
  const { safeResolvePath, escapeShellArg, sanitizeToolOutput } = require('../src/security/sanitize');
  const cwd = process.cwd();
  let result = '';

  switch (name) {
    case 'smallcode_read_file': {
      const safe = safeResolvePath(args.path, cwd);
      if (!safe.ok) return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `Error: ${safe.reason}` }], isError: true }};
      try { result = sanitizeToolOutput(fs.readFileSync(safe.fullPath, 'utf-8')); }
      catch (e) { return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true }}; }
      break;
    }
    case 'smallcode_bash': {
      const { execSync } = require('child_process');
      const command = String(args.command || '');
      // Apply same blocked-command checks as the agent's bash tool
      if (/rm\s+-rf\s+\/[^.]/.test(command) || /format\s+c:/i.test(command)) {
        return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Error: destructive command blocked' }], isError: true }};
      }
      try {
        const output = execSync(command, { encoding: 'utf-8', timeout: 30000, cwd, maxBuffer: 1024 * 1024 });
        result = sanitizeToolOutput(output).slice(0, 4000);
      } catch (e) { result = sanitizeToolOutput((e.stdout || '') + (e.stderr || e.message || '')).slice(0, 2000); }
      break;
    }
    case 'smallcode_search': {
      const { execSync } = require('child_process');
      const pattern = String(args.pattern || '');
      const searchPath = args.path ? safeResolvePath(args.path, cwd) : { ok: true, fullPath: '.' };
      if (!searchPath.ok) { result = `Error: ${searchPath.reason}`; break; }
      try {
        const cmd = 'rg --line-number --max-count 10 ' + escapeShellArg(pattern) + ' ' + escapeShellArg(searchPath.fullPath || '.');
        result = sanitizeToolOutput(execSync(cmd, { encoding: 'utf-8', timeout: 10000, cwd })).slice(0, 3000);
      } catch { result = 'No matches'; }
      break;
    }
    case 'smallcode_patch': {
      const safe = safeResolvePath(args.path, cwd);
      if (!safe.ok) { result = `Error: ${safe.reason}`; break; }
      try {
        let content = fs.readFileSync(safe.fullPath, 'utf-8');
        if (!content.includes(args.old_str)) { result = 'Error: old_str not found'; break; }
        const count = content.split(args.old_str).length - 1;
        if (count > 1) { result = `Error: old_str matches ${count} locations`; break; }
        content = content.replace(args.old_str, args.new_str);
        fs.writeFileSync(safe.fullPath, content);
        result = `Patched ${args.path}`;
      } catch (e) { result = `Error: ${e.message}`; }
      break;
    }
    case 'smallcode_memory_load': {
      const objects = memoryStore.loadForTask(args.task || '', 2000);
      // Handle both array return (MemoryStore in memory.js) and {objects} return
      const items = Array.isArray(objects) ? objects : (objects?.objects || []);
      result = items.length > 0
        ? items.map(o => `[${o.type}] ${o.title}: ${o.content}`).join('\n\n')