draftgo-cli 4.0.1 → 4.0.23

package/src/mcp/client.js

@@ -184,7 +184,7 @@ 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 (!token) throw new Error('DraftGo MCP config is missing API Key.');
     if (!config.server && !config.mcp_url) throw new Error('DraftGo MCP config is missing server.');
 
     this.config = { ...config, token };
@@ -453,7 +453,7 @@ class DraftGoMcpClient {
     })).filter((entry) => entry.tool);
     const byCanonical = Object.fromEntries(selected.map((entry) => [entry.canonical, entry.tool]));
     const overrideCanonical = safeTools.find((canonical) => toolMatches(firstSafeTool.name, canonical));
-    const defaultPlan = hasDiagnosticOverrides ? [{
+    let defaultPlan = hasDiagnosticOverrides ? [{
       label: overrideCanonical,
       canonical: overrideCanonical,
       tool: firstSafeTool,
@@ -473,6 +473,15 @@ class DraftGoMcpClient {
         args: { resource_type: 'db_meta', limit: 100 },
       },
     ];
+    const spaceScope = options.scopeType === 'space' && Number(options.spaceId) > 0
+      ? { scope_type: 'space', space_id: Number(options.spaceId) }
+      : {};
+    if (!hasDiagnosticOverrides && !spaceScope.scope_type) {
+      defaultPlan = defaultPlan.filter(entry => entry.label !== 'resource:docs/articles');
+    }
+    for (const entry of defaultPlan) {
+      if (entry.label === 'resource:docs/articles') entry.args = { ...entry.args, ...spaceScope };
+    }
     const runPlan = (plan, startIndex = 0) => allWithAbort(plan.map((entry, offset) =>
       async (queryOptions) => {
         if (typeof options.onStage === 'function') options.onStage(`tools/call:${entry.label}`, 'started');

package/src/mcp/protocol.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const DEFAULT_PROTOCOL_VERSION = '2025-06-18';
+const DEFAULT_PROTOCOL_VERSION = '2026-07-28';
 
 class McpHttpError extends Error {
   constructor(message, { status = 0, rpc = null, code = null } = {}) {
@@ -34,7 +34,7 @@ function endpointFor(config) {
     ...((config.mcp_allowed_origins || []).map((value) => new URL(value).origin)),
   ]);
   if (!allowedOrigins.has(endpoint.origin)) {
-    throw new McpHttpError('DraftGo MCP endpoint origin is not allowlisted; refusing to send the SAT.');
+    throw new McpHttpError('DraftGo MCP endpoint origin is not allowlisted; refusing to send the API Key.');
   }
   return endpoint.toString();
 }
@@ -44,6 +44,24 @@ function jsonRpcMessages(value) {
   return value && typeof value === 'object' ? [value] : [];
 }
 
+function routingHeaders(message) {
+  const messages = jsonRpcMessages(message);
+  if (messages.length !== 1 || typeof messages[0].method !== 'string' || !messages[0].method) return {};
+  const request = messages[0];
+  const headers = { 'Mcp-Method': request.method };
+  const params = request.params && typeof request.params === 'object' && !Array.isArray(request.params)
+    ? request.params
+    : {};
+  if (request.method === 'tools/call' && typeof params.name === 'string' && params.name) {
+    headers['Mcp-Name'] = params.name;
+  } else if (request.method === 'prompts/get' && typeof params.name === 'string' && params.name) {
+    headers['Mcp-Name'] = params.name;
+  } else if (request.method === 'resources/read' && typeof params.uri === 'string' && params.uri) {
+    headers['Mcp-Name'] = params.uri;
+  }
+  return headers;
+}
+
 async function parseEventStream(body, onMessage) {
   if (!body) return [];
   const reader = body.getReader();
@@ -113,6 +131,7 @@ async function postJsonRpc(config, message, options = {}) {
     Accept: 'application/json, text/event-stream',
     'Content-Type': 'application/json',
     'MCP-Protocol-Version': options.protocolVersion || DEFAULT_PROTOCOL_VERSION,
+    ...routingHeaders(message),
   };
   if (options.sessionId) headers['Mcp-Session-Id'] = options.sessionId;
 
@@ -169,6 +188,7 @@ module.exports = {
   McpHttpError,
   redactText,
   endpointFor,
+  routingHeaders,
   postJsonRpc,
   parseEventStream,
 };

package/src/mcp/tools.js

@@ -35,6 +35,19 @@ async function openToolSession(config, expected = [], options = {}) {
   return { client, tools, names };
 }
 
+function configuredScope(config, description = null) {
+  const operation = description && (description.operation || description) || {};
+  if (String(operation.ownership_mode || '').toLowerCase() === 'platform_only') return {};
+  const supported = Array.isArray(operation.supported_scopes)
+    ? operation.supported_scopes.map(value => String(value).toLowerCase()) : [];
+  const needsSpace = String(operation.ownership_mode || '').toLowerCase() === 'workspace_required'
+    && supported.length > 0 && !supported.includes('platform');
+  if (config && config.scope_type === 'space' && Number(config.space_id) > 0 && (needsSpace || supported.includes('space'))) {
+    return { scope_type: 'space', space_id: Number(config.space_id) };
+  }
+  return {};
+}
+
 async function callStructured(session, expectedName, args = {}, options = {}) {
   const name = session.names[expectedName] || expectedName;
   const result = await session.client.toolsCall(name, args, options);
@@ -44,4 +57,4 @@ async function callStructured(session, expectedName, args = {}, options = {}) {
     : data;
 }
 
-module.exports = { TOOL_NAMES, openToolSession, callStructured };
+module.exports = { TOOL_NAMES, openToolSession, callStructured, configuredScope };

package/src/platforms.js

@@ -94,6 +94,15 @@ const platforms = [
     signals: ['.gemini', 'GEMINI.md'],
     frontmatter: { name: SKILL_NAME, description: DESCRIPTION },
   },
+  {
+    name: 'pi',
+    displayName: 'Pi',
+    mainFile: '.agents/skills/draftgo/SKILL.md',
+    assetDir: '.agents/skills/draftgo',
+    skillDir: '.agents/skills/draftgo',
+    signals: ['.agents/skills', '.pi'],
+    frontmatter: { name: SKILL_NAME, description: DESCRIPTION },
+  },
 ];
 
 const byName = Object.fromEntries(platforms.map((p) => [p.name, p]));

package/src/projectConfig.js

@@ -95,16 +95,18 @@ function writePrivateJson(file, value) {
 
 function writeProjectConfig(projectDir, server, token, options = {}) {
   const normalizedServer = normalizeServer(server);
-  const sat = String(token || '').trim();
+  const apiKey = String(token || '').trim();
   if (!normalizedServer) throw new Error('DraftGo server is required.');
-  if (!sat) throw new Error('DraftGo SAT is required.');
+  if (!apiKey) throw new Error('DraftGo API Key is required.');
   const existing = readExisting(projectDir);
   const config = {
     ...existing,
     server: normalizedServer,
-    token: sat,
+    token: apiKey,
     auto_push: existing.auto_push === true,
   };
+  if (options.scope_type) config.scope_type = String(options.scope_type).trim().toLowerCase();
+  if (options.space_id) config.space_id = Number(options.space_id);
   if (options.mcp_url) config.mcp_url = normalizeMcpEndpoint(options.mcp_url);
   else delete config.mcp_url;
   const file = configPath(projectDir);
@@ -121,7 +123,7 @@ function loadProjectConfig(projectDir, { requireToken = true } = {}) {
   const mcpUrl = config.mcp_url ? normalizeMcpEndpoint(config.mcp_url) : '';
   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.');
+  if (requireToken && !token) throw new Error('DraftGo project config is missing API Key.');
   const result = { ...config, server, token, path: file };
   if (mcpUrl) result.mcp_url = mcpUrl;
   else delete result.mcp_url;

package/src/releaseInstall.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const http = require('http');
+const https = require('https');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { PACKAGE_ROOT } = require('./paths');
+
+const MARKER = '.draftgo-install.json';
+const REPO = process.env.DRAFTGO_REPO || 'draftgo/draftgo-cli';
+const BASE_URL = process.env.DRAFTGO_INSTALL_BASE_URL || 'https://draftgo.cn/draftgo-cli';
+const MIRROR = process.env.DRAFTGO_GITHUB_MIRROR || `https://ghproxy.net/https://github.com/${REPO}/releases/download`;
+
+function readInstallMarker() {
+  try {
+    const marker = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, MARKER), 'utf8'));
+    if (!marker.installRoot || !marker.binDir) return null;
+    return { installRoot: path.resolve(marker.installRoot), binDir: path.resolve(marker.binDir) };
+  } catch { return null; }
+}
+
+function download(url, output, timeoutMs = 15000, redirects = 0) {
+  return new Promise((resolve, reject) => {
+    if (redirects > 5) return reject(new Error('Too many download redirects.'));
+    const parsed = new URL(url);
+    const transport = parsed.protocol === 'http:' ? http : https;
+    const req = transport.get(parsed, { timeout: timeoutMs, headers: { 'user-agent': 'draftgo-cli' } }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        res.resume();
+        return resolve(download(new URL(res.headers.location, parsed).toString(), output, timeoutMs, redirects + 1));
+      }
+      if (res.statusCode !== 200) { res.resume(); return reject(new Error(`HTTP ${res.statusCode}`)); }
+      const stream = fs.createWriteStream(output, { flags: 'wx' });
+      stream.on('error', reject);
+      res.on('error', reject);
+      stream.on('finish', () => stream.close(() => resolve(url)));
+      res.pipe(stream);
+    });
+    req.on('error', reject);
+    req.on('timeout', () => req.destroy(new Error('Download timed out.')));
+  });
+}
+
+async function downloadFirst(urls, output) {
+  const errors = [];
+  for (const url of urls) {
+    try { return { url: await download(url, output), output }; }
+    catch (error) { errors.push(`${url}: ${error.message}`); try { fs.rmSync(output, { force: true }); } catch {} }
+  }
+  throw new Error(`Unable to download DraftGo release.\n${errors.join('\n')}`);
+}
+
+function hashFile(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function writeLauncher(binDir, packageDir) {
+  fs.mkdirSync(binDir, { recursive: true });
+  if (process.platform === 'win32') {
+    const launcher = path.join(binDir, 'draftgo.cmd');
+    fs.writeFileSync(launcher, `@echo off\r\nnode "${path.join(packageDir, 'bin', 'draftgo.js')}" %*\r\n`, 'ascii');
+    return launcher;
+  }
+  const launcher = path.join(binDir, 'draftgo');
+  fs.writeFileSync(launcher, `#!/usr/bin/env sh\nexec node "${path.join(packageDir, 'bin', 'draftgo.js')}" "$@"\n`, { mode: 0o755 });
+  fs.chmodSync(launcher, 0o755);
+  return launcher;
+}
+
+async function installRelease(version, expectedSha, marker = readInstallMarker()) {
+  if (!marker) return null;
+  if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(String(version))) throw new Error('Invalid release version.');
+  fs.mkdirSync(marker.installRoot, { recursive: true });
+  const tempDir = fs.mkdtempSync(path.join(marker.installRoot, '.update-'));
+  const archive = path.join(tempDir, `draftgo-cli-${version}.tgz`);
+  const asset = path.basename(archive);
+  const urls = [`${BASE_URL}/${asset}`, `${MIRROR}/v${version}/${asset}`, `https://github.com/${REPO}/releases/download/v${version}/${asset}`];
+  try {
+    const downloaded = await downloadFirst(urls, archive);
+    let checksum = expectedSha;
+    if (!checksum) {
+      const checksumFile = path.join(tempDir, `${asset}.sha256`);
+      await download(`${downloaded.url}.sha256`, checksumFile);
+      checksum = fs.readFileSync(checksumFile, 'utf8').trim().split(/\s+/)[0];
+    }
+    if (!/^[0-9a-f]{64}$/i.test(String(checksum)) || hashFile(archive).toLowerCase() !== checksum.toLowerCase()) {
+      throw new Error('DraftGo archive checksum mismatch.');
+    }
+    const staged = path.join(tempDir, 'package');
+    fs.mkdirSync(staged);
+    const extract = spawnSync('tar', ['-xzf', archive, '-C', staged, '--strip-components=1'], { encoding: 'utf8', shell: false });
+    if (extract.error || extract.status !== 0) throw new Error(extract.error ? extract.error.message : (extract.stderr || 'Unable to extract DraftGo release.'));
+    const installedVersion = JSON.parse(fs.readFileSync(path.join(staged, 'package.json'), 'utf8')).version;
+    if (installedVersion !== version) throw new Error(`Release version mismatch: expected ${version}, received ${installedVersion}.`);
+    fs.writeFileSync(path.join(staged, MARKER), JSON.stringify(marker, null, 2) + '\n');
+    const destination = path.join(marker.installRoot, version);
+    if (fs.existsSync(destination)) fs.rmSync(destination, { recursive: true, force: true });
+    fs.renameSync(staged, destination);
+    return { launcher: writeLauncher(marker.binDir, destination), destination };
+  } finally { fs.rmSync(tempDir, { recursive: true, force: true }); }
+}
+
+module.exports = { MARKER, readInstallMarker, installRelease, hashFile, writeLauncher };

package/src/updateCheck.js

@@ -1,14 +1,20 @@
 'use strict';
 
-// Fetch the latest draftgo-cli version from the npm registry.
+// Fetch the latest draftgo-cli version from the DraftGo release endpoint.
 // Results are cached for 24 hours so update stays fast and deterministic.
 
+const http = require('http');
 const https = require('https');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
-const REGISTRY_URL = 'https://registry.npmjs.org/draftgo-cli/latest';
+const REPO = process.env.DRAFTGO_REPO || 'draftgo/draftgo-cli';
+const RELEASE_BASE_URL = process.env.DRAFTGO_INSTALL_BASE_URL || 'https://draftgo.cn/draftgo-cli';
+const RELEASE_URLS = [
+  `${RELEASE_BASE_URL}/latest.json`,
+  `https://api.github.com/repos/${REPO}/releases/latest`,
+];
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 const CACHE_FILE = path.join(os.homedir(), '.draftgo-cli', 'update-check.json');
 
@@ -32,40 +38,54 @@ function writeCache(version) {
   }
 }
 
-function fetchLatestVersion(timeoutMs = 3000, opts = {}) {
-  if (!opts.force) {
-    const cached = readCache();
-    if (cached) return Promise.resolve(cached);
-  }
+function requestVersion(url, timeoutMs, redirects = 0) {
   return new Promise((resolve) => {
+    if (redirects > 5) return resolve(null);
+    let parsed;
+    try { parsed = new URL(url); } catch { return resolve(null); }
+    const transport = parsed.protocol === 'http:' ? http : https;
     let req;
     try {
-      req = https.get(
-        REGISTRY_URL,
-        { timeout: timeoutMs, headers: { accept: 'application/json' } },
-        (res) => {
-          if (res.statusCode !== 200) { res.resume(); return resolve(null); }
-          let body = '';
-          res.setEncoding('utf8');
-          res.on('data', (c) => { body += c; });
-          res.on('end', () => {
-              try {
-                const version = JSON.parse(body).version || null;
-                if (version) writeCache(version);
-                resolve(version);
-              }
-            catch { resolve(null); }
-          });
+      req = transport.get(parsed, {
+        timeout: timeoutMs,
+        headers: { accept: 'application/json', 'user-agent': 'draftgo-cli' },
+      }, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          res.resume();
+          return resolve(requestVersion(new URL(res.headers.location, parsed).toString(), timeoutMs, redirects + 1));
         }
-      );
-    } catch {
-      return resolve(null);
-    }
+        if (res.statusCode !== 200) { res.resume(); return resolve(null); }
+        let body = '';
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => {
+          body += chunk;
+          if (body.length > 64 * 1024) req.destroy();
+        });
+        res.on('end', () => {
+          try {
+            const payload = JSON.parse(body);
+            resolve(payload.version || String(payload.tag_name || '').replace(/^v/, '') || null);
+          } catch { resolve(null); }
+        });
+      });
+    } catch { return resolve(null); }
     req.on('error', () => resolve(null));
     req.on('timeout', () => { req.destroy(); resolve(null); });
   });
 }
 
+async function fetchLatestVersion(timeoutMs = 3000, opts = {}) {
+  if (!opts.force) {
+    const cached = readCache();
+    if (cached) return Promise.resolve(cached);
+  }
+  for (const url of RELEASE_URLS) {
+    const version = await requestVersion(url, timeoutMs);
+    if (version) { writeCache(version); return version; }
+  }
+  return null;
+}
+
 // Compare 'a.b.c' ignoring prerelease tags. Returns 1 / 0 / -1.
 function cmpSemver(a, b) {
   const pa = String(a).split('-')[0].split('.').map((x) => Number(x) || 0);
@@ -77,4 +97,4 @@ function cmpSemver(a, b) {
   return 0;
 }
 
-module.exports = { fetchLatestVersion, cmpSemver, readCache, CACHE_TTL_MS };
+module.exports = { fetchLatestVersion, cmpSemver, readCache, requestVersion, CACHE_TTL_MS };

package/src/worklog.js

@@ -215,7 +215,8 @@ function acquireLock(destination, options = {}) {
       if (descriptor !== undefined) {
         try { fs.closeSync(descriptor); } catch { /* Preserve the original failure. */ }
       }
-      if (!error || error.code !== 'EEXIST') throw error;
+      const retryable = error && ['EEXIST', 'EPERM', 'EACCES', 'EBUSY'].includes(error.code);
+      if (!retryable) throw error;
     }
     if (removeStaleLock(lockPath, staleMs)) continue;
     const elapsed = Date.now() - started;

package/src/worktree/backend.js

@@ -156,7 +156,7 @@ function normalizeUrl(config, value, purpose) {
   if (!allowed.has(url.origin)) {
     throw new WorktreeError(
       'UNTRUSTED_BACKEND_ORIGIN',
-      `${purpose} URL origin is not allowlisted; refusing to send the SAT.`,
+      `${purpose} URL origin is not allowlisted; refusing to send the API Key.`,
       { origin: url.origin },
     );
   }

package/src/worktree/index.js

@@ -491,11 +491,16 @@ async function commitResources(projectDir, resourceType, resourceIds, options =
   const failures = settled.filter((item) => item.status === 'rejected');
   if (failures.length) {
     const first = failures[0].reason;
+    const inputOrder = new Map(ids.map((id, index) => [String(id), index]));
+    const ordered = (items) => [...items].sort((left, right) => (
+      (inputOrder.get(String(left.resource_id)) ?? Number.MAX_SAFE_INTEGER)
+      - (inputOrder.get(String(right.resource_id)) ?? Number.MAX_SAFE_INTEGER)
+    ));
     first.details = {
       ...(first.details || {}),
       batch: {
-        completed: results.filter((item) => ['committed', 'unchanged'].includes(item.status)),
-        failed: results.filter((item) => item.status === 'failed'),
+        completed: ordered(results.filter((item) => ['committed', 'unchanged'].includes(item.status))),
+        failed: ordered(results.filter((item) => item.status === 'failed')),
         not_started: [],
       },
     };