draftgo-cli 4.0.1 → 4.0.23

package/src/commands/reconcile.js

@@ -6,7 +6,7 @@ const { reconcileResources } = require('../worktree');
 async function reconcile(projectDir, positional, flags = {}) {
   const [resourceType, ...ids] = positional;
   if (!resourceType || !ids.length) {
-    log.err('Usage: draftgo reconcile <pages|nav|docs> <id...>');
+    log.err('Usage: draftgo reconcile <pages|nav|docs|custom-services> <id...>');
     return 1;
   }
   if (require('./customService').isServiceType(resourceType)) {

package/src/commands/role.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const log = require('../logger');
+const { callOperation } = require('./api');
+
+// Role is a permission template. Use `draftgo grant` to bind it to a subject.
+const OPERATIONS = Object.freeze({
+  permissions: 'listPermissionCatalog',
+  list: 'listRoles',
+  create: 'createRole',
+  get: 'getRole',
+  update: 'updateRole',
+  delete: 'deleteRole',
+});
+
+function operationKey(value) {
+  const action = String(value || 'list').trim().toLowerCase();
+  return OPERATIONS[action] ? action : '';
+}
+
+async function roleCommand(projectDir, positional, flags = {}) {
+  const action = operationKey(positional[0]);
+  if (!action) {
+    log.err('Usage: draftgo role permissions|list|create|get|update|delete [--input <json-file>]');
+    return 1;
+  }
+  return callOperation(projectDir, OPERATIONS[action], flags);
+}
+
+module.exports = roleCommand;
+module.exports.OPERATIONS = OPERATIONS;
+module.exports.operationKey = operationKey;

package/src/commands/space.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const log = require('../logger');
+const { callOperation } = require('./api');
+
+const OPERATIONS = Object.freeze({
+  list: 'listSpaces',
+  create: 'createSpace',
+  get: 'getSpace',
+  update: 'updateSpace',
+  replace: 'replaceSpace',
+  disable: 'deleteSpace',
+  'members.list': 'listWorkspaceMembers',
+  'members.add': 'addWorkspaceMember',
+  'members.get': 'getWorkspaceMember',
+  'members.update': 'updateWorkspaceMember',
+  'members.replace': 'replaceWorkspaceMember',
+  'members.remove': 'removeWorkspaceMember',
+});
+
+function operationKey(parts) {
+  const values = parts.map((part) => String(part || '').trim().toLowerCase()).filter(Boolean);
+  if (values.length === 1) return values[0] === 'delete' ? 'disable' : values[0];
+  if (values.length === 2 && ['member', 'members'].includes(values[0])) {
+    return `members.${values[1] === 'delete' ? 'remove' : values[1]}`;
+  }
+  return '';
+}
+
+async function spaceCommand(projectDir, positional, flags = {}) {
+  const key = operationKey(positional);
+  if (!OPERATIONS[key]) {
+    log.err('Usage: draftgo space list|create|get|update|replace|disable | members list|add|get|update|replace|remove [--input <json-file>]');
+    return 1;
+  }
+  return callOperation(projectDir, OPERATIONS[key], flags);
+}
+
+module.exports = spaceCommand;
+module.exports.OPERATIONS = OPERATIONS;
+module.exports.operationKey = operationKey;

package/src/commands/status.js

@@ -3,21 +3,124 @@
 const log = require('../logger');
 const { all } = require('../targets');
 const { readInstalledVersion, getPackageVersion } = require('../skill');
+const { loadProjectConfig } = require('../projectConfig');
+const { TOOL_NAMES, openToolSession, callStructured } = require('../mcp/tools');
+const { normalizeDescription } = require('../apiContractCache');
+const { parseTimeout } = require('../timeout');
+
+const API_KEY_STATUS_OPERATION = 'getCurrentUserAPIKey';
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function scopeFrom(value) {
+  let candidates = [asObject(value)];
+  for (let depth = 0; depth < 4; depth += 1) {
+    const next = [];
+    for (const candidate of candidates) {
+      const type = String(candidate.scope_type || candidate.type || '').trim().toLowerCase();
+      if (type === 'platform') return { scope_type: 'platform', workspace_id: null, space_id: null };
+      if (type === 'space') {
+        return {
+          scope_type: 'space',
+          workspace_id: candidate.workspace_id ?? null,
+          space_id: candidate.space_id ?? null,
+        };
+      }
+      for (const key of ['context', 'scope', 'principal', 'credential', 'authentication', 'response', 'data', 'value']) {
+        const nested = asObject(candidate[key]);
+        if (Object.keys(nested).length) next.push(nested);
+      }
+    }
+    candidates = next;
+  }
+  return null;
+}
+
+async function connectionDiagnostic(projectDir, options = {}) {
+  let config;
+  try {
+    config = loadProjectConfig(projectDir);
+  } catch (error) {
+    return { health: 'not_configured', connected: false, error: error.message };
+  }
+
+  const diagnostic = { health: 'unhealthy', connected: false, server: config.server };
+  try {
+    const session = await openToolSession(config, [
+      TOOL_NAMES.projectOverview, TOOL_NAMES.apiDescribe, TOOL_NAMES.apiCall,
+    ], { timeoutMs: options.timeoutMs });
+    const overview = await callStructured(session, TOOL_NAMES.projectOverview, {}, { timeoutMs: options.timeoutMs });
+    const project = asObject(asObject(overview).project);
+    diagnostic.connected = true;
+    diagnostic.server_version = project.version || null;
+    diagnostic.protocol_version = session.client.protocolVersion || null;
+    diagnostic.registry_revision = asObject(asObject(overview).operation_registry).registry_revision || null;
+
+    let scope = scopeFrom(overview);
+    if (!scope) {
+      const described = normalizeDescription(await callStructured(
+        session, TOOL_NAMES.apiDescribe, { operation_id: API_KEY_STATUS_OPERATION }, { timeoutMs: options.timeoutMs },
+      ));
+      if (!described) throw new Error('DraftGo API Key status contract is missing revision metadata.');
+      const result = await callStructured(session, TOOL_NAMES.apiCall, {
+        operation_id: API_KEY_STATUS_OPERATION,
+        registry_revision: described.registry_revision,
+      }, { timeoutMs: options.timeoutMs });
+      scope = scopeFrom(asObject(result).response || result);
+    }
+    if (!scope) throw new Error('DraftGo server did not report the current API Key scope.');
+    Object.assign(diagnostic, scope, { health: 'healthy' });
+    return diagnostic;
+  } catch (error) {
+    diagnostic.error = error && error.message || String(error);
+    return diagnostic;
+  }
+}
+
+async function status(projectDir, _positional = [], flags = {}) {
+  const targets = all.map((target) => {
+    const value = target.status(projectDir);
+    return { name: target.name, display_name: target.displayName, installed: value.installed === true };
+  });
+  const connection = await connectionDiagnostic(projectDir, { timeoutMs: parseTimeout(flags.timeout) });
+  const result = {
+    project_dir: projectDir,
+    cli_version: getPackageVersion(),
+    skill_version: readInstalledVersion(projectDir) || null,
+    connection,
+    targets,
+  };
+  if (flags.output === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
 
-function status(projectDir) {
   log.title('draftgo status');
   log.info(`项目目录：${projectDir}`);
-  log.info(`CLI 版本：${getPackageVersion()}`);
-  log.info(`已装 skill 版本：${readInstalledVersion(projectDir) || '（未安装）'}`);
+  log.info(`CLI 版本：${result.cli_version}`);
+  log.info(`已装 skill 版本：${result.skill_version || '（未安装）'}`);
+  log.info(`服务端：${connection.server || '（未连接）'}`);
+  if (connection.health === 'healthy') {
+    log.ok(`连接健康：healthy${connection.server_version ? `（server ${connection.server_version}）` : ''}`);
+    const ids = connection.scope_type === 'space'
+      ? `，workspace_id=${connection.workspace_id ?? '-'}，space_id=${connection.space_id ?? '-'}` : '';
+    log.info(`当前上下文：${connection.scope_type}${ids}`);
+  } else {
+    log.warn(`连接健康：${connection.health}`);
+    if (connection.error) log.dim(`  ${connection.error}`);
+  }
 
   console.log('');
   console.log('AI 工具入口：');
-  for (const t of all) {
-    const st = t.status(projectDir);
-    const mark = st.installed ? log.c.green('✓') : log.c.gray('·');
-    console.log(`  ${mark} ${t.name.padEnd(12)} ${t.displayName}`);
+  for (const target of targets) {
+    const mark = target.installed ? log.c.green('✓') : log.c.gray('·');
+    console.log(`  ${mark} ${target.name.padEnd(12)} ${target.display_name}`);
   }
   return 0;
 }
 
 module.exports = status;
+module.exports.scopeFrom = scopeFrom;
+module.exports.connectionDiagnostic = connectionDiagnostic;

package/src/commands/update.js

@@ -6,6 +6,7 @@ const { all, byName, resolveTargets } = require('../targets');
 const { ensureRuntime, writeInstalledVersion, readInstalledVersion, getPackageVersion } = require('../skill');
 const { fetchLatestVersion, cmpSemver } = require('../updateCheck');
 const { detectTargets } = require('../detect');
+const { readInstallMarker, installRelease } = require('../releaseInstall');
 
 const REENTRY_FLAG = 'DRAFTGO_UPDATE_REENTERED';
 
@@ -30,19 +31,30 @@ async function updateCliIfNeeded(projectDir, positional, flags) {
     return null;
   }
 
-  const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const marker = readInstallMarker();
+  let command = process.platform === 'win32' ? 'draftgo.cmd' : 'draftgo';
   log.step(`更新 draftgo-cli：${current} → ${latest}`);
-  const install = spawnSync(npm, ['install', '-g', `draftgo-cli@${latest}`], { stdio: 'inherit', shell: false });
-  if (install.error) {
-    log.err(`CLI 更新启动失败：${install.error.message}`);
-    return 1;
-  }
-  if (install.status !== 0) {
-    log.err(`npm install 返回码 ${install.status}`);
-    return Number.isInteger(install.status) ? install.status : 1;
+  if (marker) {
+    try {
+      const result = await installRelease(latest, null, marker);
+      command = result.launcher;
+      log.ok(`CLI Release updated to ${latest}`);
+    } catch (error) {
+      log.err(`CLI Release update failed: ${error.message}`);
+      return 1;
+    }
+  } else {
+    const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const install = spawnSync(npm, ['install', '-g', `draftgo-cli@${latest}`], { stdio: 'inherit', shell: false });
+    if (install.error) {
+      log.err(`CLI 更新启动失败：${install.error.message}`);
+      return 1;
+    }
+    if (install.status !== 0) {
+      log.err(`npm install 返回码 ${install.status}`);
+      return Number.isInteger(install.status) ? install.status : 1;
+    }
   }
-
-  const command = process.platform === 'win32' ? 'draftgo.cmd' : 'draftgo';
   const rerun = spawnSync(command, ['update', ...positional, '--project', projectDir, '--skip-update-check'], {
     stdio: 'inherit',
     shell: false,

package/src/commands/verify.js

@@ -4,6 +4,11 @@ const log = require('../logger');
 const check = require('./check');
 const visualVerify = require('./visualVerify');
 const { canonicalResourceType } = require('../worktree/types');
+const fs = require('fs');
+const path = require('path');
+const parse5 = require('parse5');
+const { loadProjectConfig } = require('../projectConfig');
+const { loadManifest, getEntry, absolutePath } = require('../worktree/manifest');
 
 function mode(value, fallback, flag) {
   const normalized = String(value == null ? fallback : value).toLowerCase();
@@ -53,6 +58,73 @@ function visualRequest(flags, url) {
   };
 }
 
+function walkNodes(node, visit) {
+  if (!node) return;
+  visit(node);
+  for (const child of node.childNodes || []) walkNodes(child, visit);
+}
+
+async function verifyPageComponents(projectDir, selected) {
+  const pages = selected.filter(item => item.resourceType === 'pages');
+  if (!pages.length) return [];
+  const config = loadProjectConfig(projectDir);
+  const manifest = loadManifest(projectDir);
+  const uses = [];
+  for (const page of pages) {
+    const entry = getEntry(manifest, 'pages', page.resourceId);
+    if (!entry) continue;
+    const file = absolutePath(projectDir, entry.local_path);
+    const source = fs.readFileSync(file, 'utf8');
+    const document = parse5.parse(source);
+    const instances = new Set();
+    walkNodes(document, node => {
+      const attrs = new Map((node.attrs || []).map(attr => [attr.name, attr.value]));
+      const name = attrs.get('data-dg-use');
+      if (!name) return;
+      if (!/^([a-z][a-z0-9-]*)\/([a-z][a-z0-9-]*)$/.test(name)) throw new Error(`pages ${page.resourceId}: invalid data-dg-use "${name}"`);
+      const instance = attrs.get('data-dg-instance');
+      if (instance) { if (instances.has(instance)) throw new Error(`pages ${page.resourceId}: duplicate data-dg-instance "${instance}"`); instances.add(instance); }
+      uses.push({ page: page.resourceId, node, attrs, name });
+    });
+  }
+  const cache = new Map();
+  for (const use of uses) {
+    if (!cache.has(use.name)) {
+      const slug = use.name.split('/')[1];
+      const response = await fetch(`${config.server}/api/components?library=${encodeURIComponent(use.name.split('/')[0])}&q=${encodeURIComponent(slug)}&page_size=100`, { headers: { Authorization: `Bearer ${config.token}` } });
+      const payload = await response.json().catch(() => ({}));
+      if (!response.ok) throw new Error(`component lookup failed for ${use.name} (${response.status})`);
+      const items = payload.data?.items || payload.items || [];
+      cache.set(use.name, items.find(item => item.slug === slug && (item.library_slug === use.name.split('/')[0] || item.full_name === use.name)) || null);
+    }
+    const component = cache.get(use.name);
+    if (!component) throw new Error(`pages ${use.page}: component not found ${use.name}`);
+    if (!component.published || Number(component.published_revision || 0) < 1) throw new Error(`pages ${use.page}: component is not published ${use.name}`);
+    const definition = component.published;
+    const rootTag = String(definition.root_tag || '').toLowerCase();
+    if (rootTag && String(use.node.nodeName || '').toLowerCase() !== rootTag) throw new Error(`pages ${use.page}: ${use.name} requires <${rootTag}> but found <${use.node.nodeName}>`);
+    const props = new Map((definition.props || []).map(prop => [prop.name, prop]));
+    for (const [name, value] of use.attrs) {
+      if (!name.startsWith('data-dg-prop-')) continue;
+      const propName = name.slice('data-dg-prop-'.length);
+      const prop = props.get(propName);
+      if (!prop) throw new Error(`pages ${use.page}: unknown prop ${name} on ${use.name}`);
+      if (prop.type === 'boolean' && !['', 'true', 'false', '1', '0'].includes(String(value).toLowerCase())) {
+        throw new Error(`pages ${use.page}: invalid boolean prop ${name} on ${use.name}`);
+      }
+      if (prop.type === 'number' && !Number.isFinite(Number(value))) {
+        throw new Error(`pages ${use.page}: invalid number prop ${name} on ${use.name}`);
+      }
+    }
+    const slots = new Set((definition.slots || []).map(slot => slot.name));
+    for (const child of use.node.childNodes || []) {
+      const slot = (child.attrs || []).find(attr => attr.name === 'data-dg-slot')?.value;
+      if (slot && slots.size && !slots.has(slot)) throw new Error(`pages ${use.page}: unknown slot ${slot} on ${use.name}`);
+    }
+  }
+  return uses;
+}
+
 async function verify(projectDir, positional = [], flags = {}) {
   let selected;
   let remoteMode;
@@ -65,6 +137,8 @@ async function verify(projectDir, positional = [], flags = {}) {
   }
 
   log.title('draftgo verify');
+  try { await verifyPageComponents(projectDir, selected); }
+  catch (error) { log.err(error.message); return 1; }
   const checkCode = await check(projectDir, [], {
     strict: flags.strict,
     remote: remoteMode === 'always',
@@ -110,3 +184,4 @@ module.exports.mode = mode;
 module.exports.resources = resources;
 module.exports.viewports = viewports;
 module.exports.visualRequest = visualRequest;
+module.exports.verifyPageComponents = verifyPageComponents;

package/src/commands/worklog.js

@@ -38,8 +38,12 @@ function add(projectDir, positional, flags, status) {
     const next = appendItem(blocks, title, status, flags.note ? [String(flags.note).trim()] : [], date);
     return { blocks: next, reference: latestReference(next) };
   });
-  output(flags, { path: result.path, item: resultFor(result.blocks, result.reference) });
-  if (flags.output !== 'json') log.ok(`Worklog item added: ${title}`);
+  const item = resultFor(result.blocks, result.reference);
+  output(flags, { path: result.path, item });
+  if (flags.output !== 'json') {
+    const verb = status === 'active' ? 'Started' : 'Added';
+    log.ok(`${verb} work item #${item.number} (${item.date}#${item.number}): ${item.title}`);
+  }
   return 0;
 }
 

package/src/consoleEncoding.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+
+/**
+ * Windows console hosts still use the active console code page to decode the
+ * UTF-8 bytes Node writes. Switch only an interactive console to UTF-8.
+ *
+ * This deliberately does not run for redirected stdout: JSON consumers and
+ * MCP stdio use pipes, where Node's UTF-8 byte stream is already correct and
+ * changing a shared console would be both unnecessary and surprising.
+ */
+function configureConsoleUtf8(options = {}) {
+  const platform = options.platform || process.platform;
+  const stdout = options.stdout || process.stdout;
+  const run = options.spawnSync || spawnSync;
+
+  if (platform !== 'win32' || !stdout || !stdout.isTTY) return false;
+
+  try {
+    // chcp changes the code page for the inherited Windows console. Redirect
+    // its own localized status line so stdout remains exclusively CLI output.
+    run('cmd.exe', ['/d', '/s', '/c', 'chcp 65001 >nul'], {
+      stdio: 'ignore',
+      windowsHide: true,
+    });
+    return true;
+  } catch {
+    // Encoding setup is a presentation enhancement; never block the command.
+    return false;
+  }
+}
+
+module.exports = { configureConsoleUtf8 };

package/src/contractCompatibility.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const HARD_INCOMPATIBLE_CODES = new Set([
+  'CONTRACT_INCOMPATIBLE',
+  'CLIENT_VERSION_UNSUPPORTED',
+  'CLI_VERSION_UNSUPPORTED',
+]);
+
+function errorCode(error) {
+  return String(error && error.code || '').trim().toUpperCase();
+}
+
+function isContractCompatibilityError(error) {
+  const code = errorCode(error);
+  return code === 'CONTRACT_CHANGED' || HARD_INCOMPATIBLE_CODES.has(code);
+}
+
+function isHardContractIncompatibility(error) {
+  return HARD_INCOMPATIBLE_CODES.has(errorCode(error));
+}
+
+function isDangerousOperation(contract) {
+  const operation = contract && contract.operation || contract || {};
+  return operation.destructive === true || String(operation.risk || '').toLowerCase() === 'high';
+}
+
+function canonicalValue(value) {
+  if (Array.isArray(value)) return value.map(canonicalValue);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalValue(value[key])]));
+}
+
+function sameOperationContract(left, right) {
+  const leftOperation = left && left.operation || left || {};
+  const rightOperation = right && right.operation || right || {};
+  return JSON.stringify(canonicalValue(leftOperation)) === JSON.stringify(canonicalValue(rightOperation));
+}
+
+function incompatibleOperationError(operationId, error) {
+  const wrapped = new Error(
+    `DraftGo CLI and server contracts are incompatible for dangerous operation ${operationId}; `
+    + 'the call was blocked before retry. Upgrade DraftGo CLI, then describe and confirm the operation again.',
+  );
+  wrapped.code = 'CLI_CONTRACT_INCOMPATIBLE';
+  wrapped.details = error && (error.details || error.data);
+  wrapped.cause = error;
+  return wrapped;
+}
+
+module.exports = {
+  errorCode,
+  isContractCompatibilityError,
+  isHardContractIncompatibility,
+  isDangerousOperation,
+  sameOperationContract,
+  incompatibleOperationError,
+};