draco-cli 0.0.0-stage → 3.0.3

package/src/integrations/mcp-manager.js

@@ -0,0 +1,248 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const config = require('../config.js');
+const ui = require('../ui/terminal.js');
+
+const REQUEST_TIMEOUT_MS = 30000;
+const MAX_TOOL_RESULT_CHARS = 32000;
+
+class McpServer {
+  constructor(name, definition) {
+    this.name = name;
+    this.definition = definition;
+    this.proc = null;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.buffer = '';
+    this.tools = [];
+    this.ready = false;
+  }
+
+  connect() {
+    const def = this.definition;
+    if (!def || typeof def.command !== 'string') {
+      throw new Error(`server "${this.name}" needs a "command" field`);
+    }
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      try {
+        this.proc = spawn(def.command, Array.isArray(def.args) ? def.args : [], {
+          env: { ...process.env, ...(def.env || {}) },
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+      } catch (e) {
+        return reject(e);
+      }
+      const failTimer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          reject(new Error(`MCP server "${this.name}" did not respond in time`));
+        }
+      }, REQUEST_TIMEOUT_MS);
+
+      this.proc.stdout.on('data', (chunk) => this.onData(chunk));
+      this.proc.stderr.on('data', () => {});
+      this.proc.on('error', (e) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(failTimer);
+          reject(e);
+        }
+      });
+      this.proc.on('exit', () => {
+        for (const p of this.pending.values()) {
+          p.reject(new Error(`MCP server "${this.name}" exited`));
+        }
+        this.pending.clear();
+        this.ready = false;
+      });
+
+      this.request('initialize', {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: { name: 'draco-cli', version: config.VERSION },
+      })
+        .then(async () => {
+          this.notify('notifications/initialized', {});
+          const res = await this.request('tools/list', {});
+          this.tools = Array.isArray(res.tools) ? res.tools : [];
+          this.ready = true;
+          settled = true;
+          clearTimeout(failTimer);
+          resolve(this.tools);
+        })
+        .catch((e) => {
+          if (!settled) {
+            settled = true;
+            clearTimeout(failTimer);
+            reject(e);
+          }
+        });
+    });
+  }
+
+  onData(chunk) {
+    this.buffer += chunk.toString('utf8');
+    let nl;
+    while ((nl = this.buffer.indexOf('\n')) >= 0) {
+      const line = this.buffer.slice(0, nl).trim();
+      this.buffer = this.buffer.slice(nl + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (msg.id !== undefined && this.pending.has(msg.id)) {
+        const p = this.pending.get(msg.id);
+        this.pending.delete(msg.id);
+        if (msg.error) p.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+        else p.resolve(msg.result);
+      }
+    }
+  }
+
+  send(obj) {
+    if (!this.proc || !this.proc.stdin.writable) throw new Error(`MCP server "${this.name}" is not running`);
+    this.proc.stdin.write(JSON.stringify(obj) + '\n');
+  }
+
+  request(method, params) {
+    const id = this.nextId++;
+    const payload = { jsonrpc: '2.0', id, method, params };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP request "${method}" timed out`));
+      }, REQUEST_TIMEOUT_MS);
+      this.pending.set(id, {
+        resolve: (v) => {
+          clearTimeout(timer);
+          resolve(v);
+        },
+        reject: (e) => {
+          clearTimeout(timer);
+          reject(e);
+        },
+      });
+      try {
+        this.send(payload);
+      } catch (e) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(e);
+      }
+    });
+  }
+
+  notify(method, params) {
+    try {
+      this.send({ jsonrpc: '2.0', method, params });
+    } catch {
+      // notifications are best-effort
+    }
+  }
+
+  async callTool(toolName, args) {
+    const result = await this.request('tools/call', { name: toolName, arguments: args || {} });
+    if (result && result.isError) {
+      const errText = extractText(result).slice(0, 500);
+      throw new Error(errText || 'tool reported an error');
+    }
+    return extractText(result);
+  }
+
+  stop() {
+    if (this.proc) {
+      try {
+        this.proc.kill();
+      } catch {}
+      this.proc = null;
+      this.ready = false;
+    }
+  }
+}
+
+function extractText(result) {
+  if (!result) return '';
+  const content = Array.isArray(result.content) ? result.content : [];
+  const parts = content
+    .filter((item) => item && item.type === 'text' && typeof item.text === 'string')
+    .map((item) => item.text);
+  const text = parts.join('\n').trim();
+  return truncate(text);
+}
+
+function truncate(text, max = MAX_TOOL_RESULT_CHARS) {
+  if (text.length <= max) return text;
+  return text.slice(0, max) + `\n[...truncated ${text.length - max} chars...]`;
+}
+
+class McpManager {
+  constructor(serverDefs) {
+    this.servers = [];
+    for (const [name, definition] of Object.entries(serverDefs || {})) {
+      this.servers.push(new McpServer(name, definition));
+    }
+  }
+
+  async startAll() {
+    const summaries = [];
+    for (const server of this.servers) {
+      try {
+        const tools = await server.connect();
+        summaries.push(`${server.name}: ${tools.length} tool(s)`);
+      } catch (e) {
+        ui.error(`MCP server "${server.name}" failed to start (${e.message}). Continuing without it.`);
+      }
+    }
+    return summaries;
+  }
+
+  listTools() {
+    const out = [];
+    for (const server of this.servers) {
+      if (!server.ready) continue;
+      for (const tool of server.tools) {
+        out.push({
+          qualifiedName: `mcp_${sanitize(server.name)}_${sanitize(tool.name)}`,
+          serverName: server.name,
+          toolName: tool.name,
+          description: tool.description || '',
+          inputSchema: tool.inputSchema || { type: 'object', properties: {} },
+        });
+      }
+    }
+    return out;
+  }
+
+  async call(qualifiedName, args) {
+    const tool = this.listTools().find((t) => t.qualifiedName === qualifiedName);
+    if (!tool) throw new Error(`Unknown MCP tool "${qualifiedName}".`);
+    const server = this.servers.find((s) => s.name === tool.serverName && s.ready);
+    if (!server) throw new Error(`MCP server "${tool.serverName}" is not running.`);
+    return server.callTool(tool.toolName, args);
+  }
+
+  stopAll() {
+    for (const server of this.servers) server.stop();
+  }
+}
+
+function sanitize(name) {
+  return String(name).replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 24);
+}
+
+async function createFromConfig() {
+  const defs = config.loadMcpConfig();
+  const manager = new McpManager(defs);
+  if (Object.keys(defs).length > 0) {
+    const summaries = await manager.startAll();
+    if (summaries.length) ui.info(`MCP servers: ${summaries.join(', ')}`);
+  }
+  return manager;
+}
+
+module.exports = { McpManager, McpServer, createFromConfig };

package/src/providers/openai-compatible.js

@@ -0,0 +1,288 @@
+'use strict';
+
+const {
+  CHAT_TIMEOUT_MS,
+  MODELS_TIMEOUT_MS,
+} = require('../config.js');
+
+const DEFAULT_PROBE_MODEL = 'nemotron-3-ultra-free';
+
+class ApiError extends Error {
+  constructor(status, message, bodyText) {
+    super(message);
+    this.name = 'ApiError';
+    this.status = status || 0;
+    this.bodyText = bodyText || '';
+  }
+}
+
+function extractEmbeddedStatus(message) {
+  const m = /\[(\d{3})\]/.exec(String(message));
+  return m ? Number(m[1]) : undefined;
+}
+
+function isFallbackable(err) {
+  if (!(err instanceof ApiError)) return false;
+  if (err.status === 429) return true;
+  if ([400, 502, 503, 504, 529].includes(err.status)) {
+    return /unavailable|not supported|ModelError|overloaded|upstream|temporarily/i.test(
+      err.message + ' ' + err.bodyText
+    );
+  }
+  if (/overloaded|upstream error|temporarily unavailable/i.test(err.message + ' ' + err.bodyText)) {
+    return true;
+  }
+  return false;
+}
+
+async function safeBodyText(res, maxChars = 2000) {
+  try {
+    const text = await res.text();
+    return text.slice(0, maxChars);
+  } catch {
+    return '';
+  }
+}
+
+function extractApiMessage(status, bodyText) {
+  try {
+    const json = JSON.parse(bodyText);
+    const msg =
+      (json.error && (json.error.message || json.error.code)) ||
+      json.message ||
+      '';
+    if (msg) return `${msg}`;
+  } catch {
+    // fall through to raw body
+  }
+  return bodyText ? bodyText.slice(0, 200) : `HTTP ${status}`;
+}
+
+async function listModels(cfg) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), MODELS_TIMEOUT_MS);
+  try {
+    let res;
+    try {
+      res = await fetch(`${cfg.apiBase}/zen/v1/models`, {
+        signal: controller.signal,
+        headers: { Authorization: `Bearer ${cfg.apiKey}` },
+      });
+    } catch (e) {
+      if (e.name === 'AbortError') {
+        throw new ApiError(0, 'Request timed out — connection may have dropped.');
+      }
+      throw new ApiError(0, `Network error: ${e.message}`);
+    }
+    if (!res.ok) {
+      const body = await safeBodyText(res);
+      throw new ApiError(res.status, extractApiMessage(res.status, body), body);
+    }
+    const text = await res.text();
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch {
+      throw new ApiError(res.status, 'Malformed JSON in models registry response.');
+    }
+    const rawList = Array.isArray(json.data)
+      ? json.data
+      : Array.isArray(json.models)
+        ? json.models
+        : Array.isArray(json)
+          ? json
+          : [];
+    const ids = rawList
+      .map((m) => (typeof m === 'string' ? m : m && (m.id || m.name)))
+      .filter((id) => typeof id === 'string' && id.length > 0);
+    if (!ids.length) {
+      throw new ApiError(res.status, 'Models registry returned no usable ids.');
+    }
+    return ids;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+class AbortedError extends Error {
+  constructor() {
+    super('Stopped by user.');
+    this.name = 'AbortedError';
+    this.userAbort = true;
+  }
+}
+
+async function streamChatCompletion(opts) {
+  const { cfg, model, messages, tools, onDelta, signal } = opts;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), CHAT_TIMEOUT_MS);
+  let externalAborted = false;
+  const onExternalAbort = () => {
+    externalAborted = true;
+    controller.abort();
+  };
+  if (signal) {
+    if (signal.aborted) onExternalAbort();
+    else signal.addEventListener('abort', onExternalAbort);
+  }
+  const cleanup = () => {
+    clearTimeout(timer);
+    if (signal) signal.removeEventListener('abort', onExternalAbort);
+  };
+
+  let res;
+  try {
+    res = await fetch(`${cfg.apiBase}/zen/v1/chat/completions`, {
+      method: 'POST',
+      signal: controller.signal,
+      headers: {
+        Authorization: `Bearer ${cfg.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ model, messages, tools, stream: true }),
+    });
+  } catch (e) {
+    cleanup();
+    if (externalAborted) throw new AbortedError();
+    if (e.name === 'AbortError') {
+      throw new ApiError(0, 'Request timed out — connection may have dropped.');
+    }
+    throw new ApiError(0, `Network error: ${e.message}`);
+  }
+
+  if (!res.ok) {
+    cleanup();
+    const body = await safeBodyText(res);
+    throw new ApiError(res.status, extractApiMessage(res.status, body), body);
+  }
+  if (!res.body) {
+    cleanup();
+    throw new ApiError(res.status || 0, 'Server returned an empty response body.');
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let finishReason = null;
+  const parts = new Map();
+  let done = false;
+
+  try {
+    outer: for await (const chunk of res.body) {
+      buffer += decoder.decode(chunk, { stream: true });
+      let nl;
+      while ((nl = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, nl).trim();
+        buffer = buffer.slice(nl + 1);
+        if (!line || line.startsWith(':')) continue;
+        if (!line.startsWith('data:')) continue;
+        const payload = line.slice(5).trim();
+        if (payload === '[DONE]') {
+          done = true;
+          break outer;
+        }
+        let evt;
+        try {
+          evt = JSON.parse(payload);
+        } catch {
+          continue;
+        }
+        if (evt.error) {
+          const msg =
+            (evt.error.message || evt.error.code || JSON.stringify(evt.error)).toString();
+          const status =
+            evt.error.status ||
+            extractEmbeddedStatus(msg) ||
+            evt.status ||
+            res.status;
+          throw new ApiError(status, msg);
+        }
+        const choice = evt.choices && evt.choices[0];
+        if (!choice) continue;
+        if (choice.finish_reason) finishReason = choice.finish_reason;
+        const delta = choice.delta || {};
+        if (typeof delta.content === 'string' && delta.content.length > 0 && onDelta) {
+          onDelta(delta.content);
+        }
+        if (Array.isArray(delta.tool_calls)) {
+          for (const frag of delta.tool_calls) {
+            const idx = typeof frag.index === 'number' ? frag.index : 0;
+            let part = parts.get(idx);
+            if (!part) {
+              part = { id: '', name: '', arguments: '' };
+              parts.set(idx, part);
+            }
+            if (frag.id) part.id = frag.id;
+            if (frag.function) {
+              if (frag.function.name) part.name += frag.function.name;
+              if (frag.function.arguments) part.arguments += frag.function.arguments;
+            }
+          }
+        }
+      }
+    }
+  } catch (e) {
+    cleanup();
+    if (externalAborted) throw new AbortedError();
+    if (done) {
+      // stream already completed; ignore trailing read errors
+    } else if (e instanceof ApiError) {
+      throw e;
+    } else if (e.name === 'AbortError') {
+      throw new ApiError(res.status, 'Stream timed out — connection may have dropped.');
+    } else {
+      throw new ApiError(res.status, `Connection dropped mid-stream: ${e.message}`);
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+
+  const toolCalls = [...parts.entries()]
+    .sort((a, b) => a[0] - b[0])
+    .map(([i, p], n) => ({
+      id: p.id || `call_${n}`,
+      type: 'function',
+      function: { name: p.name, arguments: p.arguments || '{}' },
+    }));
+
+  return { toolCalls, finishReason };
+}
+
+async function probeApiKey(cfg, apiKey) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), MODELS_TIMEOUT_MS);
+  try {
+    let res;
+    try {
+      res = await fetch(`${cfg.apiBase}/zen/v1/chat/completions`, {
+        method: 'POST',
+        signal: controller.signal,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model: DEFAULT_PROBE_MODEL,
+          messages: [{ role: 'user', content: 'ping' }],
+          max_tokens: 1,
+        }),
+      });
+    } catch (e) {
+      if (e.name === 'AbortError') {
+        return { verdict: 'unreachable', detail: 'request timed out' };
+      }
+      return { verdict: 'unreachable', detail: e.message };
+    }
+    if (res.ok || res.status === 429 || res.status === 400) {
+      // 429 = rate-limited but authenticated; 400 ModelError = auth fine, model busy
+      return { verdict: 'ok', status: res.status };
+    }
+    if (res.status === 401 || res.status === 403) {
+      return { verdict: 'invalid', status: res.status };
+    }
+    return { verdict: 'unknown', status: res.status };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+module.exports = { ApiError, AbortedError, isFallbackable, listModels, streamChatCompletion, probeApiKey };

