draftgo-cli 1.0.11 → 1.0.13

package/README.md

@@ -164,10 +164,10 @@ RBAC 与 API Key 快捷命令：
 draftgo role list
 draftgo group members add --input request.json
 draftgo api-key status
-draftgo api-key rotate
+draftgo api-key rotate --input api-key.json --yes
 ```
 
-`role` 管理 Role 权限模板，`group` 管理用户组及其角色。交互式 CLI、MCP 和普通 HTTP API 均使用当前用户的 API Key，并按同一基础 RBAC 与业务守卫授权；API Key 不能创建或伪造服务身份。未知能力始终通过 `api search/describe/call` 使用实时 Registry，不依赖固化权限表。
+`role` 管理 Role 权限模板，`group` 管理用户组及其角色。`api-key create|rotate` 按 Registry 的私有凭据交付 workflow 获取新密钥，验证后原子替换项目连接；命令不会把明文密钥打印到 stdout。若交付后验证或写配置中断，重跑同一命令会从 `.draftgo/credential-recovery.json` 恢复，不会再次轮换。交互式 CLI、MCP 和普通 HTTP API 均使用当前用户的 API Key，并按同一基础 RBAC 与业务守卫授权；API Key 不能创建或伪造服务身份。未知能力始终通过 `api search/describe/call` 使用实时 Registry，不依赖固化权限表。
 
 ### 交付与记录
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "draftgo-cli",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Install and manage the DraftGo skill across AI coding agents (Claude Code, Codex, Cursor, Windsurf, Antigravity, Copilot, Gemini, Kiro, Pi, ZCode).",
   "bin": {
     "draftgo": "bin/draftgo.js"
@@ -48,8 +48,9 @@
     "validate:skill": "node scripts/validate-skill.js",
     "build:release": "node scripts/build-release.js",
     "verify:package": "node scripts/verify-package.js",
-    "test": "npm run lint && npm run validate:skill && npm run verify:package && npm run test:unit && npm run test:components && npm run test:capabilities && npm run test:worklog && npm run test:mcp && npm run test:worktree && npm run test:integration && npm run test:local && npm run test:e2e",
+    "test": "npm run lint && npm run validate:skill && npm run verify:package && npm run test:unit && npm run test:api-key && npm run test:components && npm run test:capabilities && npm run test:worklog && npm run test:mcp && npm run test:worktree && npm run test:integration && npm run test:local && npm run test:e2e",
     "test:unit": "node tests/unit.js",
+    "test:api-key": "node --test tests/api-key.test.js",
     "test:components": "node --test tests/components.test.js",
     "test:capabilities": "node --test tests/capabilities.test.js",
     "test:worklog": "node tests/worklog.test.js",

package/resources/skill/manifest.json

@@ -2,7 +2,7 @@
   "schema_version": "1.0",
   "id": "draftgo",
   "name": "DraftGo 开发助手",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "entry": "SKILL.md",
   "description": "以 Skill/reference 任务路由、MCP 实时发现、长正文 checkout/commit、统一验证和完成日志为边界的 DraftGo 工作流。",
   "license": "MIT",

package/resources/skill/references/services.md

@@ -23,7 +23,9 @@ func Register(app *sdk.App) {
 
 func createOrder(ctx *sdk.Context) (any, error) {
 	if err := ctx.Auth.RequireLogin(); err != nil {
-		return nil, err
+		return ctx.Respond(map[string]any{
+			"code": "unauthenticated", "message": "请先登录",
+		}, 401, nil), nil
 	}
 	return ctx.DB.Create("order", ctx.Input)
 }
@@ -31,6 +33,23 @@ func createOrder(ctx *sdk.Context) (any, error) {
 
 普通结果 `return body, nil`。要控 HTTP 状态码或响应头：`return ctx.Respond(body, status, headers), nil`。handler 返回前收束 goroutine。依赖走平台锁定，不替换托管 SDK。不要调用自定义 Go 服务自己的管理/执行 API。
 
+### 业务错误与执行失败
+
+Route 的预期业务失败（参数不合法、余额不足、订单不存在、业务权限不足）用 `ctx.Respond` 明确返回状态码和可展示正文，第二个返回值必须为 `nil`。例如在余额校验失败的分支中：
+
+```go
+return ctx.Respond(map[string]any{
+	"code":    "insufficient_balance",
+	"message": "余额不足，请先充值",
+}, 400, nil), nil
+```
+
+`code` / `message` 是这个业务接口约定的正文示例，不是平台强制包装；页面按双方约定读取。根据业务语义选择 400、403、404、409 等状态码，签名以 checkout 的当前实例 SDK 为准。
+
+`return nil, err`（包括 `errors.New` / `fmt.Errorf`）表示执行失败。当前普通 handler error 会转成 HTTP 500，外部只看到 `Internal Server Error`，脱敏后的具体原因保存在执行记录。即使同时返回 `ctx.Respond(...)`，只要第二个返回值非空，响应也不会被采用。SDK 调用返回的错误不会自动恢复成该模块原来的 HTTP 状态码；已识别的业务失败需要服务代码显式转换，未知错误保留为执行失败，不把任意 `err.Error()` 直接公开。
+
+Event / Schedule 没有外部 HTTP 响应接收者，失败时返回 error 供执行记录追踪，不用 `ctx.Respond` 掩盖失败。Route 返回业务错误响应且 error 为 nil 时，执行记录仍算执行成功；必须检查响应状态码和正文判断业务结果。
+
 已有服务源码：
 
 ```bash
