@lark-apaas/miaoda-cli 0.1.39-alpha.2937ea8 → 0.1.39-alpha.4481d0b

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -49,6 +49,7 @@ miaoda file ls --output json
49
49
  | `miaoda comment ...` | 应用评论:查看评论列表、解决评论(仅 design-html 场景开放) |
50
50
  | `miaoda registry ...` | 组件 registry:列出 / copy-in SDK 文件(本地执行) |
51
51
  | `miaoda app ...` | 应用生命周期:元数据、初始化、外部项目导入、平台同步、源码导出、静态产物导出 |
52
+ | `miaoda skills ...` | 按项目技术栈同步 skill、查看同步状态 |
52
53
 
53
54
  完整命令通过 `miaoda --help` 或 `miaoda <domain> --help` 查看。
54
55
 
@@ -57,7 +58,7 @@ miaoda file ls --output json
57
58
  `miaoda app init / import / sync / migrate` 管理本地应用工程(平台调用方与本地开发共用):
58
59
 
59
60
  - `init`:按 `--template` 或 `--app-type` 渲染模板(`full_stack → nestjs-react-fullstack`,`frontend / jspage → vite-react`)。工程已存在时不重新渲染、不覆盖业务代码,只输出就绪核验结果 `ready / problems`;`--strict` 下未就绪(meta 损坏、stack 不符、必要文件缺失、依赖未安装、上次操作失败)退出码 1。同步安装失败输出 `status=failed`、`failedStage=install`;退出码只在 `--strict` 时为 1,不带 `--strict` 时为 0(依赖由后续 `sync` 补装)。
60
- - `import`:外部项目导入(平台在 `init` 渲染模板之后、首次 git 提交之前于工程根目录调用)。`--zip <path>` 或 `--zip-url <预签名 URL>` 二选一,`--platform lovable|replit|gemini|zip`(默认 `zip`)。按平台规则把用户代码叠加到 `client/src`、`client/public`、`shared`,其余原样落到 `source_package/`;从不新建 / 覆盖模板托管文件(根 `package.json`、`package-lock.json`、`.npmrc`、`tsconfig*.json`、`vite.config.*`、`eslint.config.*`、`AGENTS.md`、`.githooks/`、`scripts/`、`.spark/`、`node_modules/`、`server/main.ts`、`client/src/index.tsx`),命中时改放 `source_package/` 并记入 `protectedConflicts`。**不合并 package.json、不装依赖**:用户 `package.json` 保留为 `source_package/package.json`,依赖静态分类(`platform_managed` / `present` / `build_chain` / `missing`)写进 `.spark/import/manifest.json`,由 Coding Agent 后续按需安装。先算完整计划、整体暂存再移入,失败时工程原样(`WRITE_FAILED`);同时写待迁移标记 `.spark/import/MIGRATION_PENDING`(沙箱 skill `import-migration` 以它为加载条件,Coding Agent 迁移完成后删除);manifest 最后写,存在即视为已导入(`alreadyImported=true`,不再改动)。`--dry-run` 只输出计划;`--rules-json` 覆盖默认排除路径。错误码:`ARGS_INVALID`(退出码 2)、`NOT_INITIALIZED`、`DOWNLOAD_FAILED`、`INVALID_ZIP`(非 zip / 超 50MB / 解压失败)、`WRITE_FAILED`。
61
+ - `import`(不在 help 列表中展示,仅供平台调用):外部项目导入(平台在 `init` 渲染模板之后、首次 git 提交之前于工程根目录调用)。`--zip <path>` 或 `--zip-url <预签名 URL>` 二选一,`--platform lovable|replit|gemini|zip`(默认 `zip`)。按平台规则把用户代码叠加到 `client/src`、`client/public`、`shared`,其余原样落到 `source_package/`;从不新建 / 覆盖模板托管文件(根 `package.json`、`package-lock.json`、`.npmrc`、`tsconfig*.json`、`vite.config.*`、`eslint.config.*`、`AGENTS.md`、`.githooks/`、`scripts/`、`.spark/`、`node_modules/`、`server/main.ts`、`client/src/index.tsx`),命中时改放 `source_package/` 并记入 `protectedConflicts`。**不合并 package.json、不装依赖**:用户 `package.json` 保留为 `source_package/package.json`,依赖静态分类(`platform_managed` / `present` / `build_chain` / `missing`)写进 `.spark/import/manifest.json`,由 Coding Agent 后续按需安装。先算完整计划、整体暂存、预检移入目标再逐个移入,任一阶段失败都会回滚,工程恢复原样(`WRITE_FAILED`,只可能留下新建的空目录);同时写待迁移标记 `.spark/import/MIGRATION_PENDING`(沙箱 skill `import-migration` 以它为加载条件,Coding Agent 迁移完成后删除);manifest 最后写,存在即视为已导入(`alreadyImported=true`,不再改动)。`--dry-run` 只输出计划;`--rules-json` 覆盖默认排除路径。错误码:`ARGS_INVALID`(退出码 2)、`NOT_INITIALIZED`、`DOWNLOAD_FAILED`、`INVALID_ZIP`(非 zip / 超 50MB / 解压失败)、`WRITE_FAILED`。
61
62
  - `sync`:按 stack 的同步规则更新平台托管内容。全栈工程的托管文件是明确清单(`scripts/dev.sh`、`dev.js`、`dev-local.js`、`build.sh`、`run.sh`、`lint.js`、`prune-smart.js`、`hooks/run-precommit.js` 与 `.githooks/pre-commit`),`scripts/` 下其他用户文件保留;连续执行无漂移。依赖安装失败输出 `status=failed`、`failedStage=install`;退出码只在 `--strict`(平台严格调用)时为 1,不带 `--strict` 时为 0,`dev.sh` 与 lark-cli `+init` 不带它。
62
63
  - `migrate`(不在 help 列表中展示):工程转换原语,在原工程目录内执行。目标模板先渲染到临时模板目录(不复制用户工程),再只读预检冲突(同路径不同内容、重复插件 ID、自定义同名 script、无法确定的 package.json / tsconfig / vite.config / index.html 形态等),随后在原目录定向转换(`src/ public/ → client/`、插件迁 `server/capabilities`、配置定向适配)并安装依赖;迁移配置声明了验证步骤时再执行验证(vite-react → 全栈不做完整构建)。冲突按 `--purpose` 决定的策略处理,结果字段 `conflictPolicy` 给出本次策略:
63
64
  - `stop`(`--purpose upgrade` / `history_restore`,平台调用):预检发现冲突返回 `status=conflict` 与具体路径,工程不写入;执行中才出现的冲突即停、不覆盖用户不同内容。
@@ -72,6 +73,14 @@ miaoda file ls --output json
72
73
 
73
74
  全栈 / design-stack 的 `postinstall` 只升级完整历史平台值(`fullstack-cli action-plugin init` 或 `npx -y @lark-apaas/fullstack-cli action-plugin init`),目标为 `npx -y @lark-apaas/fullstack-cli@latest action-plugin init`;`latest` 是渠道,不是固定版本。带追加命令、参数或用户指定版本的值保留。`migrate` 在原目录执行正常 npm 安装生命周期,包括用户脚本及依赖补丁;生命周期失败即 `install` 阶段失败,保留现场。
74
75
 
76
+ ## 同步项目的技术栈 skill
77
+
78
+ `miaoda app init` 在初始化支持的技术栈时同步 steering。已有项目运行 `miaoda skills sync --local` 可更新项目内的 `.agents/skills/`。沙箱的 `miaoda skills sync --type <type>` 使用相同的 steering 来源规则。
79
+
80
+ 宿主设置 `MIAODA_SANDBOX_PROVIDER=tae` 时,CLI 在公共包上叠加 bnpm 的 `@byted-miaoda/coding-steering`。同一栈、同一开发模式下,内网包的同名 skill 会整目录覆盖社区版。内网包独立选版,BOE 使用 `dev`,其他环境使用 `alpha`。命令的 `--version` 和沙箱 lane 只选择公共版本。同步结果中的 `internalVersion`(`app init` 为 `internalSteeringVersion`)给出实际取得的内网版本。
81
+
82
+ 本地切回公共版后,在同一项目再执行 `miaoda skills sync --local` 会将未经手改的同名 skill 恢复为当前社区版本,并清理仅内网提供的受管 skill。同名自建目录或已手改的内网 skill 会保留,结果中的 `preservedLocalSkills` 列出需要人工处理的条目。
83
+
75
84
  ## 全栈应用的 MCP UI 检查
76
85
 
77
86
  创建 MCP UI 时,Agent 在 `server/mcp/ui` 中同时生成 `tsconfig.json` 和 `eslint.config.cjs`,修改 UI 或其 shared 依赖后主动运行独立检查。模板和 CLI 不生成 UI 配置,也不将 UI 检查接入主工程 lint/type:check。
@@ -142,6 +151,7 @@ miaoda registry add deck-slide --overwrite # 目标已存在时覆盖(
142
151
  ## 环境变量
143
152
 
144
153
  - `MIAODA_APP_ID`:默认应用 ID,等价于 `--app-id`。
154
+ - `MIAODA_SANDBOX_PROVIDER` 标识宿主的沙箱提供方。值为 `tae` 时追加内网 steering 包,其他值或未设置时仅同步公共包。
145
155
  - `MIAODA_MIGRATE_STEP_TIMEOUT_MS`:`app migrate` 单个依赖安装 / 构建步骤的超时(毫秒),默认 20 分钟。
146
156
  - `MIAODA_CANARY_HEADER`:HTTP 请求的 `x-tt-env` 小流量头取值。未设置时默认 `boe_miaoda_ccm`;设为空字符串则不带该头(例:`export MIAODA_CANARY_HEADER=boe_xxx`)。值形如 `ppe_xxx` 时额外带上 `x-use-ppe: 1`。
147
157
 
@@ -435,6 +435,7 @@ JSON 输出
435
435
  "appId": "...", "appType": "modern_html", "sourceImported": true, "importedFileCount": 7,
436
436
  "platformStackFound": true, "platformSyncedFiles": [...],
