@lark-apaas/fullstack-cli 1.1.59-alpha.3 → 1.1.59

package/templates/scripts/dev.js

@@ -3,16 +3,8 @@
 
 const fs = require('fs');
 const path = require('path');
-const { spawn, execFileSync, execSync } = require('child_process');
+const { spawn, execSync } = require('child_process');
 const readline = require('readline');
-const {
-  buildListeningPortLookupArgs,
-  createPreviewPhaseReporter,
-  normalizeTcpPort,
-  parseTscWatchSummary,
-  resolvePreviewServerCommand,
-  waitForTcpReady,
-} = require('./preview-startup-timing.cjs');
 
 // ── Project root ──────────────────────────────────────────────────────────────
 const PROJECT_ROOT = path.resolve(__dirname, '..');
@@ -44,12 +36,8 @@ const MAX_RESTART_COUNT = process.env.MAX_RESTART_COUNT != null && process.env.M
   : Infinity;
 const RESTART_DELAY = parseInt(process.env.RESTART_DELAY, 10) || 2;
 const MAX_DELAY = 8;
-const SERVER_PORT = normalizeTcpPort(process.env.SERVER_PORT, 3000, 'SERVER_PORT');
-const CLIENT_DEV_PORT = normalizeTcpPort(
-  process.env.CLIENT_DEV_PORT,
-  8080,
-  'CLIENT_DEV_PORT'
-);
+const SERVER_PORT = process.env.SERVER_PORT || '3000';
+const CLIENT_DEV_PORT = process.env.CLIENT_DEV_PORT || '8080';
 
 fs.mkdirSync(LOG_DIR, { recursive: true });
 
@@ -90,10 +78,6 @@ function writeOutput(msg) {
   try { fs.write(1, msg, () => { _stdoutInFlight--; }); } catch { _stdoutInFlight--; }
 }
 
