draftgo-cli 3.0.1 → 3.0.33

package/resources/skill/story/SKILL.md

@@ -1,16 +1,11 @@
 ---
 name: draftgo-story
-description: "Use this skill to build, load, evolve, or conflict-check the project's Story file (.draftgo/story.yaml). Required for high-risk development tasks when story.yaml is missing, and used whenever a development decision conflicts with the existing Story."
-version: 1.0.0
-allowed-tools: Read, Write, Glob, Bash(find:*)
+description: "Use this skill to build, load, evolve, or conflict-check the project's Story file (.draftgo/story.yaml). Use it when the user requests product-story work, when an existing Story conflicts with a requested product decision, or when preserving a durable product decision is valuable."
 ---
 
 # DraftGo Story System
 
-> **Story 是系统的灵魂档案。高风险开发必须先确认 Story 存在；功能开发若 Story 已存在则静默加载，小修不强制触发 Story。**
->
-> Story 不是文档，不是规范，是创作者对"这个系统是什么、为什么存在、不做什么"的持续叙述。
-> 文件只是理解的副产品。
+> Story 记录产品身份、设计总述、长期决策和当前方向。项目已有 Story 且请求触及定位或既有决策时加载；用户要求或形成需要长期保留的产品决策时创建或更新。
 
 ---
 
@@ -18,11 +13,11 @@ allowed-tools: Read, Write, Glob, Bash(find:*)
 
 | 原则 | 含义 |
 |------|------|
-| Gate, not Doc | 高风险任务没有 Story 就不开发；普通功能把 Story 作为上下文而不是阻塞器 |
+| Decision record | 记录会影响后续取舍的产品定位与决策 |
 | AI 维护，人确认 | 开发者只聊天，AI 负责提炼和写入 |
 | 三层结构 | 身份(稳) → 决策(只增) → 当前(频变) |
 | 决策日志最值钱 | 取舍依据是代码永远表达不了的信息 |
-| 工具无关 | yaml 文件谁都能读，不绑定任何 AI 生态 |
+| 工具无关 | 使用可移植的 YAML 文件 |
 
 ---
 
@@ -43,7 +38,7 @@ identity:
   what: "一句话讲清这是什么，不超过 30 字"
   why: |
     解决什么具体痛点，给谁用。
-    两三句话，要有画面感，不要空话。
+    用两三句具体描述说明使用者和场景。
   not:
     - "不是 XX"
     - "不变成 YY"
@@ -71,7 +66,7 @@ decisions:
 # === 第四层：当前方向（频繁更新）===
 now:
   focus: "当前阶段在做什么"
-  next: "下一步大致方向（粗粒度，不是 TODO）"
+  next: "下一步的大致方向"
   open_questions:
     - "还没想清楚的事"
 ```
@@ -81,18 +76,16 @@ now:
 ## 触发协议
 
 ```
-任何开发对话开始时：
+需要 Story 时：
 
 1. 静默检查 .draftgo/story.yaml
 2. 分流：
-   ├─ 不存在            → 进入「构建流程」，暂存开发请求
-   ├─ maturity = seed   → 加载 + 提示"Story 还稚嫩，开发中会持续补充"
+   ├─ 不存在            → 用户要求创建或需要沉淀关键决策时，进入「构建流程」
+   ├─ maturity = seed   → 加载并把不确定项作为后续判断背景
    └─ growing / stable  → 静默加载，直接开始
 3. 整个对话期间，Story 作为最高优先级上下文锚定
 ```
 
-**Gate 不可妥协**：开发者说"加个页面"，AI 必须先确保 Story 存在，再动手。
-
 ---
 
 ## 构建流程
@@ -102,7 +95,7 @@ now:
 ```
 扫描 .draftgo/ 下的数据，判断走哪条路径：
 
-├─ 存在用户自建内容（非 tag="系统" 的页面、db_meta、custom_scripts、外部API）→ 路径 A
+├─ 存在用户自建内容（非 tag="系统" 的页面、db_meta、custom_scripts）→ 路径 A
 ├─ 用户提供了设计文档（PRD、原型图描述、需求文档等）→ 路径 A（以文档为分析素材）
 └─ 只有内置系统页面，无用户自建内容，无设计文档 → 路径 B（对话采集）
 ```
@@ -117,7 +110,6 @@ now:
    - .draftgo/navigations/index.json → 导航结构
    - .draftgo/db_meta/index.json → 数据模型
    - .draftgo/custom_scripts/index.json → 自定义脚本
-   - .draftgo/external_apis/index.json → 外部 API
    - .draftgo/changelog.md → 更新日志
    - .draftgo/lessons/ → 开发经验记录
    - .draftgo/Task/ → 历史任务文档
@@ -144,9 +136,9 @@ now:
 ```
 输出：[ 检测到全新项目，先聊一下你想做什么 ]
 
