@lark-apaas/miaoda-cli 0.1.37 → 0.1.39-alpha.24bc5ff

package/dist/utils/coding-steering.js

@@ -237,7 +237,33 @@ function syncCodingSteering(opts) {
  *   - 已是软链但指错地方：删旧的，建新的（updated）
  *   - 已是普通目录 / 文件：不覆盖，警告并跳过（conflict）—— 用户可能手动放了别的 skills
  *   - 不存在：建新的（created）
+ *
+ * 软链建不出来时返回 unsupported 而不是抛错：Windows 上非管理员且未开「开发者模式」
+ * 时 symlinkSync 报 EPERM，这不该让整条 steering 同步（进而 app init / app sync）失败。
+ * 退化后果是 Claude Code 默认路径读不到 skills —— 功能降级但项目可用，且日志里给了
+ * 明确的开启方式。不做「复制代替软链」的兜底：那会让两份内容各自漂移，比读不到更糟。
+ */
+/**
+ * 建目录软链，失败只 warn 不抛。返回是否建成。
+ *
+ * 主要挡的是 Windows 的 EPERM（创建软链需要 SeCreateSymbolicLinkPrivilege，
+ * 默认只给管理员；开启「开发者模式」后普通用户也可以）。其它 errno 一样按降级处理 ——
+ * 这一步是锦上添花，不值得中断整次同步。
  */
+function trySymlink(linkTarget, linkPath, logPrefix) {
+    try {
+        node_fs_1.default.symlinkSync(linkTarget, linkPath, 'dir');
+        return true;
+    }
+    catch (err) {
+        const code = err.code ?? 'UNKNOWN';
+        const hint = process.platform === 'win32'
+            ? '（Windows 需以管理员运行，或在「设置 → 隐私和安全性 → 开发者选项」开启开发者模式）'
+            : '';
+        (0, logger_2.log)(logPrefix, `  ⚠ .claude/skills 软链创建失败 [${code}]，跳过${hint}；skills 仍在 .agents/skills 下可用`);
+        return false;
+    }
+}
 function ensureClaudeSkillsSymlink(targetDir, logPrefix) {
     const linkPath = node_path_1.default.join(targetDir, '.claude', 'skills');
     const linkTarget = node_path_1.default.join('..', '.agents', 'skills');
@@ -251,7 +277,8 @@ function ensureClaudeSkillsSymlink(targetDir, logPrefix) {
             throw err;
     }
     if (existing === null) {
-        node_fs_1.default.symlinkSync(linkTarget, linkPath, 'dir');
+        if (!trySymlink(linkTarget, linkPath, logPrefix))
+            return 'unsupported';
         (0, logger_2.log)(logPrefix, `  ✓ .claude/skills → ${linkTarget} (symlink created)`);
         return 'created';
     }
@@ -261,7 +288,8 @@ function ensureClaudeSkillsSymlink(targetDir, logPrefix) {
             return 'noop';
         }
         node_fs_1.default.unlinkSync(linkPath);
-        node_fs_1.default.symlinkSync(linkTarget, linkPath, 'dir');
+        if (!trySymlink(linkTarget, linkPath, logPrefix))
+            return 'unsupported';
         (0, logger_2.log)(logPrefix, `  ✓ .claude/skills → ${linkTarget} (symlink updated, was → ${current})`);
         return 'updated';
     }

package/dist/utils/file-ops.js

@@ -63,7 +63,15 @@ function removeLineFromContent(content, pattern) {
 // 不碰权限 —— 它跑在同一次调用里、紧随 syncSandboxSkills 之后，目录已经可写；
 // 各写入方各自 chmod 会与收尾的 lockDirReadonly 形成隐式耦合，范围一旦不对称就会
 // 出「跑一次 skills sync 把整个 skills 目录解封」这种事。
+//
+// **平台前提**：整套只读锁语义是 POSIX mode 位的，靠 shell `chmod -R` 实现。Windows
+// 没有对应概念（NTFS 用 ACL，mode 位不映射），所以那里直接跳过加解锁 —— 锁和解锁
+// 成对失效，语义仍自洽：目录始终可写，只是少了「防手改」这层保护。这是有意的降级，
+// 不是遗漏；不用 fs.chmodSync 模拟，因为它在 Windows 上对目录基本是 no-op，
+// 只会制造「以为锁上了」的假象。
 // ─────────────────────────────────────────────────────────────────────────────
+/** POSIX mode 位语义是否可用；Windows 上整套只读锁降级为 no-op */
+const SUPPORTS_POSIX_MODE = process.platform !== 'win32';
 /**
  * 解锁目录使其可写（`chmod -R u+w`）。
  *
@@ -71,8 +79,12 @@ function removeLineFromContent(content, pattern) {
  * 只加 owner 写位、不动 g/o，与老链路一致。目录不存在直接返回 false（调用方
  * 通常紧接着 mkdir）。失败只 debug 不抛：解锁是尽力而为，真写不进去让后续
  * 写操作自己报错，错误信息更具体。
+ *
+ * Windows 返回 false（没上过锁，也就无需解锁）。
  */
 function unlockDirForWrite(dir) {
+    if (!SUPPORTS_POSIX_MODE)
+        return false;
     if (!node_fs_1.default.existsSync(dir))
         return false;
     try {
@@ -92,8 +104,12 @@ function unlockDirForWrite(dir) {
  * {@link unlockDirForWrite}。
  *
  * **调用时机必须是全部写入完成之后**——锁上就写不进去了。
+ *
+ * Windows 直接返回 false（不加锁，对应 unlockDirForWrite 也不解锁）。
  */
 function lockDirReadonly(dir) {
+    if (!SUPPORTS_POSIX_MODE)
+        return false;
     if (!node_fs_1.default.existsSync(dir))
         return false;
     try {
@@ -112,18 +128,22 @@ function lockDirReadonly(dir) {
  * 只读锁下；另外老 update.sh 曾以 root 跑过，可能留下异主文件（如 root-owned 的
  * `.last-update`），`rmSync{force:true}` 只忽略 ENOENT、遇 EACCES 仍抛。
  * shell `rm -rf` 对异主文件 / 怪符号链接比 rmSync 宽容，故作主档。
+ *
+ * Windows 上没有 `rm`（也没有异主/只读锁那套前提），直接走 `fs.rmSync` 这一层。
  */
 function forceRemove(target) {
     if (!node_fs_1.default.existsSync(target))
         return;
-    unlockDirForWrite(target);
-    try {
-        (0, node_child_process_1.execFileSync)('rm', ['-rf', target], { stdio: ['ignore', 'ignore', 'pipe'] });
-        if (!node_fs_1.default.existsSync(target))
-            return;
-    }
-    catch (err) {
-        (0, logger_1.debug)(`file-ops: rm -rf ${target} failed: ${err.message}`);
+    if (SUPPORTS_POSIX_MODE) {
+        unlockDirForWrite(target);
+        try {
+            (0, node_child_process_1.execFileSync)('rm', ['-rf', target], { stdio: ['ignore', 'ignore', 'pipe'] });
+            if (!node_fs_1.default.existsSync(target))
+                return;
+        }
+        catch (err) {
+            (0, logger_1.debug)(`file-ops: rm -rf ${target} failed: ${err.message}`);
+        }
     }
     node_fs_1.default.rmSync(target, { recursive: true, force: true });
 }

package/dist/utils/http.js

@@ -64,13 +64,13 @@ function createClient(opts) {
  * 默认灰度泳道。当前 miaoda CLI 接入的新接口（modern deploy 等）只在该泳道生效，
  * 缺省走这个。MIAODA_CANARY_HEADER 可显式覆盖；设为空字符串则去掉头。
  *
- * ⚠️ TEMP（creative-upgrade 联调用）：默认泳道临时指向开发泳道 boe_debug_detail_lookup，
- * 使 alpha 发版进沙箱镜像后，app export / code-archive 等新接口无需 wrapper 即可命中
- * 尚未合流的 studio_server 改动。
- * 上线前必须还原为 'boe_miaoda_ccm'，或改为由 agent_tool 按请求 x-tt-env 注入
- * MIAODA_CANARY_HEADER（详见 http.ts 的 applyCanaryHeader 与 agent_tool ExecShellCmd）。
+ * 联调未合流的服务端改动时，不要改这个默认值 —— 用 MIAODA_CANARY_HEADER 覆盖，
+ * 或由 agent_tool 按请求 x-tt-env 注入（详见 applyCanaryHeader 与 agent_tool
+ * ExecShellCmd）。改默认值意味着所有沙箱都被带去开发泳道，且历史上多次忘记还原
+ * （boe_miaoda_doubao → ppe_miaoda_ccm → boe_miaoda_ccm → boe_debug_detail_lookup
+ * → boe_creative_history）。
  */
-const DEFAULT_CANARY_HEADER = 'boe_debug_detail_lookup';
+const DEFAULT_CANARY_HEADER = 'prod';
 /**
  * 注入 x-tt-env 小流量头：env 显式设值 > DEFAULT_CANARY_HEADER。
  *

package/dist/utils/npm-pack.js

@@ -6,12 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pickLaneVersion = pickLaneVersion;
 exports.extractLaneFromTgzKey = extractLaneFromTgzKey;
 exports.fetchNpmPackage = fetchNpmPackage;
-const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
+const archive_1 = require("./archive");
 const error_1 = require("./error");
 const logger_1 = require("./logger");
+const run_npm_1 = require("./run-npm");
 const DEFAULT_REGISTRY = 'https://registry.npmmirror.com/';
 /**
  * 从 `npm view <pkg> versions --json` 里过滤出后缀 `-alpha.<X>` 的版本。
@@ -29,7 +30,7 @@ function pickLaneVersion(packageName, X, registry) {
     const reg = registry ?? process.env.MIAODA_NPM_REGISTRY ?? DEFAULT_REGISTRY;
     const suffix = `-alpha.${X}`;
     try {
-        const stdout = (0, node_child_process_1.execFileSync)('npm', ['view', packageName, 'versions', '--json', '--registry', reg], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        const stdout = (0, run_npm_1.execNpmSyncCapture)(['view', packageName, 'versions', '--json', '--registry', reg], { stdio: ['pipe', 'pipe', 'pipe'] });
         const versions = JSON.parse(stdout);
         if (!Array.isArray(versions))
             return null;
@@ -75,7 +76,7 @@ function extractLaneFromTgzKey(tgzKey) {
     return lane;
 }
 /**
- * `npm pack <pkg>@<ver> --registry <r>` + `tar -xzf`，解到临时目录。
+ * `npm pack <pkg>@<ver> --registry <r>` + 解压（走 archive 跨平台封装），解到临时目录。
  * extractDir 是包内容根（含 package.json）。使用完必须 cleanup()。
  */
 function fetchNpmPackage(opts) {
@@ -85,7 +86,7 @@ function fetchNpmPackage(opts) {
     const tmpDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'miaoda-pack-'));
     try {
         (0, logger_1.debug)(`npm pack ${pkgSpec} --registry ${registry} → ${tmpDir}`);
-        const stdout = (0, node_child_process_1.execFileSync)('npm', ['pack', pkgSpec, '--pack-destination', tmpDir, '--json', '--registry', registry], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        const stdout = (0, run_npm_1.execNpmSyncCapture)(['pack', pkgSpec, '--pack-destination', tmpDir, '--json', '--registry', registry], { stdio: ['pipe', 'pipe', 'pipe'] });
         const packInfo = JSON.parse(stdout);
         const tgzFilename = packInfo[0]?.filename;
         const pkgVersion = packInfo[0]?.version ?? version;
@@ -95,9 +96,7 @@ function fetchNpmPackage(opts) {
         const tgzPath = node_path_1.default.join(tmpDir, tgzFilename);
         const extractDir = node_path_1.default.join(tmpDir, 'extracted');
         node_fs_1.default.mkdirSync(extractDir, { recursive: true });
-        (0, node_child_process_1.execFileSync)('tar', ['-xzf', tgzPath, '-C', extractDir], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
+        (0, archive_1.extractTarGz)(tgzPath, extractDir);
         return {
             extractDir: node_path_1.default.join(extractDir, 'package'),
             version: pkgVersion,

package/dist/utils/run-npm.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execNpmSync = execNpmSync;
+exports.execNpmSyncCapture = execNpmSyncCapture;
+exports.runNpmSync = runNpmSync;
+exports.spawnNpm = spawnNpm;
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const error_1 = require("../utils/error");
+const logger_1 = require("../utils/logger");
+/**
+ * 跨平台 npm 执行入口 —— 仓库内**所有** npm 调用必须走这里，禁止再裸写
+ * `execFileSync('npm', ...)` / `spawnSync('npm', ...)` / `spawn('npm', ...)`，
+ * 也禁止直接 import `cross-spawn` 绕过这层（两条都由 ESLint 强制）。
+ *
+ * 为什么必须封装：Windows 上 npm 不是可执行文件而是 `npm.cmd` 批处理包装。
+ *   - `execFile` / `spawn` 不带 shell 时按可执行文件解析，命中不到 `npm` → ENOENT；
+ *   - 自 Node 18.20.2 / 20.12.2（CVE-2024-27980）起，不带 `shell: true` 执行
+ *     `.cmd` / `.bat` 会直接抛 EINVAL，连"碰巧能跑"都不再成立。
+ *
+ * 为什么用 `cross-spawn` 而不是自己处理：正确的做法不只是"加 shell"。cross-spawn
+ * 在 Windows 上先判断目标是否真可执行文件，只在需要时切到 cmd.exe，并对参数做完整的
+ * 元字符转义（还专门处理了 `node_modules/.bin/*.cmd` 这类 cmd-shim 需要**双重**转义
+ * 的情况）。这些边角自己写必定漏，而它是 5000 万周下载量级的生态基建。
+ *
+ * 这层封装自身只做三件事：钉死命令名为 `npm`、把 spawn 结果的失败语义统一成
+ * `AppError`、给调用点一个稳定的收口位置。
+ */
+/** npm 子进程失败时统一抛的错误码 */
+const NPM_FAILED_CODE = 'NPM_COMMAND_FAILED';
+/** stderr 被 pipe 时，附进错误信息的尾部长度上限（避免把整篇 npm 日志灌进 message） */
+const STDERR_TAIL_LIMIT = 800;
+/**
+ * 取 stderr 尾部拼进错误信息。
+ *
+ * 参数刻意收窄成结构类型并显式带 `null`：node 的 `SpawnSyncReturns.stderr` 类型上是
+ * 非空的，但 `stdio: 'inherit' | 'ignore'` 时运行时实际为 null（输出已直出或丢弃）。
+ * 照类型写会漏掉这种情况，照运行时写又会被 no-unnecessary-condition 判成多余判断 ——
+ * 所以在这里把真实契约写清楚。
+ */
+function stderrTail(result) {
+    const raw = result.stderr;
+    if (raw === null || raw === undefined)
+        return '';
+    const text = typeof raw === 'string' ? raw : raw.toString('utf-8');
+    const trimmed = text.trim();
+    if (trimmed === '')
+        return '';
+    const tail = trimmed.length > STDERR_TAIL_LIMIT ? trimmed.slice(-STDERR_TAIL_LIMIT) : trimmed;
+    return `\n${tail}`;
+}
+/**
+ * 把 spawnSync 结果里的失败翻译成 AppError。
+ *
+ * 两类失败要分开报，因为处置动作不同：
+ *   - `error` 非空 = 进程根本没起来（npm 不在 PATH、权限问题）；
+ *   - `status !== 0` = npm 起来了但命令失败（装包失败、脚本报错），此时 stderr 才有内容。
+ */
+function assertNpmOk(args, result) {
+    if (result.error) {
+        throw new error_1.AppError(NPM_FAILED_CODE, `npm 启动失败（npm ${args.join(' ')}）：${result.error.message}`, {
+            next_actions: ['确认本机已安装 npm 且在 PATH 中', '可加 --verbose 查看执行详情'],
+        });
+    }
+    if (result.status !== 0) {
+        const code = result.status === null ? `signal ${String(result.signal)}` : `exit ${String(result.status)}`;
+        throw new error_1.AppError(NPM_FAILED_CODE, `npm ${args.join(' ')} 失败（${code}）${stderrTail(result)}`, { next_actions: ['检查上方 npm 输出定位具体错误'] });
+    }
+}
+/**
+ * 同步跑 npm，失败抛 `NPM_COMMAND_FAILED`（对齐原先 `execFileSync('npm', args)` 的
+ * "失败即抛"语义）。`stdio` 等选项原样透传。
+ */
+function execNpmSync(args, options = {}) {
+    (0, logger_1.debug)(`run-npm: npm ${args.join(' ')}`);
+    const result = cross_spawn_1.default.sync('npm', args, options);
+    assertNpmOk(args, result);
+}
+/**
+ * 同步跑 npm 并拿回 stdout 字符串，失败抛 `NPM_COMMAND_FAILED`。
+ * 用于需要解析输出的场景（如 `npm pack --json`）。
+ */
+function execNpmSyncCapture(args, options = {}) {
+    (0, logger_1.debug)(`run-npm: npm ${args.join(' ')} (capture)`);
+    const result = cross_spawn_1.default.sync('npm', args, { ...options, encoding: 'utf-8' });
+    assertNpmOk(args, result);
+    return result.stdout;
+}
+/**
+ * 同步跑 npm，**不抛错**，返回 spawnSync 结果（对齐 `spawnSync('npm', args)` 的语义）。
+ * 调用方自行判 `error` / `status` —— 用于需要把失败当正常分支处理的场景。
+ */
+function runNpmSync(args, options = {}) {
+    (0, logger_1.debug)(`run-npm: npm ${args.join(' ')} (no-throw)`);
+    return cross_spawn_1.default.sync('npm', args, options);
+}
+function spawnNpm(args, options = {}) {
+    (0, logger_1.debug)(`run-npm: npm ${args.join(' ')} (async)`);
+    return (0, cross_spawn_1.default)('npm', args, options);
+}

package/dist/utils/sync-rule.js

@@ -43,6 +43,7 @@ const jsonc = __importStar(require("jsonc-parser"));
 const file_ops_1 = require("./file-ops");
 const merge_json_1 = require("./merge-json");
 const logger_1 = require("./logger");
+const typescript_exclude_1 = require("./typescript-exclude");
 /**
  * 顺序执行 SyncRule[]，逐条 apply。一条 rule 报错不影响后续 rule（catch + 记录），最终
  * 在 handler 层决定是否整体 fail。
@@ -106,6 +107,11 @@ function applyOne(rule, opts) {
         case 'patch-script': {
             return applyPatchScript(rule, targetDir, logPrefix);
         }
+        case 'typescript-exclude': {
+            const changed = (0, typescript_exclude_1.excludeTypeScriptPath)(node_path_1.default.join(targetDir, rule.to), rule.path);
+            (0, logger_1.log)(logPrefix, `  ${changed ? '✓' : '○'} ${rule.to} (exclude ${rule.path})`);
+            return { rule, action: changed ? 'patched' : 'noop', path: rule.to };
+        }
         case 'merge-json': {
             return applyMergeJson(rule, sourceRoot, targetDir, logPrefix);
         }

package/dist/utils/typescript-exclude.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.excludeTypeScriptPath = excludeTypeScriptPath;
+const node_fs_1 = __importDefault(require("node:fs"));
+const jsonc_parser_1 = require("jsonc-parser");
+const error_1 = require("./error");
+/** Only append to explicit template excludes; never rewrite inherited user configuration. */
+function excludeTypeScriptPath(filename, excludedPath) {
+    if (!node_fs_1.default.existsSync(filename))
+        return false;
+    const source = node_fs_1.default.readFileSync(filename, 'utf8');
+    const errors = [];
+    const raw = (0, jsonc_parser_1.parse)(source, errors, { allowTrailingComma: true });
+    if (errors.length || !raw || typeof raw !== 'object')
+        throw new error_1.AppError('INVALID_CONFIG', `Invalid exclude array: ${filename}`);
+    if (raw.exclude === undefined) {
+        console.warn(`Cannot safely update inherited excludes in ${filename}; add ${excludedPath} to the effective TypeScript exclude configuration.`);
+        return false;
+    }
+    if (!Array.isArray(raw.exclude) || raw.exclude.some((p) => typeof p !== 'string'))
+        throw new error_1.AppError('INVALID_CONFIG', `Invalid exclude array: ${filename}`);
+    if (raw.exclude.includes(excludedPath))
+        return false;
+    node_fs_1.default.writeFileSync(filename, (0, jsonc_parser_1.applyEdits)(source, (0, jsonc_parser_1.modify)(source, ['exclude', raw.exclude.length], excludedPath, {
+        isArrayInsertion: true,
+        formattingOptions: {
+            insertSpaces: true,
+            tabSize: 2,
+            eol: source.includes('\r\n') ? '\r\n' : '\n',
+        },
+    })));
+    return true;
+}

package/dist/utils/which.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whichSync = whichSync;
+const which_1 = __importDefault(require("which"));
+/**
+ * 跨平台可执行文件查找 —— 仓库内查 PATH 的唯一入口，禁止 shell out `which`。
+ *
+ * 为什么不 shell out：`which` 在 Windows 上不存在（对应的是 `where`），而 `where`
+ * 的输出格式与退出码语义又跟 `which` 不同。
+ *
+ * 为什么用社区 `which` 包而不是自己遍历 PATH：Windows 要按 PATHEXT 逐个后缀试探
+ * （`npm` 实际是 `npm.cmd`），POSIX 要看执行位，还有 all / delimiter 这些边角。
+ * 这些是 npm 官方维护的 `which` 已经做完并被全生态验证过的事，自己写只会漏。
+ *
+ * 保留这层薄封装而不是让各处直接 `import which`，是为了：
+ *   1. 把 `null`（社区库的「没找到」）归一成仓库内统一的 `undefined` optional 语义；
+ *   2. 留一个收口点 —— 换实现、加缓存、加平台特例都只改这里；
+ *   3. 配合 ESLint no-restricted-imports，保证不会有人绕过去直接用。
+ */
+function whichSync(name) {
+    if (name === '')
+        return undefined;
+    return which_1.default.sync(name, { nothrow: true }) ?? undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/miaoda-cli",
-  "version": "0.1.37",
+  "version": "0.1.39-alpha.24bc5ff",
   "description": "Miaoda 平台命令行工具，面向 Agent 调用",
   "type": "commonjs",
   "bin": {
@@ -29,12 +29,16 @@
   "dependencies": {
     "@lark-apaas/http-client": "^0.1.5",
     "commander": "^13.1.0",
+    "cross-spawn": "^7.0.6",
     "jsonc-parser": "^3.3.1",
     "ora": "^5.4.1",
-    "picocolors": "^1.1.1"
+    "picocolors": "^1.1.1",
+    "which": "^7.0.0"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22.15.3",
+    "@types/which": "^3.0.4",
     "@typescript-eslint/eslint-plugin": "^8.58.2",
     "@typescript-eslint/parser": "^8.58.2",
     "@vitest/coverage-v8": "^4.1.4",

package/upgrade/templates/nestjs-react-fullstack/templates/nest-cli.json

@@ -11,15 +11,6 @@
         "outDir": "dist/server",
         "watchAssets": true
       }
-    ],
-    "plugins": [
-      {
-        "name": "@nestjs/swagger",
-        "options": {
-          "introspectComments": true,
-          "classValidatorShim": true
-        }
-      }
     ]
   }
-}
+}

package/upgrade/templates/nestjs-react-fullstack/templates/scripts/build.sh

@@ -146,6 +146,11 @@ STEP_START=$(node -e "console.log(Date.now())")
 # 使用 mv 而非 cp：HTML 不能上传到公网 CDN，移走后 dist/client 中不再包含 HTML
 if [ -d "$DIST_DIR/client" ]; then
   mkdir -p "$DIST_DIR/dist/client"
+  # public 先进（顶层 client 打包被排除；server setBaseViewsDir + 中间件同源 serve）
+  if [ -d "$ROOT_DIR/client/public" ]; then
+    cp -R "$ROOT_DIR/client/public/." "$DIST_DIR/dist/client/"
+  fi
+  # 构建产物 HTML 随后 move，覆盖 public 里的同名文件（保证入口页是构建版，不被 public 静默覆盖）
   find "$DIST_DIR/client" -maxdepth 1 -name "*.html" -exec mv {} "$DIST_DIR/dist/client/" \;
 fi
 

package/upgrade/templates/nestjs-react-fullstack/templates/scripts/prune-smart.js

@@ -6,6 +6,13 @@ const fs = require('fs');
 const path = require('path');
 
 const ROOT_DIR = path.resolve(__dirname, '..');
+
+// 加载提交的 .env，供读取构建期配置（如 MIAODA_RUNTIME_ENTRIES）。dotenv 不一定安装 → 静默降级。
+try {
+  require('dotenv').config({ path: path.join(ROOT_DIR, '.env') });
+} catch {
+  // dotenv 未安装：跳过；MIAODA_RUNTIME_ENTRIES 仍可来自真实环境变量
+}
 const DIST_DIR = path.join(ROOT_DIR, 'dist');
 const DIST_SERVER_DIR = path.join(DIST_DIR, 'server');
 const ROOT_PACKAGE_JSON = path.join(ROOT_DIR, 'package.json');
@@ -16,6 +23,36 @@ const OUT_PACKAGE_JSON = path.join(DIST_DIR, 'package.json');
 // Server 入口文件
 const SERVER_ENTRY = path.join(DIST_SERVER_DIR, 'main.js');
 
+// nest sourceRoot（源码根，默认 server）：把 .env 里声明的源码路径映射到构建产物位置
+let SOURCE_ROOT = 'server';
+try {
+  const nestCli = JSON.parse(fs.readFileSync(path.join(ROOT_DIR, 'nest-cli.json'), 'utf8'));
+  if (nestCli.sourceRoot) SOURCE_ROOT = nestCli.sourceRoot;
+} catch {
+  // 读不到 nest-cli.json 则用默认 server
+}
+const SRC_TO_OUT_EXT = { '.mts': '.mjs', '.cts': '.cjs', '.ts': '.js' };
+
+// 额外 trace 入口：经 new Function/动态 import 加载、nft 无法从 main.js 静态发现的 ESM runtime。
+// 应用在提交的 .env 里用 MIAODA_RUNTIME_ENTRIES 声明【源码路径】（相对项目根，逗号分隔），例如：
+//   MIAODA_RUNTIME_ENTRIES=server/modules/ethics/runtime/review-run.mjs,server/modules/ethics/runtime/parse-core.mjs
+// 脚本按 nest sourceRoot 自动映射到 dist/server 下的构建产物（并重写 .mts→.mjs / .ts→.js）。
+const RUNTIME_ENTRIES = (process.env.MIAODA_RUNTIME_ENTRIES || '')
+  .split(',')
+  .map((s) => s.trim())
+  .filter(Boolean)
+  .map((srcRel) => {
+    const fromSrc = path.relative(SOURCE_ROOT, srcRel); // 去掉 sourceRoot 前缀
+    const ext = path.extname(fromSrc);
+    const outRel = SRC_TO_OUT_EXT[ext] ? fromSrc.slice(0, -ext.length) + SRC_TO_OUT_EXT[ext] : fromSrc;
+    return path.join(DIST_SERVER_DIR, outRel);
+  })
+  .filter((p) => {
+    if (fs.existsSync(p)) return true;
+    console.warn(`⚠️  MIAODA_RUNTIME_ENTRIES 入口在构建产物中不存在，已忽略: ${path.relative(ROOT_DIR, p)}`);
+    return false;
+  });
+
 // Node.js 内置模块列表
 const BUILTIN_MODULES = new Set([
   'assert', 'buffer', 'child_process', 'cluster', 'crypto', 'dgram', 'dns',
@@ -145,12 +182,15 @@ async function smartPrune() {
   }
 
   console.log(`📂 分析入口文件: ${path.relative(ROOT_DIR, SERVER_ENTRY)}`);
+  if (RUNTIME_ENTRIES.length) {
+    console.log(`📎 额外 trace 入口 (${RUNTIME_ENTRIES.length}): ${RUNTIME_ENTRIES.map((p) => path.relative(DIST_SERVER_DIR, p)).join(', ')}`);
+  }
 
   // 2. 使用 @vercel/nft 追踪依赖
   console.log('🔎 追踪实际依赖...');
   const analyzeStart = Date.now();
 
-  const { fileList } = await nodeFileTrace([SERVER_ENTRY], {
+  const { fileList } = await nodeFileTrace([SERVER_ENTRY, ...RUNTIME_ENTRIES], {
     base: ROOT_DIR,
     processCwd: ROOT_DIR,
     ts: false, // 禁用 TS 解析

package/upgrade/templates/vite-react/templates/scripts/build.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+set -e
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+OUTPUT="$ROOT/dist/output"
+OUTPUT_RESOURCE="$ROOT/dist/output_resource"
+OUTPUT_STATIC="$ROOT/dist/output_static"
+
+# 映射平台环境变量到 preset 期望的变量名
+#   MIAODA_APP_ID            → /app/<appId> 作为客户端 base path
+#   MIAODA_RESOURCE_CDN_PREFIX → assets (JS/CSS) 的 CDN 前缀
+# CLI 注入约定见 miaoda-cli src/services/deploy/modern/atoms/build.ts
+export CLIENT_BASE_PATH="${MIAODA_APP_ID:+/app/$MIAODA_APP_ID}"
+export ASSETS_CDN_PATH="${MIAODA_RESOURCE_CDN_PREFIX:-/}"
+export STATIC_ASSETS_BASE_URL="${MIAODA_STATIC_CDN_PREFIX}"
+export NODE_ENV="${NODE_ENV:-production}"
+
+# 清理
+rm -rf "$ROOT/dist"
+
+# 1. Vite 构建 → dist/client/（相对于项目根目录输出）
+npx vite build --outDir "$ROOT/dist/client" --emptyOutDir
+
+# 2. public/ 静态资源 + HTML → dist/output/（模型 B：public = 应用根目录，同源 /app/<appId>/*）
+mkdir -p "$OUTPUT"
+# 2a. public/*：vite copyPublicDir 已把 public/* 平铺进 dist/client，但下面白名单只取
+#     *.html/routes.json，其余（favicon / 图片 / 运行时 fetch 的数据文件）会随 dist/client 被删。
+#     从源 public/ 补拷到 output/（同源根），让 fetch('/x') / resolveAppUrl('/x') 线上可用。
+#     先拷 public、再拷 HTML，保证构建产出的 index.html/routes.json 覆盖 public 里的同名文件（若有）。
+if [ -d "$ROOT/public" ]; then
+  cp -R "$ROOT/public/." "$OUTPUT/"
+fi
+# 2b. HTML + routes.json（构建产物）
+find "$ROOT/dist/client" -maxdepth 1 \( -name '*.html' -o -name 'routes.json' \) -exec cp {} "$OUTPUT/" \;
+
+# 3. assets/ → dist/output_resource/（JS/CSS/字体，上传到 CDN）
+if [ -d "$ROOT/dist/client/assets" ]; then
+  mkdir -p "$OUTPUT_RESOURCE"
+  cp -r "$ROOT/dist/client/assets" "$OUTPUT_RESOURCE/"
+fi
+
+# 4. 私有静态资源 → dist/output_static/（排除代码文件）
+if [ -d "$ROOT/shared/static" ]; then
+  mkdir -p "$OUTPUT_STATIC"
+  rsync -a --exclude='*.ts' --exclude='*.tsx' --exclude='*.js' --exclude='*.jsx' "$ROOT/shared/static/" "$OUTPUT_STATIC/"
+fi
+
+# 5. capability 配置 → dist/output_capabilities/
+if [ -d "$ROOT/shared/capabilities" ]; then
+  mkdir -p "$ROOT/dist/output_capabilities"
+  cp -r "$ROOT/shared/capabilities/." "$ROOT/dist/output_capabilities/"
+fi
+
+# 清理中间产物
+rm -rf "$ROOT/dist/client"
+
+echo "Build complete"
+echo "  HTML         → dist/output/"
+[ -d "$OUTPUT_RESOURCE" ] && echo "  Resource     → dist/output_resource/" || true
+[ -d "$OUTPUT_STATIC" ] && echo "  Static       → dist/output_static/" || true
+[ -d "$ROOT/dist/output_capabilities" ] && echo "  Capabilities → dist/output_capabilities/" || true