-const previewPhaseReporter = createPreviewPhaseReporter({
-  write: (line) => writeOutput(`${line}\n`),
-});
-
 /** Structured event log → terminal + dev.std.log + dev.log */
 function logEvent(level, name, message) {
   const msg = `[${timestamp()}] [${level}] [${name}] ${message}\n`;
@@ -110,38 +94,16 @@ function killProcessGroup(pid, signal) {
 
 function killOrphansByPort(port) {
   try {
-    const output = execFileSync('lsof', buildListeningPortLookupArgs(port), {
-      encoding: 'utf8',
-      timeout: 5000,
-    }).trim();
-    const killedPids = [];
-    const failures = [];
-    if (output) {
-      for (const pidText of output.split('\n').filter(Boolean)) {
-        const pid = Number(pidText);
-        try {
-          process.kill(pid, 'SIGKILL');
-          killedPids.push(pidText);
-        } catch (error) {
-          if (error?.code !== 'ESRCH') {
-            failures.push(
-              `${pidText}: ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-        }
+    const pids = execSync(`lsof -ti :${port}`, { encoding: 'utf8', timeout: 5000 }).trim();
+    if (pids) {
+      const pidList = pids.split('\n').filter(Boolean);
+      for (const p of pidList) {
+        try { process.kill(parseInt(p, 10), 'SIGKILL'); } catch {}
       }
+      return pidList;
     }
-    return {
-      pids: killedPids,
-      error: failures.length > 0 ? failures.join('; ') : null,
-    };
-  } catch (error) {
-    if (error?.status === 1) return { pids: [], error: null };
-    return {
-      pids: [],
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
+  } catch {}
+  return [];
 }
 
 // ── Process supervision ───────────────────────────────────────────────────────
@@ -156,7 +118,7 @@ function sleep(ms) {
  * Start and supervise a process with auto-restart and log piping.
  * Returns a promise that resolves when the process loop ends.
  */
-function startProcess({ name, command, args, cleanupPort, phaseDetail = {}, onReady }) {
+function startProcess({ name, command, args, cleanupPort }) {
   const logFilePath = path.join(LOG_DIR, `${name}.std.log`);
   const logFd = fs.openSync(logFilePath, 'a');
 
@@ -166,30 +128,6 @@ function startProcess({ name, command, args, cleanupPort, phaseDetail = {}, onRe
   const run = async () => {
     let restartCount = 0;
 
-    if (cleanupPort) {
-      const portCleanup = killOrphansByPort(cleanupPort);
-      const stalePids = portCleanup.pids;
-      logEvent(
-        portCleanup.error ? 'ERROR' : stalePids.length > 0 ? 'WARN' : 'INFO',
-        name,
-        portCleanup.error
-          ? `Port ${cleanupPort} preflight failed: ${portCleanup.error}`
-          : stalePids.length > 0
-          ? `Killed stale processes on port ${cleanupPort} before first spawn: ${stalePids.join(' ')}`
-          : `Port ${cleanupPort} is clear before first spawn`
-      );
-      previewPhaseReporter.emit(
-        name === 'server' ? 'backend_port_preflight' : 'client_port_preflight',
-        portCleanup.error ? 'error' : 'success',
-        {
-          exact: true,
-          cleanup_count: stalePids.length,
-          ...(portCleanup.error ? { error: portCleanup.error } : {}),
-        }
-      );
-      if (stalePids.length > 0) await sleep(500);
-    }
-
     while (!stopping) {
       const child = spawn(command, args, {
         detached: true,
@@ -203,80 +141,12 @@ function startProcess({ name, command, args, cleanupPort, phaseDetail = {}, onRe
       entry.child = child;
 
       const startTime = Date.now();
-      const attempt = restartCount + 1;
       logEvent('INFO', name, `Process started (PGID: ${child.pid}): ${command} ${args.join(' ')}`);
-      const processPhase =
-        name === 'server'
-          ? 'backend_process_spawn'
-          : name === 'server-typecheck'
-            ? 'backend_typecheck_process_spawn'
-            : 'client_process_spawn';
-      previewPhaseReporter.emit(processPhase, 'success', {
-        at_ms: startTime,
-        attempt,
-        exact: true,
-        ...phaseDetail,
-      });
-      if (name === 'server') {
-        void waitForTcpReady({
-          port: Number(SERVER_PORT),
-          started_at_ms: startTime,
-          interval_ms: 50,
-          timeout_ms: 120000,
-          should_continue: () => entry.child === child && !stopping,
-        })
-          .then(result => {
-            if (result.cancelled) return;
-            previewPhaseReporter.emit(
-              'backend_tcp_ready',
-              result.ready ? 'success' : 'error',
-              { ...result, attempt, exact: false }
-            );
-            if (result.ready && onReady) {
-              try {
-                onReady(result);
-              } catch (error) {
-                logEvent(
-                  'ERROR',
-                  name,
-                  `Backend ready callback failed: ${error instanceof Error ? error.message : String(error)}`
-                );
-              }
-            }
-          })
-          .catch(error => {
-            if (entry.child !== child || stopping) return;
-            previewPhaseReporter.emit('backend_tcp_ready', 'error', {
-              duration_ms: Date.now() - startTime,
-              attempt,
-              exact: false,
-              precision_ms: 50,
-              error: error instanceof Error ? error.message : String(error),
-            });
-          });
-      }
 
       // Pipe stdout and stderr through readline for timestamped logging
-      let typecheckSummaryReported = false;
       const pipeLines = (stream) => {
         const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
         rl.on('line', (line) => {
-          if (name === 'server-typecheck' && !typecheckSummaryReported) {
-            const summary = parseTscWatchSummary(line);
-            if (summary) {
-              typecheckSummaryReported = true;
-              previewPhaseReporter.emit(
-                'backend_typecheck_ready',
-                summary.passed ? 'success' : 'error',
-                {
-                  duration_ms: Date.now() - startTime,
-                  attempt,
-                  exact: true,
-                  ...summary,
-                }
-              );
-            }
-          }
           const msg = `[${timestamp()}] [${name}] ${line}\n`;
           try { fs.writeSync(logFd, msg); } catch {}
           writeOutput(msg);
@@ -305,15 +175,7 @@ function startProcess({ name, command, args, cleanupPort, phaseDetail = {}, onRe
 
       // Port cleanup fallback
       if (cleanupPort) {
-        const portCleanup = killOrphansByPort(cleanupPort);
-        const orphans = portCleanup.pids;
-        if (portCleanup.error) {
-          logEvent(
-            'ERROR',
-            name,
-            `Port ${cleanupPort} cleanup failed: ${portCleanup.error}`
-          );
-        }
+        const orphans = killOrphansByPort(cleanupPort);
         if (orphans.length > 0) {
           logEvent('WARN', name, `Killed orphan processes on port ${cleanupPort}: ${orphans.join(' ')}`);
           await sleep(500);
@@ -375,12 +237,8 @@ async function cleanup() {
   }
 
   // Port cleanup fallback
-  for (const port of [SERVER_PORT, CLIENT_DEV_PORT]) {
-    const portCleanup = killOrphansByPort(port);
-    if (portCleanup.error) {
-      logEvent('ERROR', 'main', `Port ${port} cleanup failed: ${portCleanup.error}`);
-    }
-  }
+  killOrphansByPort(SERVER_PORT);
+  killOrphansByPort(CLIENT_DEV_PORT);
 
   logEvent('INFO', 'main', 'All processes stopped');
 
@@ -406,102 +264,24 @@ function cleanStaleDist() {
 // ── Main ──────────────────────────────────────────────────────────────────────
 async function main() {
   logEvent('INFO', 'main', '========== Dev session started ==========');
-  previewPhaseReporter.emit('dev_orchestrator_start', 'success', { exact: true });
 
   cleanStaleDist();
 
   // Initialize action plugins
   writeOutput('\n🔌 Initializing action plugins...\n');
-  const actionPluginStartedAt = Date.now();
-  previewPhaseReporter.emit('action_plugin_init', 'start', {
-    at_ms: actionPluginStartedAt,
-    exact: true,
-  });
   try {
     execSync('fullstack-cli action-plugin init', { cwd: PROJECT_ROOT, stdio: 'inherit' });
-    previewPhaseReporter.emit('action_plugin_init', 'success', {
-      duration_ms: Date.now() - actionPluginStartedAt,
-      exact: true,
-    });
     writeOutput('✅ Action plugins initialized\n\n');
-  } catch (error) {
-    previewPhaseReporter.emit('action_plugin_init', 'error', {
-      duration_ms: Date.now() - actionPluginStartedAt,
-      exact: true,
-      error: error instanceof Error ? error.message : String(error),
-    });
+  } catch {
     writeOutput('⚠️  Action plugin initialization failed, continuing anyway...\n\n');
   }
 
   // Start server and client
-  const serverCommand = resolvePreviewServerCommand({
-    project_root: PROJECT_ROOT,
-  });
-  logEvent(
-    'INFO',
-    'server',
-    `Selected ${serverCommand.compiler} compiler (${serverCommand.reason})`
-  );
-  previewPhaseReporter.emit('backend_compiler_selected', 'success', {
-    exact: true,
-    compiler: serverCommand.compiler,
-    type_check: serverCommand.type_check,
-    type_check_mode: serverCommand.type_check_mode,
-    reason: serverCommand.reason,
-    missing_modules: serverCommand.missing_modules,
-  });
-  let serverTypecheckStarted = false;
-  const startServerTypecheck = () => {
-    if (serverTypecheckStarted || !serverCommand.type_check_command) return;
-    try {
-      logEvent(
-        'INFO',
-        'server-typecheck',
-        'Starting deferred server type checker after backend TCP ready'
-      );
-      previewPhaseReporter.emit('backend_typecheck_deferred_start', 'success', {
-        exact: true,
-        type_check_mode: serverCommand.type_check_mode,
-      });
-      const typecheckPromise = startProcess({
-        name: 'server-typecheck',
-        command: serverCommand.type_check_command.command,
-        args: serverCommand.type_check_command.args,
-        phaseDetail: { type_check_mode: serverCommand.type_check_mode },
-      });
-      serverTypecheckStarted = true;
-      void typecheckPromise.catch(error => {
-        logEvent(
-          'ERROR',
-          'server-typecheck',
-          `Deferred server type checker failed: ${error instanceof Error ? error.message : String(error)}`
-        );
-      });
-    } catch (error) {
-      previewPhaseReporter.emit('backend_typecheck_deferred_start', 'error', {
-        exact: true,
-        type_check_mode: serverCommand.type_check_mode,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      logEvent(
-        'ERROR',
-        'server-typecheck',
-        `Failed to start deferred server type checker: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  };
   const serverPromise = startProcess({
     name: 'server',
-    command: serverCommand.command,
-    args: serverCommand.args,
+    command: 'npm',
+    args: ['run', 'dev:server'],
     cleanupPort: SERVER_PORT,
-    phaseDetail: {
-      compiler: serverCommand.compiler,
-      type_check: serverCommand.type_check,
-      type_check_mode: serverCommand.type_check_mode,
-      compiler_selection_reason: serverCommand.reason,
-    },
-    onReady: startServerTypecheck,
   });
 
   const clientPromise = startProcess({

package/templates/scripts/dev.sh

@@ -1,2 +1,24 @@
 #!/usr/bin/env bash
-exec node "$(dirname "$0")/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 判断）。
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+if [ -n "${SANDBOX_ID:-}" ]; then
+  exec node "$SCRIPT_DIR/dev.js" "$@"
+fi
+
+if [ ! -f "$SCRIPT_DIR/dev-local.js" ]; then
+  echo "[dev] scripts/dev-local.js 缺失；先跑 \`npx -y @lark-apaas/miaoda-cli@latest app sync\` 同步平台脚本" >&2
+  exit 1
+fi
+
+# 本地启动前先跑一次 miaoda app sync：同步 platform-controlled 内容 + 升 @lark-apaas/* 到
+# 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/lint.js

@@ -23,6 +23,19 @@ function runCommand(command, args) {
   });
 }
 
+// 串行依次执行每个任务，全部跑完后再聚合退出码：
+// 降低并发资源占用、让各任务输出按顺序清晰可读，同时保留“一次暴露所有 lint 问题”的行为。
+async function runTasksSerially(taskSpecs) {
+  let exitCode = 0;
+  for (const [command, args] of taskSpecs) {
+    const code = await runCommand(command, args);
+    if (code !== 0) {
+      exitCode = 1;
+    }
+  }
+  return exitCode;
+}
+
 function normalizeProjectFile(filePath) {
   const absolutePath = path.isAbsolute(filePath)
     ? filePath
@@ -63,14 +76,35 @@ 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 配置，跑 stylelint 会以
+ * "ConfigurationError: No configuration provided" 挂掉、把 pre-commit 卡死。没配置就跳过。
+ */
+function hasStylelintConfig() {
+  return STYLELINT_CONFIG_FILES.some(file => fs.existsSync(path.join(cwd, file)));
+}
+
 async function runDefaultLint() {
-  const code = await runCommand(getBinName('npx'), [
-    'concurrently',
-    'npm run eslint',
-    'npm run type:check',
-    'npm run stylelint',
-  ]);
-  process.exit(code);
+  const taskSpecs = [
+    [getBinName('npm'), ['run', 'eslint']],
+    [getBinName('npm'), ['run', 'type:check']],
+  ];
+
+  if (hasStylelintConfig()) {
+    taskSpecs.push([getBinName('npm'), ['run', 'stylelint']]);
+  } else {
+    console.warn('[lint] Skip stylelint: no stylelint config found');
+  }
+
+  process.exit(await runTasksSerially(taskSpecs));
 }
 
 async function runSelectiveLint(inputFiles) {
@@ -101,31 +135,32 @@ async function runSelectiveLint(inputFiles) {
     }
   }
 
-  const tasks = [];
+  const taskSpecs = [];
 
   if (eslintFiles.length > 0) {
-    tasks.push(runCommand(getBinName('npx'), ['eslint', '--quiet', ...eslintFiles]));
+    taskSpecs.push([getBinName('npx'), ['eslint', '--quiet', ...eslintFiles]]);
   }
 
-  if (stylelintFiles.length > 0) {
-    tasks.push(runCommand(getBinName('npx'), ['stylelint', '--quiet', ...stylelintFiles]));
+  if (stylelintFiles.length > 0 && !hasStylelintConfig()) {
+    console.warn('[lint] Skip stylelint: no stylelint config found');
+  } else if (stylelintFiles.length > 0) {
+    taskSpecs.push([getBinName('npx'), ['stylelint', '--quiet', ...stylelintFiles]]);
   }
 
   if (clientTypeFiles.length > 0) {
-    tasks.push(runCommand(getBinName('npm'), ['run', 'type:check:client']));
+    taskSpecs.push([getBinName('npm'), ['run', 'type:check:client']]);
   }
 
   if (serverTypeFiles.length > 0) {
-    tasks.push(runCommand(getBinName('npm'), ['run', 'type:check:server']));
+    taskSpecs.push([getBinName('npm'), ['run', 'type:check:server']]);
   }
 
-  if (tasks.length === 0) {
+  if (taskSpecs.length === 0) {
     console.log('[lint] No supported files matched for lint');
     process.exit(0);
   }
 
-  const results = await Promise.all(tasks);
-  process.exit(results.some(code => code !== 0) ? 1 : 0);
+  process.exit(await runTasksSerially(taskSpecs));
 }
 
 async function main() {

package/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 解析