draftgo-cli 3.0.33 → 3.0.38

package/src/mcp/stdio.js

@@ -0,0 +1,300 @@
+'use strict';
+
+const { loadProjectConfig } = require('../projectConfig');
+const { DraftGoMcpClient, redactValue } = require('./client');
+const { redactText } = require('./protocol');
+
+const DEFAULT_MAX_FRAME_BYTES = 64 * 1024 * 1024;
+
+function indexOfHeaderEnd(buffer, start = 0) {
+  const crlf = buffer.indexOf('\r\n\r\n', start, 'ascii');
+  const lf = buffer.indexOf('\n\n', start, 'ascii');
+  if (crlf < 0) return lf < 0 ? null : { index: lf, length: 2 };
+  if (lf < 0 || crlf <= lf) return { index: crlf, length: 4 };
+  return { index: lf, length: 2 };
+}
+
+function leadingWhitespaceLength(buffer) {
+  let offset = 0;
+  while (offset < buffer.length) {
+    const byte = buffer[offset];
+    if (byte !== 0x20 && byte !== 0x09 && byte !== 0x0d && byte !== 0x0a) break;
+    offset += 1;
+  }
+  return offset;
+}
+
+function headerState(buffer, offset) {
+  const target = 'content-length:';
+  const available = buffer.subarray(offset, Math.min(buffer.length, offset + target.length))
+    .toString('ascii')
+    .toLowerCase();
+  if (target.startsWith(available)) return available.length === target.length ? 'header' : 'partial';
+  return available.startsWith(target) ? 'header' : 'json';
+}
+
+class StdioFrameParser {
+  constructor(onMessage, onError, options = {}) {
+    this.onMessage = onMessage;
+    this.onError = onError;
+    this.maxFrameBytes = Number(options.maxFrameBytes || DEFAULT_MAX_FRAME_BYTES);
+    this.buffer = Buffer.alloc(0);
+  }
+
+  push(chunk) {
+    if (chunk == null || chunk.length === 0) return;
+    const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    this.buffer = this.buffer.length ? Buffer.concat([this.buffer, value]) : value;
+    this._consume(false);
+  }
+
+  end() {
+    this._consume(true);
+    if (this.buffer.length && this.buffer.toString('utf8').trim()) {
+      this._emitError(new Error('Incomplete JSON-RPC frame.'), 'newline');
+    }
+    this.buffer = Buffer.alloc(0);
+  }
+
+  _emitError(error, framing) {
+    if (typeof this.onError === 'function') this.onError(error, framing);
+  }
+
+  _emitBody(body, framing) {
+    let parsed;
+    try {
+      parsed = JSON.parse(body.toString('utf8'));
+    } catch (error) {
+      this._emitError(error, framing);
+      return;
+    }
+    this.onMessage(parsed, framing);
+  }
+
+  _consume(flush) {
+    while (this.buffer.length) {
+      const whitespace = leadingWhitespaceLength(this.buffer);
+      if (whitespace === this.buffer.length) {
+        if (flush) this.buffer = Buffer.alloc(0);
+        return;
+      }
+
+      if (whitespace) this.buffer = this.buffer.subarray(whitespace);
+      const state = headerState(this.buffer, 0);
+      if (state === 'partial' && !flush) return;
+
+      if (state === 'header') {
+        const end = indexOfHeaderEnd(this.buffer);
+        if (!end) {
+          if (flush) {
+            this._emitError(new Error('Incomplete Content-Length header.'), 'content-length');
+            this.buffer = Buffer.alloc(0);
+          }
+          return;
+        }
+        const rawHeaders = this.buffer.subarray(0, end.index).toString('ascii');
+        const headers = rawHeaders.split(/\r?\n/);
+        const lengthHeader = headers.find((line) => /^\s*content-length\s*:/i.test(line));
+        const rawLength = lengthHeader && lengthHeader.replace(/^[^:]*:/, '').trim();
+        const length = rawLength && /^\d+$/.test(rawLength) ? Number(rawLength) : NaN;
+        if (!Number.isSafeInteger(length) || length < 0 || length > this.maxFrameBytes) {
+          this._emitError(new Error('Invalid Content-Length header.'), 'content-length');
+          this.buffer = this.buffer.subarray(end.index + end.length);
+          continue;
+        }
+        const bodyStart = end.index + end.length;
+        if (this.buffer.length - bodyStart < length) {
+          if (flush) {
+            this._emitError(new Error('Incomplete Content-Length body.'), 'content-length');
+            this.buffer = Buffer.alloc(0);
+          }
+          return;
+        }
+        const body = this.buffer.subarray(bodyStart, bodyStart + length);
+        this.buffer = this.buffer.subarray(bodyStart + length);
+        this._emitBody(body, 'content-length');
+        continue;
+      }
+
+      const newline = this.buffer.indexOf(0x0a);
+      if (newline < 0) {
+        if (!flush) return;
+        const body = this.buffer;
+        this.buffer = Buffer.alloc(0);
+        if (body.toString('utf8').trim()) this._emitBody(body, 'newline');
+        continue;
+      }
+      const body = this.buffer.subarray(0, newline);
+      this.buffer = this.buffer.subarray(newline + 1);
+      if (body.toString('utf8').trim()) this._emitBody(body, 'newline');
+    }
+  }
+}
+
+function createFrameWriter(output, options = {}) {
+  const secrets = options.secrets || [];
+  return function writeFrame(message, framing = 'newline') {
+    const body = Buffer.from(JSON.stringify(redactValue(message, secrets)), 'utf8');
+    if (framing === 'content-length') {
+      output.write(Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, 'ascii'));
+      output.write(body);
+      return;
+    }
+    output.write(body);
+    output.write('\n');
+  };
+}
+
+function rpcError(id, code, message, data) {
+  const error = { code, message };
+  if (data !== undefined) error.data = data;
+  return { jsonrpc: '2.0', id: id == null ? null : id, error };
+}
+
+function requestIds(message) {
+  const messages = Array.isArray(message) ? message : [message];
+  return messages
+    .filter((item) => item && typeof item === 'object'
+      && typeof item.method === 'string'
+      && Object.prototype.hasOwnProperty.call(item, 'id'))
+    .map((item) => item.id);
+}
+
+function idKey(id) {
+  return `${typeof id}:${JSON.stringify(id)}`;
+}
+
+function validRpcMessage(message) {
+  if (!message || typeof message !== 'object' || Array.isArray(message)) return false;
+  if (message.jsonrpc !== '2.0') return false;
+  if (typeof message.method === 'string') return true;
+  return Object.prototype.hasOwnProperty.call(message, 'id')
+    && (Object.prototype.hasOwnProperty.call(message, 'result')
+      || Object.prototype.hasOwnProperty.call(message, 'error'));
+}
+
+function validRpcPayload(payload) {
+  return Array.isArray(payload)
+    ? payload.length > 0 && payload.every(validRpcMessage)
+    : validRpcMessage(payload);
+}
+
+function isCancellation(payload) {
+  const messages = Array.isArray(payload) ? payload : [payload];
+  return messages.some((message) => message
+    && message.method === 'notifications/cancelled');
+}
+
+async function serveStdio(projectDir, options = {}) {
+  const input = options.input || process.stdin;
+  const output = options.output || process.stdout;
+  const errorOutput = options.error || process.stderr;
+  const config = options.config || loadProjectConfig(projectDir);
+  const token = String(config.token || config.sat || '');
+  const secrets = [token].filter(Boolean);
+  const client = options.client || new DraftGoMcpClient(config);
+  const writeFrame = createFrameWriter(output, { secrets });
+  const pending = new Set();
+  let initializePending = null;
+  let ended = false;
+
+  const reportStreamError = (error) => {
+    const text = redactText(error && error.message ? error.message : error, secrets);
+    errorOutput.write(`draftgo mcp serve: ${text}\n`);
+  };
+
+  const dispatch = async (message, framing) => {
+    if (!validRpcPayload(message)) {
+      writeFrame(rpcError(null, -32600, 'Invalid Request'), framing);
+      return;
+    }
+    const responded = new Set();
+    try {
+      await client.forward(message, {
+        onMessage(remoteMessage) {
+          if (remoteMessage && typeof remoteMessage === 'object' && !remoteMessage.method
+              && Object.prototype.hasOwnProperty.call(remoteMessage, 'id')) {
+            responded.add(idKey(remoteMessage.id));
+          }
+          writeFrame(remoteMessage, framing);
+        },
+      });
+      const missing = requestIds(message).filter((id) => !responded.has(idKey(id)));
+      if (missing.length) {
+        const errors = missing.map((id) => rpcError(id, -32000, 'DraftGo MCP returned no response.'));
+        writeFrame(errors.length === 1 ? errors[0] : errors, framing);
+      }
+    } catch (error) {
+      let missing = requestIds(message).filter((id) => !responded.has(idKey(id)));
+      if (!missing.length) {
+        reportStreamError(error);
+        return;
+      }
+      if (error && error.rpc) {
+        const rpc = redactValue(error.rpc, secrets);
+        writeFrame(rpc, framing);
+        for (const response of Array.isArray(rpc) ? rpc : [rpc]) {
+          if (response && Object.prototype.hasOwnProperty.call(response, 'id')) {
+            responded.add(idKey(response.id));
+          }
+        }
+        missing = missing.filter((id) => !responded.has(idKey(id)));
+        if (!missing.length) return;
+      }
+      const code = Number.isInteger(error && error.code) ? error.code : -32000;
+      const safeMessage = redactText(error && error.message ? error.message : error, secrets);
+      const errors = missing.map((id) => rpcError(id, code, safeMessage || 'DraftGo MCP bridge error.'));
+      writeFrame(errors.length === 1 ? errors[0] : errors, framing);
+    }
+  };
+
+  const track = (promise) => {
+    pending.add(promise);
+    promise.finally(() => pending.delete(promise));
+    return promise;
+  };
+
+  const parser = new StdioFrameParser((message, framing) => {
+    const messages = Array.isArray(message) ? message : [message];
+    const hasInitialize = messages.some((item) => item && item.method === 'initialize');
+    let task;
+    if (hasInitialize) {
+      task = dispatch(message, framing);
+      initializePending = task.finally(() => { initializePending = null; });
+    } else if (initializePending && !isCancellation(message)) {
+      task = initializePending.then(() => dispatch(message, framing));
+    } else {
+      task = dispatch(message, framing);
+    }
+    track(Promise.resolve(task).catch(reportStreamError));
+  }, (error, framing) => {
+    writeFrame(rpcError(null, -32700, 'Parse error'), framing);
+    reportStreamError(error);
+  }, options);
+
+  return new Promise((resolve, reject) => {
+    const finish = async () => {
+      if (ended) return;
+      ended = true;
+      parser.end();
+      await Promise.allSettled([...pending]);
+      resolve(0);
+    };
+    input.on('data', (chunk) => parser.push(chunk));
+    input.once('end', finish);
+    input.once('error', (error) => {
+      reportStreamError(error);
+      reject(error);
+    });
+    if (input.readableEnded || input.destroyed) queueMicrotask(finish);
+    else if (typeof input.resume === 'function') input.resume();
+  });
+}
+
+module.exports = {
+  DEFAULT_MAX_FRAME_BYTES,
+  StdioFrameParser,
+  createFrameWriter,
+  rpcError,
+  serveStdio,
+};

