@lark-apaas/fullstack-cli 1.1.16-beta.1 → 1.1.16-beta.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.16-beta.1",
+  "version": "1.1.16-beta.10",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",
@@ -32,18 +32,23 @@
   },
   "dependencies": {
     "@lark-apaas/http-client": "^0.1.2",
+    "@lydell/node-pty": "1.1.0",
     "@vercel/nft": "^0.30.3",
     "commander": "^13.0.0",
+    "debug": "^4.4.3",
     "dotenv": "^16.0.0",
     "drizzle-kit": "0.31.5",
     "drizzle-orm": "0.44.6",
+    "es-toolkit": "^1.44.0",
     "inflection": "^3.0.2",
     "pinyin-pro": "^3.27.0",
     "postgres": "^3.4.3",
+    "shadcn": "3.8.2",
     "ts-morph": "^27.0.0",
     "zod-to-json-schema": "^3.24.1"
   },
   "devDependencies": {
+    "@types/debug": "^4",
     "@types/node": "^22.0.0",
     "tsup": "^8.3.5",
     "typescript": "^5.9.2",

package/templates/.spark_project

@@ -0,0 +1,16 @@
+run = ["npm", "run", "dev"] # 默认 spark-cli dev
+hidden = [".config", ".git", "scripts", "node_modules", "dist", ".spark", ".agent", ".agents", "tmp", ".spark_project", ".playwright-cli"]
+lint = ["npm", "run", "lint"]
+test = ["npm", "run", "test"]
+genDbSchema = ["npm", "run", "gen:db-schema"]
+genOpenApiClient = ["npm", "run", "gen:openapi"]
+
+[deployment]
+build = ["npm", "run", "build"]
+run = ["npm", "run", "start"]
+
+[files]
+[files.restrict]
+pathPatterns = ["client/src/api/gen", "package.json", ".spark_project", ".gitignore"]
+[files.hidden]
+pathPatterns = [".config", ".git", "scripts", "node_modules", "dist", ".spark", ".agent", ".agents", "tmp", ".spark_project", ".playwright-cli"]

package/templates/nest-cli.json

@@ -3,7 +3,7 @@
   "collection": "@nestjs/schematics",
   "sourceRoot": "server",
   "compilerOptions": {
-    "deleteOutDir": true,
+    "deleteOutDir": false,
     "tsConfigPath": "tsconfig.node.json",
     "assets": [
       {

package/templates/scripts/build.sh

@@ -3,7 +3,7 @@
 set -euo pipefail
 
 ROOT_DIR="$(pwd)"
-OUT_DIR="$ROOT_DIR/dist/server"
+DIST_DIR="$ROOT_DIR/dist"
 
 # 记录总开始时间
 TOTAL_START=$(node -e "console.log(Date.now())")
@@ -78,20 +78,26 @@ print_time $STEP_START
 echo ""
 
 # ==================== 步骤 4 ====================
-echo "📦 [4/5] 准备 server 依赖产物"
+echo "📦 [4/5] 准备产物"
 STEP_START=$(node -e "console.log(Date.now())")
 
-mkdir -p "$OUT_DIR/dist/client"
+# 拷贝 run.sh 到 dist/（prod 从 dist/ 启动，确保 cwd 一致性）
+cp "$ROOT_DIR/scripts/run.sh" "$DIST_DIR/"
 
-# 拷贝 HTML
-cp "$ROOT_DIR/dist/client/"*.html "$OUT_DIR/dist/client/" || true
+# 拷贝 .env 文件（如果存在）
+if [ -f "$ROOT_DIR/.env" ]; then
+  cp "$ROOT_DIR/.env" "$DIST_DIR/"
+fi
 
-# 拷贝 run.sh 文件
-cp "$ROOT_DIR/scripts/run.sh" "$OUT_DIR/"
+# 移动 client 下的 HTML 文件到 dist/dist/client，保证 views 路径在 dev/prod 下一致
+if [ -d "$DIST_DIR/client" ]; then
+  mkdir -p "$DIST_DIR/dist/client"
+  find "$DIST_DIR/client" -maxdepth 1 -name "*.html" -exec mv {} "$DIST_DIR/dist/client/" \;
+fi
 
 # 清理无用文件
-rm -rf "$ROOT_DIR/dist/scripts"
-rm -rf "$ROOT_DIR/dist/tsconfig.node.tsbuildinfo"
+rm -rf "$DIST_DIR/scripts"
+rm -rf "$DIST_DIR/tsconfig.node.tsbuildinfo"
 
 print_time $STEP_START
 echo ""
@@ -111,8 +117,8 @@ echo "构建完成"
 print_time $TOTAL_START
 
 # 输出产物信息
-DIST_SIZE=$(du -sh "$OUT_DIR" | cut -f1)
-NODE_MODULES_SIZE=$(du -sh "$ROOT_DIR/dist/node_modules" | cut -f1)
+DIST_SIZE=$(du -sh "$DIST_DIR" | cut -f1)
+NODE_MODULES_SIZE=$(du -sh "$DIST_DIR/node_modules" | cut -f1)
 echo ""
 echo "📊 构建产物统计:"
 echo "   产物大小:        $DIST_SIZE"

package/templates/scripts/dev.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
+const readline = require('readline');
+
+// ── Project root ──────────────────────────────────────────────────────────────
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+process.chdir(PROJECT_ROOT);
+
+// ── Load .env ─────────────────────────────────────────────────────────────────
+function loadEnv() {
+  const envPath = path.join(PROJECT_ROOT, '.env');
+  if (!fs.existsSync(envPath)) return;
+  const lines = fs.readFileSync(envPath, 'utf8').split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eqIdx = trimmed.indexOf('=');
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim();
+    if (!(key in process.env)) {
+      process.env[key] = value;
+    }
+  }
+}
+loadEnv();
+
+// ── Configuration ─────────────────────────────────────────────────────────────
+const LOG_DIR = process.env.LOG_DIR || 'logs';
+const MAX_RESTART_COUNT = parseInt(process.env.MAX_RESTART_COUNT, 10) || 10;
+const RESTART_DELAY = parseInt(process.env.RESTART_DELAY, 10) || 2;
+const MAX_DELAY = 60;
+const SERVER_PORT = process.env.SERVER_PORT || '3000';
+const CLIENT_DEV_PORT = process.env.CLIENT_DEV_PORT || '8080';
+
+fs.mkdirSync(LOG_DIR, { recursive: true });
+
+// ── Logging infrastructure ────────────────────────────────────────────────────
+const devStdLogPath = path.join(LOG_DIR, 'dev.std.log');
+const devLogPath = path.join(LOG_DIR, 'dev.log');
+const devStdLogFd = fs.openSync(devStdLogPath, 'a');
+const devLogFd = fs.openSync(devLogPath, 'a');
+
+function timestamp() {
+  const now = new Date();
+  return (
+    now.getFullYear() + '-' +
+    String(now.getMonth() + 1).padStart(2, '0') + '-' +
+    String(now.getDate()).padStart(2, '0') + ' ' +
+    String(now.getHours()).padStart(2, '0') + ':' +
+    String(now.getMinutes()).padStart(2, '0') + ':' +
+    String(now.getSeconds()).padStart(2, '0')
+  );
+}
+
+/** Write to terminal + dev.std.log */
+function writeOutput(msg) {
+  try { process.stdout.write(msg); } catch {}
+  try { fs.writeSync(devStdLogFd, msg); } catch {}
+}
+
+/** Structured event log → terminal + dev.std.log + dev.log */
+function logEvent(level, name, message) {
+  const msg = `[${timestamp()}] [${level}] [${name}] ${message}\n`;
+  writeOutput(msg);
+  try { fs.writeSync(devLogFd, msg); } catch {}
+}
+
+// ── Process group management ──────────────────────────────────────────────────
+function killProcessGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+  } catch {}
+}
+
+function killOrphansByPort(port) {
+  try {
+    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;
+    }
+  } catch {}
+  return [];
+}
+
+// ── Process supervision ───────────────────────────────────────────────────────
+let stopping = false;
+const managedProcesses = []; // { name, pid, child }
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, 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 }) {
+  const logFilePath = path.join(LOG_DIR, `${name}.std.log`);
+  const logFd = fs.openSync(logFilePath, 'a');
+
+  const entry = { name, pid: null, child: null };
+  managedProcesses.push(entry);
+
+  const run = async () => {
+    let restartCount = 0;
+
+    while (!stopping) {
+      const child = spawn(command, args, {
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: true,
+        cwd: PROJECT_ROOT,
+        env: { ...process.env },
+      });
+
+      entry.pid = child.pid;
+      entry.child = child;
+
+      logEvent('INFO', name, `Process started (PGID: ${child.pid}): ${command} ${args.join(' ')}`);
+
+      // Pipe stdout and stderr through readline for timestamped logging
+      const pipeLines = (stream) => {
+        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+        rl.on('line', (line) => {
+          const msg = `[${timestamp()}] [${name}] ${line}\n`;
+          try { fs.writeSync(logFd, msg); } catch {}
+          writeOutput(msg);
+        });
+      };
+      if (child.stdout) pipeLines(child.stdout);
+      if (child.stderr) pipeLines(child.stderr);
+
+      // Wait for the direct child to exit.
+      // NOTE: must use 'exit', not 'close'. With shell:true, grandchild processes
+      // (e.g. nest's server) inherit stdout pipes. 'close' won't fire until ALL
+      // pipe holders exit, causing dev.js to hang when npm/nest dies but server survives.
+      const exitCode = await new Promise((resolve) => {
+        child.on('exit', (code) => resolve(code ?? 1));
+        child.on('error', () => resolve(1));
+      });
+
+      // Kill the entire process group
+      if (entry.pid) {
+        killProcessGroup(entry.pid, 'SIGTERM');
+        await sleep(2000);
+        killProcessGroup(entry.pid, 'SIGKILL');
+      }
+      entry.pid = null;
+      entry.child = null;
+
+      // Port cleanup fallback
+      if (cleanupPort) {
+        const orphans = killOrphansByPort(cleanupPort);
+        if (orphans.length > 0) {
+          logEvent('WARN', name, `Killed orphan processes on port ${cleanupPort}: ${orphans.join(' ')}`);
+          await sleep(500);
+        }
+      }
+
+      if (stopping) break;
+
+      restartCount++;
+      if (restartCount >= MAX_RESTART_COUNT) {
+        logEvent('ERROR', name, `Max restart count (${MAX_RESTART_COUNT}) reached, giving up`);
+        break;
+      }
+
+      const delay = Math.min(RESTART_DELAY * (1 << (restartCount - 1)), MAX_DELAY);
+      logEvent('WARN', name, `Process exited with code ${exitCode}, restarting (${restartCount}/${MAX_RESTART_COUNT}) in ${delay}s...`);
+      await sleep(delay * 1000);
+    }
+
+    try { fs.closeSync(logFd); } catch {}
+  };
+
+  return run();
+}
+
+// ── Cleanup ───────────────────────────────────────────────────────────────────
+let cleanupDone = false;
+
+async function cleanup() {
+  if (cleanupDone) return;
+  cleanupDone = true;
+  stopping = true;
+
+  logEvent('INFO', 'main', 'Shutting down all processes...');
+
+  // Kill all managed process groups
+  for (const entry of managedProcesses) {
+    if (entry.pid) {
+      logEvent('INFO', 'main', `Stopping process group (PGID: ${entry.pid})`);
+      killProcessGroup(entry.pid, 'SIGTERM');
+    }
+  }
+
+  // Wait for graceful shutdown
+  await sleep(2000);
+
+  // Force kill any remaining
+  for (const entry of managedProcesses) {
+    if (entry.pid) {
+      logEvent('WARN', 'main', `Force killing process group (PGID: ${entry.pid})`);
+      killProcessGroup(entry.pid, 'SIGKILL');
+    }
+  }
+
+  // Port cleanup fallback
+  killOrphansByPort(SERVER_PORT);
+  killOrphansByPort(CLIENT_DEV_PORT);
+
+  logEvent('INFO', 'main', 'All processes stopped');
+
+  try { fs.closeSync(devStdLogFd); } catch {}
+  try { fs.closeSync(devLogFd); } catch {}
+
+  process.exit(0);
+}
+
+process.on('SIGTERM', cleanup);
+process.on('SIGINT', cleanup);
+process.on('SIGHUP', cleanup);
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+async function main() {
+  logEvent('INFO', 'main', '========== Dev session started ==========');
+
+  // Initialize action plugins
+  writeOutput('\n🔌 Initializing action plugins...\n');
+  try {
+    execSync('fullstack-cli action-plugin init', { cwd: PROJECT_ROOT, stdio: 'inherit' });
+    writeOutput('✅ Action plugins initialized\n\n');
+  } catch {
+    writeOutput('⚠️  Action plugin initialization failed, continuing anyway...\n\n');
+  }
+
+  // Start server and client
+  const serverPromise = startProcess({
+    name: 'server',
+    command: 'npm',
+    args: ['run', 'dev:server'],
+    cleanupPort: SERVER_PORT,
+  });
+
+  const clientPromise = startProcess({
+    name: 'client',
+    command: 'npm',
+    args: ['run', 'dev:client'],
+    cleanupPort: CLIENT_DEV_PORT,
+  });
+
+  writeOutput(`📋 Dev processes running. Press Ctrl+C to stop.\n`);
+  writeOutput(`📄 Logs: ${devStdLogPath}\n\n`);
+
+  // Wait for both (they loop until stopping or max restarts)
+  await Promise.all([serverPromise, clientPromise]);
+
+  if (!cleanupDone) {
+    await cleanup();
+  }
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/templates/scripts/dev.sh

@@ -1,245 +1,2 @@
 #!/usr/bin/env bash
-# This file is auto-generated by @lark-apaas/fullstack-cli
-
-set -uo pipefail
-
-# Ensure the script always runs from the project root
-cd "$(dirname "${BASH_SOURCE[0]}")/.."
-
-# Configuration
-LOG_DIR=${LOG_DIR:-logs}
-DEV_LOG="${LOG_DIR}/dev.log"
-MAX_RESTART_COUNT=${MAX_RESTART_COUNT:-10}
-RESTART_DELAY=${RESTART_DELAY:-2}
-
-# Process tracking
-SERVER_PID=""
-CLIENT_PID=""
-PARENT_PID=$$
-STOP_FLAG_FILE="/tmp/dev_sh_stop_$$"
-CLEANUP_DONE=false
-
-mkdir -p "${LOG_DIR}"
-
-# Redirect all stdout/stderr to both terminal and log file
-DEV_STD_LOG="${LOG_DIR}/dev.std.log"
-exec > >(tee -a "$DEV_STD_LOG") 2>&1
-
-# Log event to dev.log with timestamp
-log_event() {
-  local level=$1
-  local process_name=$2
-  local message=$3
-  local msg="[$(date '+%Y-%m-%d %H:%M:%S')] [${level}] [${process_name}] ${message}"
-  echo "$msg"
-  echo "$msg" >> "${DEV_LOG}"
-}
-
-# Check if PID is valid (positive integer and process exists)
-is_valid_pid() {
-  local pid=$1
-  [[ -n "$pid" ]] && [[ "$pid" =~ ^[0-9]+$ ]] && [[ "$pid" -gt 0 ]] && kill -0 "$pid" 2>/dev/null
-}
-
-# Check if parent process is still alive
-is_parent_alive() {
-  kill -0 "$PARENT_PID" 2>/dev/null
-}
-
-# Check if should stop (parent exited or stop flag exists)
-should_stop() {
-  [[ -f "$STOP_FLAG_FILE" ]] || ! is_parent_alive
-}
-
-# Kill entire process tree (process and all descendants)
-kill_tree() {
-  local pid=$1
-  local signal=${2:-TERM}
-
-  # Get all descendant PIDs
-  local children
-  children=$(pgrep -P "$pid" 2>/dev/null) || true
-
-  # Recursively kill children first
-  for child in $children; do
-    kill_tree "$child" "$signal"
-  done
-
-  # Kill the process itself
-  if kill -0 "$pid" 2>/dev/null; then
-    kill -"$signal" "$pid" 2>/dev/null || true
-  fi
-}
-
-# Start a process with supervision
-# $1: name
-# $2: command
-# $3: cleanup port for orphan processes (optional)
-start_supervised_process() {
-  local name=$1
-  local cmd=$2
-  local cleanup_port=${3:-""}
-  local log_file="${LOG_DIR}/${name}.std.log"
-
-  (
-    local restart_count=0
-    local child_pid=""
-    local max_delay=60  # Maximum delay in seconds
-
-    # Handle signals to kill child process tree
-    trap 'if [[ -n "$child_pid" ]]; then kill_tree "$child_pid" TERM; fi' TERM INT
-
-    while true; do
-      # Check if we should stop (parent exited or stop flag)
-      if should_stop; then
-        log_event "INFO" "$name" "Process stopped (parent exited or user requested)"
-        break
-      fi
-
-      # Start command in background and capture output with timestamps
-      eval "$cmd" > >(
-        while IFS= read -r line; do
-          local msg="[$(date '+%Y-%m-%d %H:%M:%S')] [${name}] ${line}"
-          echo "$msg"
-          echo "$msg" >> "$log_file"
-        done
-      ) 2>&1 &
-      child_pid=$!
-
-      log_event "INFO" "$name" "Process started (PID: ${child_pid}): ${cmd}"
-
-      # Wait for child to exit
-      set +e
-      wait "$child_pid"
-      exit_code=$?
-      set -e
-
-      # Kill entire process tree to avoid orphans
-      if [[ -n "$child_pid" ]]; then
-        kill_tree "$child_pid" TERM
-        sleep 0.5
-        kill_tree "$child_pid" KILL
-      fi
-      child_pid=""
-
-      # Cleanup orphan processes by port (for processes that escaped kill_tree)
-      if [[ -n "$cleanup_port" ]]; then
-        local orphan_pids
-        orphan_pids=$(lsof -ti ":${cleanup_port}" 2>/dev/null) || true
-        if [[ -n "$orphan_pids" ]]; then
-          log_event "WARN" "$name" "Killing orphan processes on port ${cleanup_port}: $(echo $orphan_pids | tr '\n' ' ')"
-          echo "$orphan_pids" | xargs kill -9 2>/dev/null || true
-          sleep 0.5
-        fi
-      fi
-
-      # Check if we should stop (parent exited or stop flag)
-      if should_stop; then
-        log_event "INFO" "$name" "Process stopped (parent exited or user requested)"
-        break
-      fi
-
-      # Process exited unexpectedly, restart
-      restart_count=$((restart_count + 1))
-
-      if [[ $restart_count -ge $MAX_RESTART_COUNT ]]; then
-        log_event "ERROR" "$name" "Max restart count (${MAX_RESTART_COUNT}) reached, giving up"
-        break
-      fi
-
-      # Exponential backoff: delay = RESTART_DELAY * 2^(restart_count-1), capped at max_delay
-      local delay=$((RESTART_DELAY * (1 << (restart_count - 1))))
-      if [[ $delay -gt $max_delay ]]; then
-        delay=$max_delay
-      fi
-
-      log_event "WARN" "$name" "Process exited with code ${exit_code}, restarting (${restart_count}/${MAX_RESTART_COUNT}) in ${delay}s..."
-      sleep "$delay"
-    done
-  ) &
-}
-
-# Cleanup function
-cleanup() {
-  # Prevent multiple cleanup calls
-  if [[ "$CLEANUP_DONE" == "true" ]]; then
-    return
-  fi
-  CLEANUP_DONE=true
-
-  log_event "INFO" "main" "Shutting down all processes..."
-
-  # Create stop flag to signal child processes
-  touch "$STOP_FLAG_FILE"
-
-  # Kill entire process trees (TERM first)
-  for pid in $SERVER_PID $CLIENT_PID; do
-    if is_valid_pid "$pid"; then
-      log_event "INFO" "main" "Stopping process tree (PID: ${pid})"
-      kill_tree "$pid" TERM
-    fi
-  done
-
-  # Kill any remaining background jobs
-  local bg_pids
-  bg_pids=$(jobs -p 2>/dev/null) || true
-  if [[ -n "$bg_pids" ]]; then
-    for pid in $bg_pids; do
-      kill_tree "$pid" TERM
-    done
-  fi
-
-  # Wait for processes to terminate
-  sleep 1
-
-  # Force kill if still running
-  for pid in $SERVER_PID $CLIENT_PID; do
-    if is_valid_pid "$pid"; then
-      log_event "WARN" "main" "Force killing process tree (PID: ${pid})"
-      kill_tree "$pid" KILL
-    fi
-  done
-
-  # Cleanup stop flag
-  rm -f "$STOP_FLAG_FILE"
-
-  log_event "INFO" "main" "All processes stopped"
-}
-
-# Set up signal handlers
-trap cleanup EXIT INT TERM HUP
-
-# Remove any stale stop flag
-rm -f "$STOP_FLAG_FILE"
-
-# Initialize dev.log
-echo "" >> "${DEV_LOG}"
-log_event "INFO" "main" "========== Dev session started =========="
-
-# Initialize action plugins before starting dev servers
-echo "🔌 Initializing action plugins..."
-if fullstack-cli action-plugin init; then
-  echo "✅ Action plugins initialized"
-else
-  echo "⚠️  Action plugin initialization failed, continuing anyway..."
-fi
-echo ""
-
-# Start server (cleanup orphan processes on SERVER_PORT)
-start_supervised_process "server" "npm run dev:server" "${SERVER_PORT:-3000}"
-SERVER_PID=$!
-log_event "INFO" "server" "Supervisor started with PID ${SERVER_PID}"
-
-# Start client (cleanup orphan processes on CLIENT_DEV_PORT)
-start_supervised_process "client" "npm run dev:client" "${CLIENT_DEV_PORT:-8080}"
-CLIENT_PID=$!
-log_event "INFO" "client" "Supervisor started with PID ${CLIENT_PID}"
-
-log_event "INFO" "main" "All processes started, monitoring..."
-echo ""
-echo "📋 Dev processes running. Press Ctrl+C to stop."
-echo "📄 Logs: ${DEV_STD_LOG}"
-echo ""
-
-# Wait for all background processes
-wait
+exec node "$(dirname "$0")/dev.js" "$@"

package/templates/scripts/prune-smart.js

@@ -6,11 +6,12 @@ const fs = require('fs');
 const path = require('path');
 
 const ROOT_DIR = path.resolve(__dirname, '..');
-const DIST_SERVER_DIR = path.join(ROOT_DIR, 'dist/server');
+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');
 const ROOT_NODE_MODULES = path.join(ROOT_DIR, 'node_modules');
-const OUT_NODE_MODULES = path.join(ROOT_DIR, 'dist/node_modules');
-const OUT_PACKAGE_JSON = path.join(DIST_SERVER_DIR, 'package.json');
+const OUT_NODE_MODULES = path.join(DIST_DIR, 'node_modules');
+const OUT_PACKAGE_JSON = path.join(DIST_DIR, 'package.json');
 
 // Server 入口文件
 const SERVER_ENTRY = path.join(DIST_SERVER_DIR, 'main.js');
@@ -294,9 +295,6 @@ async function smartPrune() {
     version: originalPackage.version,
     private: true,
     dependencies: prunedDependencies,
-    scripts: {
-      start: originalPackage.scripts?.start || 'node main.js'
-    },
     engines: originalPackage.engines
   };
 

package/templates/scripts/run.sh

@@ -2,4 +2,7 @@
 # This file is auto-generated by @lark-apaas/fullstack-cli
 
 # 生产环境下，启动服务
-npm run start
+# 从 dist/ 根目录执行，确保 process.cwd() 与 dev 模式一致
+# dev: cwd = 项目根, shared/ client/ 可达
+# prod: cwd = dist/,  shared/ client/ 可达
+NODE_ENV=production node server/main.js