@@ -89,6 +108,8 @@ checkout 服务时，SDK 落到 `.draftgo/worktree/sdk/`。读那里的 `sdk.go`
 
 完成证据：草稿 revision、验证结果、试运行执行 ID；发布时加版本和真实调用结果。
 
+涉及 Route 错误处理时，在任务授权范围内验证成功分支和预期业务失败分支，确认响应状态码、业务 code/message 与页面展示一致；不能只凭执行记录为 succeeded 判定业务成功。草稿试运行按实时契约检查结果，发布后的 HTTP 行为以真实 Route 调用为准。
+
 ## 失败
 
 | HTTP | 先查 |

package/src/commands/apiKey.js

@@ -1,7 +1,26 @@
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
 const log = require('../logger');
-const { callOperation } = require('./api');
+const { confirm } = require('../prompt');
+const {
+  ensureProjectIgnores,
+  loadProjectConfig,
+  writePrivateJson,
+  writeProjectConfig,
+} = require('../projectConfig');
+const { testConnection } = require('../mcp/client');
+const { redactText } = require('../mcp/protocol');
+const { TOOL_NAMES, openToolSession, callStructured } = require('../mcp/tools');
+const { parseTimeout } = require('../timeout');
+const {
+  readCallInput,
+  callOperation,
+  describeOperation,
+  assertInvocationResult,
+  printCallError,
+} = require('./api');
 
 const OPERATIONS = Object.freeze({
   status: 'getCurrentUserAPIKey',
@@ -10,21 +29,242 @@ const OPERATIONS = Object.freeze({
   delete: 'deleteCurrentUserAPIKey',
   rotate: 'rotateCurrentUserAPIKey',
 });
+const CREDENTIAL_ACTIONS = new Set(['create', 'rotate']);
+const RECOVERY_FILE = 'credential-recovery.json';
+const DEFAULT_RESPONSE_LIMIT = 1024 * 1024;
 
 function operationKey(value) {
   const action = String(value || 'status').trim().toLowerCase();
   return OPERATIONS[action] ? action : '';
 }
 
+function recoveryPath(projectDir) {
+  return path.join(projectDir, '.draftgo', RECOVERY_FILE);
+}
+
+function readRecovery(projectDir) {
+  const file = recoveryPath(projectDir);
+  if (!fs.existsSync(file)) return null;
+  let value;
+  try { value = JSON.parse(fs.readFileSync(file, 'utf8')); }
+  catch { throw new Error('The private API Key recovery file is invalid; remove it only after restoring the credential manually.'); }
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+      || !value.server || !value.token || !value.operation_id || !value.action) {
+    throw new Error('The private API Key recovery file is incomplete; remove it only after restoring the credential manually.');
+  }
+  return value;
+}
+
+function jsonPointer(value, pointer) {
+  const text = String(pointer || '');
+  if (!text.startsWith('/')) throw new Error('The credential delivery workflow has no valid credential JSON Pointer.');
+  let current = value;
+  for (const raw of text.slice(1).split('/')) {
+    const key = raw.replace(/~1/g, '/').replace(/~0/g, '~');
+    if (!current || typeof current !== 'object' || !Object.prototype.hasOwnProperty.call(current, key)) {
+      throw new Error('DraftGo returned no credential at the workflow JSON Pointer.');
+    }
+    current = current[key];
+  }
+  const credential = typeof current === 'string' ? current.trim() : '';
+  if (!credential) throw new Error('DraftGo returned an empty credential.');
+  return credential;
+}
+
+function workflowURL(config, workflow) {
+  const rawPath = String(workflow.path || '');
+  if (!rawPath.startsWith('/api/') || rawPath.includes('{')) {
+    throw new Error('The credential delivery workflow returned an unsupported API path.');
+  }
+  const target = new URL(rawPath, `${config.server.replace(/\/+$/, '')}/`);
+  const server = new URL(config.server);
+  if (target.origin !== server.origin || target.username || target.password || target.search || target.hash) {
+    throw new Error('The credential delivery workflow returned an invalid same-origin path.');
+  }
+  return target.toString();
+}
+
+function validateWorkflow(contract, workflow) {
+  const operation = contract && contract.operation || {};
+  const policy = operation.response_policy || {};
+  const method = String(workflow && workflow.method || '').toUpperCase();
+  if (!workflow || workflow.required !== true || workflow.workflow !== 'credential_delivery'
+      || workflow.mode !== 'sensitive' || !['POST', 'PUT', 'PATCH'].includes(method)
+      || method !== String(operation.method || '').toUpperCase()
+      || workflow.path !== operation.path
+      || workflow.credential_pointer !== policy.credential_pointer
+      || !String(workflow.credential_pointer || '').startsWith('/')) {
+    throw new Error('DraftGo returned an invalid credential delivery workflow descriptor.');
+  }
+  const types = Array.isArray(workflow.request_content_types) ? workflow.request_content_types : [];
+  if (types.length && !types.includes('application/json')) {
+    throw new Error('The credential delivery workflow does not accept JSON.');
+  }
+  return method;
+}
+
+async function readBoundedJSON(response, maximum) {
+  const headerLength = Number(response.headers.get('content-length'));
+  if (Number.isFinite(headerLength) && headerLength > maximum) {
+    throw new Error('DraftGo credential response exceeded the workflow size limit.');
+  }
+  if (!response.body) return {};
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = Buffer.from(value);
+      size += chunk.length;
+      if (size > maximum) throw new Error('DraftGo credential response exceeded the workflow size limit.');
+      chunks.push(chunk);
+    }
+  } finally { await reader.cancel().catch(() => {}); }
+  if (!size) return {};
+  try { return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks))); }
+  catch { throw new Error('DraftGo credential response was not valid UTF-8 JSON.'); }
+}
+
+async function requestCredential(config, input, contract, workflow, options = {}) {
+  const method = validateWorkflow(contract, workflow);
+  const maximum = Number(workflow.max_response_bytes || DEFAULT_RESPONSE_LIMIT);
+  const body = JSON.stringify(input.body ?? {});
+  const requestLimit = Number(workflow.max_request_bytes || 0);
+  if (requestLimit > 0 && Buffer.byteLength(body, 'utf8') > requestLimit) {
+    throw new Error('DraftGo credential request exceeded the workflow size limit.');
+  }
+  const response = await (options.fetch || fetch)(workflowURL(config, workflow), {
+    method,
+    headers: {
+      Authorization: `Bearer ${config.token}`,
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body,
+    redirect: 'error',
+    ...(options.timeoutMs ? { signal: AbortSignal.timeout(options.timeoutMs) } : {}),
+  });
+  const payload = await readBoundedJSON(response, maximum > 0 ? maximum : DEFAULT_RESPONSE_LIMIT);
+  if (!response.ok) {
+    const detail = payload && (payload.error || payload);
+    const error = new Error(String(detail && detail.message || `DraftGo returned HTTP ${response.status}.`));
+    error.code = String(detail && detail.code || 'HTTP_ERROR');
+    error.status = response.status;
+    error.details = { request_id: response.headers.get('x-request-id') || undefined };
+    throw error;
+  }
+  return {
+    token: jsonPointer(payload, workflow.credential_pointer),
+    request_id: response.headers.get('x-request-id') || null,
+  };
+}
+
+async function validateAndCommit(projectDir, config, recovery, timeoutMs, options = {}) {
+  await (options.testConnection || testConnection)({ ...config, token: recovery.token }, { timeoutMs });
+  const file = (options.writeProjectConfig || writeProjectConfig)(
+    projectDir,
+    config.server,
+    recovery.token,
+    { mcp_url: config.mcp_url || '' },
+  );
+  fs.rmSync(recoveryPath(projectDir), { force: true });
+  return file;
+}
+
+async function credentialCommand(projectDir, action, flags = {}, options = {}) {
+  const operationId = OPERATIONS[action];
+  const timeoutMs = parseTimeout(flags.timeout);
+  const config = loadProjectConfig(projectDir);
+  const pending = readRecovery(projectDir);
+  if (pending) {
+    if (pending.server !== config.server || pending.operation_id !== operationId || pending.action !== action) {
+      throw new Error(`A pending ${pending.action} credential delivery must be recovered before another API Key operation.`);
+    }
+    try {
+      await validateAndCommit(projectDir, config, pending, timeoutMs, options);
+    } catch (error) {
+      error.message = redactText(error.message || error, [pending.token, config.token]);
+      return printCallError(operationId, error, flags);
+    }
+    if (flags.output === 'json') console.log(JSON.stringify({ operation_id: operationId, credential_updated: true, recovered: true }, null, 2));
+    else log.ok('Recovered and activated the previously delivered DraftGo API Key.');
+    return 0;
+  }
+
+  if (action === 'rotate' && !flags.yes && !flags.y) {
+    if (flags.output === 'json' || !process.stdin.isTTY) {
+      console.log(JSON.stringify({ operation_id: operationId, error: { code: 'CONFIRMATION_REQUIRED', message: 'API Key rotation requires --yes in JSON or non-interactive mode.' } }, null, 2));
+      return 1;
+    }
+    if (!await confirm('Rotate the current DraftGo API Key and replace the project credential?', { default: false })) return 0;
+  }
+
+  try {
+    const openSession = options.openToolSession || openToolSession;
+    const describe = options.describeOperation || describeOperation;
+    const invoke = options.callStructured || callStructured;
+    const session = await openSession(
+      config,
+      [TOOL_NAMES.apiSearch, TOOL_NAMES.apiDescribe, TOOL_NAMES.apiCall],
+      { timeoutMs },
+    );
+    const contract = await describe(projectDir, config, session, operationId);
+    if (!contract) throw new Error('DraftGo API description is missing contract revision metadata.');
+    const input = readCallInput(projectDir, flags);
+    const descriptor = await invoke(session, TOOL_NAMES.apiCall, {
+      ...input,
+      operation_id: operationId,
+      registry_revision: contract.registry_revision,
+      ...(action === 'rotate' ? { confirm: true } : {}),
+    }, { timeoutMs });
+    if (!descriptor || !descriptor.workflow || descriptor.workflow.required !== true) {
+      assertInvocationResult(operationId, descriptor);
+      throw new Error('DraftGo did not return a credential delivery workflow.');
+    }
+    const delivered = await requestCredential(config, input, contract, descriptor.workflow, { timeoutMs, fetch: options.fetch });
+    const recovery = {
+      version: 1,
+      action,
+      operation_id: operationId,
+      server: config.server,
+      ...(config.mcp_url ? { mcp_url: config.mcp_url } : {}),
+      token: delivered.token,
+      delivered_at: new Date().toISOString(),
+    };
+    ensureProjectIgnores(projectDir);
+    writePrivateJson(recoveryPath(projectDir), recovery);
+    await validateAndCommit(projectDir, config, recovery, timeoutMs, options);
+    if (flags.output === 'json') console.log(JSON.stringify({ operation_id: operationId, request_id: delivered.request_id, credential_updated: true, recovered: false }, null, 2));
+    else log.ok(`DraftGo API Key ${action === 'rotate' ? 'rotated' : 'created'} and project credential updated.`);
+    return 0;
+  } catch (error) {
+    const secrets = [config.token];
+    const recovery = readRecovery(projectDir);
+    if (recovery) secrets.push(recovery.token);
+    if (error && error.message) error.message = redactText(error.message, secrets);
+    return printCallError(operationId, error, flags);
+  }
+}
+
 async function apiKeyCommand(projectDir, positional, flags = {}) {
   const action = operationKey(positional[0]);
   if (!action) {
     log.err('Usage: draftgo api-key status|create|update|delete|rotate [--input <json-file>]');
     return 1;
   }
+  if (CREDENTIAL_ACTIONS.has(action)) return credentialCommand(projectDir, action, flags);
   return callOperation(projectDir, OPERATIONS[action], flags);
 }
 
 module.exports = apiKeyCommand;
 module.exports.OPERATIONS = OPERATIONS;
 module.exports.operationKey = operationKey;
+module.exports.recoveryPath = recoveryPath;
+module.exports.readRecovery = readRecovery;
+module.exports.jsonPointer = jsonPointer;
+module.exports.validateWorkflow = validateWorkflow;
+module.exports.requestCredential = requestCredential;
+module.exports.validateAndCommit = validateAndCommit;
+module.exports.credentialCommand = credentialCommand;

package/src/commands/components.js

@@ -753,3 +753,4 @@ module.exports = async function components(projectDir, positional = [], flags =
 };
 module.exports.expandHtml = expandHtml;
 module.exports.verifyDefinition = verifyDefinition;
+module.exports.findComponent = findComponent;

package/src/commands/help.js

@@ -146,7 +146,7 @@ Important flags:
   --yes                    Skip supported confirmation prompts.
   --operation-id <id>      (delete) Select an operation explicitly.
   --params <json>          (api call/delete) Pass an API parameter object.
-  --input <file>           (api call/delete) Read a UTF-8 JSON object.
+  --input <file>           (api call/delete/api-key create|rotate) Read a UTF-8 JSON object.
   --delivery <mode>        (deploy) local | preview | deploy.
   --dry-run                Preview supported cleanup or delivery operations.
   --ui <mode>              (verify) always | never; default never.

package/src/commands/verify.js

@@ -9,6 +9,7 @@ const path = require('path');
 const parse5 = require('parse5');
 const { loadProjectConfig } = require('../projectConfig');
 const { loadManifest, getEntry, absolutePath } = require('../worktree/manifest');
+const { findComponent } = require('./components');
 
 function mode(value, fallback, flag) {
   const normalized = String(value == null ? fallback : value).toLowerCase();
@@ -64,65 +65,81 @@ function walkNodes(node, visit) {
   for (const child of node.childNodes || []) walkNodes(child, visit);
 }
 
+function componentTargets(projectDir, selected) {
+  if (selected.length) {
+    return selected.filter(item => item.resourceType === 'pages' || item.resourceType === 'navigations');
+  }
+  const manifest = loadManifest(projectDir);
+  return Object.values(manifest.entries)
+    .filter(entry => entry.resource_type === 'pages' || entry.resource_type === 'navigations')
+    .map(entry => ({ resourceType: entry.resource_type, resourceId: String(entry.resource_id) }));
+}
+
 async function verifyPageComponents(projectDir, selected) {
-  const pages = selected.filter(item => item.resourceType === 'pages');
-  if (!pages.length) return [];
+  const targets = componentTargets(projectDir, selected);
+  if (!targets.length) {
+    return {
+      status: 'skipped', resources: [], reference_count: 0,
+      reason: selected.length ? 'no_page_or_navigation_selected' : 'no_checked_out_page_or_navigation',
+    };
+  }
   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 covered = [];
+  for (const target of targets) {
+    const entry = getEntry(manifest, target.resourceType, target.resourceId);
+    if (!entry) throw new Error(`${target.resourceType} ${target.resourceId}: resource is not checked out`);
     const file = absolutePath(projectDir, entry.local_path);
     const source = fs.readFileSync(file, 'utf8');
     const document = parse5.parse(source);
     const instances = new Set();
+    let references = 0;
     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}"`);
+      if (!/^([a-z][a-z0-9-]*)\/([a-z][a-z0-9-]*)$/.test(name)) throw new Error(`${target.resourceType} ${target.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 });
+      if (instance) { if (instances.has(instance)) throw new Error(`${target.resourceType} ${target.resourceId}: duplicate data-dg-instance "${instance}"`); instances.add(instance); }
+      references += 1;
+      uses.push({ resourceType: target.resourceType, resourceId: target.resourceId, node, attrs, name });
     });
+    covered.push({ resource_type: target.resourceType, resource_id: target.resourceId, references });
   }
   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);
+      try { cache.set(use.name, await findComponent(config, use.name)); }
+      catch (error) { throw new Error(`component lookup failed for ${use.name}: ${error.message}`); }
     }
     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 label = `${use.resourceType} ${use.resourceId}`;
+    if (!component) throw new Error(`${label}: component not found ${use.name}`);
+    if (!component.published || Number(component.published_revision || 0) < 1) throw new Error(`${label}: 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}>`);
+    if (rootTag && String(use.node.nodeName || '').toLowerCase() !== rootTag) throw new Error(`${label}: ${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) throw new Error(`${label}: 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}`);
+        throw new Error(`${label}: 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}`);
+        throw new Error(`${label}: 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}`);
+      if (slot && slots.size && !slots.has(slot)) throw new Error(`${label}: unknown slot ${slot} on ${use.name}`);
     }
   }
-  return uses;
+  return { status: 'passed', resources: covered, reference_count: uses.length, reason: null };
 }
 
 async function verify(projectDir, positional = [], flags = {}) {
@@ -141,17 +158,42 @@ async function verify(projectDir, positional = [], flags = {}) {
   }
 
   if (flags.output !== 'json') log.title('draftgo verify');
-  try { if (flags.remote) await verifyPageComponents(projectDir, selected); }
-  catch (error) { log.err(error.message); return 1; }
-  const checkCode = await check(projectDir, [], {
+  const checkOptions = {
     output: flags.output,
     strict: flags.strict,
     remote: remoteMode === 'always',
     resourceKeys: selected.length
       ? selected.map((entry) => `${entry.resourceType}:${entry.resourceId}`)
       : null,
-  });
-  if (checkCode !== 0) return checkCode;
+  };
+  if (flags.output === 'json') {
+    const result = await check(projectDir, [], { ...checkOptions, quiet: true, returnResult: true });
+    let componentContracts = {
+      status: 'skipped', resources: [], reference_count: 0,
+      reason: 'remote_not_requested',
+    };
+    if (flags.remote) {
+      try { componentContracts = await verifyPageComponents(projectDir, selected); }
+      catch (error) {
+        componentContracts = {
+          status: 'failed', resources: [], reference_count: 0, reason: null,
+          error: { code: error.code || 'COMPONENT_VALIDATION_FAILED', message: error.message },
+        };
+      }
+    }
+    result.remote_validation.component_contracts = componentContracts;
+    const code = (result.code || componentContracts.status === 'failed') ? 1 : 0;
+    delete result.code;
+    console.log(JSON.stringify(result, null, 2));
+    if (code !== 0) return code;
+  } else {
+    if (flags.remote) {
+      try { await verifyPageComponents(projectDir, selected); }
+      catch (error) { log.err(error.message); return 1; }
+    }
+    const checkCode = await check(projectDir, [], checkOptions);
+    if (checkCode !== 0) return checkCode;
+  }
 
   if (!visual.run) {
     if (url) log.warn('--url was provided without --screenshot always or --ui always; visual verification was skipped.');
@@ -186,3 +228,4 @@ module.exports.resources = resources;
 module.exports.viewports = viewports;
 module.exports.visualRequest = visualRequest;
 module.exports.verifyPageComponents = verifyPageComponents;
+module.exports.componentTargets = componentTargets;

package/src/projectConfig.js

@@ -6,6 +6,7 @@ const { exists, ensureDir, appendGitignoreLine } = require('./fsx');
 
 const IGNORE_ENTRIES = [
   '.draftgo/config.json',
+  '.draftgo/credential-recovery.json',
   '.draftgo/token',
   '.draftgo/worktree/',
   '.draftgo/conflicts/',
@@ -134,6 +135,7 @@ module.exports = {
   normalizeMcpEndpoint,
   normalizeConnection,
   ensureProjectIgnores,
+  writePrivateJson,
   writeProjectConfig,
   loadProjectConfig,
 };

package/src/projectHealth.js

@@ -4,7 +4,7 @@ const fs = require('fs');
 const path = require('path');
 const runtime = require('./runtimeFiles');
 
-const PROTECTED_PREFIXES = ['worktree/', 'conflicts/', 'lessons/', 'tmp/', 'config.json', 'api-contract-cache.json', 'api-contract-cache.json.lock', 'worklog.md', 'story.yaml', '.version', 'runtime-manifest.json'];
+const PROTECTED_PREFIXES = ['worktree/', 'conflicts/', 'lessons/', 'tmp/', 'config.json', 'credential-recovery.json', 'api-contract-cache.json', 'api-contract-cache.json.lock', 'worklog.md', 'story.yaml', '.version', 'runtime-manifest.json'];
 function projectHealth(projectDir) {
   const root = runtime.draftgoRoot(projectDir); const registered = new Set(runtime.load(projectDir).entries.map((entry) => String(entry.path).replace(/\\/g, '/')));
   const summary = { managed_files: 0, unknown_files: 0, temporary_files: 0, artifact_files: 0, total_bytes: 0, reclaimable_bytes: 0, warnings: [] };