-对话式采集（不是问卷，是聊天，问到够用就停）：
+通过简短对话采集，信息足够后即进入提炼：
 
-Q1: 这个系统整体是干嘛的？（存在的理由，不是功能列表）
+Q1: 这个系统的整体定位和存在理由是什么？
 Q2: 谁会用它？什么场景下用？
 Q3: 类似的东西可能有哪些？你想做出什么不同？
 Q4: 大致有哪些模块/功能块？它们之间怎么串起来？
@@ -242,15 +234,13 @@ AI 在开发过程中检测到"方向性决策"时，主动提议沉淀：
 | `identity.*` | 极少 | 仅重大方向转向时（冲突检测中确认） |
 | `design.overview` | 里程碑级 | 核心流转发生结构性变化时更新 |
 | `design.modules` | 新增模块时 | 只增/改，不删已有模块（模块下线标注即可） |
-| `decisions` | 只增不删 | ID 永不复用，supersede 时不删旧的只标记 |
+| `decisions` | 只增不删 | supersede 时不删旧的只标记 |
 | `now.focus` | 周/里程碑 | 对话结束时 AI 提议更新 |
 | `now.next` | 周 | 同上 |
 | `now.open_questions` | 随时 | 出现新的悬而未决事项 |
 | `meta.last_touched` | 每次更新 | 自动 |
 | `meta.maturity` | 手动 | seed→growing: 首次确认后; growing→stable: 决策≥5条且identity不再变 |
 
-**decisions ID 编号规则：** D001 起递增，永不复用，永不删除。
-
 ---
 
 ## 操作流程汇总

package/src/cli.js

