chainlesschain 0.45.70 → 0.45.75

package/src/harness/mcp-client.js

@@ -0,0 +1,417 @@
+/**
+ * Lightweight MCP (Model Context Protocol) client.
+ * Implements JSON-RPC 2.0 over stdio transport without external SDK dependency.
+ *
+ * Canonical location (moved from src/lib/mcp-client.js as part of the
+ * CLI Runtime Convergence roadmap, Phase 3). src/lib/mcp-client.js is now a
+ * thin re-export shim for backwards compatibility.
+ */
+
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+
+/**
+ * MCP Server connection states.
+ */
+export const ServerState = {
+  DISCONNECTED: "disconnected",
+  CONNECTING: "connecting",
+  CONNECTED: "connected",
+  ERROR: "error",
+};
+
+/**
+ * MCP Client — manages connections to MCP servers.
+ */
+export class MCPClient extends EventEmitter {
+  constructor() {
+    super();
+    this.servers = new Map(); // name → { process, state, tools, resources, config }
+    this._nextId = 1;
+  }
+
+  /**
+   * Connect to an MCP server via stdio transport.
+   * @param {string} name - Server name
+   * @param {object} config - { command, args?, env? }
+   */
+  async connect(name, config) {
+    if (this.servers.has(name)) {
+      throw new Error(`Server "${name}" already connected`);
+    }
+
+    const entry = {
+      config,
+      state: ServerState.CONNECTING,
+      process: null,
+      tools: [],
+      resources: [],
+      prompts: [],
+      _pending: new Map(),
+      _buffer: "",
+    };
+
+    this.servers.set(name, entry);
+
+    try {
+      const proc = spawn(config.command, config.args || [], {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, ...(config.env || {}) },
+      });
+
+      entry.process = proc;
+
+      proc.stdout.on("data", (data) => {
+        this._handleData(name, data.toString("utf8"));
+      });
+
+      proc.stderr.on("data", (data) => {
+        this.emit("server-error", { name, error: data.toString("utf8") });
+      });
+
+      proc.on("close", (code) => {
+        entry.state = ServerState.DISCONNECTED;
+        this.emit("server-disconnected", { name, code });
+      });
+
+      proc.on("error", (err) => {
+        entry.state = ServerState.ERROR;
+        this.emit("server-error", { name, error: err.message });
+      });
+
+      // Initialize MCP protocol
+      const initResult = await this._sendRequest(name, "initialize", {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {}, resources: {} },
+        clientInfo: { name: "chainlesschain-cli", version: "0.37.9" },
+      });
+
+      // Send initialized notification
+      this._sendNotification(name, "notifications/initialized", {});
+
+      entry.state = ServerState.CONNECTED;
+      entry.serverInfo = initResult?.serverInfo || {};
+      entry.capabilities = initResult?.capabilities || {};
+
+      // Fetch available tools
+      try {
+        const toolsResult = await this._sendRequest(name, "tools/list", {});
+        entry.tools = toolsResult?.tools || [];
+      } catch {
+        // Server may not support tools
+      }
+
+      // Fetch available resources
+      try {
+        const resourcesResult = await this._sendRequest(
+          name,
+          "resources/list",
+          {},
+        );
+        entry.resources = resourcesResult?.resources || [];
+      } catch {
+        // Server may not support resources
+      }
+
+      this.emit("server-connected", { name, tools: entry.tools.length });
+      return {
+        name,
+        state: entry.state,
+        tools: entry.tools,
+        resources: entry.resources,
+        serverInfo: entry.serverInfo,
+      };
+    } catch (err) {
+      entry.state = ServerState.ERROR;
+      this.servers.delete(name);
+      throw err;
+    }
+  }
+
+  /**
+   * Disconnect from an MCP server.
+   */
+  async disconnect(name) {
+    const entry = this.servers.get(name);
+    if (!entry) return false;
+
+    if (entry.process) {
+      entry.process.kill();
+    }
+
+    entry.state = ServerState.DISCONNECTED;
+    this.servers.delete(name);
+    return true;
+  }
+
+  /**
+   * Disconnect from all servers.
+   */
+  async disconnectAll() {
+    const names = [...this.servers.keys()];
+    for (const name of names) {
+      await this.disconnect(name);
+    }
+  }
+
+  /**
+   * List all connected servers.
+   */
+  listServers() {
+    const result = [];
+    for (const [name, entry] of this.servers) {
+      result.push({
+        name,
+        state: entry.state,
+        tools: entry.tools.length,
+        resources: entry.resources.length,
+        serverInfo: entry.serverInfo || {},
+      });
+    }
+    return result;
+  }
+
+  /**
+   * List tools from a specific server or all servers.
+   */
+  listTools(serverName) {
+    if (serverName) {
+      const entry = this.servers.get(serverName);
+      if (!entry) throw new Error(`Server "${serverName}" not found`);
+      return entry.tools.map((t) => ({ ...t, server: serverName }));
+    }
+
+    const allTools = [];
+    for (const [name, entry] of this.servers) {
+      for (const tool of entry.tools) {
+        allTools.push({ ...tool, server: name });
+      }
+    }
+    return allTools;
+  }
+
+  /**
+   * Call a tool on a specific server.
+   * @param {string} serverName - Server name
+   * @param {string} toolName - Tool name
+   * @param {object} args - Tool arguments
+   */
+  async callTool(serverName, toolName, args = {}) {
+    const entry = this.servers.get(serverName);
+    if (!entry) throw new Error(`Server "${serverName}" not found`);
+    if (entry.state !== ServerState.CONNECTED) {
+      throw new Error(`Server "${serverName}" is not connected`);
+    }
+
+    const result = await this._sendRequest(serverName, "tools/call", {
+      name: toolName,
+      arguments: args,
+    });
+
+    return result;
+  }
+
+  /**
+   * Read a resource from a server.
+   */
+  async readResource(serverName, uri) {
+    const entry = this.servers.get(serverName);
+    if (!entry) throw new Error(`Server "${serverName}" not found`);
+
+    const result = await this._sendRequest(serverName, "resources/read", {
+      uri,
+    });
+    return result;
+  }
+
+  // ─── Internal JSON-RPC transport ──────────────────────────────
+
+  _sendRequest(serverName, method, params) {
+    return new Promise((resolve, reject) => {
+      const entry = this.servers.get(serverName);
+      if (!entry || !entry.process) {
+        return reject(new Error("Server not available"));
+      }
+
+      const id = this._nextId++;
+      const message = JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params,
+      });
+
+      entry._pending.set(id, { resolve, reject });
+
+      // Set timeout
+      const timeout = setTimeout(() => {
+        entry._pending.delete(id);
+        reject(new Error(`Request timeout: ${method}`));
+      }, 30000);
+
+      entry._pending.get(id).timeout = timeout;
+
+      try {
+        entry.process.stdin.write(message + "\n");
+      } catch (err) {
+        clearTimeout(timeout);
+        entry._pending.delete(id);
+        reject(err);
+      }
+    });
+  }
+
+  _sendNotification(serverName, method, params) {
+    const entry = this.servers.get(serverName);
+    if (!entry || !entry.process) return;
+
+    const message = JSON.stringify({
+      jsonrpc: "2.0",
+      method,
+      params,
+    });
+
+    try {
+      entry.process.stdin.write(message + "\n");
+    } catch {
+      // Ignore notification errors
+    }
+  }
+
+  _handleData(serverName, data) {
+    const entry = this.servers.get(serverName);
+    if (!entry) return;
+
+    entry._buffer += data;
+
+    // Process complete JSON lines
+    const lines = entry._buffer.split("\n");
+    entry._buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      try {
+        const msg = JSON.parse(trimmed);
+        this._handleMessage(serverName, msg);
+      } catch {
+        // Skip malformed lines
+      }
+    }
+  }
+
+  _handleMessage(serverName, msg) {
+    const entry = this.servers.get(serverName);
+    if (!entry) return;
+
+    // Response to a request
+    if (msg.id !== undefined && entry._pending.has(msg.id)) {
+      const { resolve, reject, timeout } = entry._pending.get(msg.id);
+      clearTimeout(timeout);
+      entry._pending.delete(msg.id);
+
+      if (msg.error) {
+        reject(new Error(msg.error.message || "Unknown error"));
+      } else {
+        resolve(msg.result);
+      }
+      return;
+    }
+
+    // Server notification
+    if (msg.method) {
+      this.emit("notification", {
+        server: serverName,
+        method: msg.method,
+        params: msg.params,
+      });
+    }
+  }
+}
+
+/**
+ * MCP server configuration storage.
+ * Persists server configs in the database.
+ */
+export class MCPServerConfig {
+  constructor(db) {
+    this.db = db;
+    this._ensureTable();
+  }
+
+  _ensureTable() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS mcp_servers (
+        name TEXT PRIMARY KEY,
+        command TEXT NOT NULL,
+        args TEXT DEFAULT '[]',
+        env TEXT DEFAULT '{}',
+        auto_connect INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+  }
+
+  add(name, config) {
+    this.db
+      .prepare(
+        "INSERT OR REPLACE INTO mcp_servers (name, command, args, env, auto_connect, updated_at) VALUES (?, ?, ?, ?, ?, datetime('now'))",
+      )
+      .run(
+        name,
+        config.command,
+        JSON.stringify(config.args || []),
+        JSON.stringify(config.env || {}),
+        config.autoConnect ? 1 : 0,
+      );
+  }
+
+  remove(name) {
+    const result = this.db
+      .prepare("DELETE FROM mcp_servers WHERE name = ?")
+      .run(name);
+    return result.changes > 0;
+  }
+
+  get(name) {
+    const row = this.db
+      .prepare("SELECT * FROM mcp_servers WHERE name = ?")
+      .get(name);
+    if (!row) return null;
+    return {
+      name: row.name,
+      command: row.command,
+      args: JSON.parse(row.args || "[]"),
+      env: JSON.parse(row.env || "{}"),
+      autoConnect: row.auto_connect === 1,
+    };
+  }
+
+  list() {
+    const rows = this.db
+      .prepare("SELECT * FROM mcp_servers ORDER BY name")
+      .all();
+    return rows.map((row) => ({
+      name: row.name,
+      command: row.command,
+      args: JSON.parse(row.args || "[]"),
+      env: JSON.parse(row.env || "{}"),
+      autoConnect: row.auto_connect === 1,
+    }));
+  }
+
+  getAutoConnect() {
+    const rows = this.db
+      .prepare("SELECT * FROM mcp_servers WHERE auto_connect = ? ORDER BY name")
+      .all(1);
+    return rows.map((row) => ({
+      name: row.name,
+      command: row.command,
+      args: JSON.parse(row.args || "[]"),
+      env: JSON.parse(row.env || "{}"),
+      autoConnect: true,
+    }));
+  }
+}

