draftgo-cli 3.0.33 → 3.0.38

package/src/mcp/client.js

@@ -0,0 +1,275 @@
+'use strict';
+
+const pkg = require('../../package.json');
+const {
+  DEFAULT_PROTOCOL_VERSION,
+  McpHttpError,
+  postJsonRpc,
+  redactText,
+} = require('./protocol');
+
+const SAFE_TEST_TOOLS = [
+  'draftgo_project_overview',
+  'draftgo_resource_list',
+  'draftgo_api_search',
+];
+
+const REQUIRED_DRAFTGO_TOOLS = [
+  'draftgo_project_overview',
+  'draftgo_resource_list',
+  'draftgo_resource_search',
+  'draftgo_resource_get_metadata',
+  'draftgo_resource_read_fragment',
+  'draftgo_api_search',
+  'draftgo_api_describe',
+  'draftgo_api_call',
+];
+
+class McpRpcError extends Error {
+  constructor(message, { code = -32000, data, id = null } = {}) {
+    super(message);
+    this.name = 'McpRpcError';
+    this.code = code;
+    this.data = data;
+    this.id = id;
+  }
+}
+
+function redactValue(value, secrets = [], seen = new WeakMap()) {
+  if (typeof value === 'string') return redactText(value, secrets);
+  if (!value || typeof value !== 'object') return value;
+  if (seen.has(value)) return seen.get(value);
+  if (Array.isArray(value)) {
+    const result = [];
+    seen.set(value, result);
+    for (const item of value) result.push(redactValue(item, secrets, seen));
+    return result;
+  }
+  const result = {};
+  seen.set(value, result);
+  for (const [key, item] of Object.entries(value)) {
+    result[key] = redactValue(item, secrets, seen);
+  }
+  return result;
+}
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function sameId(left, right) {
+  return left === right;
+}
+
+function findInitializeRequest(message) {
+  const messages = Array.isArray(message) ? message : [message];
+  return messages.find((item) => isObject(item) && item.method === 'initialize' && item.id != null);
+}
+
+function findResponse(messages, id) {
+  return messages.find((message) => isObject(message)
+    && Object.prototype.hasOwnProperty.call(message, 'id')
+    && sameId(message.id, id)
+    && !message.method);
+}
+
+function toolMatches(name, candidate) {
+  return name === candidate || name.endsWith(`.${candidate}`)
+    || name.endsWith(`/${candidate}`) || name.endsWith(`:${candidate}`);
+}
+
+class DraftGoMcpClient {
+  constructor(config, options = {}) {
+    if (!config || typeof config !== 'object') throw new TypeError('DraftGo MCP config is required.');
+    const token = String(config.token || config.sat || '').trim();
+    if (!token) throw new Error('DraftGo MCP config is missing SAT.');
+    if (!config.server && !config.mcp_url) throw new Error('DraftGo MCP config is missing server.');
+
+    this.config = { ...config, token };
+    this.secrets = [token];
+    this.sessionId = null;
+    this.protocolVersion = options.protocolVersion || DEFAULT_PROTOCOL_VERSION;
+    this.nextId = 1;
+    this.onMessage = typeof options.onMessage === 'function' ? options.onMessage : null;
+  }
+
+  async forward(message, options = {}) {
+    if (!isObject(message) && !Array.isArray(message)) {
+      throw new TypeError('MCP message must be a JSON object or batch.');
+    }
+
+    const initialize = findInitializeRequest(message);
+    const requestedVersion = initialize
+      && initialize.params
+      && initialize.params.protocolVersion;
+    const delivered = [];
+
+    try {
+      await postJsonRpc(this.config, message, {
+        signal: options.signal,
+        timeoutMs: options.timeoutMs,
+        sessionId: this.sessionId,
+        protocolVersion: requestedVersion || this.protocolVersion,
+        onSession: (sessionId) => { this.sessionId = sessionId; },
+        onMessage: (remoteMessage) => {
+          const safe = redactValue(remoteMessage, this.secrets);
+          delivered.push(safe);
+          if (this.onMessage) this.onMessage(safe);
+          if (typeof options.onMessage === 'function') options.onMessage(safe);
+        },
+      });
+    } catch (error) {
+      if (error && error.rpc) error.rpc = redactValue(error.rpc, this.secrets);
+      if (error && error.message) error.message = redactText(error.message, this.secrets);
+      throw error;
+    }
+
+    if (initialize) {
+      const response = findResponse(delivered, initialize.id);
+      const negotiated = response && response.result && response.result.protocolVersion;
+      if (negotiated) this.protocolVersion = negotiated;
+    }
+    return delivered;
+  }
+
+  async request(method, params, options = {}) {
+    const id = options.id == null ? this.nextId++ : options.id;
+    const message = { jsonrpc: '2.0', id, method };
+    if (params !== undefined) message.params = params;
+    const messages = await this.forward(message, options);
+    const response = findResponse(messages, id);
+    if (!response) {
+      throw new McpRpcError(`DraftGo MCP returned no response for ${method}.`, { id });
+    }
+    if (response.error) {
+      throw new McpRpcError(
+        redactText(response.error.message || `MCP error ${response.error.code}`, this.secrets),
+        {
+          code: response.error.code,
+          data: redactValue(response.error.data, this.secrets),
+          id,
+        },
+      );
+    }
+    return response.result;
+  }
+
+  async notify(method, params, options = {}) {
+    const message = { jsonrpc: '2.0', method };
+    if (params !== undefined) message.params = params;
+    await this.forward(message, options);
+  }
+
+  async initialize(options = {}) {
+    const result = await this.request('initialize', {
+      protocolVersion: options.protocolVersion || this.protocolVersion,
+      capabilities: options.capabilities || {},
+      clientInfo: options.clientInfo || {
+        name: 'draftgo-cli',
+        version: pkg.version,
+      },
+    }, options);
+    if (result && result.protocolVersion) this.protocolVersion = result.protocolVersion;
+    await this.notify('notifications/initialized', undefined, options);
+    return result;
+  }
+
+  async toolsList(cursor, options = {}) {
+    const params = cursor ? { cursor } : {};
+    return this.request('tools/list', params, options);
+  }
+
+  async listAllTools(options = {}) {
+    const tools = [];
+    const seenCursors = new Set();
+    let cursor;
+    const maxPages = Number(options.maxPages || 100);
+    for (let page = 0; page < maxPages; page += 1) {
+      const result = await this.toolsList(cursor, options);
+      if (result && Array.isArray(result.tools)) tools.push(...result.tools);
+      const next = result && result.nextCursor;
+      if (!next) return tools;
+      if (seenCursors.has(next)) throw new McpRpcError('DraftGo MCP repeated a tools/list cursor.');
+      seenCursors.add(next);
+      cursor = next;
+    }
+    throw new McpRpcError(`DraftGo MCP tools/list exceeded ${maxPages} pages.`);
+  }
+
+  async toolsCall(name, args = {}, options = {}) {
+    const result = await this.request('tools/call', { name, arguments: args }, options);
+    if (result && result.isError === true) {
+      const structured = result.structuredContent || result.structured_content || {};
+      const text = Array.isArray(result.content)
+        ? result.content.find((part) => part && part.type === 'text' && typeof part.text === 'string')
+        : null;
+      const message = structured.message || structured.error && structured.error.message
+        || text && text.text || `DraftGo tool failed: ${name}`;
+      throw new McpRpcError(redactText(String(message).slice(0, 4096), this.secrets), {
+        code: structured.code || structured.error && structured.error.code || -32000,
+        data: redactValue(structured, this.secrets),
+      });
+    }
+    return result;
+  }
+
+  async testConnection(options = {}) {
+    const initialized = await this.initialize(options);
+    const tools = await this.listAllTools(options);
+    const requiredTools = options.requiredTools || REQUIRED_DRAFTGO_TOOLS;
+    const missing = requiredTools.filter((expected) => !tools.some((tool) =>
+      tool && typeof tool.name === 'string' && toolMatches(tool.name, expected)));
+    if (missing.length) {
+      throw new McpRpcError(`DraftGo MCP is missing required tools: ${missing.join(', ')}.`, { code: -32601 });
+    }
+    const required = options.safeTools || SAFE_TEST_TOOLS;
+    const selected = tools.find((tool) => tool && typeof tool.name === 'string'
+      && required.some((candidate) => toolMatches(tool.name, candidate)));
+    if (!selected) {
+      throw new McpRpcError(
+        `DraftGo MCP exposes no safe diagnostic tool (${required.join(', ')}).`,
+        { code: -32601 },
+      );
+    }
+
+    const canonical = required.find((candidate) => toolMatches(selected.name, candidate));
+    const defaultArguments = canonical === 'draftgo_api_search' ? { query: 'project' } : {};
+    const toolResult = await this.toolsCall(
+      selected.name,
+      options.toolArguments || defaultArguments,
+      options,
+    );
+    return {
+      initialized,
+      protocolVersion: this.protocolVersion,
+      sessionId: this.sessionId,
+      tools,
+      testedTool: selected.name,
+      toolResult,
+    };
+  }
+}
+
+async function testConnection(config, options = {}) {
+  const client = new DraftGoMcpClient(config, options);
+  return client.testConnection(options);
+}
+
+async function callTool(config, name, args = {}, options = {}) {
+  const client = options.client || new DraftGoMcpClient(config, options);
+  if (!options.initialized) await client.initialize(options);
+  return client.toolsCall(name, args, options);
+}
+
+module.exports = {
+  DraftGoMcpClient,
+  McpClient: DraftGoMcpClient,
+  McpRpcError,
+  McpHttpError,
+  SAFE_TEST_TOOLS,
+  REQUIRED_DRAFTGO_TOOLS,
+  redactValue,
+  testConnection,
+  callTool,
+  toolMatches,
+};