draftgo-cli 3.0.35 → 3.0.39

package/src/commands/sync.js

@@ -1,61 +1,46 @@
 'use strict';
 
-const path = require('path');
-const { spawnSync } = require('child_process');
 const log = require('../logger');
-const { exists } = require('../fsx');
-const { findPython } = require('../python');
-const { platforms } = require('../platforms');
+const { canonicalResourceType } = require('../worktree/types');
 
-function findSyncScript(projectDir, command) {
-  const scriptName = command === 'pull' ? 'draftgo_pull.py' : 'draftgo_push.py';
-
-  for (const platform of platforms) {
-    const candidate = path.join(projectDir, platform.assetDir, 'scripts', scriptName);
-    if (exists(candidate)) return candidate;
+async function sync(projectDir, command, positional, flags = {}) {
+  if (command === 'pull') {
+    log.err('`draftgo pull` no longer downloads DraftGo resources.');
+    log.dim('  Use MCP project/resource discovery. For complete pages, navigation, or docs, use `draftgo checkout <type> <id...>`.');
+    log.dim('  Existing legacy .draftgo indexes are left untouched and ignored.');
+    return 1;
   }
 
-  const bundled = path.resolve(__dirname, '..', '..', 'resources', 'skill', 'scripts', scriptName);
-  return exists(bundled) ? bundled : null;
-}
-
-function sync(projectDir, command, positional, flags = {}) {
-  const py = findPython();
-  if (!py) {
-    log.err('未检测到 Python，无法运行 DraftGo 同步脚本。');
+  const [rawType, ...ids] = positional;
+  if (!rawType) {
+    log.err('The legacy push-all workflow has been removed.');
+    log.dim('  Use `draftgo commit <pages|nav|docs> <id...>` for checked-out long content.');
+    log.dim('  Use DraftGo MCP for structured resources.');
     return 1;
   }
 
-  const script = findSyncScript(projectDir, command);
-  if (!script) {
-    log.err(`未找到 ${command} 同步脚本。`);
-    log.dim('  请先运行 `draftgo init` 安装 DraftGo skill，或重新安装 CLI。');
+  let resourceType;
+  try {
+    resourceType = canonicalResourceType(rawType);
+  } catch {
+    log.err(`Legacy push for ${rawType} is no longer supported.`);
+    log.dim('  Discover the live API with `draftgo api <query>` and use MCP api_call for structured resources.');
     return 1;
   }
-
-  if (!exists(path.join(projectDir, '.draftgo', 'config.json'))) {
-    log.err('未找到 .draftgo/config.json。');
-    log.dim('  请先运行 `draftgo connect`。');
+  if (!ids.length) {
+    log.err('Refusing legacy push-all behavior; specify checked-out resource ids explicitly.');
     return 1;
   }
 
-  const args = positional.length ? positional : ['--all'];
-  if (command === 'push' && flags['dry-run']) {
-    args.push('--dry-run');
-  }
-  if (command === 'push' && flags['probe-routes']) {
-    args.push('--probe-routes');
-  }
-  const r = spawnSync(py.bin, [script, ...args], {
-    cwd: projectDir,
-    stdio: 'inherit',
-    shell: false,
-  });
-  if (r.error) {
-    log.err(`${command} 启动失败：${r.error.message}`);
-    return 1;
+  log.warn('`draftgo push` is deprecated; forwarding checked-out long content to `draftgo commit`.');
+  if (flags['dry-run']) {
+    for (const id of ids) {
+      const code = require('./diff')(projectDir, [resourceType, id], flags);
+      if (code !== 0) return code;
+    }
+    return 0;
   }
-  return Number.isInteger(r.status) ? r.status : 1;
+  return require('./commit')(projectDir, [resourceType, ...ids], flags);
 }
 
 module.exports = sync;

package/src/commands/verifyUi.js

@@ -14,8 +14,9 @@ function isUiFile(file) {
   if (!['.js', '.ts'].includes(ext)) return false;
   return /(^|\/)(frontend|web|ui|components|pages|views|client)(\/|$)/.test(normalized)
     || /(^|\/)(app|main|client)\.(js|ts)$/.test(normalized)
-    || normalized.startsWith('.draftgo/pages/')
-    || normalized.startsWith('.draftgo/navigations/');
+    || normalized.startsWith('.draftgo/worktree/pages/')
+    || normalized.startsWith('.draftgo/worktree/navigations/')
+    || normalized.startsWith('.draftgo/worktree/docs/');
 }
 
 function gitChangedFiles(projectDir) {

package/src/localdev/index.js

@@ -7,7 +7,7 @@ const { probePort, probeHttp, detectDocker } = require('./detect');
 const compose = require('./compose');
 const { ensureDatabase, testConnection, describeClient } = require('./mysqlClient');
 const { defaults, portOpen, probeRedis, probeMilvus, startService } = require('./services');
-const { writeProjectConfig, maybeRunInit } = require('../projectConfig');
+const { writeProjectConfig } = require('../projectConfig');
 const { appendGitignoreLine } = require('../fsx');
 
 const DEFAULT_APP_PORT = 3000;
@@ -147,7 +147,35 @@ async function waitForApp(appPort) {
   return ok;
 }
 
-async function runWizard(projectDir, { yes = false } = {}) {
+async function finishMcpSetup(projectDir, mcpCommands) {
+  const commands = mcpCommands || require('../commands/mcp');
+  const setupMcp = commands.setupMcp || commands.setup;
+  const testMcp = commands.testMcp || commands.test;
+  if (typeof setupMcp !== 'function' || typeof testMcp !== 'function') {
+    log.warn('  MCP setup helpers are unavailable. Run `draftgo mcp setup` after updating the CLI.');
+    return false;
+  }
+
+  let setupOk = false;
+  try {
+    setupOk = await setupMcp(projectDir, [], { yes: true }) === 0;
+  } catch {
+    log.warn('  MCP host setup failed. Retry with `draftgo mcp setup`.');
+  }
+
+  let testOk = false;
+  try {
+    testOk = await testMcp(projectDir, {}) === 0;
+  } catch {
+    log.warn('  MCP validation failed. Run `draftgo mcp test` for diagnostics.');
+  }
+  if (!testOk) {
+    log.dim('  The local stack and project config are ready; MCP may still be starting.');
+  }
+  return setupOk && testOk;
+}
+
+async function runWizard(projectDir, { yes = false, mcpCommands } = {}) {
   log.title('draftgo local setup');
   if (!yes && !await confirm('Continue with local DraftGo setup?', { default: true })) return 0;
 
@@ -169,14 +197,16 @@ async function runWizard(projectDir, { yes = false } = {}) {
   if (!composeUp(docker, out.dir) || !await waitForApp(appPort)) return 1;
 
   const url = `http://localhost:${appPort}`;
-  const token = await askRequired('Paste a DraftGo system access token (SAT)', {
-    validate: (value) => value.length < 10 ? 'Token appears too short.' : '',
-  });
+  let token = '';
+  while (token.length < 10) {
+    token = String(await askPassword('Paste a DraftGo system access token (SAT)')).trim();
+    if (token.length < 10) log.err('  Token appears too short. Please try again.');
+  }
   const cfgPath = writeProjectConfig(projectDir, url, token);
-  maybeRunInit(projectDir, url, token);
+  await finishMcpSetup(projectDir, mcpCommands);
   log.ok(`DraftGo is ready at ${url}`);
   log.dim(`Project config: ${cfgPath}`);
   return 0;
 }
 
-module.exports = { runWizard };
+module.exports = { finishMcpSetup, runWizard };

package/src/localdev/mysqlClient.js

@@ -60,7 +60,7 @@ function runSQL(client, conn, sql) {
   const args = [
     'run', '--rm', '-i',
     '--add-host', 'host.docker.internal:host-gateway',
-    '-e', `MYSQL_PWD=${conn.password || ''}`,
+    '-e', 'MYSQL_PWD',
     'mysql:8.0',
     'mysql',
     '-h', dockerHost(conn.host),

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,
+};