package/src/mcp/tools.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { DraftGoMcpClient } = require('./client');
+const { WorktreeError } = require('../worktree/errors');
+const { unwrapToolResult, toolNameMatches } = require('../worktree/backend');
+
+const TOOL_NAMES = Object.freeze({
+  projectOverview: 'draftgo_project_overview',
+  resourceList: 'draftgo_resource_list',
+  resourceSearch: 'draftgo_resource_search',
+  resourceMetadata: 'draftgo_resource_get_metadata',
+  resourceFragment: 'draftgo_resource_read_fragment',
+  apiSearch: 'draftgo_api_search',
+  apiDescribe: 'draftgo_api_describe',
+  apiCall: 'draftgo_api_call',
+});
+
+async function openToolSession(config, expected = [], options = {}) {
+  const client = options.client || new DraftGoMcpClient(config);
+  await client.initialize(options);
+  const tools = await client.listAllTools(options);
+  const names = {};
+  for (const expectedName of expected) {
+    const found = tools.find((tool) => tool && toolNameMatches(String(tool.name || ''), expectedName));
+    if (!found) throw new WorktreeError('MCP_TOOL_UNAVAILABLE', `${expectedName} is not available.`);
+    names[expectedName] = found.name;
+  }
+  return { client, tools, names };
+}
+
+async function callStructured(session, expectedName, args = {}, options = {}) {
+  const name = session.names[expectedName] || expectedName;
+  const result = await session.client.toolsCall(name, args, options);
+  return unwrapToolResult(result);
+}
+
+module.exports = { TOOL_NAMES, openToolSession, callStructured };