package/src/tools/fs-tools.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { READ_FILE_MAX_BYTES } = require('../config.js');
+const { sandboxPath } = require('./sandbox.js');
+const { approvalMode, gate } = require('../core/approvals.js');
+const { diffLines, renderDiff } = require('../ui/diff.js');
+
+function readFile(workspaceRoot, p) {
+  const abs = sandboxPath(workspaceRoot, p);
+  let stat;
+  try {
+    stat = fs.statSync(abs);
+  } catch (e) {
+    throw new Error(`Cannot stat "${p}": ${e.message}`);
+  }
+  if (stat.isDirectory()) {
+    throw new Error(`"${p}" is a directory, not a file.`);
+  }
+  if (stat.size > READ_FILE_MAX_BYTES) {
+    const fd = fs.openSync(abs, 'r');
+    const buf = Buffer.alloc(READ_FILE_MAX_BYTES);
+    fs.readSync(fd, buf, 0, READ_FILE_MAX_BYTES, 0);
+    fs.closeSync(fd);
+    return (
+      buf.toString('utf8') +
+      `\n\n[File truncated: showing the first ${Math.round(
+        READ_FILE_MAX_BYTES / 1024
+      )} KB of ${(stat.size / 1024).toFixed(1)} KB total.]`
+    );
+  }
+  return fs.readFileSync(abs, 'utf8');
+}
+
+function writeFileRaw(workspaceRoot, p, content) {
+  if (typeof content !== 'string') {
+    throw new Error('"content" must be a string.');
+  }
+  const abs = sandboxPath(workspaceRoot, p);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content, 'utf8');
+  return `Wrote ${Buffer.byteLength(content, 'utf8')} bytes to ${abs}`;
+}
+
+async function writeFile(workspaceRoot, p, content, ctx) {
+  if (typeof content !== 'string') {
+    throw new Error('"content" must be a string.');
+  }
+  const abs = sandboxPath(workspaceRoot, p);
+  const exists = fs.existsSync(abs) && fs.statSync(abs).isFile();
+  if (exists && approvalMode(ctx) !== 'suggest' && process.stdout.isTTY) {
+    const rows = diffLines(fs.readFileSync(abs, 'utf8'), content);
+    process.stdout.write(renderDiff(rows) + '\n');
+  }
+  const allowed = await gate(ctx, `Allow ${exists ? 'edit of' : 'creation of'} "${p}" ? [y/N] `, [
+    'auto-edit',
+    'full-auto',
+  ]);
+  if (!allowed) {
+    return 'User declined this file write. Do not retry it; ask how they want to proceed.';
+  }
+  return writeFileRaw(workspaceRoot, p, content);
+}
+
+async function makeDirectory(workspaceRoot, p, ctx) {
+  const allowed = await gate(ctx, `Allow creating directory "${p}" ? [y/N] `, [
+    'auto-edit',
+    'full-auto',
+  ]);
+  if (!allowed) {
+    return 'User declined this directory creation. Do not retry it; ask how they want to proceed.';
+  }
+  const abs = sandboxPath(workspaceRoot, p);
+  fs.mkdirSync(abs, { recursive: true });
+  return `Created directory ${abs}`;
+}
+
+module.exports = { readFile, writeFile, makeDirectory };