437
437
  "installed": true, "installSource": "cache|npm|skipped", "installHash": "...", ...}}
438
+ 宿主设置 MIAODA_SANDBOX_PROVIDER=tae 且内网包同步成功时,另返回 internalSteeringVersion。
438
439
  async 模式:{"data": {"initialized": true, "asyncInstall": true, "installed": false,
439
440
  "installSource": "async", "installPid": 123, "installLogPath": "...",
440
441
  "eventReadyPath": "...", "eventFailedPath": "..."}}
@@ -464,8 +465,10 @@ JSON 输出
464
465
  }));
465
466
  }
466
467
  function registerAppImport(parent) {
467
- const cmd = parent
468
- .command('import')
468
+ // 与 migrate 同理:import 只由平台(sandbox_console 建应用时)调用,**不暴露给 Agent**。
469
+ // hidden 后 `miaoda app -h` 不列出,避免 Agent 在已有应用里自行导入 zip 覆盖业务代码;
470
+ // 显式调用 `miaoda app import ...` 行为不变。
471
+ const cmd = new commander_1.Command('import')
469
472
  .description('外部项目导入:把 zip 包(lovable / replit / gemini / 普通 zip)按平台规则叠加进已初始化的工程;不碰模板托管文件、不合并 package.json、不装依赖')
470
473
  .option('--zip <path>', '本地 zip 路径(与 --zip-url 二选一)')
471
474
  .option('--zip-url <url>', 'zip 下载地址(预签名 GET URL,与 --zip 二选一)')
@@ -498,18 +501,22 @@ function registerAppImport(parent) {
498
501
  types.ts / constants.ts → client/src/
499
502
  zip src/** → client/src/**(命中排除路径 → source_package/src/**);public/** → client/public/**;
500
503
  src/components/ui/<name>.<ext> 与工程已有 client/src/components/ui/<name>.* 同名时,
501
- 删除模板文件、写入用户文件
504
+ 删除模板文件、写入用户文件(记入 replacedTemplateFiles);
505
+ 例外:用户文件是 .js / .jsx 而模板有 .ts / .tsx 时保留模板版本,
506
+ 用户文件改放 source_package/ 并记入 protectedConflicts
502
507
  受保护目标(根 package.json / package-lock.json / .npmrc / tsconfig*.json / vite.config.* /
503
508
  eslint.config.* / AGENTS.md / .githooks/ / scripts/ / .spark/ / node_modules/ / server/main.ts /
504
509
  client/src/index.tsx)从不新建或覆盖,命中时改放 source_package/ 并记入 protectedConflicts。
505
510
  用户的 package.json 保留在 source_package/package.json。
506
511
 
507
512
  原子性
508
- 先算完整计划、整体暂存,再移入工程;移入前任何失败工程保持原样(WRITE_FAILED)。
513
+ 先算完整计划、整体暂存,再预检移入目标(目标已是目录 / 父路径是文件),最后逐个移入工程。
514
+ 任一阶段失败都抛 WRITE_FAILED:移入中途失败会按逆序回滚已移入、已覆盖、已删除的文件,
515
+ 工程恢复原样(只可能留下新建的空目录)。
509
516
 
510
517
  依赖清单(.spark/import/manifest.json 的 dependencies,只做静态分析,不安装、不联网)
511
- status 优先级:platform_managed(@lark-apaas/*)> excluded(排除依赖)>
512
- present(工程已有,附 templateRange)> build_chain(构建链 / 工具链)> missing
518
+ status 优先级:platform_managed(@lark-apaas/*)> present(工程已有,附 templateRange)>
519
+ build_chain(构建链 / 工具链)> missing
513
520
 
514
521
  JSON 输出
515
522
  {"data": {"imported": true, "alreadyImported": false, "platform": "zip",
@@ -537,6 +544,7 @@ JSON 输出
537
544
  dir: rawOpts.dir,
538
545
  });
539
546
  }));
547
+ parent.addCommand(cmd, { hidden: true });
540
548
  }
541
549
  function parseInitConf(raw) {
542
550
  // --conf 为可选值:未传(undefined)、裸 --conf(Commander 给 true)、空/纯空白字符串
@@ -23,7 +23,7 @@ function registerSkillsSync(parent) {
23
23
  .command('sync')
24
24
  .description('同步 skills 到 user app(默认 coding-steering;带 --type 时走 sandbox-skills)')
25
25
  .option('--dir <path>', '项目目录,默认当前目录', '.')
26
- .option('--version <ver>', 'coding-steering 包版本或 dist-tag,缺省 latest')
26
+ .option('--version <ver>', '指定公共 coding-steering 包的版本或 dist-tag')
27
27
  .option('--local', '走本地 dev / agent 输出形态:拷到 .agents/skills 平铺 + 创建 .claude/skills 软链。' +
28
28
  '不传时退回老形态:拷到 .agent/skills/steering/<stack>/skills/(跟沙箱端 update-skills.sh 对齐)', false)
29
29
  .option('--type <type>', '走 sandbox 分支:miaoda | miaoda-modern | miaoda-design | openclaw。有值时忽略 --local,' +
@@ -35,6 +35,12 @@ function registerSkillsSync(parent) {
35
35
  前置要求
36
36
  当前目录(或 --dir)已走过 'miaoda app init'(.spark/meta.json 含 stack)
37
37
 
38
+ 技术栈 skill 来源
39
+ MIAODA_SANDBOX_PROVIDER=tae 时,从 bnpm 额外同步 @byted-miaoda/coding-steering。
40
+ 两包有同名 skill 时使用内网版本。
41
+ 内网包在 BOE 取 dev,其余环境取 alpha。--version 和 --tgz-key 仅影响公共来源。
42
+ 缺省、空值或 public 仅同步公共包,其他值会输出警告并按 public 处理。
43
+
38
44
  输出形态(--local 切换)
39
45
  默认(不传 --local):
40
46
  .agent/skills/steering/<stack>/skills/<skill>/...
@@ -54,6 +60,7 @@ function registerSkillsSync(parent) {
54
60
  JSON 输出
55
61
  {"data": {"stack": "...", "version": "...", "syncedSkills": [...], "techSynced": true|false,
56
62
  "claudeSkillsLink": "created|updated|noop|conflict|unsupported" // 仅 --local 时}}
63
+ 内网包同步成功时包含 internalVersion;保留本地同名或手改条目时包含 preservedLocalSkills。
57
64
 
58
65
  传 --type 时:
59
66
  {"data": {"mode": "sandbox", "type": "...", "packageName": "...", "version": "...",
@@ -190,6 +190,7 @@ async function handleAppInit(opts) {
190
190
  templatePackage: tplResult.packageName,
191
191
  templateVersion: tplResult.version,
192
192
  steeringVersion: steeringResult.version,
193
+ internalSteeringVersion: steeringResult.internalVersion,
193
194
  archType: tplResult.archType,
194
195
  appId: opts.appId,
195
196
  appType: opts.appType,
@@ -198,6 +199,7 @@ async function handleAppInit(opts) {
198
199
  importedFileCount: sourceImport.importedFileCount,
199
200
  sourceIgnoredReason: sourceImport.sourceIgnoredReason,
200
201
  syncedSkills: steeringResult.syncedSkills,
202
+ preservedLocalSkills: steeringResult.preservedLocalSkills,
201
203
  techSynced: steeringResult.techSynced,
202
204
  steeringError,
203
205
  gitHooks: hookActivation.action,
@@ -45,7 +45,7 @@ function syncSteeringForSandbox(params) {
45
45
  // 配了 tgzKey 也永远命中不了。把 version 原样透传(未指定就是 undefined),让
46
46
  // syncCodingSteering 一处算全链:version > lane > dev > latest。
47
47
  try {
48
- const r = (0, coding_steering_1.syncCodingSteering)({
48
+ const result = (0, coding_steering_1.syncCodingSteering)({
49
49
  stack,
50
50
  targetDir: params.targetDir,
51
51
  version: params.version,
@@ -62,14 +62,7 @@ function syncSteeringForSandbox(params) {
62
62
  // 同理固定 nested:落 .agent/skills/steering/<stack>/,与老链路一致
63
63
  outputLayout: 'nested',
64
64
  });
65
- return {
66
- status: 'synced',
67
- stack,
68
- version: r.version,
69
- syncedSkills: r.syncedSkills,
70
- techSynced: r.techSynced,
71
- prunedStacks: r.prunedStacks,
72
- };
65
+ return { status: 'synced', stack, ...result };
73
66
  }
74
67
  catch (err) {
75
68
  return { status: 'failed', reason: err.message };
@@ -183,14 +176,8 @@ function syncSteeringOnly(params) {
183
176
  (0, output_1.emit)({
184
177
  data: {
185
178
  stack: meta.stack,
186
- version: result.version,
187
179
  versionSource,
188
- syncedSkills: result.syncedSkills,
189
- techSynced: result.techSynced,
190
- prunedStacks: result.prunedStacks,
191
- ...(result.claudeSkillsLink !== undefined
192
- ? { claudeSkillsLink: result.claudeSkillsLink }
193
- : {}),
180
+ ...result,
194
181
  },
195
182
  });
196
183
  }
@@ -225,13 +225,64 @@ function writeFailed(stage, err) {
225
225
  return new error_1.AppError('WRITE_FAILED', `导入写入失败(${stage}):${err instanceof Error ? err.message : String(err)}`, { next_actions: ['检查磁盘空间 / 目录权限后重试 miaoda app import'] });
226
226
  }
227
227
  /**
228
- * 两阶段落盘:
228
+ * 预检移入目标:rename 遇到「目标已是目录」或「父路径上有普通文件」必然失败,
229
+ * 在动工程之前拦下,避免移入到一半才报错。
230
+ */
231
+ function preflightTargets(plan, projectDir) {
232
+ for (const p of plan.placements) {
233
+ const segs = p.target.split('/');
234
+ for (let i = 1; i < segs.length; i += 1) {
235
+ const parent = node_path_1.default.join(projectDir, ...segs.slice(0, i));
236
+ if (node_fs_1.default.existsSync(parent) && !node_fs_1.default.statSync(parent).isDirectory()) {
237
+ throw writeFailed('preflight', new Error(`目标父路径是文件:${segs.slice(0, i).join('/')}(${p.target})`));
238
+ }
239
+ }
240
+ const dest = node_path_1.default.join(projectDir, ...segs);
241
+ if (node_fs_1.default.existsSync(dest) && node_fs_1.default.statSync(dest).isDirectory()) {
242
+ throw writeFailed('preflight', new Error(`目标路径已是目录:${p.target}`));
243
+ }
244
+ }
245
+ }
246
+ /** 把工程里已有的 rel 挪进 backupDir,返回暂存位置;不存在则返回 undefined。 */
247
+ function backupExisting(projectDir, backupDir, rel) {
248
+ const dest = node_path_1.default.join(projectDir, ...rel.split('/'));
249
+ if (!node_fs_1.default.existsSync(dest))
250
+ return undefined;
251
+ const backup = node_path_1.default.join(backupDir, ...rel.split('/'));
252
+ node_fs_1.default.mkdirSync(node_path_1.default.dirname(backup), { recursive: true });
253
+ node_fs_1.default.renameSync(dest, backup);
254
+ return backup;
255
+ }
256
+ /** 逆序撤回已执行的移入 / 删除;返回撤回失败的路径(尽力而为,不中断)。 */
257
+ function rollbackMoves(records) {
258
+ const failed = [];
259
+ for (const r of [...records].reverse()) {
260
+ try {
261
+ node_fs_1.default.rmSync(r.dest, { force: true });
262
+ if (r.backup) {
263
+ node_fs_1.default.mkdirSync(node_path_1.default.dirname(r.dest), { recursive: true });
264
+ node_fs_1.default.renameSync(r.backup, r.dest);
265
+ }
266
+ }
267
+ catch {
268
+ failed.push(r.dest);
269
+ }
270
+ }
271
+ return failed;
272
+ }
273
+ /**
274
+ * 三阶段落盘:
229
275
  * 1. 全部文件先拷进 stagingDir(工程不动);任一失败 → 清理暂存,工程保持原样
230
- * 2. 逐个 rename 进工程,再删被替换的模板 UI 组件
231
- * 第 2 步失败只能抛 WRITE_FAILED(不写 manifest,重跑会重新导入覆盖)。
276
+ * 2. 预检所有移入目标(目标已是目录 / 父路径是文件);不通过 → 工程保持原样
277
+ * 3. 逐个移入工程、删被替换的模板 UI 组件;被覆盖或删除的原文件先挪进暂存目录下的备份,
278
+ * 中途失败按逆序回滚,工程恢复原样(只可能留下新建的空目录)
279
+ * 失败一律抛 WRITE_FAILED,调用方不写 manifest,重跑会重新导入。
232
280
  */
233
281
  function applyImportPlan(opts) {
234
282
  const { plan, extractDir, projectDir, stagingDir } = opts;
283
+ // 备份放暂存目录下(同一文件系统,rename 不跨设备),finally 一并清理;
284
+ // 放置目标都以 client/ shared/ source_package/ 开头,不会与它重名。
285
+ const backupDir = node_path_1.default.join(stagingDir, '.backup');
235
286
  try {
236
287
  try {
237
288
  for (const p of plan.placements) {
@@ -243,18 +294,30 @@ function applyImportPlan(opts) {
243
294
  catch (err) {
244
295
  throw writeFailed('stage', err);
245
296
  }
297
+ preflightTargets(plan, projectDir);
298
+ const records = [];
246
299
  try {
247
300
  for (const p of plan.placements) {
248
301
  const staged = node_path_1.default.join(stagingDir, ...p.target.split('/'));
249
302
  const dest = node_path_1.default.join(projectDir, ...p.target.split('/'));
303
+ const backup = backupExisting(projectDir, backupDir, p.target);
304
+ records.push({ dest, backup });
250
305
  node_fs_1.default.mkdirSync(node_path_1.default.dirname(dest), { recursive: true });
251
306
  node_fs_1.default.renameSync(staged, dest);
252
307
  }
253
308
  for (const rel of plan.deletions) {
254
- node_fs_1.default.rmSync(node_path_1.default.join(projectDir, ...rel.split('/')), { force: true });
309
+ const backup = backupExisting(projectDir, backupDir, rel);
310
+ if (backup)
311
+ records.push({ dest: node_path_1.default.join(projectDir, ...rel.split('/')), backup });
255
312
  }
256
313
  }
257
314
  catch (err) {
315
+ const notRestored = rollbackMoves(records);
316
+ if (notRestored.length > 0) {
317
+ throw writeFailed('move', new Error(`${err instanceof Error ? err.message : String(err)};回滚未完成:${notRestored
318
+ .map((d) => node_path_1.default.relative(projectDir, d))
319
+ .join(', ')}`));
320
+ }
258
321
  throw writeFailed('move', err);
259
322
  }
260
323
  }
@@ -0,0 +1,122 @@
1
+ "use strict";
2
+ var __importDefault = (this && this.__importDefault) || function (mod) {
3
+ return (mod && mod.__esModule) ? mod : { "default": mod };
4
+ };
5
+ Object.defineProperty(exports, "__esModule", { value: true });
6
+ exports.isSafeSteeringId = isSafeSteeringId;
7
+ exports.copySkillTree = copySkillTree;
8
+ exports.treeDigest = treeDigest;
9
+ exports.applySteeringTransaction = applySteeringTransaction;
10
+ const node_crypto_1 = require("node:crypto");
11
+ const node_fs_1 = __importDefault(require("node:fs"));
12
+ const node_path_1 = __importDefault(require("node:path"));
13
+ const error_1 = require("../utils/error");
14
+ const logger_1 = require("../utils/logger");
15
+ /** 包内与所有权记录里的 ID 只允许可移植的单个路径段。 */
16
+ function isSafeSteeringId(id) {
17
+ return (typeof id === 'string' &&
18
+ /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id) &&
19
+ !id.endsWith('.') &&
20
+ !/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(id));
21
+ }
22
+ function copySkillTree(src, dest) {
23
+ node_fs_1.default.mkdirSync(dest);
24
+ for (const entry of node_fs_1.default.readdirSync(src, { withFileTypes: true })) {
25
+ const from = node_path_1.default.join(src, entry.name);
26
+ const to = node_path_1.default.join(dest, entry.name);
27
+ if (entry.isDirectory())
28
+ copySkillTree(from, to);
29
+ else if (entry.isFile())
30
+ node_fs_1.default.copyFileSync(from, to);
31
+ else
32
+ throw new error_1.AppError('SKILLS_INVALID_PACKAGE', `skill 含软链或特殊文件:${from}`);
33
+ }
34
+ }
35
+ /** 类型、文件名与内容都参与摘要,含新增空目录。用户改成软链/特殊文件时按修改处理。 */
36
+ function treeDigest(root) {
37
+ if (!node_fs_1.default.lstatSync(root).isDirectory())
38
+ return undefined;
39
+ const hash = (0, node_crypto_1.createHash)('sha256');
40
+ for (const name of node_fs_1.default.readdirSync(root).sort()) {
41
+ const child = node_path_1.default.join(root, name);
42
+ const stat = node_fs_1.default.lstatSync(child);
43
+ let digest;
44
+ if (stat.isDirectory())
45
+ digest = treeDigest(child);
46
+ else if (stat.isFile())
47
+ digest = (0, node_crypto_1.createHash)('sha256').update(node_fs_1.default.readFileSync(child)).digest('hex');
48
+ if (digest === undefined)
49
+ return undefined;
50
+ hash
51
+ .update(stat.isDirectory() ? 'd' : 'f')
52
+ .update(name)
53
+ .update('\0')
54
+ .update(digest);
55
+ }
56
+ return hash.digest('hex');
57
+ }
58
+ /** 在调用方的项目锁内提交。每次 rename 之前保存旧项,失败时逆序恢复(包含状态文件)。 */
59
+ function applySteeringTransaction(targetDir, prepare) {
60
+ node_fs_1.default.mkdirSync(targetDir, { recursive: true });
61
+ const work = node_fs_1.default.mkdtempSync(node_path_1.default.join(targetDir, '.miaoda-steering-'));
62
+ const tx = { work, dirs: [], changes: [] };
63
+ const undo = [];
64
+ let keepBackup = false;
65
+ try {
66
+ const result = prepare(tx);
67
+ for (const dir of tx.dirs) {
68
+ const firstCreated = node_fs_1.default.mkdirSync(dir, { recursive: true });
69
+ if (firstCreated === undefined)
70
+ continue;
71
+ undo.push(() => {
72
+ for (let d = node_path_1.default.resolve(dir);; d = node_path_1.default.dirname(d)) {
73
+ node_fs_1.default.rmdirSync(d);
74
+ if (d === node_path_1.default.resolve(firstCreated))
75
+ break;
76
+ }
77
+ });
78
+ }
79
+ for (const [index, { target, staged }] of tx.changes.entries()) {
80
+ if (node_fs_1.default.lstatSync(target, { throwIfNoEntry: false })) {
81
+ const old = node_path_1.default.join(work, `backup-${String(index)}`);
82
+ node_fs_1.default.renameSync(target, old);
83
+ undo.push(() => {
84
+ node_fs_1.default.renameSync(old, target);
85
+ });
86
+ }
87
+ if (staged !== undefined) {
88
+ node_fs_1.default.renameSync(staged, target);
89
+ undo.push(() => {
90
+ node_fs_1.default.renameSync(target, staged);
91
+ });
92
+ }
93
+ }
94
+ return result;
95
+ }
96
+ catch (err) {
97
+ const failures = [];
98
+ for (const restore of undo.reverse()) {
99
+ try {
100
+ restore();
101
+ }
102
+ catch (restoreErr) {
103
+ failures.push(String(restoreErr));
104
+ }
105
+ }
106
+ if (failures.length > 0) {
107
+ keepBackup = true;
108
+ throw new error_1.AppError('SKILLS_ROLLBACK_FAILED', `${String(err)};恢复失败,备份保留于 ${work}:${failures.join(', ')}`);
109
+ }
110
+ throw err;
111
+ }
112
+ finally {
113
+ if (!keepBackup) {
114
+ try {
115
+ node_fs_1.default.rmSync(work, { recursive: true, force: true });
116
+ }
117
+ catch (err) {
118
+ (0, logger_1.log)('skills', `清理临时目录 ${work} 失败:${String(err)}`);
119
+ }
120
+ }
121
+ }
122
+ }
@@ -0,0 +1,166 @@
1
+ "use strict";
2
+ var __importDefault = (this && this.__importDefault) || function (mod) {
3
+ return (mod && mod.__esModule) ? mod : { "default": mod };
4
+ };
5
+ Object.defineProperty(exports, "__esModule", { value: true });
6
+ exports.planFlatSteering = planFlatSteering;
7
+ const node_fs_1 = __importDefault(require("node:fs"));
8
+ const node_path_1 = __importDefault(require("node:path"));
9
+ const coding_steering_files_1 = require("../utils/coding-steering-files");
10
+ const error_1 = require("../utils/error");
11
+ const file_ops_1 = require("../utils/file-ops");
12
+ const logger_1 = require("../utils/logger");
13
+ const STATE_FILE = '.miaoda-internal-steering.json';
14
+ function isRecord(value) {
15
+ return typeof value === 'object' && value !== null && !Array.isArray(value);
16
+ }
17
+ /** 严格验证整个状态后再使用任何一项;不跟随软链,也不接受上次写入一半的文件。 */
18
+ function readOwnership(file) {
19
+ const stat = node_fs_1.default.lstatSync(file, { throwIfNoEntry: false });
20
+ const owned = new Map();
21
+ if (stat === undefined)
22
+ return owned;
23
+ const invalid = new error_1.AppError('SKILLS_INVALID_STATE', `无效的内部 skills 所有权记录:${file}`);
24
+ if (!stat.isFile())
25
+ throw invalid;
26
+ const raw = node_fs_1.default.readFileSync(file, 'utf8');
27
+ let state;
28
+ try {
29
+ state = JSON.parse(raw);
30
+ }
31
+ catch {
32
+ throw invalid;
33
+ }
34
+ if (!isRecord(state) || state.version !== 1 || !Array.isArray(state.skills))
35
+ throw invalid;
36
+ const seen = new Set();
37
+ const add = (id, entry) => {
38
+ if (!(0, coding_steering_files_1.isSafeSteeringId)(id) || seen.has(id.toLowerCase()))
39
+ throw invalid;
40
+ owned.set(id, entry);
41
+ seen.add(id.toLowerCase());
42
+ };
43
+ // v1 的 skills 只记录内网目录。额外字段供新版判断切换前的社区版本和本地冲突。
44
+ for (const source of ['internal', 'community']) {
45
+ const entries = source === 'internal' ? state.skills : state.community;
46
+ if (entries === undefined)
47
+ continue;
48
+ if (!Array.isArray(entries))
49
+ throw invalid;
50
+ for (const item of entries) {
51
+ if (!isRecord(item) || typeof item.digest !== 'string' || !/^[a-f0-9]{64}$/.test(item.digest))
52
+ throw invalid;
53
+ add(item.id, { source, digest: item.digest });
54
+ }
55
+ }
56
+ if (state.local !== undefined) {
57
+ if (!Array.isArray(state.local))
58
+ throw invalid;
59
+ for (const id of state.local)
60
+ add(id, { source: 'local' });
61
+ }
62
+ return owned;
63
+ }
64
+ function planClaudeLink(tx, root, prefix) {
65
+ const linkDir = node_path_1.default.join(root, '.claude');
66
+ const link = node_path_1.default.join(linkDir, 'skills');
67
+ const target = node_path_1.default.join('..', '.agents', 'skills');
68
+ const stat = node_fs_1.default.lstatSync(link, { throwIfNoEntry: false });
69
+ if (stat !== undefined) {
70
+ if (!stat.isSymbolicLink()) {
71
+ (0, logger_1.log)(prefix, '⚠ .claude/skills 已是普通目录/文件,跳过软链创建');
72
+ return 'conflict';
73
+ }
74
+ if (node_fs_1.default.readlinkSync(link) === target)
75
+ return 'noop';
76
+ }
77
+ // 先建新软链;Windows 无权限时保留原链接,skills 本体仍然可用。
78
+ const staged = node_path_1.default.join(tx.work, 'claude-link');
79
+ try {
80
+ node_fs_1.default.symlinkSync(target, staged, 'dir');
81
+ }
82
+ catch (err) {
83
+ const hint = process.platform === 'win32' ? '(请开启开发者模式或以管理员运行)' : '';
84
+ (0, logger_1.log)(prefix, `⚠ .claude/skills 软链创建失败 ${String(err)}${hint};skills 仍在 .agents/skills 下可用`);
85
+ return 'unsupported';
86
+ }
87
+ tx.dirs.push(linkDir);
88
+ tx.changes.push({ target: link, staged });
89
+ return stat === undefined ? 'created' : 'updated';
90
+ }
91
+ function planFlatSteering(tx, targetDir, stagedStack, internalIds, communitySources, logPrefix) {
92
+ (0, file_ops_1.assertNoSymlinkedAncestor)(targetDir, ['.agents', 'skills']);
93
+ (0, file_ops_1.assertNoSymlinkedAncestor)(targetDir, ['.claude']);
94
+ const agents = node_path_1.default.join(targetDir, '.agents');
95
+ const skillsDir = node_path_1.default.join(agents, 'skills');
96
+ const statePath = node_path_1.default.join(agents, STATE_FILE);
97
+ const owned = readOwnership(statePath);
98
+ const next = new Map();
99
+ const preserved = new Set();
100
+ const stagedSkills = node_path_1.default.join(stagedStack, 'skills');
101
+ const desired = new Set(node_fs_1.default.readdirSync(stagedSkills));
102
+ const allIds = new Set(desired);
103
+ // 只有先前装入的内网 skill 在上游消失时需要撤回。
104
+ for (const [id, entry] of owned) {
105
+ if (entry.source === 'internal')
106
+ allIds.add(id);
107
+ }
108
+ if (new Set(Array.from(allIds, (id) => id.toLowerCase())).size !== allIds.size) {
109
+ throw new error_1.AppError('SKILLS_ID_CONFLICT', '已有内部技能记录与当前包的 skill ID 大小写冲突');
110
+ }
111
+ tx.dirs.push(skillsDir);
112
+ for (const id of allIds) {
113
+ const target = node_path_1.default.join(skillsDir, id);
114
+ const previous = owned.get(id);
115
+ const existing = node_fs_1.default.lstatSync(target, { throwIfNoEntry: false });
116
+ const isInternal = internalIds.has(id);
117
+ if (existing !== undefined &&
118
+ (isInternal || previous?.source === 'internal' || previous?.source === 'local')) {
119
+ const community = communitySources.get(id);
120
+ let expected = previous?.source === 'local' ? undefined : previous?.digest;
121
+ if (!previous && community !== undefined)
122
+ expected = (0, coding_steering_files_1.treeDigest)(community);
123
+ if (expected === undefined || (0, coding_steering_files_1.treeDigest)(target) !== expected) {
124
+ (0, logger_1.log)(logPrefix, `⚠ 保留本地 skill ${id}(${previous && previous.source !== 'local' ? '已手动修改' : '已有同名条目'}):${target}`);
125
+ preserved.add(id);
126
+ next.set(id, previous?.source === 'internal' ? previous : { source: 'local' });
127
+ continue;
128
+ }
129
+ }
130
+ if (desired.has(id)) {
131
+ const staged = node_path_1.default.join(stagedSkills, id);
132
+ const digest = (0, coding_steering_files_1.treeDigest)(staged);
133
+ if (digest === undefined)
134
+ throw new error_1.AppError('SKILLS_INVALID_PACKAGE', `无效的 skill:${id}`);
135
+ next.set(id, { source: isInternal ? 'internal' : 'community', digest });
136
+ tx.changes.push({ target, staged });
137
+ }
138
+ else if (existing !== undefined) {
139
+ tx.changes.push({ target });
140
+ }
141
+ }
142
+ const tech = node_path_1.default.join(stagedStack, 'tech.md');
143
+ tx.changes.push({
144
+ target: node_path_1.default.join(agents, 'tech.md'),
145
+ staged: node_fs_1.default.existsSync(tech) ? tech : undefined,
146
+ });
147
+ const claudeSkillsLink = planClaudeLink(tx, targetDir, logPrefix);
148
+ if (next.size > 0) {
149
+ const staged = node_path_1.default.join(tx.work, 'ownership');
150
+ const skills = [];
151
+ const community = [];
152
+ const local = [];
153
+ for (const [id, entry] of next) {
154
+ if (entry.source === 'local')
155
+ local.push(id);
156
+ else
157
+ (entry.source === 'internal' ? skills : community).push({ id, digest: entry.digest });
158
+ }
159
+ node_fs_1.default.writeFileSync(staged, JSON.stringify({ version: 1, skills, community, local }, null, 2) + '\n');
160
+ tx.changes.push({ target: statePath, staged });
161
+ }
162
+ else if (owned.size > 0) {
163
+ tx.changes.push({ target: statePath });
164
+ }
165
+ return { claudeSkillsLink, preserved };
166
+ }
@@ -9,10 +9,13 @@ const node_path_1 = __importDefault(require("node:path"));
9
9
  const npm_pack_1 = require("../utils/npm-pack");
10
10
  const error_1 = require("../utils/error");
11
11
  const file_ops_1 = require("../utils/file-ops");
12
+ const coding_steering_files_1 = require("../utils/coding-steering-files");
13
+ const coding_steering_flat_1 = require("../utils/coding-steering-flat");
12
14
  const logger_1 = require("../utils/logger");
13
- const logger_2 = require("../utils/logger");
14
15
  const env_1 = require("../utils/env");
15
16
  const STEERING_PACKAGE = '@lark-apaas/coding-steering';
17
+ const INTERNAL_PACKAGE = '@byted-miaoda/coding-steering';
18
+ const INTERNAL_REGISTRY = 'https://bnpm.byted.org/';
16
19
  /** nested 目标的祖先链,破坏性操作前逐段验真(见 `assertNoSymlinkedAncestor`)。 */
17
20
  const NESTED_ANCESTORS = ['.agent', 'skills', 'steering'];
18
21
  /**
@@ -30,9 +33,8 @@ const NESTED_ANCESTORS = ['.agent', 'skills', 'steering'];
30
33
  *
31
34
  * 首字符限定字母数字,顺带排掉了 `.` / `..` 与隐藏目录名。
32
35
  */
33
- const STACK_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
34
36
  function assertSafeStack(stack) {
35
- if (!STACK_NAME_PATTERN.test(stack)) {
37
+ if (!(0, coding_steering_files_1.isSafeSteeringId)(stack)) {
36
38
  throw new error_1.AppError('SKILLS_INVALID_STACK', `stack 名非法:${JSON.stringify(stack)}。只允许单个路径段(首字符为字母数字,其余可含 . _ -);` +
37
39
  `请检查 .spark/meta.json 的 stack 字段`);
38
40
  }
@@ -41,357 +43,169 @@ function inferMode() {
41
43
  // 沙箱(MIAODA_DEP_CACHE_DIR 非空)→ sandbox;本地 → local
42
44
  return (0, env_1.isSandboxEnv)() ? 'sandbox' : 'local';
43
45
  }
44
- /**
45
- * 把 coding-steering 包内 <stack>/skills_common + 专有层(skills 或 skills_local)同步到
46
- * user app。
47
- *
48
- * 包内目录约定(每个 stack 三层):
49
- * <stack>/skills_common → 沙箱 + 本地都下发的共有层
50
- * <stack>/skills → 沙箱专有(沙箱端 update-skills.sh / mode=sandbox 时拿)
51
- * <stack>/skills_local → 本地专有(本地 dev / agent 环境拿)
52
- *
53
- * 下发组合(mode):
54
- * mode='sandbox' → skills_common + skills
55
- * mode='local' → skills_common + skills_local
56
- *
57
- * 目标路径形态(outputLayout):
58
- * 'nested' (默认,向后兼容):拷到 .agent/skills/steering/<stack>/skills/,tech.md 同目录
59
- * 'flat':拷到 .agents/skills/(平铺),tech.md → .agents/tech.md,并创建 .claude/skills
60
- * 软链指向 ../.agents/skills 让 Claude Code 识别同一份
61
- *
62
- * 同名 skill 覆盖顺序:common < 专有(专有覆盖 common 同名)。mode 缺省按 isSandboxEnv()
63
- * 推断(MIAODA_DEP_CACHE_DIR 非空 → sandbox;空 / undefined → local)。
64
- *
65
- * 纯本地 atom(pull npm package + 拷贝文件),不属于任何 cli 域;放在 utils 让
66
- * app init handler 与独立 skills sync handler 都能复用。
67
- */
46
+ function selectSkills(pkg, opts, mode, logPrefix, internal) {
47
+ const { stack, templateVersion } = opts;
48
+ const root = node_path_1.default.join(pkg.extractDir, 'steering');
49
+ if (!node_fs_1.default.lstatSync(pkg.extractDir, { throwIfNoEntry: false })?.isDirectory() ||
50
+ !node_fs_1.default.lstatSync(root, { throwIfNoEntry: false })?.isDirectory()) {
51
+ throw new error_1.AppError('SKILLS_INVALID_PACKAGE', `包中缺少 steering 目录:${internal ? INTERNAL_PACKAGE : STEERING_PACKAGE}`);
52
+ }
53
+ const selected = [];
54
+ // 两包各自按 common < 专有层选取。缺栈/缺层为零条目。
55
+ for (const layer of ['skills_common', mode === 'sandbox' ? 'skills' : 'skills_local']) {
56
+ (0, file_ops_1.assertNoSymlinkedAncestor)(root, [stack, layer]);
57
+ const dir = node_path_1.default.join(root, stack, layer);
58
+ if (!node_fs_1.default.lstatSync(dir, { throwIfNoEntry: false }))
59
+ continue;
60
+ for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
61
+ if (entry.isFile())
62
+ continue; // README / 占位文件
63
+ const src = node_path_1.default.join(dir, entry.name);
64
+ if (!entry.isDirectory() || !(0, coding_steering_files_1.isSafeSteeringId)(entry.name)) {
65
+ throw new error_1.AppError('SKILLS_INVALID_PACKAGE', `无效的 skill 目录:${src}`);
66
+ }
67
+ if (!matchesTemplate(src, stack, templateVersion, logPrefix))
68
+ continue;
69
+ selected.push({
70
+ packageName: internal ? INTERNAL_PACKAGE : STEERING_PACKAGE,
71
+ id: entry.name,
72
+ src,
73
+ label: `${stack}/${layer}/${entry.name}`,
74
+ });
75
+ }
76
+ }
77
+ return selected;
78
+ }
79
+ function mergeSkills(publicSkills, internalSkills) {
80
+ // key 归一化以兼容大小写不敏感的文件系统,报错仍保留两个源条目的实际拼写。
81
+ const effective = new Map();
82
+ for (const skill of [...publicSkills, ...internalSkills]) {
83
+ const key = skill.id.toLowerCase();
84
+ const prior = effective.get(key);
85
+ if (prior !== undefined && prior.id !== skill.id) {
86
+ throw new error_1.AppError('SKILLS_ID_CONFLICT', `steering skill ID 冲突:${prior.packageName} 的 ${prior.label} 与 ${skill.packageName} 的 ${skill.label}`);
87
+ }
88
+ effective.set(key, skill);
89
+ }
90
+ return effective;
91
+ }
92
+ /** 公共和内网来源独立解析,合并当前栈生效的 skill 后在调用方持有的项目锁内提交。 */
68
93
  function syncCodingSteering(opts) {
69
- const logPrefix = opts.logPrefix ?? 'skills';
70
- // 版本优先级:--version(显式 pin / 止血)> lane(TCC 定向灰度)> BOE 默认 @dev > @latest
71
- //
72
- // 与 sandbox-skills 的 syncSandboxSkills 完全同一套口径,只是包名不同。BOE 的 @dev
73
- // 由 miaoda-coding develop 分支的自动发布维护;lane 必须压过 dev —— TCC 配了 tgzKey
74
- // 就是定向到某个 feat 分支的快照,不该被"BOE 跟 develop"这条默认规则盖掉。
75
- //
76
- // BOE→dev 这一档在本函数里算,不由调用方预填:`skills sync --type` 分支会带 tgzKey
77
- // 进来,调用方若先把 'dev' 塞进 version,version 档位更高,lane 就永远命不中。
78
- // 本地分支 / app init 为了回报 versionSource 仍会自己算 dev 再传 version —— 那两条路
79
- // 没有 tgzKey,lane 档天然为空,两处口径一致不会打架。
80
- //
81
- // lane 解析与 sandbox-skills 同一套:`extractLaneFromTgzKey` 反推 X,`pickLaneVersion`
82
- // 过滤后缀 `-alpha.<X>`。**匹配只看后缀、不看 base 版本**,所以 coding-steering
83
- // (`0.1.3x-alpha.<X>`)和 sandbox-skills(`0.1.x-alpha.<X>`)能共用 TCC 里的同一个
84
- // key —— 前提是 lane 发布脚本用同一个 X 把两边一起发出去。这个包没发 `-alpha.<X>`
85
- // 时 pickLaneVersion 返回 null(它对报错 / 无匹配都返回 null,绝不 throw),静默
86
- // 回落到 dev / latest,不影响现有行为。
87
94
  assertSafeStack(opts.stack);
95
+ const logPrefix = opts.logPrefix ?? 'skills';
88
96
  const lane = (0, npm_pack_1.extractLaneFromTgzKey)(opts.tgzKey);
89
97
  const laneVersion = lane === null ? null : (0, npm_pack_1.pickLaneVersion)(STEERING_PACKAGE, lane);
90
98
  const isBoe = process.env.FORCE_FRAMEWORK_ENVIRONMENT === 'boe';
91
- const effectiveVersion = opts.version ?? laneVersion ?? (isBoe ? 'dev' : 'latest');
99
+ const version = opts.version ?? laneVersion ?? (isBoe ? 'dev' : 'latest');
92
100
  const mode = opts.mode ?? inferMode();
93
101
  const layout = opts.outputLayout ?? 'nested';
94
- (0, logger_2.log)(logPrefix, `Fetching ${STEERING_PACKAGE}@${effectiveVersion} (mode=${mode}, layout=${layout})...`);
95
- const fetched = (0, npm_pack_1.fetchNpmPackage)({
96
- packageName: STEERING_PACKAGE,
97
- version: effectiveVersion,
98
- });
102
+ const context = `stack=${opts.stack}, mode=${mode}, layout=${layout}`;
103
+ (0, logger_1.log)(logPrefix, `Fetching ${STEERING_PACKAGE}@${version} (${context})...`);
104
+ const pub = (0, npm_pack_1.fetchNpmPackage)({ packageName: STEERING_PACKAGE, version });
105
+ let internal;
99
106
  try {
100
- const steeringRoot = node_path_1.default.join(fetched.extractDir, 'steering');
101
- const stackDir = node_path_1.default.join(steeringRoot, opts.stack);
102
- // 目标路径按 layout 切:
103
- // nested → .agent/skills/steering/<stack>/{skills, tech.md}(老链路、stack 命名空间)
104
- // flat → .agents/{skills, tech.md}(平铺,无 stack 命名空间,跟 .claude/skills 软链对齐)
105
- const { dstSkillsDir, dstTechPath } = layout === 'flat'
106
- ? {
107
- dstSkillsDir: node_path_1.default.join(opts.targetDir, '.agents', 'skills'),
108
- dstTechPath: node_path_1.default.join(opts.targetDir, '.agents', 'tech.md'),
109
- }
110
- : {
111
- dstSkillsDir: node_path_1.default.join(opts.targetDir, '.agent', 'skills', 'steering', opts.stack, 'skills'),
112
- dstTechPath: node_path_1.default.join(opts.targetDir, '.agent', 'skills', 'steering', opts.stack, 'tech.md'),
113
- };
114
- // **本函数不碰任何权限位**——解锁是调用方的事:
115
- // - 老链路:`update-skills.sh:162` 在跑一切之前统一 `chmod -R u+w "$TARGET_DIR"`
116
- // - 新链路(`skills sync --type X`):同一次调用里 syncSandboxSkills 已经递归解锁过
117
- // 整个 skills 根,本函数紧随其后执行,目录必然可写
118
- // - 本地 dev / `app init`:目录从来不会被锁
119
- //
120
- // 曾在这里加过「解锁 + 写完还原」,两个理由下掉:steering 子树的所有权明确归 CLI
121
- // (老脚本 :179/:208 写明 `steering/ 子树由 miaoda CLI 独占,update.sh 不写不删`),
122
- // 锁它没收益;而权限逻辑散在写入方会跟收尾的 lockDirReadonly 形成隐式耦合,
123
- // 范围一旦不对称就会出「跑一次 skills sync 把整个 skills 目录解封」这种事。
124
- // nested:把 `steering/<stack>/` 整棵清掉再重建。
125
- //
126
- // 这一刀同时覆盖了三件事,省掉了此前一堆对账逻辑:源包删掉的 skill、被门禁判否的
127
- // skill、源包这版不再提供的 tech.md —— 全都因为「先清后拷」自然消失。
128
- //
129
- // flat(`.agents/skills`)**刻意不清**:那是本地 dev 目录,开发者会往里放自己手写的
130
- // skill,「不在本轮同步清单里就删」等于替用户删东西。老脚本压根没有 flat 概念。
131
- if (layout === 'nested') {
132
- (0, file_ops_1.assertNoSymlinkedAncestor)(opts.targetDir, NESTED_ANCESTORS);
133
- const steeringRootDst = node_path_1.default.join(opts.targetDir, '.agent', 'skills', 'steering');
134
- const stackDst = node_path_1.default.join(steeringRootDst, opts.stack);
135
- (0, file_ops_1.assertStrictlyInside)(steeringRootDst, stackDst);
136
- (0, file_ops_1.forceRemove)(stackDst);
137
- }
138
- node_fs_1.default.mkdirSync(dstSkillsDir, { recursive: true });
139
- let techSynced = false;
140
- const techSrc = node_path_1.default.join(stackDir, 'tech.md');
141
- if (node_fs_1.default.existsSync(techSrc)) {
142
- node_fs_1.default.mkdirSync(node_path_1.default.dirname(dstTechPath), { recursive: true });
143
- node_fs_1.default.copyFileSync(techSrc, dstTechPath);
144
- techSynced = true;
107
+ if (process.env.MIAODA_SANDBOX_PROVIDER === 'tae') {
108
+ const internalTag = isBoe ? 'dev' : 'alpha';
109
+ (0, logger_1.log)(logPrefix, `Fetching ${INTERNAL_PACKAGE}@${internalTag}...`);
110
+ internal = (0, npm_pack_1.fetchNpmPackage)({
111
+ packageName: INTERNAL_PACKAGE,
112
+ version: internalTag,
113
+ registry: INTERNAL_REGISTRY,
114
+ });
145
115
  }
146
- else if (layout === 'flat' && node_fs_1.default.existsSync(dstTechPath)) {
147
- // flat 没有整清,源包不再提供 tech.md 时需显式删掉残留;nested 已被整清带走
148
- try {
149
- (0, file_ops_1.forceRemove)(dstTechPath);
150
- }
151
- catch (err) {
152
- (0, logger_1.debug)(`coding-steering: remove stale tech.md failed: ${err.message}`);
116
+ const versions = [`${STEERING_PACKAGE}@${pub.version}`];
117
+ if (internal)
118
+ versions.push(`${INTERNAL_PACKAGE}@${internal.version}`);
119
+ (0, logger_1.log)(logPrefix, `Resolved ${versions.join(', ')} (${context})`);
120
+ const publicSkills = selectSkills(pub, opts, mode, logPrefix, false);
121
+ const internalSkills = internal ? selectSkills(internal, opts, mode, logPrefix, true) : [];
122
+ const effective = mergeSkills(publicSkills, internalSkills);
123
+ const techSrc = node_path_1.default.join(pub.extractDir, 'steering', opts.stack, 'tech.md');
124
+ const tech = node_fs_1.default.lstatSync(techSrc, { throwIfNoEntry: false });
125
+ if (tech !== undefined && !tech.isFile())
126
+ throw new error_1.AppError('SKILLS_INVALID_PACKAGE', `无效的 tech.md:${techSrc}`);
127
+ const result = (0, coding_steering_files_1.applySteeringTransaction)(opts.targetDir, (tx) => {
128
+ const stagedRoot = node_path_1.default.join(tx.work, 'steering');
129
+ const stagedStack = node_path_1.default.join(stagedRoot, opts.stack);
130
+ const stagedSkills = node_path_1.default.join(stagedStack, 'skills');
131
+ node_fs_1.default.mkdirSync(stagedSkills, { recursive: true });
132
+ if (tech !== undefined)
133
+ node_fs_1.default.copyFileSync(techSrc, node_path_1.default.join(stagedStack, 'tech.md'));
134
+ for (const { id, src } of effective.values())
135
+ (0, coding_steering_files_1.copySkillTree)(src, node_path_1.default.join(stagedSkills, id));
136
+ let claudeSkillsLink;
137
+ let preserved = new Set();
138
+ let prunedStacks = [];
139
+ if (layout === 'flat') {
140
+ const internalIds = new Set(internalSkills.map((skill) => skill.id));
141
+ // 旧版 CLI 没有记录社区 skill 摘要。用于识别与当前社区包一致的已安装目录。
142
+ const communitySources = new Map(publicSkills.map((skill) => [skill.id, skill.src]));
143
+ ({ claudeSkillsLink, preserved } = (0, coding_steering_flat_1.planFlatSteering)(tx, opts.targetDir, stagedStack, internalIds, communitySources, logPrefix));
153
144
  }
154
- }
155
- const synced = [];
156
- const filteredOut = [];
157
- // 顺序拷贝,后者覆盖前者:skills_common 铺底,专有层(skills 或 skills_local)覆盖同名
158
- const exclusiveLayer = mode === 'sandbox' ? 'skills' : 'skills_local';
159
- const layers = [
160
- { dir: node_path_1.default.join(stackDir, 'skills_common'), label: `${opts.stack}/skills_common` },
161
- { dir: node_path_1.default.join(stackDir, exclusiveLayer), label: `${opts.stack}/${exclusiveLayer}` },
162
- ];
163
- for (const layer of layers) {
164
- if (!node_fs_1.default.existsSync(layer.dir))
165
- continue;
166
- for (const name of node_fs_1.default.readdirSync(layer.dir)) {
167
- const src = node_path_1.default.join(layer.dir, name);
168
- if (!node_fs_1.default.statSync(src).isDirectory())
169
- continue;
170
- if (!matchesTemplate(src, opts.stack, opts.templateVersion, logPrefix)) {
171
- filteredOut.push(`${layer.label}/${name}`);
172
- continue;
173
- }
174
- const dst = node_path_1.default.join(dstSkillsDir, name);
175
- // flat 下目录没被整清,同名仍需先删再拷(skills_common 铺底、专有层覆盖同名)
145
+ else {
146
+ (0, file_ops_1.assertNoSymlinkedAncestor)(opts.targetDir, NESTED_ANCESTORS);
147
+ const dst = node_path_1.default.join(opts.targetDir, ...NESTED_ANCESTORS);
176
148
  if (node_fs_1.default.existsSync(dst))
177
- node_fs_1.default.rmSync(dst, { recursive: true, force: true });
178
- copyDir(src, dst);
179
- synced.push(`${layer.label}/${name}`);
149
+ prunedStacks = node_fs_1.default.readdirSync(dst).filter((name) => name !== opts.stack);
150
+ tx.dirs.push(node_path_1.default.dirname(dst));
151
+ tx.changes.push({ target: dst, staged: stagedRoot });
180
152
  }
181
- }
182
- // 收尾(仅 nested):删掉同级其它 stack 的整棵 steering 目录。
183
- // meta.json 的 stack 唯一,切栈后旧 stack 的 steering 不该再留 —— 修的正是
184
- // 「vite-react 升级到 nestjs-react-fullstack 后 steering/vite-react/ 永久残留」。
185
- // 老脚本靠 should_sync 里 `path_stack != STACK → return 1` + 逐文件删除达到同样效果。
186
- // flat layout 没有 stack 命名空间,天然不涉及。
187
- const prunedStacks = [];
188
- if (layout === 'nested') {
189
- (0, file_ops_1.assertNoSymlinkedAncestor)(opts.targetDir, NESTED_ANCESTORS);
190
- const steeringDst = node_path_1.default.join(opts.targetDir, '.agent', 'skills', 'steering');
191
- if (node_fs_1.default.existsSync(steeringDst)) {
192
- for (const entry of node_fs_1.default.readdirSync(steeringDst)) {
193
- if (entry === opts.stack)
194
- continue;
195
- try {
196
- const entryDst = node_path_1.default.join(steeringDst, entry);
197
- (0, file_ops_1.assertStrictlyInside)(steeringDst, entryDst);
198
- (0, file_ops_1.forceRemove)(entryDst);
199
- prunedStacks.push(entry);
200
- }
201
- catch (err) {
202
- (0, logger_1.debug)(`coding-steering: prune stale stack ${entry} failed: ${err.message}`);
203
- }
204
- }
205
- }
206
- }
207
- let claudeSkillsLink;
208
- if (layout === 'flat') {
209
- claudeSkillsLink = ensureClaudeSkillsSymlink(opts.targetDir, logPrefix);
210
- }
211
- const extras = [
212
- prunedStacks.length > 0 ? `pruned stack(s) ${prunedStacks.join(',')}` : '',
213
- filteredOut.length > 0 ? `filtered ${String(filteredOut.length)} by version` : '',
214
- ].filter((x) => x !== '');
215
- (0, logger_2.log)(logPrefix, `Synced ${String(synced.length)} skill(s), tech.md ${techSynced ? 'yes' : 'no'} ` +
216
- `(mode=${mode}, layout=${layout})${extras.length > 0 ? ` [${extras.join('; ')}]` : ''}`);
217
- return {
218
- version: fetched.version,
219
- syncedSkills: synced,
220
- techSynced,
221
- prunedStacks,
222
- ...(claudeSkillsLink !== undefined ? { claudeSkillsLink } : {}),
223
- };
153
+ // 公共标签沿用旧协议(包含被专有层覆盖的 common 来源)。
154
+ const syncedSkills = [...publicSkills, ...internalSkills]
155
+ .filter((skill) => !preserved.has(skill.id) &&
156
+ effective.get(skill.id.toLowerCase())?.packageName === skill.packageName)
157
+ .map((skill) => skill.packageName === INTERNAL_PACKAGE
158
+ ? `${INTERNAL_PACKAGE}:${skill.label}`
159
+ : skill.label);
160
+ return {
161
+ version: pub.version,
162
+ ...(internal !== undefined ? { internalVersion: internal.version } : {}),
163
+ syncedSkills,
164
+ techSynced: tech !== undefined,
165
+ prunedStacks,
166
+ ...(claudeSkillsLink !== undefined ? { claudeSkillsLink } : {}),
167
+ ...(preserved.size > 0 ? { preservedLocalSkills: [...preserved] } : {}),
168
+ };
169
+ });
170
+ (0, logger_1.log)(logPrefix, `Synced ${String(result.syncedSkills.length)} skill(s), tech.md ${result.techSynced ? 'yes' : 'no'} (mode=${mode}, layout=${layout})`);
171
+ return result;
224
172
  }
225
173
  finally {
226
- fetched.cleanup();
227
- }
228
- }
229
- /**
230
- * flat layout 下创建 `<targetDir>/.claude/skills` 软链 → `../.agents/skills`,让 Claude Code
231
- * 默认的 skills 加载路径跟 user app 的 .agents/skills 是同一份内容。
232
- *
233
- * 用相对路径软链(不是 absolute)—— user app 移动目录 / clone 到别处不会断链。
234
- *
235
- * 处理 4 种已有状态:
236
- * - 已是软链且指向对的:noop
237
- * - 已是软链但指错地方:删旧的,建新的(updated)
238
- * - 已是普通目录 / 文件:不覆盖,警告并跳过(conflict)—— 用户可能手动放了别的 skills
239
- * - 不存在:建新的(created)
240
- *
241
- * 软链建不出来时返回 unsupported 而不是抛错:Windows 上非管理员且未开「开发者模式」
242
- * 时 symlinkSync 报 EPERM,这不该让整条 steering 同步(进而 app init / app sync)失败。
243
- * 退化后果是 Claude Code 默认路径读不到 skills —— 功能降级但项目可用,且日志里给了
244
- * 明确的开启方式。不做「复制代替软链」的兜底:那会让两份内容各自漂移,比读不到更糟。
245
- */
246
- /**
247
- * 建目录软链,失败只 warn 不抛。返回是否建成。
248
- *
249
- * 主要挡的是 Windows 的 EPERM(创建软链需要 SeCreateSymbolicLinkPrivilege,
250
- * 默认只给管理员;开启「开发者模式」后普通用户也可以)。其它 errno 一样按降级处理 ——
251
- * 这一步是锦上添花,不值得中断整次同步。
252
- */
253
- function trySymlink(linkTarget, linkPath, logPrefix) {
254
- try {
255
- node_fs_1.default.symlinkSync(linkTarget, linkPath, 'dir');
256
- return true;
257
- }
258
- catch (err) {
259
- const code = err.code ?? 'UNKNOWN';
260
- const hint = process.platform === 'win32'
261
- ? '(Windows 需以管理员运行,或在「设置 → 隐私和安全性 → 开发者选项」开启开发者模式)'
262
- : '';
263
- (0, logger_2.log)(logPrefix, ` ⚠ .claude/skills 软链创建失败 [${code}],跳过${hint};skills 仍在 .agents/skills 下可用`);
264
- return false;
265
- }
266
- }
267
- function ensureClaudeSkillsSymlink(targetDir, logPrefix) {
268
- const linkPath = node_path_1.default.join(targetDir, '.claude', 'skills');
269
- const linkTarget = node_path_1.default.join('..', '.agents', 'skills');
270
- node_fs_1.default.mkdirSync(node_path_1.default.dirname(linkPath), { recursive: true });
271
- let existing = null;
272
- try {
273
- existing = node_fs_1.default.lstatSync(linkPath);
274
- }
275
- catch (err) {
276
- if (err.code !== 'ENOENT')
277
- throw err;
278
- }
279
- if (existing === null) {
280
- if (!trySymlink(linkTarget, linkPath, logPrefix))
281
- return 'unsupported';
282
- (0, logger_2.log)(logPrefix, ` ✓ .claude/skills → ${linkTarget} (symlink created)`);
283
- return 'created';
284
- }
285
- if (existing.isSymbolicLink()) {
286
- const current = node_fs_1.default.readlinkSync(linkPath);
287
- if (current === linkTarget) {
288
- return 'noop';
174
+ for (const pkg of [pub, internal]) {
175
+ try {
176
+ pkg?.cleanup();
177
+ }
178
+ catch (err) {
179
+ (0, logger_1.log)(logPrefix, `清理 steering 下载缓存失败:${String(err)}`);
180
+ }
289
181
  }
290
- node_fs_1.default.unlinkSync(linkPath);
291
- if (!trySymlink(linkTarget, linkPath, logPrefix))
292
- return 'unsupported';
293
- (0, logger_2.log)(logPrefix, ` ✓ .claude/skills → ${linkTarget} (symlink updated, was → ${current})`);
294
- return 'updated';
295
- }
296
- (0, logger_2.log)(logPrefix, ` ⚠ .claude/skills 已是普通目录/文件,跳过软链创建`);
297
- return 'conflict';
298
- }
299
- /**
300
- * 读 SKILL.md frontmatter 里的 `match-template-version`。逐字对齐老脚本的取值方式
301
- * (`update-skills.sh:80-90`):只看第一段 `---` 围起来的 frontmatter,去掉引号与全部空白。
302
- * 没有该字段(或没有 SKILL.md)返回 undefined = 不设版本门禁。
303
- */
304
- function readMatchTemplateVersion(skillDir) {
305
- const skillMd = node_path_1.default.join(skillDir, 'SKILL.md');
306
- if (!node_fs_1.default.existsSync(skillMd))
307
- return undefined;
308
- let content;
309
- try {
310
- content = node_fs_1.default.readFileSync(skillMd, 'utf-8');
311
182
  }
312
- catch {
313
- return undefined;
314
- }
315
- const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
316
- if (fm === null)
317
- return undefined;
318
- const line = /^match-template-version:(.*)$/m.exec(fm[1]);
319
- if (line === null)
320
- return undefined;
321
- const value = line[1].replace(/["']/g, '').replace(/\s/g, '');
322
- return value === '' ? undefined : value;
323
183
  }
324
- /** 读 frontmatter 里的 `match-template-name`(同上,取不到返回 undefined)。 */
325
- function readMatchTemplateName(skillDir) {
184
+ /** 只读第一段 frontmatter,保留原有名字/版本门禁的比较口径。 */
185
+ function matchesTemplate(skillDir, stack, templateVersion, logPrefix) {
326
186
  const skillMd = node_path_1.default.join(skillDir, 'SKILL.md');
327
- if (!node_fs_1.default.existsSync(skillMd))
328
- return undefined;
329
- let content;
330
- try {
331
- content = node_fs_1.default.readFileSync(skillMd, 'utf-8');
332
- }
333
- catch {
334
- return undefined;
335
- }
336
- const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
337
- if (fm === null)
338
- return undefined;
339
- const line = /^match-template-name:(.*)$/m.exec(fm[1]);
340
- if (line === null)
341
- return undefined;
342
- const value = line[1].replace(/["']/g, '').trim();
343
- return value === '' ? undefined : value;
344
- }
345
- /**
346
- * `match-template-version` 门禁,语义逐字对齐老 `check_version_match`
347
- * (`update-skills.sh:76-108`):
348
- * - skill 没声明该字段 → 放行
349
- * - 声明值是纯整数 → 与用户版本的 **major** 比(`3` 匹配 `3.2.1`)
350
- * - 其它形态(如 `2.2.6`) → 与用户版本**全等**
351
- * - 用户版本未知(meta 里没 version)→ 放行(见 opts.templateVersion 注释)
352
- */
353
- function matchesTemplateVersion(skillDir, templateVersion) {
354
- const required = readMatchTemplateVersion(skillDir);
355
- if (required === undefined)
187
+ const stat = node_fs_1.default.lstatSync(skillMd, { throwIfNoEntry: false });
188
+ if (stat === undefined)
356
189
  return true;
357
- if (templateVersion === undefined || templateVersion === '') {
358
- (0, logger_1.debug)(`coding-steering: ${node_path_1.default.basename(skillDir)} 声明 match-template-version=${required},` +
359
- `但 .spark/meta.json 无 version,放行不过滤`);
190
+ if (!stat.isFile())
191
+ throw new error_1.AppError('SKILLS_INVALID_PACKAGE', `无效的 SKILL.md:${skillMd}`);
192
+ const content = node_fs_1.default.readFileSync(skillMd, 'utf8');
193
+ const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content)?.[1];
194
+ if (fm === undefined)
360
195
  return true;
361
- }
362
- if (/^\d+$/.test(required)) {
363
- return templateVersion.split('.')[0] === required;
364
- }
365
- return templateVersion === required;
366
- }
367
- /**
368
- * 组合门禁:`match-template-name` + `match-template-version`。
369
- *
370
- * `match-template-name` 在这里是**防御性校验**而非过滤主力:包内 skill 本来就住在
371
- * `steering/<stack>/` 下、目录结构已经按 stack 隔离,声明值理应等于所在 stack
372
- * (实测包里 23 处全是 `nestjs-react-fullstack`)。真正跨 stack 的池化过滤在 feida-ai
373
- * 加载时做(`skills.ts:1209` 的 `isTemplateMatched`)。所以这里对不上就是**包结构出问题**,
374
- * 用 log(常显)而不是 debug 报出来,别静默下发到错误的 stack。
375
- */
376
- function matchesTemplate(skillDir, stack, templateVersion, logPrefix) {
377
- const declaredName = readMatchTemplateName(skillDir);
378
- if (declaredName !== undefined && declaredName !== stack) {
379
- (0, logger_2.log)(logPrefix, `⚠ ${node_path_1.default.basename(skillDir)} 声明 match-template-name=${declaredName},` +
380
- `但它位于 steering/${stack}/ 下 —— 包结构异常,跳过该 skill`);
196
+ const declaredName = /^match-template-name:(.*)$/m.exec(fm)?.[1].replace(/["']/g, '').trim();
197
+ if (declaredName && declaredName !== stack) {
198
+ (0, logger_1.log)(logPrefix, `⚠ ${node_path_1.default.basename(skillDir)} 声明 match-template-name=${declaredName},但它位于 steering/${stack}/ 下,跳过该 skill`);
381
199
  return false;
382
200
  }
383
- return matchesTemplateVersion(skillDir, templateVersion);
384
- }
385
- function copyDir(src, dest) {
386
- node_fs_1.default.mkdirSync(dest, { recursive: true });
387
- for (const entry of node_fs_1.default.readdirSync(src, { withFileTypes: true })) {
388
- const srcPath = node_path_1.default.join(src, entry.name);
389
- const destPath = node_path_1.default.join(dest, entry.name);
390
- if (entry.isDirectory()) {
391
- copyDir(srcPath, destPath);
392
- }
393
- else {
394
- node_fs_1.default.copyFileSync(srcPath, destPath);
395
- }
201
+ const required = /^match-template-version:(.*)$/m.exec(fm)?.[1].replace(/["'\s]/g, '');
202
+ if (!required)
203
+ return true;
204
+ if (!templateVersion) {
205
+ (0, logger_1.debug)(`coding-steering: ${node_path_1.default.basename(skillDir)} 声明 match-template-version=${required},但 .spark/meta.json 无 version,放行`);
206
+ return true;
396
207
  }
208
+ return /^\d+$/.test(required)
209
+ ? templateVersion.split('.')[0] === required
210
+ : templateVersion === required;
397
211
  }
@@ -86,7 +86,19 @@ function fetchNpmPackage(opts) {
86
86
  const tmpDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'miaoda-pack-'));
87
87
  try {
88
88
  (0, logger_1.debug)(`npm pack ${pkgSpec} --registry ${registry} → ${tmpDir}`);
89
- const stdout = (0, run_npm_1.execNpmSyncCapture)(['pack', pkgSpec, '--pack-destination', tmpDir, '--json', '--registry', registry], { stdio: ['pipe', 'pipe', 'pipe'] });
89
+ // npm 对 scoped 包优先采用 @scope:registry;显式选库时一并固定该 scope。
90
+ const scope = /^(@[^/]+)\//.exec(opts.packageName)?.[1];
91
+ const scopeRegistry = opts.registry !== undefined && scope !== undefined ? [`--${scope}:registry=${registry}`] : [];
92
+ const stdout = (0, run_npm_1.execNpmSyncCapture)([
93
+ 'pack',
94
+ pkgSpec,
95
+ '--pack-destination',
96
+ tmpDir,
97
+ '--json',
98
+ '--registry',
99
+ registry,
100
+ ...scopeRegistry,
101
+ ], { stdio: ['pipe', 'pipe', 'pipe'] });
90
102
  const packInfo = JSON.parse(stdout);
91
103
  const tgzFilename = packInfo[0]?.filename;
92
104
  const pkgVersion = packInfo[0]?.version ?? version;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@lark-apaas/miaoda-cli",
3
- "version": "0.1.39-alpha.2937ea8",
3
+ "version": "0.1.39-alpha.4481d0b",
4
4
  "description": "Miaoda 平台命令行工具,面向 Agent 调用",
5
5
  "type": "commonjs",
6
6
  "bin": {
@@ -45,32 +45,49 @@ STEP_START=$(node -e "console.log(Date.now())")
45
45
 
46
46
  # 在 client/server 构建之前生成到 dist/,供 DefinePlugin 注入前端 bundle
47
47
  # 注意:nest-cli.json 中 deleteOutDir 必须为 false(模板默认值),否则 nest build 会清掉 dist/
48
- echo " ├─ 生成 API 路由定义..."
49
- npx generate-api-routes --server-dir ./server --out-dir ./dist > /tmp/gen-api-routes.log 2>&1 &
50
- API_ROUTES_PID=$!
51
-
52
- echo " ├─ 生成页面路由定义..."
53
- npx generate-page-routes --app-path ./client/src/app.tsx --out-dir ./dist > /tmp/gen-page-routes.log 2>&1 &
54
- PAGE_ROUTES_PID=$!
55
-
56
- API_ROUTES_EXIT=0
57
- PAGE_ROUTES_EXIT=0
58
-
59
- wait $API_ROUTES_PID || API_ROUTES_EXIT=$?
60
- wait $PAGE_ROUTES_PID || PAGE_ROUTES_EXIT=$?
61
-
62
- if [ $API_ROUTES_EXIT -ne 0 ]; then
63
- echo " ⚠️ API 路由生成失败(不影响构建)"
64
- cat /tmp/gen-api-routes.log
48
+ # 生成器来自 @lark-apaas/devtool-kits(由 preset 间接安装)。只用本地命令:
49
+ # 未安装时直接跳过,不走 npx,避免联网查同名包 404 的等待;preset 读不到文件会注入空路由。
50
+ API_ROUTES_BIN="$ROOT_DIR/node_modules/.bin/generate-api-routes"
51
+ PAGE_ROUTES_BIN="$ROOT_DIR/node_modules/.bin/generate-page-routes"
52
+ API_ROUTES_PID=""
53
+ PAGE_ROUTES_PID=""
54
+
55
+ if [ -x "$API_ROUTES_BIN" ]; then
56
+ echo " ├─ 生成 API 路由定义..."
57
+ "$API_ROUTES_BIN" --server-dir ./server --out-dir ./dist > /tmp/gen-api-routes.log 2>&1 &
58
+ API_ROUTES_PID=$!
65
59
  else
66
- echo " ✅ API 路由生成完成"
60
+ echo " ⏭️ 未安装 generate-api-routes,跳过 API 路由定义生成"
67
61
  fi
68
62
 
69
- if [ $PAGE_ROUTES_EXIT -ne 0 ]; then
70
- echo " ⚠️ 页面路由生成失败(不影响构建)"
71
- cat /tmp/gen-page-routes.log
63
+ if [ -x "$PAGE_ROUTES_BIN" ]; then
64
+ echo " ├─ 生成页面路由定义..."
65
+ "$PAGE_ROUTES_BIN" --app-path ./client/src/app.tsx --out-dir ./dist > /tmp/gen-page-routes.log 2>&1 &
66
+ PAGE_ROUTES_PID=$!
72
67
  else
73
- echo " ✅ 页面路由生成完成"
68
+ echo " ⏭️ 未安装 generate-page-routes,跳过页面路由定义生成"
69
+ fi
70
+
71
+ if [ -n "$API_ROUTES_PID" ]; then
72
+ API_ROUTES_EXIT=0
73
+ wait $API_ROUTES_PID || API_ROUTES_EXIT=$?
74
+ if [ $API_ROUTES_EXIT -ne 0 ]; then
75
+ echo " ⚠️ API 路由生成失败(不影响构建)"
76
+ cat /tmp/gen-api-routes.log
77
+ else
78
+ echo " ✅ API 路由生成完成"
79
+ fi
80
+ fi
81
+
82
+ if [ -n "$PAGE_ROUTES_PID" ]; then
83
+ PAGE_ROUTES_EXIT=0
84
+ wait $PAGE_ROUTES_PID || PAGE_ROUTES_EXIT=$?
85
+ if [ $PAGE_ROUTES_EXIT -ne 0 ]; then
86
+ echo " ⚠️ 页面路由生成失败(不影响构建)"
87
+ cat /tmp/gen-page-routes.log
88
+ else
89
+ echo " ✅ 页面路由生成完成"
90
+ fi
74
91
  fi
75
92
  print_time $STEP_START
76
93
  echo ""
@@ -1,9 +1,28 @@
1
1
  #!/usr/bin/env node
2
2
  // This file is auto-generated by @lark-apaas/fullstack-cli
3
3
 
4
- const { nodeFileTrace } = require('@vercel/nft');
5
4
  const fs = require('fs');
6
5
  const path = require('path');
6
+ const { createRequire } = require('module');
7
+
8
+ // @vercel/nft 是 fullstack-cli 自身的依赖:应用装了 CLI 时从应用 node_modules 加载;
9
+ // 构建镜像全局预装 CLI、应用未安装时,从 PATH 上 fullstack-cli 的安装目录加载
10
+ function loadNft() {
11
+ try {
12
+ return require('@vercel/nft');
13
+ } catch (err) {
14
+ if (err.code !== 'MODULE_NOT_FOUND') throw err;
15
+ }
16
+ for (const dir of (process.env.PATH || '').split(path.delimiter)) {
17
+ const cliBin = dir && path.join(dir, 'fullstack-cli');
18
+ if (cliBin && fs.existsSync(cliBin)) {
19
+ return createRequire(fs.realpathSync(cliBin))('@vercel/nft');
20
+ }
21
+ }
22
+ throw new Error('未找到 @vercel/nft:应用未安装 fullstack-cli,PATH 上也没有全局 fullstack-cli');
23
+ }
24
+
25
+ const { nodeFileTrace } = loadNft();
7
26
 
8
27
  const ROOT_DIR = path.resolve(__dirname, '..');
9
28