package/src/platforms.js

@@ -1,12 +1,11 @@
 'use strict';
 
 // Single source of truth describing every supported AI-tool target.
-// Each platform receives the complete instruction body (SKILL.md + sub-skills
-// + rules + scripts). Only the large OpenAPI snapshot is shared once under
-// .draftgo/skill-shared.
+// Each platform receives the complete instruction body, subskills, domain
+// references, and the small scripts directory used for bundled documentation.
 //
 //   mainFile : the markdown file the AI tool reads first
-//   assetDir : where sub-skills (init/sync/bug), rules/, scripts/ are placed
+//   assetDir : where subskills, references, and scripts are placed
 //   skillDir : project-relative path used to substitute {{SKILL_DIR}} in
 //              template files (typically === assetDir written with forward
 //              slashes so it works in markdown)

package/src/projectConfig.js

@@ -1,62 +1,104 @@
 'use strict';
 
-// Shared helpers for writing <project>/.draftgo/config.json and (optionally)
-// bootstrapping local context via draftgo_init.py.
-
+const fs = require('fs');
 const path = require('path');
-const { spawnSync } = require('child_process');
-const log = require('./logger');
-const { writeText, exists, appendGitignoreLine } = require('./fsx');
-const { findPython } = require('./python');
-const { platforms } = require('./platforms');
+const { exists, ensureDir, appendGitignoreLine } = require('./fsx');
 
