@lark-apaas/fullstack-cli 1.1.61 → 1.1.62-alpha.20260823195003

package/dist/index.js

@@ -7698,7 +7698,7 @@ function sanitizeStructuredLog(value) {
   delete sanitized.pid;
   return sanitized;
 }
-var TRANSIENT_CONNECTION_ERROR_PATTERN = /ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|socket hang up|proxy error|\[Proxy\] (?:Error:\s*$|Error during|Connection error|Non-connection error|Headers already sent|Service (?:recovered|did not recover))/i;
+var TRANSIENT_CONNECTION_ERROR_PATTERN = /ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|proxy error|\[Proxy\] (?:Error:\s*$|Error during|Connection error|Non-connection error|Headers already sent|Service (?:recovered|did not recover))/i;
 function hasErrorInStdLines(lines) {
   const filtered = lines.filter((line) => !TRANSIENT_CONNECTION_ERROR_PATTERN.test(line));
   const combined = filtered.join("\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.61",
+  "version": "1.1.62-alpha.20260823195003",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",

package/templates/.gitignore.append

@@ -5,4 +5,3 @@
 # scripts/ directory is auto-generated
 # DO NOT modify manually
 scripts/
-

package/templates/scripts/build.sh

@@ -149,6 +149,18 @@ if [ -d "$DIST_DIR/client" ]; then
   find "$DIST_DIR/client" -maxdepth 1 -name "*.html" -exec mv {} "$DIST_DIR/dist/client/" \;
 fi
 
+# 拷贝 shared/static → dist/shared/static
+# Nest server 生产从 process.cwd() + shared/static 读 (nestjs-core static.controller.ts:100),
+# 生产 cwd = dist/, 所以目标是 dist/shared/static。coding-preset 的 static-assets plugin
+# 之前 closeBundle 拷贝, 现在删除后交给 build.sh 显式做 (跟 jsPage 的 output_static rsync 对齐)。
+# 排除 .ts/.tsx/.js/.jsx: 避免 shared/static/ 里若有开发脚本被误传到生产。
+if [ -d "$ROOT_DIR/shared/static" ]; then
+  mkdir -p "$DIST_DIR/shared/static"
+  rsync -a --exclude='*.ts' --exclude='*.tsx' --exclude='*.js' --exclude='*.jsx' \
+    "$ROOT_DIR/shared/static/" "$DIST_DIR/shared/static/"
+  echo "   Static → dist/shared/static/"
+fi
+
 # server 相关产物准备（only_frontend_change=true 时跳过）
 if [[ "${only_frontend_change:-false}" == "true" ]]; then
   echo "   [skip] 跳过 run.sh/.env 复制 (only_frontend_change=true)"

package/templates/scripts/dev.js

@@ -252,20 +252,22 @@ process.on('SIGTERM', cleanup);
 process.on('SIGINT', cleanup);
 process.on('SIGHUP', cleanup);
 
-// Stale dist makes nest --watch skip missing files; watcher won't self-heal.
-function cleanStaleDist() {
-  const distPath = path.join(PROJECT_ROOT, 'dist');
-  if (fs.existsSync(distPath)) {
-    fs.rmSync(distPath, { recursive: true, force: true });
-    logEvent('INFO', 'main', 'Cleaned dist/ to force full rebuild');
-  }
-}
+// dist 缓存策略:
+//   沙箱首次启动 → 保留 dist/, 让 nest --watch 复用上次编译产物
+//   后续启动 (agent 主动触发 npm run dev) → 全清 dist/, 让模型面对新鲜产物避免 stale
+//   依赖升级 (lockfile hash 变) → 同后续启动 (清 dist), log 里点出 "deps changed"
+//   FORCE_CLEAN_DIST=true → escape hatch, 强清
+// marker 放 os.tmpdir()/.miaoda-dev-boot (跟沙箱容器 lifecycle 同, 沙箱重启会清空,
+// 语义对齐"沙箱首次启动"); 具体逻辑抽到 lib/preserve-dev-cache.cjs 便于单测。
+const { preserveDevCache } = require('./lib/preserve-dev-cache.cjs');
 
 // ── Main ──────────────────────────────────────────────────────────────────────
 async function main() {
   logEvent('INFO', 'main', '========== Dev session started ==========');
 
-  cleanStaleDist();
+  preserveDevCache(PROJECT_ROOT, {
+    log: (level, msg) => logEvent(level, 'main', msg),
+  });
 
   // Initialize action plugins
   writeOutput('\n🔌 Initializing action plugins...\n');

package/templates/scripts/dev.sh

@@ -1,18 +1,14 @@
 #!/usr/bin/env bash
-# `npm run dev` 入口；按 MIAODA_DEP_CACHE_DIR 是否非空判断运行环境（与 miaoda-cli
-# isSandboxEnv() 同口径）：
-#   - 非空（沙箱平台注入的依赖缓存目录）→ 直接跑 dev.js
+# `npm run dev` 入口；按 SANDBOX_ID 是否非空判断运行环境：
+#   - SANDBOX_ID 非空（沙箱平台注入应用所属沙箱 ID）→ 直接跑 dev.js
 #       （保活 / restart loop / 文件日志 —— 沙箱生产形态）。脚本同步由平台 pod 启动阶段做过，
 #       dev 入口不再额外 `npm run upgrade`。
 #   - 否则（本地）→ 走 miaoda app sync 兜底 + 跑 dev-local.js：纯 stdout、崩了就崩、Agent 友好。
-# 显式想跑本地路径可用 `npm run dev:local`（绕过本判断）。
-#
-# 不用 SANDBOX_ID：它由 sandbox_console 在绑定沙箱时才写入 .force/environment/env，预热池实例
-# 在绑定前拿不到，会被误判成本地。保留为附加条件只为兼容，不影响判定结果。
+# 显式想跑本地路径可用 `npm run dev:local`（绕过 SANDBOX_ID 判断）。
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 
-if [ -n "${MIAODA_DEP_CACHE_DIR:-}" ] || [ -n "${SANDBOX_ID:-}" ]; then
+if [ -n "${SANDBOX_ID:-}" ]; then
   exec node "$SCRIPT_DIR/dev.js" "$@"
 fi
 
@@ -22,7 +18,7 @@ if [ ! -f "$SCRIPT_DIR/dev-local.js" ]; then
 fi
 
 # 本地启动前先跑一次 miaoda app sync：同步 platform-controlled 内容 + 升 @lark-apaas/* 到
-# latest + 迁移老 npm scripts。沙箱不走这里（上面的沙箱分支已经 exec return）。
+# latest + 迁移老 npm scripts。沙箱不走这里（SANDBOX_ID 分支已经 exec return）。
 npx -y @lark-apaas/miaoda-cli@latest app sync || echo "[dev] miaoda app sync 失败，按现状继续" >&2
 
 exec node "$SCRIPT_DIR/dev-local.js" "$@"

package/templates/scripts/lib/__test__/preserve-dev-cache.test.ts

@@ -0,0 +1,308 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { preserveDevCache } = require('../preserve-dev-cache.cjs');
+
+interface LogEntry {
+  level: string;
+  msg: string;
+}
+
+function makeLogger(entries: LogEntry[]) {
+  return (level: string, msg: string) => {
+    entries.push({ level, msg });
+  };
+}
+
+describe('preserveDevCache', () => {
+  let tmpDir: string;
+  let markerPath: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'preserve-dev-cache-'));
+    markerPath = path.join(tmpDir, '.miaoda-dev-boot-marker');
+  });
+
+  afterEach(() => {
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  describe('FORCE_CLEAN_DIST escape hatch', () => {
+    it('cleans dist and writes marker regardless of state', () => {
+      fs.mkdirSync(path.join(tmpDir, 'dist', 'server'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, 'yarn.lock'), 'lock-content');
+      const logs: LogEntry[] = [];
+
+      const r = preserveDevCache(tmpDir, {
+        log: makeLogger(logs),
+        forceClean: true,
+        markerPath,
+      });
+
+      expect(r.action).toBe('force_cleaned');
+      expect(fs.existsSync(path.join(tmpDir, 'dist'))).toBe(false);
+      expect(fs.existsSync(markerPath)).toBe(true);
+      expect(logs[0].msg).toContain('FORCE_CLEAN_DIST');
+    });
+  });
+
+  describe('first boot (no marker)', () => {
+    it('preserves existing dist and writes marker', () => {
+      fs.mkdirSync(path.join(tmpDir, 'dist', 'server'), { recursive: true });
+      fs.writeFileSync(
+        path.join(tmpDir, 'dist', 'server', 'main.js'),
+        'compiled-content'
+      );
+      const logs: LogEntry[] = [];
+
+      const r = preserveDevCache(tmpDir, {
+        log: makeLogger(logs),
+        forceClean: false,
+        markerPath,
+      });
+
+      expect(r.action).toBe('first_boot_preserved');
+      expect(fs.existsSync(path.join(tmpDir, 'dist', 'server', 'main.js'))).toBe(true);
+      expect(fs.existsSync(markerPath)).toBe(true);
+      expect(logs[0].msg).toContain('first boot');
+    });
+
+    it('handles no dist as first_boot_no_dist', () => {
+      const logs: LogEntry[] = [];
+
+      const r = preserveDevCache(tmpDir, {
+        log: makeLogger(logs),
+        forceClean: false,
+        markerPath,
+      });
+
+      expect(r.action).toBe('first_boot_no_dist');
+      expect(fs.existsSync(markerPath)).toBe(true);
+      expect(logs[0].msg).toContain('no dist/');
+    });
+
+    it('marker stores current lockfile hash', () => {
+      fs.writeFileSync(path.join(tmpDir, 'yarn.lock'), 'initial-lock');
+
+      preserveDevCache(tmpDir, {
+        log: makeLogger([]),
+        forceClean: false,
+        markerPath,
+      });
+
+      const raw = fs.readFileSync(markerPath, 'utf-8');
+      const data = JSON.parse(raw);
+      expect(typeof data.lockfileHash).toBe('string');
+      expect(data.lockfileHash.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('subsequent boot (marker exists)', () => {
+    it('cleans dist and rewrites marker when lockfile unchanged', () => {
+      fs.writeFileSync(path.join(tmpDir, 'yarn.lock'), 'lock-content');
+      preserveDevCache(tmpDir, {
+        log: makeLogger([]),
+        forceClean: false,
+        markerPath,
+      });
+
+      fs.mkdirSync(path.join(tmpDir, 'dist', 'server'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, 'dist', 'server', 'stale.js'), 'stale');
+
+      const logs: LogEntry[] = [];
+      const r = preserveDevCache(tmpDir, {
+        log: makeLogger(logs),
+        forceClean: false,
+        markerPath,
+      });
+
+      expect(r.action).toBe('subsequent_boot_cleaned');
+      expect(fs.existsSync(path.join(tmpDir, 'dist'))).toBe(false);
+      expect(fs.existsSync(markerPath)).toBe(true);
+      expect(logs[0].msg).toContain('subsequent boot');
+    });
+
+    it('reports deps_changed when lockfile hash mismatches marker', () => {
+      fs.writeFileSync(path.join(tmpDir, 'yarn.lock'), 'lock-v1');
+      preserveDevCache(tmpDir, {
+        log: makeLogger([]),
+        forceClean: false,
+        markerPath,
+      });
+
+      fs.writeFileSync(path.join(tmpDir, 'yarn.lock'), 'lock-v2');
+      fs.mkdirSync(path.join(tmpDir, 'dist', 'server'), { recursive: true });
+
+      const logs: LogEntry[] = [];
+      const r = preserveDevCache(tmpDir, {
+        log: makeLogger(logs),
+        forceClean: false,
+        markerPath,
+      });
+
+      expect(r.action).toBe('deps_changed_cleaned');
+      expect(fs.existsSync(path.join(tmpDir, 'dist'))).toBe(false);
+      expect(logs[0].msg).toContain('deps changed');
+    });
+
+    it('reports subsequent_boot_no_dist when marker exists but no dist', () => {
+      preserveDevCache(tmpDir, {
+        log: makeLogger([]),
+        forceClean: false,
+        markerPath,
+      });
+
+      const logs: LogEntry[] = [];
+      const r = preserveDevCache(tmpDir, {
+        log: makeLogger(logs),
+        forceClean: false,
+        markerPath,
+      });
+
+      expect(r.action).toBe('subsequent_boot_no_dist');
+      expect(fs.existsSync(markerPath)).toBe(true);
+      expect(logs[0].msg).toContain('no dist/');
+    });
+  });
+
+  describe('lockfile detection', () => {
+    it('supports package-lock.json', () => {
+      fs.writeFileSync(path.join(tmpDir, 'package-lock.json'), '{}');
+      preserveDevCache(tmpDir, {
+        log: makeLogger([]),
+        forceClean: false,
+        markerPath,
+      });
+
+      const raw = fs.readFileSync(markerPath, 'utf-8');
+      expect(JSON.parse(raw).lockfileHash).not.toBeNull();
+    });
+
+    it('supports pnpm-lock.yaml', () => {
+      fs.writeFileSync(path.join(tmpDir, 'pnpm-lock.yaml'), 'lockfileVersion: 9');
+      preserveDevCache(tmpDir, {
+        log: makeLogger([]),
+        forceClean: false,
+        markerPath,
+      });
+
+      const raw = fs.readFileSync(markerPath, 'utf-8');
+      expect(JSON.parse(raw).lockfileHash).not.toBeNull();
+    });
+
+    it('stores null lockfileHash when no lockfile present', () => {
+      preserveDevCache(tmpDir, {
+        log: makeLogger([]),
+        forceClean: false,
+        markerPath,
+      });
+
+      const raw = fs.readFileSync(markerPath, 'utf-8');
+      expect(JSON.parse(raw).lockfileHash).toBeNull();
+    });
+  });
+
+  describe('first boot + deps changed (lockfile newer than buildinfo)', () => {
+    // 制造"lockfile mtime > buildinfo mtime": 先建 dist + buildinfo,sleep 20ms,再 touch lockfile
+    // 20ms 是保守值,避免 macOS/APFS mtime 精度问题让两个时间戳相等
+    function makeStaleDist() {
+      fs.mkdirSync(path.join(tmpDir, 'dist'), { recursive: true });
+      fs.mkdirSync(path.join(tmpDir, 'dist', 'server'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, 'dist', 'server', 'main.js'), 'compiled');
+      fs.writeFileSync(path.join(tmpDir, 'dist', 'tsconfig.node.tsbuildinfo'), '{}');
+    }
+
+    it('cleans dist when lockfile mtime > buildinfo mtime', async () => {
+      makeStaleDist();
+      await new Promise((r) => setTimeout(r, 20));
+      fs.writeFileSync(path.join(tmpDir, 'yarn.lock'), 'newer-lock');
+
+      const logs: LogEntry[] = [];
+      const r = preserveDevCache(tmpDir, {
+        log: makeLogger(logs),
+        forceClean: false,
+        markerPath,
+      });
+
+      expect(r.action).toBe('first_boot_deps_changed_cleaned');
+      expect(fs.existsSync(path.join(tmpDir, 'dist'))).toBe(false);
+      expect(logs[0].msg).toContain('deps changed');
+    });
+
+    it('preserves dist when lockfile mtime <= buildinfo mtime', async () => {
+      fs.writeFileSync(path.join(tmpDir, 'yarn.lock'), 'older-lock');
+      await new Promise((r) => setTimeout(r, 20));
+      makeStaleDist();
+
+      const logs: LogEntry[] = [];
+      const r = preserveDevCache(tmpDir, {
+        log: makeLogger(logs),
+        forceClean: false,
+        markerPath,
+      });
+
+      expect(r.action).toBe('first_boot_preserved');
+      expect(fs.existsSync(path.join(tmpDir, 'dist', 'server', 'main.js'))).toBe(true);
+    });
+
+    it('cleans dist when buildinfo is missing (dist exists but never compiled)', () => {
+      fs.writeFileSync(path.join(tmpDir, 'yarn.lock'), 'lock');
+      fs.mkdirSync(path.join(tmpDir, 'dist', 'server'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, 'dist', 'server', 'main.js'), 'compiled');
+      // 故意不建 tsconfig.node.tsbuildinfo
+
+      const r = preserveDevCache(tmpDir, {
+        log: makeLogger([]),
+        forceClean: false,
+        markerPath,
+      });
+
+      expect(r.action).toBe('first_boot_deps_changed_cleaned');
+      expect(fs.existsSync(path.join(tmpDir, 'dist'))).toBe(false);
+    });
+
+    it('preserves dist when no lockfile present (cannot judge staleness)', () => {
+      // dist 有 buildinfo 但没 lockfile
+      fs.mkdirSync(path.join(tmpDir, 'dist'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, 'dist', 'tsconfig.node.tsbuildinfo'), '{}');
+      fs.mkdirSync(path.join(tmpDir, 'dist', 'server'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, 'dist', 'server', 'main.js'), 'compiled');
+
+      const r = preserveDevCache(tmpDir, {
+        log: makeLogger([]),
+        forceClean: false,
+        markerPath,
+      });
+
+      expect(r.action).toBe('first_boot_preserved');
+      expect(fs.existsSync(path.join(tmpDir, 'dist', 'server', 'main.js'))).toBe(true);
+    });
+  });
+
+  describe('marker path (sandbox lifecycle alignment)', () => {
+    it('defaults markerPath to os.tmpdir()/.miaoda-dev-boot when not passed', () => {
+      // 不传 markerPath, 走默认路径
+      const defaultMarker = path.join(os.tmpdir(), '.miaoda-dev-boot');
+      // 清理默认位置的残留 marker (可能来自其他测试),避免干扰本用例
+      try { fs.unlinkSync(defaultMarker); } catch { /* noop */ }
+
+      const r = preserveDevCache(tmpDir, {
+        log: makeLogger([]),
+        forceClean: false,
+      });
+
+      expect(r.action).toBe('first_boot_no_dist');
+      expect(fs.existsSync(defaultMarker)).toBe(true);
+
+      // cleanup
+      try { fs.unlinkSync(defaultMarker); } catch { /* noop */ }
+    });
+  });
+});

package/templates/scripts/lib/preserve-dev-cache.cjs

@@ -0,0 +1,178 @@
+'use strict';
+
+// dev.js 启动时的 dist 缓存策略:
+//  - 沙箱首次启动 (marker 不存在) + dist 未过期: 保留 dist/, 让 nest --watch 复用上次编译产物
+//  - 沙箱首次启动 + dist 过期 (lockfile mtime > buildinfo mtime): 清 dist/, 避免 stale binding
+//  - 后续启动 (agent 主动触发 npm run dev): 全清 dist/, 让模型面对新鲜产物避免 stale
+//  - 依赖升级 (marker 里 lockfile hash 变): 后续启动分支自然覆盖 (清 dist), log 里点出原因
+//  - FORCE_CLEAN_DIST=true: escape hatch, 强清
+//
+// marker 位置放 os.tmpdir()(通常是 /tmp), 跟沙箱容器 lifecycle 同 —— 沙箱重启时
+// /tmp 会清空, marker 消失, 下次进 dev 视为"首次启动"复用 dist; 应用工作目录是
+// persistent volume 会跨沙箱重启保留, 放这里的 marker 无法反映"沙箱首次启动"语义。
+//
+// dist 过期判定 (仅首次启动分支需要): lockfile mtime > dist/tsconfig.node.tsbuildinfo mtime
+// 意味着依赖变动之后 dist 未重新编译, 保留会 stale binding。后续启动分支反正全清不需要判。
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+const MARKER_FILENAME = '.miaoda-dev-boot';
+
+/**
+ * @param {string} projectRoot 项目根目录
+ * @param {object} [options]
+ * @param {(level: string, msg: string) => void} [options.log]
+ * @param {boolean} [options.forceClean]
+ * @param {string} [options.markerPath] 覆盖 marker 文件路径 (单测用; 生产默认 /tmp/.miaoda-dev-boot)
+ * @returns {{ action: 'force_cleaned' | 'first_boot_preserved' | 'first_boot_deps_changed_cleaned' | 'first_boot_no_dist' | 'subsequent_boot_cleaned' | 'deps_changed_cleaned' | 'subsequent_boot_no_dist' }}
+ */
+function preserveDevCache(projectRoot, options) {
+  const log = (options && options.log) || defaultLogger;
+  const forceClean =
+    options && typeof options.forceClean === 'boolean'
+      ? options.forceClean
+      : process.env.FORCE_CLEAN_DIST === 'true';
+  const markerPath =
+    (options && options.markerPath) ||
+    path.join(os.tmpdir(), MARKER_FILENAME);
+
+  const distPath = path.join(projectRoot, 'dist');
+  const currentLockfileHash = computeLockfileHash(projectRoot);
+
+  if (forceClean) {
+    if (fs.existsSync(distPath)) {
+      fs.rmSync(distPath, { recursive: true, force: true });
+    }
+    writeMarker(markerPath, currentLockfileHash);
+    log('INFO', 'preserveDevCache: FORCE_CLEAN_DIST=true, cleaned dist/');
+    return { action: 'force_cleaned' };
+  }
+
+  const markerExists = fs.existsSync(markerPath);
+  const distExists = fs.existsSync(distPath);
+
+  if (!markerExists) {
+    writeMarker(markerPath, currentLockfileHash);
+    if (distExists) {
+      if (distIsStaleVsLockfile(projectRoot)) {
+        fs.rmSync(distPath, { recursive: true, force: true });
+        log(
+          'INFO',
+          'preserveDevCache: first boot but deps changed (lockfile newer than buildinfo), cleaned dist/'
+        );
+        return { action: 'first_boot_deps_changed_cleaned' };
+      }
+      log('INFO', 'preserveDevCache: first boot, dist/ preserved');
+      return { action: 'first_boot_preserved' };
+    }
+    log('INFO', 'preserveDevCache: first boot, no dist/ (will be created)');
+    return { action: 'first_boot_no_dist' };
+  }
+
+  // 后续启动: 无脑清 dist
+  const prevLockfileHash = readMarkerHash(markerPath);
+  const depsChanged =
+    prevLockfileHash !== null &&
+    currentLockfileHash !== null &&
+    prevLockfileHash !== currentLockfileHash;
+
+  if (distExists) {
+    fs.rmSync(distPath, { recursive: true, force: true });
+  }
+  writeMarker(markerPath, currentLockfileHash);
+
+  if (depsChanged) {
+    log('INFO', 'preserveDevCache: deps changed (lockfile hash), cleaned dist/');
+    return { action: 'deps_changed_cleaned' };
+  }
+  if (distExists) {
+    log('INFO', 'preserveDevCache: subsequent boot, cleaned dist/');
+    return { action: 'subsequent_boot_cleaned' };
+  }
+  log('INFO', 'preserveDevCache: subsequent boot, no dist/ to clean');
+  return { action: 'subsequent_boot_no_dist' };
+}
+
+/**
+ * 判定当前 dist 是否 stale (相对当前 lockfile)。
+ *
+ * 依据: 依赖变动会更新 lockfile mtime; tsc --watch 编译完更新 buildinfo mtime。
+ * lockfile mtime > buildinfo mtime → dist 是"依赖变动前"编译的 → stale。
+ *
+ * 边界:
+ *  - lockfile 不存在 → 返回 false (无法判断, 保守认为不 stale, 保留 dist)
+ *  - buildinfo 不存在 → 返回 true (dist 里没编译过 → 保守清)
+ *  - `git checkout` 之类 touch lockfile 但内容没改 → 误判 stale 多清一次 (可接受, 安全方向)
+ */
+function distIsStaleVsLockfile(projectRoot) {
+  const lockfiles = ['yarn.lock', 'package-lock.json', 'pnpm-lock.yaml'];
+  let lockMtime = 0;
+  for (const name of lockfiles) {
+    try {
+      lockMtime = Math.max(
+        lockMtime,
+        fs.statSync(path.join(projectRoot, name)).mtimeMs
+      );
+    } catch {
+      // lockfile 不存在,跳过
+    }
+  }
+  if (lockMtime === 0) return false;
+
+  try {
+    const buildinfoMtime = fs.statSync(
+      path.join(projectRoot, 'dist', 'tsconfig.node.tsbuildinfo')
+    ).mtimeMs;
+    return lockMtime > buildinfoMtime;
+  } catch {
+    return true;
+  }
+}
+
+function computeLockfileHash(projectRoot) {
+  const candidates = ['yarn.lock', 'package-lock.json', 'pnpm-lock.yaml'];
+  for (const name of candidates) {
+    const p = path.join(projectRoot, name);
+    if (fs.existsSync(p)) {
+      try {
+        const content = fs.readFileSync(p);
+        return crypto.createHash('sha1').update(content).digest('hex');
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
+function readMarkerHash(markerPath) {
+  try {
+    const raw = fs.readFileSync(markerPath, 'utf-8');
+    const data = JSON.parse(raw);
+    return typeof data.lockfileHash === 'string' ? data.lockfileHash : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeMarker(markerPath, lockfileHash) {
+  try {
+    fs.writeFileSync(
+      markerPath,
+      JSON.stringify({ lockfileHash: lockfileHash || null }),
+      'utf-8'
+    );
+  } catch {
+    // marker 写失败下次会重试, 不阻塞 dev 启动
+  }
+}
+
+function defaultLogger(level, msg) {
+  // eslint-disable-next-line no-console
+  console.log(`[${level}] [main] ${msg}`);
+}
+
+module.exports = { preserveDevCache };

package/templates/scripts/lint.js

@@ -76,49 +76,13 @@ function isStylelintTarget(filePath) {
   return filePath.endsWith('.css');
 }
 
-const STYLELINT_CONFIG_FILES = [
-  '.stylelintrc',
-  '.stylelintrc.js',
-  '.stylelintrc.cjs',
-  '.stylelintrc.json',
-  'stylelint.config.js',
-];
-
-/**
- * 老模板（fullstack-nestjs-template 1.x 时代）的应用跑不了 stylelint，跑了就挂、把 pre-commit
- * 卡死。两种形态都实测过：
- *
- * - 缺 scripts.stylelint → `npm error Missing script: "stylelint"`
- * - 缺 .stylelintrc.*    → `ConfigurationError: No configuration provided`
- *
- * 注意光判断 stylelint 装没装拦不住：@lark-apaas/fullstack-presets 的 dependencies 里有
- * stylelint，只要 dep 了 presets 二进制就在。缺任一件就跳过这一步。
- */
-function canRunStylelint() {
-  let pkg;
-  try {
-    pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
-  } catch {
-    return false;
-  }
-
-  if (!pkg.scripts || !pkg.scripts.stylelint) return false;
-
-  return STYLELINT_CONFIG_FILES.some(file => fs.existsSync(path.join(cwd, file)));
-}
-
 async function runDefaultLint() {
   const taskSpecs = [
     [getBinName('npm'), ['run', 'eslint']],
     [getBinName('npm'), ['run', 'type:check']],
+    [getBinName('npm'), ['run', 'stylelint']],
   ];
 
-  if (canRunStylelint()) {
-    taskSpecs.push([getBinName('npm'), ['run', 'stylelint']]);
-  } else {
-    console.warn('[lint] Skip stylelint: missing scripts.stylelint or stylelint config');
-  }
-
   process.exit(await runTasksSerially(taskSpecs));
 }
 
@@ -156,9 +120,7 @@ async function runSelectiveLint(inputFiles) {
     taskSpecs.push([getBinName('npx'), ['eslint', '--quiet', ...eslintFiles]]);
   }
 
-  if (stylelintFiles.length > 0 && !canRunStylelint()) {
-    console.warn('[lint] Skip stylelint: missing scripts.stylelint or stylelint config');
-  } else if (stylelintFiles.length > 0) {
+  if (stylelintFiles.length > 0) {
     taskSpecs.push([getBinName('npx'), ['stylelint', '--quiet', ...stylelintFiles]]);
   }