package/src/harness/mock-llm-provider.js

@@ -0,0 +1,167 @@
+/**
+ * Mock LLM Provider — Phase 7 Parity Harness foundation.
+ *
+ * Produces a deterministic `chatWithTools`-shaped function from a scripted
+ * sequence of responses. Each script entry describes what the mock returns
+ * for the next LLM call, in order. This is the foundation for golden-
+ * transcript parity tests in `packages/cli/__tests__/integration/parity-*`.
+ *
+ * Design goals:
+ *   - Zero network, zero provider SDK — pure in-memory dispatch
+ *   - Same return shape as real `chatWithTools`: `{ message: { role, content, tool_calls? } }`
+ *   - Supports tool_calls to drive multi-turn agent loops
+ *   - Runs out of steps cleanly (throws a descriptive error) so tests can't
+ *     silently loop forever
+ *   - Optional match predicates per step let tests assert that the loop
+ *     is feeding back the expected messages before the mock replies
+ *
+ * Example:
+ *
+ *   const mock = createMockLLMProvider([
+ *     {
+ *       // First LLM call — ask for a tool invocation
+ *       response: {
+ *         message: {
+ *           role: "assistant",
+ *           content: "",
+ *           tool_calls: [
+ *             {
+ *               id: "call_1",
+ *               type: "function",
+ *               function: {
+ *                 name: "read_file",
+ *                 arguments: JSON.stringify({ path: "README.md" }),
+ *               },
+ *             },
+ *           ],
+ *         },
+ *       },
+ *     },
+ *     {
+ *       // Second LLM call — produce the final assistant text
+ *       expect: (messages) =>
+ *         messages.some((m) => m.role === "tool" && m.name === "read_file"),
+ *       response: {
+ *         message: { role: "assistant", content: "Done." },
+ *       },
+ *     },
+ *   ]);
+ *
+ *   // Drop-in replacement for chatWithTools:
+ *   await agentLoop(messages, { ...opts, chatFn: mock.chatFn });
+ *
+ *   mock.assertDrained(); // verify the loop consumed every scripted response
+ */
+
+/**
+ * @typedef {object} MockScriptStep
+ * @property {(messages: Array<object>, options: object) => boolean} [expect]
+ *   Optional predicate run against the messages passed to the mock. If it
+ *   returns false, the mock throws — this lets tests assert that the loop
+ *   is in the expected state before it receives the next scripted reply.
+ * @property {object} response
+ *   The value the mock returns. Must match the `chatWithTools` shape:
+ *   `{ message: { role, content, tool_calls? } }`.
+ */
+
+/**
+ * Create a mock LLM provider backed by a scripted sequence.
+ *
+ * @param {Array<MockScriptStep>} script
+ * @returns {{ chatFn: Function, calls: Array<{messages, options}>, assertDrained: Function, remaining: () => number }}
+ */
+export function createMockLLMProvider(script) {
+  if (!Array.isArray(script)) {
+    throw new TypeError("Mock LLM script must be an array");
+  }
+
+  const calls = [];
+  let cursor = 0;
+
+  const chatFn = async function mockChatWithTools(messages, options) {
+    if (cursor >= script.length) {
+      throw new Error(
+        `Mock LLM script exhausted after ${cursor} call(s). The agent loop made ` +
+          `an unexpected extra LLM call. Add another script step or tighten the ` +
+          `loop's stop condition.`,
+      );
+    }
+
+    const step = script[cursor];
+    cursor += 1;
+
+    // Snapshot-before-mutation so test assertions see exactly what the mock
+    // was called with (agentLoop mutates its messages array in place).
+    const snapshot = messages.map((m) => ({ ...m }));
+    calls.push({ messages: snapshot, options });
+
+    if (typeof step.expect === "function") {
+      const ok = step.expect(snapshot, options);
+      if (!ok) {
+        throw new Error(
+          `Mock LLM script step ${cursor - 1} expectation failed. Messages ` +
+            `passed to the mock did not match the expected predicate. Received ` +
+            `${snapshot.length} messages; last role = "${snapshot[snapshot.length - 1]?.role}".`,
+        );
+      }
+    }
+
+    if (!step.response || !step.response.message) {
+      throw new Error(
+        `Mock LLM script step ${cursor - 1} is missing response.message. ` +
+          `Every step must return a chatWithTools-shaped { message: {...} }.`,
+      );
+    }
+
+    // Deep clone the response so tests can safely reuse script objects across
+    // multiple runs without the loop mutating their contents.
+    return {
+      message: JSON.parse(JSON.stringify(step.response.message)),
+    };
+  };
+
+  return {
+    chatFn,
+    calls,
+    remaining: () => script.length - cursor,
+    assertDrained() {
+      if (cursor !== script.length) {
+        throw new Error(
+          `Mock LLM script not fully consumed: ${cursor}/${script.length} steps called. ` +
+            `The agent loop stopped before reaching the end of the script.`,
+        );
+      }
+    },
+  };
+}
+
+/**
+ * Convenience builder for a single tool_call assistant message.
+ * @param {string} toolName
+ * @param {object} args
+ * @param {string} [callId]
+ */
+export function mockToolCallMessage(toolName, args, callId = "call_1") {
+  return {
+    role: "assistant",
+    content: "",
+    tool_calls: [
+      {
+        id: callId,
+        type: "function",
+        function: {
+          name: toolName,
+          arguments: JSON.stringify(args),
+        },
+      },
+    ],
+  };
+}
+
+/**
+ * Convenience builder for a final assistant text message.
+ * @param {string} text
+ */
+export function mockTextMessage(text) {
+  return { role: "assistant", content: text };
+}