-function writeProjectConfig(projectDir, server, token) {
-  const cfg = path.join(projectDir, '.draftgo', 'config.json');
-  let existing = {};
-  if (exists(cfg)) {
-    try { existing = JSON.parse(require('fs').readFileSync(cfg, 'utf8')); } catch { /* reset malformed config */ }
+const IGNORE_ENTRIES = [
+  '.draftgo/config.json',
+  '.draftgo/token',
+  '.draftgo/worktree/',
+  '.draftgo/conflicts/',
+];
+
+function normalizeServer(raw) {
+  let value = String(raw || '').trim();
+  if (!value) return '';
+  if (!/^https?:\/\//i.test(value)) value = `http://${value}`;
+  const parsed = new URL(value);
+  if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username || parsed.password
+      || parsed.search || parsed.hash) {
+    throw new Error('DraftGo server must be an absolute HTTP(S) URL without credentials, query, or fragment.');
   }
-  const config = {
-    ...existing,
-    server,
-    token,
-    auto_push: existing.auto_push === true,
-  };
-  writeText(cfg, JSON.stringify(config, null, 2) + '\n');
-  appendGitignoreLine(projectDir, '.draftgo/config.json');
-  return cfg;
+  return value.replace(/\/+$/, '');
 }
 
-// Find a draftgo_init.py shipped with any installed platform.
-function findInitScript(projectDir) {
-  for (const p of platforms) {
-    const candidate = path.join(projectDir, p.assetDir, 'scripts', 'draftgo_init.py');
-    if (exists(candidate)) return candidate;
-  }
-  return null;
+function configPath(projectDir) {
+  return path.join(projectDir, '.draftgo', 'config.json');
 }
 
-function maybeRunInit(projectDir, server, token) {
-  const py = findPython();
-  if (!py) {
-    log.dim('  未检测到 Python，跳过自动初始化项目上下文。');
-    log.dim('  安装 Python 3.9+ 后运行 `draftgo pull` 获取项目资源。');
-    return false;
+function ensureProjectIgnores(projectDir) {
+  for (const entry of IGNORE_ENTRIES) appendGitignoreLine(projectDir, entry);
+}
+
+function readExisting(projectDir) {
+  const file = configPath(projectDir);
+  if (!exists(file)) return {};
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch (error) {
+    throw new Error(`Invalid .draftgo/config.json: ${error.message}`);
   }
-  const script = findInitScript(projectDir);
-  if (!script) {
-    log.dim('  未找到 init 脚本（先运行 `draftgo init` 安装到至少一个 AI 工具目录）。');
-    return false;
+}
+
+function writePrivateJson(file, value) {
+  ensureDir(path.dirname(file));
+  const suffix = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const temporary = `${file}.tmp-${suffix}`;
+  const backup = `${file}.bak-${suffix}`;
+  let backedUp = false;
+  try {
+    fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    try { fs.chmodSync(temporary, 0o600); } catch { /* Windows ACLs are inherited. */ }
+    const descriptor = fs.openSync(temporary, 'r+');
+    try { fs.fsyncSync(descriptor); } finally { fs.closeSync(descriptor); }
+    if (exists(file)) { fs.renameSync(file, backup); backedUp = true; }
+    fs.renameSync(temporary, file);
+  } catch (error) {
+    if (backedUp && !exists(file) && exists(backup)) fs.renameSync(backup, file);
+    throw error;
+  } finally {
+    if (exists(temporary)) fs.rmSync(temporary, { force: true });
   }
-  log.step('运行 draftgo_init.py 拉取初始上下文…');
-  const r = spawnSync(py.bin, [script, '--server', server, projectDir], {
-    stdio: 'inherit',
-    shell: false,
-    env: { ...process.env, DRAFTGO_TOKEN: token },
-  });
-  if (r.status === 0) { log.ok('  初始化完成'); return true; }
-  log.warn('  init 脚本返回非零状态，可稍后手动重跑。');
-  return false;
+  if (exists(backup)) fs.rmSync(backup, { force: true });
+  try { fs.chmodSync(file, 0o600); } catch { /* Windows ACLs are inherited. */ }
+}
+
+function writeProjectConfig(projectDir, server, token) {
+  const normalizedServer = normalizeServer(server);
+  const sat = String(token || '').trim();
+  if (!normalizedServer) throw new Error('DraftGo server is required.');
+  if (!sat) throw new Error('DraftGo SAT is required.');
+  const existing = readExisting(projectDir);
+  const config = {
+    ...existing,
+    server: normalizedServer,
+    token: sat,
+    auto_push: existing.auto_push === true,
+  };
+  const file = configPath(projectDir);
+  writePrivateJson(file, config);
+  ensureProjectIgnores(projectDir);
+  return file;
+}
+
+function loadProjectConfig(projectDir, { requireToken = true } = {}) {
+  const file = configPath(projectDir);
+  if (!exists(file)) throw new Error('Missing .draftgo/config.json; run `draftgo connect` first.');
+  const config = readExisting(projectDir);
+  const server = normalizeServer(config.server);
+  const token = String(config.token || config.sat || '').trim();
+  if (!server) throw new Error('DraftGo project config is missing server.');
+  if (requireToken && !token) throw new Error('DraftGo project config is missing SAT.');
+  return { ...config, server, token, path: file };
 }
 
-module.exports = { writeProjectConfig, maybeRunInit, findInitScript };
+module.exports = {
+  IGNORE_ENTRIES,
+  configPath,
+  normalizeServer,
+  ensureProjectIgnores,
+  writeProjectConfig,
+  loadProjectConfig,
+};