draftgo-cli 3.0.35 → 3.0.39

package/src/skill.js

@@ -2,14 +2,12 @@
 
 // Per-platform skill renderer.
 //
-// For every AI-tool target (see src/platforms.js) we render the complete
-// instruction body into that tool's own directory. The large OpenAPI snapshot
-// is shared once under .draftgo/skill-shared to avoid redundant copies.
+// Every AI-tool target receives the complete Skill and its domain references
+// in that target's own project directory.
 //
 // Templating in .md files:
 //   {{SKILL_DIR}}     → platform's project-relative skill dir (forward slashes)
 //   {{SKILL_SCRIPTS}} → {{SKILL_DIR}}/scripts
-//   {{SKILL_SHARED}}  → .draftgo/skill-shared
 
 const path = require('path');
 const fs = require('fs');
@@ -21,8 +19,6 @@ const {
 } = require('./fsx');
 
 const SKILL_SOURCE_DIR = path.join(RESOURCES_DIR, 'skill');
-const SHARED_RESOURCE_DIR = path.join('.draftgo', 'skill-shared');
-const SHARED_FILES = new Set(['references/api.json']);
 
 function getPackageVersion() {
   try {
@@ -80,8 +76,7 @@ function substitute(text, platform) {
   const scriptsDir = `${skillDir}/scripts`;
   return text
     .replace(/\{\{SKILL_DIR\}\}/g, skillDir)
-    .replace(/\{\{SKILL_SCRIPTS\}\}/g, scriptsDir)
-    .replace(/\{\{SKILL_SHARED\}\}/g, SHARED_RESOURCE_DIR.replace(/\\/g, '/'));
+    .replace(/\{\{SKILL_SCRIPTS\}\}/g, scriptsDir);
 }
 
 function walk(root, onFile) {
@@ -98,7 +93,6 @@ function renderInto(destDir, platform) {
   const srcRoot = SKILL_SOURCE_DIR;
   walk(srcRoot, (absSrc) => {
     const rel = path.relative(srcRoot, absSrc);
-    if (SHARED_FILES.has(rel.replace(/\\/g, '/'))) return;
     const absDst = path.join(destDir, rel);
     ensureDir(path.dirname(absDst));
     if (absSrc.endsWith('.md')) {
@@ -116,21 +110,6 @@ function renderInto(destDir, platform) {
 
 }
 
-function ensureSharedResources(projectDir) {
-  const sharedRoot = path.join(projectDir, SHARED_RESOURCE_DIR);
-  for (const rel of SHARED_FILES) {
-    const src = path.join(SKILL_SOURCE_DIR, rel);
-    const dest = path.join(sharedRoot, rel);
-    if (exists(dest)) {
-      const sourceStat = fs.statSync(src);
-      const destStat = fs.statSync(dest);
-      if (sourceStat.size === destStat.size && destStat.mtimeMs >= sourceStat.mtimeMs) continue;
-    }
-    copyFile(src, dest);
-  }
-  return sharedRoot;
-}
-
 function validateRenderedSkill(assetDir) {
   const main = path.join(assetDir, 'SKILL.md');
   if (!exists(main)) throw new Error('渲染结果缺少 SKILL.md');
@@ -140,7 +119,7 @@ function validateRenderedSkill(assetDir) {
   if (!text.startsWith('---\n') || firstEnd < 0 || body.startsWith('---\n')) {
     throw new Error('SKILL.md frontmatter 必须且只能有一个');
   }
-  if (/\{\{(?:SKILL_DIR|SKILL_SCRIPTS|SKILL_SHARED)\}\}/.test(text)) {
+  if (/\{\{(?:SKILL_DIR|SKILL_SCRIPTS)\}\}/.test(text)) {
     throw new Error('SKILL.md 仍包含未替换占位符');
   }
 }
@@ -157,7 +136,8 @@ function ensureRuntime(projectDir) {
   }
   appendGitignoreLine(projectDir, '.draftgo/config.json');
   appendGitignoreLine(projectDir, '.draftgo/token');
-  ensureSharedResources(projectDir);
+  appendGitignoreLine(projectDir, '.draftgo/worktree/');
+  appendGitignoreLine(projectDir, '.draftgo/conflicts/');
 }
 
 function installPlatform(projectDir, platform, opts = {}) {
@@ -173,7 +153,6 @@ function installPlatform(projectDir, platform, opts = {}) {
     return { path: platform.mainFile, skipped: true };
   }
 
-  ensureSharedResources(projectDir);
   const token = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
   const stageAsset = `${destAsset}.tmp-${token}`;
   const backupAsset = `${destAsset}.bak-${token}`;
@@ -259,6 +238,5 @@ module.exports = {
   statusPlatform,
   installAll,
   ensureRuntime,
-  ensureSharedResources,
   splitFrontmatter,
 };

package/src/worktree/backend.js

@@ -0,0 +1,326 @@
+'use strict';
+
+const fs = require('fs');
+const { Readable } = require('stream');
+const { DraftGoMcpClient } = require('../mcp/client');
+const { BackendHttpError, WorktreeError } = require('./errors');
+const { canonicalResourceType, mediaType, normalizeExtension } = require('./types');
+const { normalizeSha256 } = require('./streams');
+
+const METADATA_TOOL = 'draftgo_resource_get_metadata';
+const MAX_ERROR_BYTES = 64 * 1024;
+const MAX_JSON_BYTES = 1024 * 1024;
+
+function isObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function toolNameMatches(name, expected) {
+  return name === expected
+    || name.endsWith(`.${expected}`)
+    || name.endsWith(`/${expected}`)
+    || name.endsWith(`:${expected}`);
+}
+
+function parseJsonText(text, label) {
+  try { return JSON.parse(text); } catch {
+    throw new WorktreeError('INVALID_BACKEND_RESPONSE', `${label} did not return structured JSON.`);
+  }
+}
+
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+
+function isMcpPayload(value) {
+  return isObject(value) && (
+    hasOwn(value, 'jsonrpc')
+    || hasOwn(value, 'result')
+    || hasOwn(value, 'structuredContent')
+    || hasOwn(value, 'structured_content')
+    || hasOwn(value, 'content')
+    || hasOwn(value, 'isError')
+    || hasOwn(value, 'ok')
+  );
+}
+
+function toolError(envelope, fallbackCode, fallbackMessage) {
+  const error = isObject(envelope && envelope.error) ? envelope.error : {};
+  return new WorktreeError(
+    String(firstValue(error.code, fallbackCode)),
+    String(firstValue(error.message, fallbackMessage)),
+    isObject(error.details) ? error.details : {},
+  );
+}
+
+function unwrapToolResult(payload) {
+  if (!isObject(payload)) {
+    throw new WorktreeError('INVALID_BACKEND_RESPONSE', 'DraftGo MCP tool returned no structured result.');
+  }
+
+  let result = payload;
+  if (hasOwn(payload, 'jsonrpc') || hasOwn(payload, 'result')) {
+    if (isObject(payload.error)) {
+      throw toolError({ error: payload.error }, 'MCP_RPC_ERROR', 'DraftGo MCP request failed.');
+    }
+    if (!isObject(payload.result)) {
+      throw new WorktreeError('INVALID_BACKEND_RESPONSE', 'DraftGo MCP returned no tool result.');
+    }
+    result = payload.result;
+  }
+
+  if (!isObject(result)) {
+    throw new WorktreeError('INVALID_BACKEND_RESPONSE', 'DraftGo MCP returned an invalid tool result.');
+  }
+  if (hasOwn(result, 'isError') && typeof result.isError !== 'boolean') {
+    throw new WorktreeError('INVALID_BACKEND_RESPONSE', 'DraftGo MCP returned an invalid isError value.');
+  }
+
+  let envelope;
+  if (hasOwn(result, 'structuredContent')) {
+    if (!isObject(result.structuredContent)) {
+      throw new WorktreeError('INVALID_BACKEND_RESPONSE', 'DraftGo MCP returned invalid structuredContent.');
+    }
+    envelope = result.structuredContent;
+  } else if (hasOwn(result, 'structured_content')) {
+    if (!isObject(result.structured_content)) {
+      throw new WorktreeError('INVALID_BACKEND_RESPONSE', 'DraftGo MCP returned invalid structured_content.');
+    }
+    envelope = result.structured_content;
+  } else if (Array.isArray(result.content)) {
+    const textPart = result.content.find((part) => part && part.type === 'text' && typeof part.text === 'string');
+    if (textPart && Buffer.byteLength(textPart.text, 'utf8') <= MAX_JSON_BYTES) {
+      envelope = parseJsonText(textPart.text, 'DraftGo MCP tool');
+    }
+  } else if (hasOwn(result, 'ok')) {
+    envelope = result;
+  }
+
+  if (!isObject(envelope)) {
+    throw new WorktreeError('INVALID_BACKEND_RESPONSE', 'DraftGo MCP tool returned no structured JSON result.');
+  }
+  if (result.isError === true) {
+    throw toolError(envelope, 'MCP_TOOL_ERROR', 'DraftGo MCP tool reported an error.');
+  }
+  if (envelope.ok !== true) {
+    throw toolError(envelope, 'INVALID_BACKEND_RESPONSE', 'DraftGo MCP tool did not report success.');
+  }
+  return envelope.data;
+}
+
+function unwrapProtectedResult(data, label = 'DraftGo resource tool') {
+  if (!isObject(data) || !hasOwn(data, 'value') || typeof data.omitted !== 'boolean') {
+    throw new WorktreeError(
+      'INVALID_PROTECTED_RESULT',
+      `${label} returned an invalid protected result.`,
+    );
+  }
+  if (data.artifacts !== undefined && !Array.isArray(data.artifacts)) {
+    throw new WorktreeError(
+      'INVALID_PROTECTED_RESULT',
+      `${label} returned invalid artifact descriptors.`,
+    );
+  }
+  if (data.omitted || (Array.isArray(data.artifacts) && data.artifacts.length > 0)) {
+    throw new WorktreeError(
+      'PROTECTED_RESULT_OMITTED',
+      `${label} omitted fields required by the CLI.`,
+      { artifacts: data.artifacts || [] },
+    );
+  }
+  return data.value;
+}
+
+function firstObject(...values) {
+  return values.find(isObject) || {};
+}
+
+function firstValue(...values) {
+  return values.find((value) => value !== undefined && value !== null && value !== '');
+}
+
+function normalizeUrl(config, value, purpose) {
+  if (!value) return null;
+  let url;
+  try { url = new URL(String(value), `${config.server.replace(/\/+$/, '')}/`); } catch {
+    throw new WorktreeError('INVALID_BACKEND_URL', `DraftGo returned an invalid ${purpose} URL.`);
+  }
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) {
+    throw new WorktreeError('INVALID_BACKEND_URL', `DraftGo returned an unsafe ${purpose} URL.`);
+  }
+  const serverOrigin = new URL(config.server).origin;
+  const allowed = new Set([
+    serverOrigin,
+    ...((config.checkout && config.checkout.allowed_origins) || []).map((origin) => new URL(origin).origin),
+  ]);
+  if (!allowed.has(url.origin)) {
+    throw new WorktreeError(
+      'UNTRUSTED_BACKEND_ORIGIN',
+      `${purpose} URL origin is not allowlisted; refusing to send the SAT.`,
+      { origin: url.origin },
+    );
+  }
+  return url.toString();
+}
+
+function normalizeMetadata(config, resourceType, resourceId, payload) {
+  const data = isMcpPayload(payload)
+    ? unwrapProtectedResult(unwrapToolResult(payload), 'DraftGo metadata tool')
+    : payload;
+  if (!isObject(data)) {
+    throw new WorktreeError('INVALID_BACKEND_RESPONSE', 'DraftGo returned invalid checkout metadata.');
+  }
+  const checkout = isObject(data.checkout) ? data.checkout : {};
+  const checkoutConfig = firstObject(config.checkout);
+  const version = firstValue(data.base_version, data.version, data.revision, data.base_revision);
+  const hash = data.content_hash;
+  const contentType = data.content_type;
+  const backendExtension = data.file_extension;
+  const downloadRaw = firstValue(checkout.download, data.download_url);
+  const commitRaw = firstValue(checkout.commit, data.commit_url);
+
+  if (!contentType || !hash || version === undefined || !downloadRaw || !commitRaw) {
+    throw new WorktreeError(
+      'INCOMPLETE_CHECKOUT_METADATA',
+      'DraftGo checkout metadata must include content_type, SHA-256, base version/revision, download URL, and commit URL.',
+    );
+  }
+  const normalizedHash = normalizeSha256(hash);
+  if (!normalizedHash) throw new WorktreeError('INVALID_CONTENT_HASH', 'DraftGo returned an invalid content SHA-256.');
+
+  return {
+    resource_type: canonicalResourceType(firstValue(data.resource_type, resourceType)),
+    resource_id: String(firstValue(data.resource_id, resourceId)),
+    title: String(firstValue(data.title, '')),
+    route: firstValue(data.route, null),
+    code: firstValue(data.code, null),
+    slug: firstValue(data.slug, null),
+    content_type: String(contentType),
+    file_extension: normalizeExtension(contentType, backendExtension),
+    content_size: data.content_size == null ? null : Number(data.content_size),
+    content_hash: normalizedHash,
+    base_version: data.base_version !== undefined ? data.base_version : (data.version !== undefined ? data.version : null),
+    base_revision: data.base_revision !== undefined ? data.base_revision : (data.revision !== undefined ? data.revision : null),
+    etag: firstValue(data.etag, null),
+    updated_at: firstValue(data.updated_at, null),
+    updated_by: firstValue(data.updated_by, null),
+    download_url: normalizeUrl(config, downloadRaw, 'download'),
+    commit_url: commitRaw ? normalizeUrl(config, commitRaw, 'commit') : null,
+    commit_method: String(firstValue(data.commit_method, checkoutConfig.commit_method, 'PUT')).toUpperCase(),
+    raw: data,
+  };
+}
+
+async function resolveMetadata(config, resourceType, resourceId, options = {}) {
+  if (options.metadata) return normalizeMetadata(config, resourceType, resourceId, options.metadata);
+  const client = options.client || new DraftGoMcpClient(config);
+  if (!options.clientInitialized) await client.initialize(options);
+  let toolName = METADATA_TOOL;
+  if (typeof client.listAllTools === 'function') {
+    const tools = options.tools || await client.listAllTools(options);
+    const found = tools.find((tool) => tool && toolNameMatches(String(tool.name || ''), METADATA_TOOL));
+    if (!found) throw new WorktreeError('MCP_TOOL_UNAVAILABLE', `${METADATA_TOOL} is not available.`);
+    toolName = found.name;
+  }
+  const result = await client.toolsCall(toolName, {
+    resource_type: canonicalResourceType(resourceType),
+    resource_id: String(resourceId),
+  }, options);
+  return normalizeMetadata(config, resourceType, resourceId, result);
+}
+
+function authHeaders(config, extra = {}) {
+  return { Authorization: `Bearer ${config.token || config.sat}`, ...extra };
+}
+
+async function readBounded(response, maximum = MAX_ERROR_BYTES) {
+  if (!response.body) return '';
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  let ended = false;
+  while (size < maximum) {
+    const { done, value } = await reader.read();
+    if (done) { ended = true; break; }
+    const chunk = Buffer.from(value);
+    const remaining = maximum - size;
+    chunks.push(chunk.subarray(0, remaining));
+    size += Math.min(chunk.length, remaining);
+  }
+  if (!ended) await reader.cancel().catch(() => {});
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function errorForResponse(response, token) {
+  const text = await readBounded(response);
+  let details = {};
+  try { details = text ? JSON.parse(text) : {}; } catch { details = { response: text }; }
+  const error = firstObject(details.error, details);
+  const code = firstValue(error.code, details.code, response.status === 409 || response.status === 412
+    ? 'RESOURCE_VERSION_CONFLICT' : 'BACKEND_HTTP_ERROR');
+  let message = String(firstValue(error.message, details.message, `DraftGo HTTP ${response.status}`));
+  if (token) message = message.split(String(token)).join('[REDACTED]');
+  return new BackendHttpError(response.status, code, message, isObject(error.details) ? error.details : details);
+}
+
+async function download(config, metadata, options = {}) {
+  const response = await (options.fetch || fetch)(metadata.download_url, {
+    method: 'GET',
+    headers: authHeaders(config, { Accept: '*/*' }),
+    signal: options.signal,
+  });
+  if (!response.ok) throw await errorForResponse(response, config.token || config.sat);
+  return response;
+}
+
+async function commit(config, metadata, localPath, current, options = {}) {
+  if (!metadata.commit_url) {
+    throw new WorktreeError(
+      'COMMIT_URL_UNAVAILABLE',
+      'DraftGo metadata did not provide a commit URL.',
+    );
+  }
+  if (!['POST', 'PUT', 'PATCH'].includes(metadata.commit_method)) {
+    throw new WorktreeError('INVALID_COMMIT_METHOD', 'DraftGo returned an unsupported commit method.');
+  }
+  const headers = authHeaders(config, {
+    'Content-Type': metadata.content_type,
+    'Content-Length': String(current.size),
+    'X-Content-SHA256': current.hash,
+  });
+  if (metadata.etag) headers['If-Match'] = String(metadata.etag);
+  else if (metadata.base_version != null) headers['If-Match'] = String(metadata.base_version);
+  else if (metadata.base_revision != null) headers['If-Match'] = String(metadata.base_revision);
+  if (metadata.base_version != null) headers['DraftGo-Base-Version'] = String(metadata.base_version);
+  if (metadata.base_revision != null) headers['DraftGo-Base-Revision'] = String(metadata.base_revision);
+
+  const response = await (options.fetch || fetch)(metadata.commit_url, {
+    method: metadata.commit_method,
+    headers,
+    body: fs.createReadStream(localPath),
+    duplex: 'half',
+    signal: options.signal,
+  });
+  if (!response.ok) throw await errorForResponse(response, config.token || config.sat);
+  const text = await readBounded(response, MAX_JSON_BYTES);
+  if (!text.trim()) return {};
+  return parseJsonText(text, 'DraftGo commit endpoint');
+}
+
+function nodeReadable(response) {
+  if (!response.body) throw new WorktreeError('DOWNLOAD_INCOMPLETE', 'DraftGo response has no body.');
+  return typeof response.body.getReader === 'function' ? Readable.fromWeb(response.body) : response.body;
+}
+
+module.exports = {
+  METADATA_TOOL,
+  toolNameMatches,
+  unwrapToolResult,
+  unwrapProtectedResult,
+  normalizeMetadata,
+  resolveMetadata,
+  download,
+  commit,
+  nodeReadable,
+  errorForResponse,
+};

package/src/worktree/errors.js

@@ -0,0 +1,28 @@
+'use strict';
+
+class WorktreeError extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = 'WorktreeError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+class BackendHttpError extends WorktreeError {
+  constructor(status, code, message, details = {}) {
+    super(code || 'BACKEND_HTTP_ERROR', message || `Backend request failed with HTTP ${status}.`, details);
+    this.name = 'BackendHttpError';
+    this.status = status;
+  }
+}
+
+function isVersionConflict(error) {
+  return Boolean(error) && (
+    error.code === 'RESOURCE_VERSION_CONFLICT'
+    || error.status === 409
+    || error.status === 412
+  );
+}
+
+module.exports = { WorktreeError, BackendHttpError, isVersionConflict };