@@ -9,13 +9,22 @@ const VALUE_FLAGS = new Set([
   'server',
   'token',
   'output',
+  'url',
+  'browser',
+  'mobile-check',
+  'screenshot',
+  'selector',
+  'width',
+  'height',
+  'wait-ms',
+  'delivery',
   'assignee',
   'assignee-id',
 ]);
 
 function parse(argv) {
   const args = argv.slice();
-  const out = { command: null, positional: [], flags: {} };
+  const out = { command: null, positional: [], flags: {}, errors: [] };
   while (args.length) {
     const a = args.shift();
     if (a === '--') { out.positional.push(...args); break; }
@@ -23,16 +32,22 @@ function parse(argv) {
       const raw = a.slice(2);
       const eq = raw.indexOf('=');
       if (eq >= 0) {
-        out.flags[raw.slice(0, eq)] = raw.slice(eq + 1);
+        const key = raw.slice(0, eq);
+        const value = raw.slice(eq + 1);
+        if (VALUE_FLAGS.has(key) && !value) {
+          out.errors.push(`选项 --${key} 需要一个值。`);
+        } else {
+          out.flags[key] = value;
+        }
       } else {
         const next = args[0];
-        if (next !== undefined && !next.startsWith('-')) {
-          // Only consume next token as value for a known set of flags.
-          if (VALUE_FLAGS.has(raw)) {
+        if (VALUE_FLAGS.has(raw)) {
+          // A declared value flag must never silently become boolean true.
+          if (next === undefined || next === '--' || next.startsWith('--')) {
+            out.errors.push(`选项 --${raw} 需要一个值。`);
+          } else {
             out.flags[raw] = next;
             args.shift();
-          } else {
-            out.flags[raw] = true;
           }
         } else {
           out.flags[raw] = true;

package/src/commandRegistry.js

@@ -0,0 +1,34 @@
+'use strict';
+
+// Keep command names, aliases, and dispatch behavior in one place. This avoids
+// aliases silently drifting away from the implementation as the CLI grows.
+const commands = [
+  { name: 'init', run: (dir, args, flags) => require('./commands/init')(dir, args, flags) },
+  { name: 'update', run: (dir, args, flags) => require('./commands/update')(dir, args, flags) },
+  { name: 'uninstall', aliases: ['remove'], run: (dir, args, flags) => require('./commands/uninstall')(dir, args, flags) },
+  { name: 'status', run: (dir) => require('./commands/status')(dir) },
+  { name: 'map', run: (dir, _args, flags) => require('./commands/map')(dir, flags) },
+  { name: 'check', run: (dir, _args, flags) => require('./commands/check')(dir, flags) },
+  { name: 'verify-ui', aliases: ['verifyui'], run: (dir, args, flags) => require('./commands/verifyUi')(dir, args, flags) },
+  { name: 'api', run: (_dir, args, flags) => require('./commands/api')(args, flags) },
+  { name: 'delete', aliases: ['del', 'rm'], run: (dir, args, flags) => require('./commands/delete')(dir, args, flags) },
+  { name: 'deploy', run: (dir, args, flags) => require('./commands/deploy')(dir, args, flags) },
+  { name: 'auto-push', aliases: ['autopush'], run: (dir, args, flags) => require('./commands/autoPush')(dir, args, flags) },
+  { name: 'pull', run: (dir, args, flags) => require('./commands/sync')(dir, 'pull', args, flags) },
+  { name: 'push', run: (dir, args, flags) => require('./commands/sync')(dir, 'push', args, flags) },
+  { name: 'local', run: (dir, args, flags) => require('./commands/local')(dir, args, flags) },
+  { name: 'list-targets', aliases: ['targets'], run: () => require('./commands/listTargets')() },
+  { name: 'local-dev', aliases: ['localdev'], run: (dir, args, flags) => require('./commands/localDev')(dir, args, flags) },
+  { name: 'connect', aliases: ['login'], run: (dir, args, flags) => require('./commands/connect')(dir, args, flags) },
+];
+
+const aliases = new Map();
+for (const command of commands) {
+  for (const alias of [command.name, ...(command.aliases || [])]) aliases.set(alias, command);
+}
+
+function resolveCommand(name) {
+  return aliases.get(name);
+}
+
+module.exports = { commands, resolveCommand };

package/src/commands/api.js

@@ -0,0 +1,204 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const log = require('../logger');
+
+const API_FILE = path.resolve(__dirname, '..', '..', 'resources', 'skill', 'references', 'api.json');
+const HTTP_METHODS = new Set(['get', 'post', 'put', 'patch', 'delete', 'head', 'options']);
+const AUTH_HEADER_NAMES = new Set(['authorization', 'proxy-authorization', 'x-api-key']);
+
+function resolveRef(spec, ref) {
+  if (!ref || !ref.startsWith('#/')) return null;
+  return ref.slice(2).split('/').reduce((value, part) => value && value[part], spec);
+}
+
+function schemaType(schema, spec) {
+  if (!schema || !Object.keys(schema).length) return 'unspecified';
+  if (schema.$ref) {
+    const target = resolveRef(spec, schema.$ref);
+    return target && (target.title || schema.$ref.split('/').pop()) || schema.$ref;
+  }
+  if (schema.anyOf) return schema.anyOf.map((item) => schemaType(item, spec)).join(' | ');
+  if (schema.oneOf) return schema.oneOf.map((item) => schemaType(item, spec)).join(' | ');
+  if (schema.allOf) return schema.allOf.map((item) => schemaType(item, spec)).join(' & ');
+  if (schema.type === 'array') return `${schemaType(schema.items, spec)}[]`;
+  if (schema.type) return schema.format ? `${schema.type} (${schema.format})` : schema.type;
+  if (schema.properties) return 'object';
+  return 'unspecified';
+}
+
+function schemaNotes(schema) {
+  const notes = [];
+  if (schema.description) notes.push(schema.description);
+  if (schema.default !== undefined) notes.push(`default: ${JSON.stringify(schema.default)}`);
+  if (schema.enum) notes.push(`enum: ${schema.enum.map((item) => JSON.stringify(item)).join(', ')}`);
+  return notes.length ? ` (${notes.join('; ')})` : '';
+}
+
+function printSchema(schema, spec, indent = '      ', seen = new Set()) {
+  if (!schema || !Object.keys(schema).length) {
+    console.log(`${indent}schema: unspecified`);
+    return;
+  }
+
+  let resolved = schema;
+  let refName = '';
+  if (schema.$ref) {
+    refName = schema.$ref.split('/').pop();
+    if (seen.has(schema.$ref)) {
+      console.log(`${indent}${refName} (recursive)`);
+      return;
+    }
+    resolved = resolveRef(spec, schema.$ref) || schema;
+    seen = new Set(seen).add(schema.$ref);
+  }
+
+  console.log(`${indent}schema: ${refName ? `${refName} (${schemaType(resolved, spec)})` : schemaType(resolved, spec)}${schemaNotes(resolved)}`);
+  const variants = resolved.anyOf || resolved.oneOf || resolved.allOf;
+  if (variants) {
+    variants.forEach((variant, index) => {
+      console.log(`${indent}  variant ${index + 1}:`);
+      printSchema(variant, spec, `${indent}    `, seen);
+    });
+    return;
+  }
+  const required = new Set(resolved.required || []);
+  for (const [name, property] of Object.entries(resolved.properties || {})) {
+    const fieldSchema = property.$ref ? resolveRef(spec, property.$ref) || property : property;
+    const marker = required.has(name) ? ' required' : ' optional';
+    console.log(`${indent}  ${name}: ${schemaType(property, spec)}${marker}${schemaNotes(fieldSchema)}`);
+  }
+  if (resolved.additionalProperties === true) console.log(`${indent}  additional properties: allowed`);
+  if (resolved.items && !resolved.properties) printSchema(resolved.items, spec, `${indent}  `, seen);
+}
+
+function authenticationFor(operation, spec) {
+  const security = operation.security === undefined ? spec.security : operation.security;
+  const schemes = (security || []).flatMap((requirement) => Object.keys(requirement).map((name) => {
+    const definition = spec.components && spec.components.securitySchemes && spec.components.securitySchemes[name] || {};
+    return { name, type: definition.type || 'unknown', scheme: definition.scheme, bearerFormat: definition.bearerFormat };
+  }));
+  const headers = (operation.parameters || []).filter((parameter) =>
+    parameter.in === 'header' && AUTH_HEADER_NAMES.has(String(parameter.name).toLowerCase())
+  );
+  return { schemes, headers };
+}
+
+function printAuthentication(operation, spec) {
+  const auth = authenticationFor(operation, spec);
+  if (!auth.schemes.length && !auth.headers.length) {
+    console.log('  Authentication: no requirement declared in the bundled OpenAPI.');
+    return;
+  }
+  console.log('  Authentication:');
+  for (const scheme of auth.schemes) {
+    const detail = [scheme.type, scheme.scheme, scheme.bearerFormat].filter(Boolean).join(', ');
+    console.log(`    security scheme ${scheme.name}${detail ? ` (${detail})` : ''}`);
+  }
+  for (const header of auth.headers) {
+    console.log(`    header ${header.name}: ${schemaType(header.schema, spec)}${header.required ? ' (required)' : ' (optional)'}${schemaNotes(header)}`);
+  }
+}
+
+function printOperation(item, spec) {
+  console.log(`\n${item.method} ${item.route}${item.summary ? `  ${item.summary}` : ''}`);
+  if (item.operationId) console.log(`  Operation: ${item.operationId}`);
+  printAuthentication(item.operation, spec);
+
+  const parameters = (item.operation.parameters || []).filter((parameter) =>
+    !(parameter.in === 'header' && AUTH_HEADER_NAMES.has(String(parameter.name).toLowerCase()))
+  );
+  if (parameters.length) {
+    console.log('  Parameters:');
+    for (const parameter of parameters) {
+      console.log(`    ${parameter.in} ${parameter.name}: ${schemaType(parameter.schema, spec)}${parameter.required ? ' (required)' : ' (optional)'}${schemaNotes(parameter)}`);
+    }
+  }
+
+  if (item.operation.requestBody) {
+    console.log(`  Request body: ${item.operation.requestBody.required ? 'required' : 'optional'}`);
+    for (const [contentType, media] of Object.entries(item.operation.requestBody.content || {})) {
+      console.log(`    ${contentType}:`);
+      printSchema(media.schema, spec, '      ');
+    }
+  }
+
+  const responses = Object.entries(item.operation.responses || {});
+  if (responses.length) {
+    console.log('  Responses:');
+    for (const [status, response] of responses) {
+      console.log(`    ${status}${response.description ? ` ${response.description}` : ''}`);
+      for (const [contentType, media] of Object.entries(response.content || {})) {
+        console.log(`      ${contentType}:`);
+        printSchema(media.schema, spec, '        ');
+      }
+    }
+  }
+}
+
+function apiCommand(positional, flags = {}) {
+  const keyword = String(positional.join(' ') || '').trim().toLowerCase();
+  if (!keyword) {
+    log.err('用法：draftgo api <keyword>');
+    log.dim('  示例：draftgo api pages batch');
+    return 1;
+  }
+
+  let spec;
+  try {
+    spec = JSON.parse(fs.readFileSync(API_FILE, 'utf8'));
+  } catch (err) {
+    log.err(`无法读取 OpenAPI：${err.message}`);
+    return 1;
+  }
+
+  const words = keyword.split(/\s+/).filter(Boolean);
+  const matches = [];
+  for (const [route, methods] of Object.entries(spec.paths || {})) {
+    for (const [method, operation] of Object.entries(methods || {})) {
+      if (!HTTP_METHODS.has(method.toLowerCase())) continue;
+      const haystack = [route, method, operation.summary, operation.operationId, ...(operation.tags || [])]
+        .filter(Boolean).join(' ').toLowerCase();
+      if (!words.every((word) => haystack.includes(word))) continue;
+      matches.push({
+        method: method.toUpperCase(),
+        route,
+        summary: operation.summary || '',
+        operationId: operation.operationId || '',
+        tags: operation.tags || [],
+        operation,
+      });
+    }
+  }
+
+  if (flags.output === 'json') {
+    console.log(JSON.stringify({
+      source: {
+        kind: 'DraftGo bundled base OpenAPI',
+        openapi: spec.openapi || null,
+        version: spec.info && spec.info.version || null,
+        customServiceRoutes: {
+          included: false,
+          reason: 'Custom service routes are registered dynamically from local app.Route calls.',
+          derive: '<METHOD> /api/x/<slug><route-path>',
+        },
+      },
+      query: keyword,
+      matches,
+    }, null, 2));
+    return matches.length ? 0 : 1;
+  }
+  if (!matches.length) {
+    log.warn(`未找到包含“${keyword}”的 API。`);
+    return 1;
+  }
+  log.title(`DraftGo base API — ${keyword}`);
+  log.dim(`Source: bundled DraftGo base OpenAPI v${spec.info && spec.info.version || 'unknown'}; these are platform APIs, not project-defined APIs.`);
+  log.dim('Custom service routes are not indexed here: derive them from local app.Route calls as <METHOD> /api/x/<slug><route-path>.');
+  for (const item of matches.slice(0, 50)) printOperation(item, spec);
+  if (matches.length > 50) log.dim(`\nOnly the first 50 of ${matches.length} matches are shown; use --output json for all contracts.`);
+  return 0;
+}
+
+module.exports = apiCommand;

package/src/commands/autoPush.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const log = require('../logger');
+const check = require('./check');
+const sync = require('./sync');
+
+function autoPush(projectDir, positional, flags = {}) {
+  const configPath = path.join(projectDir, '.draftgo', 'config.json');
+  if (!fs.existsSync(configPath)) {
+    log.dim('自动推送未执行：未连接 DraftGo 服务器（缺少 .draftgo/config.json）。');
+    return 0;
+  }
+
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (err) {
+    log.err(`自动推送未执行：config.json 解析失败：${err.message}`);
+    return 1;
+  }
+
+  log.step('auto-push: 先执行 check …');
+  const checkCode = check(projectDir, { strict: flags.strict });
+  if (checkCode !== 0) {
+    log.err('自动推送终止：check 未通过，请修复后重试。');
+    return checkCode;
+  }
+
+  if (config.auto_push !== true) {
+    log.dim('自动推送已跳过：check 已通过，但 .draftgo/config.json 的 auto_push 不为 true。');
+    return 0;
+  }
+
+  log.step('auto_push=true：开始 push …');
+  const pushArgs = flags.batch ? ['--batch', ...positional] : positional;
+  return sync(projectDir, 'push', pushArgs, flags);
+}
+
+module.exports = autoPush;

package/src/commands/check.js

@@ -14,39 +14,49 @@ function check(projectDir, flags = {}) {
   log.title('draftgo check');
   log.info(`项目目录：${projectDir}`);
 
+  const m = result.map;
   console.log('');
-  log.info(`资源概览：pages=${result.map.pages.length}, nav=${result.map.navigations.length}, db=${result.map.db_meta.length}, scripts=${result.map.custom_scripts.length}, aihub=${result.map.aihub.length}, external_apis=${result.map.external_apis.length}, docs=${result.map.docs.length}, doc_categories=${result.map.doc_categories.length}, system_config=${result.map.system_config.length}`);
+  const overview = [
+    ['pages', m.pages.length],
+    ['nav', m.navigations.length],
+    ['db', m.db_meta.length],
+    ['scripts', m.custom_scripts.length],
+    ['aihub', m.aihub.length],
+    ['docs', m.docs.length],
+  ];
+  console.log('  ' + overview.map(([k, v]) => `${log.c.cyan(k)} ${v}`).join('  '));
+  const pageAreas = [
+    ['home', m.pageGroups.home.length],
+    ['admin', m.pageGroups.admin.length],
+    ['business', m.pageGroups.business.length],
+    ['system', m.pageGroups.system.length],
+  ];
+  console.log('  ' + pageAreas.map(([k, v]) => `${log.c.cyan(k)} ${v}`).join('  '));
 
   if (result.errors.length) {
     console.log('');
-    console.log(`${log.c.red('x')} 错误：`);
-    result.errors.forEach((msg) => console.log(`  - ${msg}`));
+    result.errors.forEach((msg) => console.log(`  ${log.c.red('x')} ${msg}`));
   }
 
   if (result.warnings.length) {
     console.log('');
-    console.log(`${log.c.yellow('!')} 提醒：`);
-    result.warnings.forEach((msg) => console.log(`  - ${msg}`));
-  }
-
-  if (!result.errors.length && !result.warnings.length) {
-    console.log('');
-    log.ok('未发现明显闭环问题。');
+    result.warnings.forEach((msg) => {
+      const detail = (result.warningDetails || []).find((item) => item.message === msg);
+      const prefix = detail ? `[${detail.code}/${detail.confidence}] ` : '';
+      console.log(`  ${log.c.yellow('!')} ${prefix}${msg}`);
+    });
   }
 
+  console.log('');
   if (result.errors.length) {
-    console.log('');
-    console.log(`${log.c.red('x')} 检查未通过：请先修复错误。`);
+    log.err('检查未通过：请先修复错误。');
     return 1;
   }
   if (flags.strict && result.warnings.length) {
-    console.log('');
-    console.log(`${log.c.red('x')} strict 模式：存在提醒项，检查未通过。`);
+    log.err('strict 模式：存在提醒项，检查未通过。');
     return 1;
   }
-
-  console.log('');
-  log.ok(result.warnings.length ? '检查完成：存在提醒项，建议开发代理处理后再 push。' : '检查通过。');
+  log.ok(result.warnings.length ? '检查完成（有提醒项）。' : '检查通过。');
   return 0;
 }
 

package/src/commands/delete.js

@@ -30,8 +30,6 @@ const TYPE_ALIASES = {
   docs: 'docs',
   doc_category: 'doc_categories',
   doc_categories: 'doc_categories',
-  external_api: 'external_apis',
-  external_apis: 'external_apis',
   aihub: 'aihub',
 };
 
@@ -40,7 +38,7 @@ async function deleteResource(projectDir, positional, flags) {
 
   if (!typeRaw || !id) {
     log.err('用法：draftgo delete <type> <id>');
-    log.dim('  支持类型：pages | nav | db_meta | custom_scripts | docs | doc_categories | external_apis | aihub');
+    log.dim('  支持类型：pages | nav | db_meta | custom_scripts | docs | doc_categories | aihub');
     return 1;
   }
 
@@ -80,7 +78,11 @@ async function deleteResource(projectDir, positional, flags) {
     stdio: 'inherit',
     shell: false,
   });
-  return r.status || 0;
+  if (r.error) {
+    log.err(`删除脚本启动失败：${r.error.message}`);
+    return 1;
+  }
+  return Number.isInteger(r.status) ? r.status : 1;
 }
 
 module.exports = deleteResource;

package/src/commands/deploy.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const log = require('../logger');
+const check = require('./check');
+const sync = require('./sync');
+
+function deploy(projectDir, positional, flags = {}) {
+  const delivery = String(flags.delivery || 'deploy').toLowerCase();
+  if (!['local', 'preview', 'deploy'].includes(delivery)) {
+    log.err('--delivery 只支持 local、preview、deploy。');
+    return 1;
+  }
+  log.step('deploy: 先执行 check …');
+  const checkCode = check(projectDir, { strict: flags.strict });
+  if (checkCode !== 0) {
+    log.err('deploy 终止：check 未通过，请修复后重试。');
+    return checkCode;
+  }
+  if (delivery === 'local') {
+    log.ok('delivery=local：本地检查通过，未修改云端。');
+    return 0;
+  }
+  if (delivery === 'preview') {
+    log.step('delivery=preview：执行 push dry-run …');
+    return sync(projectDir, 'push', positional, { ...flags, 'dry-run': true });
+  }
+  log.step('delivery=deploy：开始 push …');
+  return sync(projectDir, 'push', positional, flags);
+}
+
+module.exports = deploy;