@coze-arch/cli 0.1.5 → 0.1.8-alpha.2ee669

package/lib/__templates__/taro/.cozeproj/scripts/prepare-node-modules.sh

@@ -0,0 +1,380 @@
+#!/usr/bin/env bash
+# Install dependencies on local disk and expose them to the source tree by symlink.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+if [ "$(basename "$(dirname "$SCRIPT_DIR")")" = ".cozeproj" ]; then
+  PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd -P)"
+else
+  PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
+fi
+
+command -v pnpm >/dev/null 2>&1 || {
+  echo "[node_modules] pnpm is required" >&2
+  exit 1
+}
+
+DRIVE_ROOT="${COZE_DRIVE_ROOT:-/Coze/Drive}"
+if [ -d "$DRIVE_ROOT" ]; then
+  DRIVE_ROOT="$(cd "$DRIVE_ROOT" && pwd -P)"
+else
+  DRIVE_ROOT="${DRIVE_ROOT%/}"
+fi
+case "$PROJECT_ROOT" in
+  "$DRIVE_ROOT"|"$DRIVE_ROOT"/*) ;;
+  *)
+    (cd "$PROJECT_ROOT" && pnpm install "$@")
+    exit 0
+    ;;
+esac
+
+NM_ROOT="/tmp/nm"
+PROJECT_ID="$(basename "$PROJECT_ROOT")-$(printf '%s' "$PROJECT_ROOT" | cksum | awk '{print $1}')"
+mkdir -p "$NM_ROOT"
+WORK_DIR="$NM_ROOT/$PROJECT_ID"
+case "$WORK_DIR" in
+  "$DRIVE_ROOT"|"$DRIVE_ROOT"/*)
+    echo "[node_modules] local dependency directory must not be on Coze Drive: $WORK_DIR" >&2
+    exit 1
+    ;;
+esac
+
+LOCK_DIR="$NM_ROOT/$PROJECT_ID.lock"
+LOCK_TIMEOUT_SECONDS="${COZE_NODE_MODULES_LOCK_TIMEOUT_SECONDS:-120}"
+case "$LOCK_TIMEOUT_SECONDS" in
+  ''|*[!0-9]*|0)
+    echo "[node_modules] COZE_NODE_MODULES_LOCK_TIMEOUT_SECONDS must be a positive integer" >&2
+    exit 1
+    ;;
+esac
+
+lock_owner_is_alive() {
+  local owner_pid=""
+  [ -f "$LOCK_DIR/pid" ] || return 1
+  IFS= read -r owner_pid < "$LOCK_DIR/pid" || return 1
+  case "$owner_pid" in
+    ''|*[!0-9]*) return 1 ;;
+  esac
+  kill -0 "$owner_pid" 2>/dev/null
+}
+
+release_lock() {
+  local owner_pid=""
+  [ -f "$LOCK_DIR/pid" ] || return 0
+  IFS= read -r owner_pid < "$LOCK_DIR/pid" || true
+  if [ "$owner_pid" = "$$" ]; then
+    rm -f "$LOCK_DIR/pid"
+    rmdir "$LOCK_DIR" 2>/dev/null || true
+  fi
+}
+
+lock_started_at="$(date +%s)"
+missing_owner_checks=0
+while ! mkdir "$LOCK_DIR" 2>/dev/null; do
+  if lock_owner_is_alive; then
+    missing_owner_checks=0
+  else
+    missing_owner_checks=$((missing_owner_checks + 1))
+    if [ "$missing_owner_checks" -ge 2 ]; then
+      stale_lock_dir="$LOCK_DIR.stale.$$"
+      if mv "$LOCK_DIR" "$stale_lock_dir" 2>/dev/null; then
+        echo "[node_modules] Recovering stale dependency preparation lock."
+        rm -rf "$stale_lock_dir"
+      fi
+      missing_owner_checks=0
+      continue
+    fi
+  fi
+
+  lock_now="$(date +%s)"
+  if [ $((lock_now - lock_started_at)) -ge "$LOCK_TIMEOUT_SECONDS" ]; then
+    echo "[node_modules] Timed out waiting ${LOCK_TIMEOUT_SECONDS}s for dependency preparation lock: $LOCK_DIR" >&2
+    exit 1
+  fi
+  echo "[node_modules] Waiting for another dependency preparation for this project..."
+  sleep 1
+done
+printf '%s\n' "$$" > "$LOCK_DIR/pid"
+trap release_lock EXIT
+
+mkdir -p "$WORK_DIR"
+INSTALL_STATE_FILE="$WORK_DIR/.install-state"
+
+# Previous versions mirrored the whole project into WORK_DIR. That gives pnpm
+# and framework dev servers two paths for the same source tree, which breaks
+# file watching and on-demand compilation. Keep only managed local outputs.
+cleanup_legacy_workspace() {
+  local workspace_dir="$1" entry name
+  if [ -L "$workspace_dir" ] || { [ -e "$workspace_dir" ] && [ ! -d "$workspace_dir" ]; }; then
+    rm -rf "$workspace_dir"
+    return
+  fi
+  if [ ! -d "$workspace_dir" ]; then
+    return 0
+  fi
+
+  while IFS= read -r -d '' entry; do
+    name="$(basename "$entry")"
+    [ "$name" = "node_modules" ] || rm -rf "$entry"
+  done < <(find "$workspace_dir" -mindepth 1 -maxdepth 1 -print0)
+}
+
+# Preserve existing project caches during dependency preparation.
+cleanup_legacy_shadow_project() {
+  local entry name
+  while IFS= read -r -d '' entry; do
+    name="$(basename "$entry")"
+    case "$name" in
+      node_modules|client|server|caches|.install-state) continue ;;
+    esac
+    rm -rf "$entry"
+  done < <(find "$WORK_DIR" -mindepth 1 -maxdepth 1 -print0)
+
+  for workspace in client server; do
+    cleanup_legacy_workspace "$WORK_DIR/$workspace"
+  done
+}
+
+link_install_entry() {
+  local source_path="$1" target_path="$2"
+  rm -rf "$target_path"
+  if [ -e "$source_path" ]; then
+    ln -s "$source_path" "$target_path"
+  fi
+}
+
+hash_install_input() {
+  if command -v sha256sum >/dev/null 2>&1; then
+    sha256sum | awk '{print $1}'
+  elif command -v shasum >/dev/null 2>&1; then
+    shasum -a 256 | awk '{print $1}'
+  else
+    cksum | awk '{print $1 "-" $2}'
+  fi
+}
+
+append_file_to_install_fingerprint() {
+  local relative_path="$1"
+  local source_path="$PROJECT_ROOT/$relative_path"
+  printf 'path=%s\n' "$relative_path"
+  if [ -f "$source_path" ]; then
+    cat "$source_path"
+  else
+    printf '<missing>\n'
+  fi
+}
+
+append_directory_to_install_fingerprint() {
+  local relative_path="$1"
+  local source_path="$PROJECT_ROOT/$relative_path"
+  local file
+  printf 'path=%s\n' "$relative_path"
+  if [ ! -d "$source_path" ]; then
+    printf '<missing>\n'
+    return
+  fi
+
+  while IFS= read -r file; do
+    printf 'file=%s\n' "${file#"${PROJECT_ROOT}/"}"
+    cat "$file"
+  done < <(find -P "$source_path" -type f -print | LC_ALL=C sort)
+}
+
+# Everything that can change the resolved dependency tree. The leading version marker
+# invalidates every stored state when this scheme itself changes.
+calculate_install_fingerprint() {
+  local filename workspace argument
+  {
+    printf 'prepare-node-modules-install-state=1\n'
+    printf 'node-version=%s\n' "$(node --version)"
+    printf 'pnpm-version=%s\n' "$(pnpm --version)"
+    printf 'node-env=%s\n' "${NODE_ENV:-}"
+    printf 'npm-config-production=%s\n' "${npm_config_production:-}"
+    printf 'npm-config-production-upper=%s\n' "${NPM_CONFIG_PRODUCTION:-}"
+    printf 'pnpm-config-production=%s\n' "${PNPM_CONFIG_PRODUCTION:-}"
+    for argument in "$@"; do
+      printf 'install-argument=%s\n' "$argument"
+    done
+    for filename in package.json pnpm-lock.yaml pnpm-workspace.yaml .npmrc; do
+      append_file_to_install_fingerprint "$filename"
+    done
+    for workspace in client server; do
+      append_file_to_install_fingerprint "$workspace/package.json"
+    done
+    append_directory_to_install_fingerprint patches
+  } | hash_install_input
+}
+
+install_requires_refresh() {
+  local argument
+  for argument in "$@"; do
+    case "$argument" in
+      --force|-f|--lockfile-only|--fix-lockfile) return 0 ;;
+    esac
+  done
+  return 1
+}
+
+# Reuse skips pnpm install entirely, so it must not skip side effects that live outside
+# node_modules. preinstall is exempt: it only guards which package manager may run, and
+# there is no install to guard when the tree is already in place.
+package_has_install_lifecycle() {
+  local package_path="$1"
+  node - "$package_path" <<'NODE'
+const fs = require('node:fs');
+const [packagePath] = process.argv.slice(2);
+
+try {
+  const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  const scripts = packageJson && typeof packageJson.scripts === 'object' && packageJson.scripts
+    ? packageJson.scripts
+    : {};
+  const hasLifecycle = ['install', 'postinstall', 'prepare'].some(
+    name => typeof scripts[name] === 'string' && scripts[name].trim() !== '',
+  );
+
+  process.exit(hasLifecycle ? 0 : 1);
+} catch {
+  process.exit(0);
+}
+NODE
+}
+
+install_reuse_is_safe() {
+  local workspace package_path
+  for package_path in "$PROJECT_ROOT/.pnpmfile.cjs" "$PROJECT_ROOT/.pnpmfile.js"; do
+    if [ -e "$package_path" ]; then
+      echo "[node_modules] Reinstalling because pnpm hooks are present: $package_path"
+      return 1
+    fi
+  done
+
+  if [ -f "$PROJECT_ROOT/.npmrc" ] && grep -Eq '^[[:space:]]*pnpmfile[[:space:]]*=' "$PROJECT_ROOT/.npmrc"; then
+    echo "[node_modules] Reinstalling because .npmrc configures a pnpm hook."
+    return 1
+  fi
+
+  for workspace in . client server; do
+    package_path="$PROJECT_ROOT/$workspace/package.json"
+    [ -f "$package_path" ] || continue
+    if package_has_install_lifecycle "$package_path"; then
+      echo "[node_modules] Reinstalling because $package_path has an install lifecycle script."
+      return 1
+    fi
+  done
+  return 0
+}
+
+dependencies_are_ready() {
+  local workspace
+  [ -f "$WORK_DIR/node_modules/.modules.yaml" ] || return 1
+  for workspace in client server; do
+    if [ -f "$PROJECT_ROOT/$workspace/package.json" ] &&
+      [ ! -f "$WORK_DIR/$workspace/node_modules/.modules.yaml" ]; then
+      return 1
+    fi
+  done
+  return 0
+}
+
+# 判断顺序按代价从小到大排。指纹要读云盘上的 lockfile 和整个 patches/，所以放最后：只有其余
+# 条件都满足、确实可能复用时才付这份开销。build.sh 和 prepare.sh 不设开关，第一行就返回了。
+install_can_be_reused() {
+  local installed_fingerprint=""
+
+  [ "${COZE_REUSE_NODE_MODULES:-}" = "1" ] || return 1
+  install_requires_refresh "$@" && return 1
+  [ -f "$INSTALL_STATE_FILE" ] || return 1
+  IFS= read -r installed_fingerprint < "$INSTALL_STATE_FILE" || return 1
+  dependencies_are_ready || return 1
+  install_reuse_is_safe || return 1
+  [ "$installed_fingerprint" = "$(calculate_install_fingerprint "$@")" ] || return 1
+  return 0
+}
+
+write_install_state() {
+  local fingerprint="$1" temporary_state
+  temporary_state="$(mktemp "$WORK_DIR/.install-state.XXXXXX")"
+  printf '%s\n' "$fingerprint" > "$temporary_state"
+  mv -f "$temporary_state" "$INSTALL_STATE_FILE"
+}
+
+copy_install_metadata() {
+  local filename source_file target_file workspace
+  for filename in pnpm-lock.yaml pnpm-workspace.yaml .npmrc; do
+    source_file="$PROJECT_ROOT/$filename"
+    target_file="$WORK_DIR/$filename"
+    rm -f "$target_file"
+    if [ -f "$source_file" ]; then
+      cp "$source_file" "$target_file"
+    fi
+  done
+
+  link_install_entry "$PROJECT_ROOT/package.json" "$WORK_DIR/package.json"
+  link_install_entry "$PROJECT_ROOT/patches" "$WORK_DIR/patches"
+  link_install_entry "$PROJECT_ROOT/scripts" "$WORK_DIR/scripts"
+
+  for workspace in client server; do
+    if [ -f "$PROJECT_ROOT/$workspace/package.json" ]; then
+      mkdir -p "$WORK_DIR/$workspace"
+      link_install_entry "$PROJECT_ROOT/$workspace/package.json" "$WORK_DIR/$workspace/package.json"
+      link_install_entry "$PROJECT_ROOT/$workspace/scripts" "$WORK_DIR/$workspace/scripts"
+    else
+      rm -rf "$WORK_DIR/$workspace"
+    fi
+  done
+}
+
+link_node_modules() {
+  local source_dir="$1" target_dir="$2"
+  local current=""
+  mkdir -p "$target_dir"
+  if [ -L "$source_dir/node_modules" ]; then
+    current="$(readlink "$source_dir/node_modules")"
+    case "$current" in
+      "$NM_ROOT"/*/node_modules|"$NM_ROOT"/*/*/node_modules) ;;
+      *)
+        echo "[node_modules] refusing to replace unmanaged symlink: $source_dir/node_modules" >&2
+        exit 1
+        ;;
+    esac
+    rm "$source_dir/node_modules"
+  elif [ -e "$source_dir/node_modules" ]; then
+    rm -rf "$source_dir/node_modules"
+  fi
+  ln -s "$target_dir" "$source_dir/node_modules"
+}
+
+cleanup_legacy_shadow_project
+copy_install_metadata
+
+if install_can_be_reused "$@"; then
+  echo "[node_modules] Reusing unchanged dependencies in $WORK_DIR"
+else
+  # A stale state file must not survive a failed install.
+  rm -f "$INSTALL_STATE_FILE"
+  echo "[node_modules] Installing dependencies in $WORK_DIR"
+  if ! (cd "$WORK_DIR" && pnpm install "$@"); then
+    exit 1
+  fi
+
+  if [ -f "$WORK_DIR/pnpm-lock.yaml" ]; then
+    temporary_lockfile="$(mktemp "$PROJECT_ROOT/.pnpm-lock.yaml.XXXXXX")"
+    cp "$WORK_DIR/pnpm-lock.yaml" "$temporary_lockfile"
+    chmod 0644 "$temporary_lockfile"
+    mv -f "$temporary_lockfile" "$PROJECT_ROOT/pnpm-lock.yaml"
+  fi
+
+  # pnpm may have rewritten the lockfile, so record the fingerprint of the tree as it
+  # now stands. Otherwise the next run would see a changed input and reinstall.
+  write_install_state "$(calculate_install_fingerprint "$@")"
+fi
+
+link_node_modules "$PROJECT_ROOT" "$WORK_DIR/node_modules"
+for workspace in client server; do
+  if [ -f "$PROJECT_ROOT/$workspace/package.json" ]; then
+    link_node_modules "$PROJECT_ROOT/$workspace" "$WORK_DIR/$workspace/node_modules"
+  fi
+done
+
+echo "[node_modules] Dependencies ready"

package/lib/__templates__/taro/.cozeproj/scripts/taro-build.cjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/* eslint-disable @typescript-eslint/no-require-imports -- Standalone CommonJS runtime shipped without CLI dependencies. */
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+const scriptRoot = fs.realpathSync(path.resolve(__dirname, '..', '..'));
+const [action, target, ...extraArgs] = process.argv.slice(2);
+const normalizedTarget = target === 'h5' ? 'web' : target;
+const taroTypeByTarget = {
+  web: 'h5',
+  weapp: 'weapp',
+  tt: 'tt',
+};
+const validTargets = new Set(['web', 'weapp', 'tt']);
+const validActions = new Set(['build', 'preview']);
+
+function run(command, args, options = {}) {
+  const child = spawn(command, args, {
+    cwd: options.cwd || process.cwd(),
+    env: options.env || process.env,
+    stdio: 'inherit',
+  });
+  child.once('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code || 0);
+  });
+  child.once('error', error => {
+    console.error(error.message);
+    process.exit(1);
+  });
+}
+
+if (!validActions.has(action) || !validTargets.has(normalizedTarget)) {
+  console.error('Usage: taro-build.cjs <build|preview> <web|weapp|tt|h5> [...args]');
+  process.exit(1);
+}
+
+if (action === 'preview' && normalizedTarget === 'web') {
+  console.error('Taro preview is only supported for weapp or tt.');
+  process.exit(1);
+}
+
+if (process.env.COZE_TARO_LOCAL_ACTIVE !== scriptRoot) {
+  run(process.execPath, [
+    path.join(scriptRoot, '.cozeproj', 'scripts', 'local-workspace.cjs'),
+    'taro-build',
+    action,
+    normalizedTarget,
+    ...extraArgs,
+  ], { cwd: scriptRoot });
+  return;
+}
+
+const taroArgs = ['exec', 'taro', 'build', '--type', taroTypeByTarget[normalizedTarget]];
+if (action === 'preview') {
+  taroArgs.push('--preview');
+}
+taroArgs.push(...extraArgs);
+
+run('pnpm', taroArgs, {
+  cwd: process.env.COZE_WORKSPACE_PATH || scriptRoot,
+});

package/lib/__templates__/taro/.cozeproj/scripts/validate.ps1

@@ -1,6 +1,8 @@
 $ErrorActionPreference = "Stop"
 
-$workspace = if ($env:COZE_WORKSPACE_PATH) { $env:COZE_WORKSPACE_PATH } else { (Get-Location).Path }
+$projectRoot = (Resolve-Path (Join-Path $PSScriptRoot "../..")).Path
+$workspace = if ($env:COZE_WORKSPACE_PATH) { $env:COZE_WORKSPACE_PATH } else { $projectRoot }
+$env:COZE_WORKSPACE_PATH = $workspace
 Set-Location $workspace
 
 & pnpm validate

package/lib/__templates__/taro/.cozeproj/scripts/validate.sh

@@ -1,6 +1,13 @@
 #!/bin/bash
 set -Eeuo pipefail
 
+ROOT_DIR="$(cd "$(dirname "$0")/../.." && pwd)"
+if [[ "${COZE_TARO_LOCAL_ACTIVE:-}" != "${ROOT_DIR}" ]]; then
+    exec node "$ROOT_DIR/.cozeproj/scripts/local-workspace.cjs" validate "$@"
+fi
+COZE_WORKSPACE_PATH="${COZE_WORKSPACE_PATH:-${ROOT_DIR}}"
+export COZE_WORKSPACE_PATH
+
 cd "${COZE_WORKSPACE_PATH}"
 
 echo "🔍 Running validate..."

package/lib/__templates__/taro/_gitignore

@@ -17,6 +17,7 @@ dist-*/
 .env.production.local
 
 # Logs
+/logs
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*

package/lib/__templates__/taro/package.json

@@ -7,9 +7,9 @@
     "build": "pnpm exec concurrently --kill-others-on-fail --kill-signal SIGKILL -n lint,tsc,web,weapp,tt,server -c red,blue,green,yellow,cyan,magenta \"pnpm lint:build\" \"pnpm tsc\" \"pnpm build:web\" \"pnpm build:weapp\" \"pnpm build:tt\" \"pnpm build:server\"",
     "build:pack": "pnpm exec concurrently --kill-others-on-fail --kill-signal SIGKILL -n weapp,tt -c yellow,cyan \"pnpm build:weapp\" \"pnpm build:tt\"",
     "build:server": "pnpm --filter server build",
-    "build:tt": "taro build --type tt",
-    "build:weapp": "taro build --type weapp",
-    "build:web": "taro build --type h5",
+    "build:tt": "node .cozeproj/scripts/taro-build.cjs build tt",
+    "build:weapp": "node .cozeproj/scripts/taro-build.cjs build weapp",
+    "build:web": "node .cozeproj/scripts/taro-build.cjs build web",
     "dev": "pnpm exec concurrently --kill-others --kill-signal SIGKILL -n web,server -c blue,green \"pnpm dev:web\" \"pnpm dev:server\"",
     "dev:server": "pnpm --filter server dev",
     "dev:tt": "taro build --type tt --watch",
@@ -22,8 +22,8 @@
     "lint:build": "eslint \"src/**/*.{js,jsx,ts,tsx,css}\" --max-warnings=0 --quiet",
     "lint:fix": "eslint \"src/**/*.{js,jsx,ts,tsx,css}\" --fix",
     "new": "taro new",
-    "preview:tt": "taro build --type tt --preview",
-    "preview:weapp": "taro build --type weapp --preview",
+    "preview:tt": "node .cozeproj/scripts/taro-build.cjs preview tt",
+    "preview:weapp": "node .cozeproj/scripts/taro-build.cjs preview weapp",
     "tsc": "npx tsc --noEmit --skipLibCheck",
     "validate": "pnpm exec concurrently --kill-others-on-fail --kill-signal SIGKILL -n lint,tsc -c red,blue \"pnpm lint:build\" \"pnpm tsc\""
   },

package/lib/__templates__/vite/.coze

@@ -9,7 +9,7 @@ run = ["bash", "./scripts/dev.sh"]
 run_win = ["powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", "./scripts/dev.ps1"]
 validate = ["bash", "./scripts/validate.sh"]
 validate_win = ["powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", "./scripts/validate.ps1"]
-deps = ["git"] # -> apt install git
+deps = ["git", "rsync"] # -> apt install git rsync
 
 [deploy]
 build = ["bash","./scripts/build.sh"]

package/lib/__templates__/vite/README.md

@@ -228,6 +228,8 @@ app.innerHTML = `
 
 **必须使用 pnpm 管理依赖**
 
+云盘开发先修改源码 `package.json`，再执行 `bash ./scripts/prepare.sh`；以下安装命令仅适用于普通本地项目。
+
 ```bash
 # ✅ 安装依赖
 pnpm install
@@ -416,3 +418,21 @@ const pool = new Pool({ connectionString: process.env.DATABASE_URL });
 2. 将整个项目上传到服务器
 3. 运行 `pnpm install --prod`
 4. 运行 `coze-dev start` 启动服务
+
+## 云盘源码与本地开发
+
+Vite、Next.js、Nuxt 的 Unix 开发脚本在 `COZE_DRIVE_ROOT`（默认 `/Coze/Drive`）内通过
+`scripts/local-workspace.cjs` 将源码用 `rsync` 同步到本机临时目录。系统需提供 Node.js、pnpm、bash 和 rsync。
+所有开发与修复仍在云盘源码目录完成，从该目录执行 `.coze` 的 `[dev]` 命令。
+
+- `prepare.sh` 同步并在本地安装依赖；安装成功且云盘依赖输入未变化时，仅将更新的锁文件回写云盘。
+- `dev.sh` 在本地镜像运行开发服务，每轮 rsync 结束后等待一秒再同步，框架监听本地文件进行热更新。
+  同步失败或依赖输入变化时停止服务；修复后重新运行 `prepare.sh` / `dev.sh`。
+- `validate.sh` 使用独立的本地 `check` 目录，避免类型生成影响正在运行的 `dev` 服务。
+- 同步排除 `.git`、`node_modules`、日志和框架输出；不要在镜像修复源码或将依赖、编译产物回传云盘。
+  日志和 PID 默认保留在源码目录的 `logs/`，实际镜像路径见脚本输出。
+
+本地镜像仅用于 `[dev].build/run/validate`。部署配置、`build.sh`、`start.sh` 保持原流程；
+普通本地目录和 Windows PowerShell 入口也保持原流程。
+存量项目通过新版 CLI 的 `coze-dev patch --dry-run` / `coze-dev patch` 升级，沿用 patch 总开关。
+仅升级完整匹配旧模板的三个 Unix 开发脚本并保留端口；自定义开发脚本、命令或同名 helper 会跳过。

package/lib/__templates__/vite/scripts/dev.ps1

@@ -56,9 +56,9 @@ $startupTimeoutSeconds = 30
 $startupDeadline = (Get-Date).AddSeconds($startupTimeoutSeconds)
 while ((Get-Date) -lt $startupDeadline) {
   if ($process.HasExited) {
-    Write-Error "Dev server exited before listening on port $port."
     Get-Content $errorLogFile -Tail 20 -ErrorAction SilentlyContinue
     Remove-Item $pidFile -Force -ErrorAction SilentlyContinue
+    Write-Error "Dev server exited before listening on port $port." -ErrorAction Continue
     exit 1
   }
 
@@ -71,9 +71,9 @@ while ((Get-Date) -lt $startupDeadline) {
   Start-Sleep -Milliseconds 200
 }
 
-Write-Error "Dev server did not listen on port $port within $startupTimeoutSeconds seconds."
 Stop-ProcessTree $process.Id
 Get-Content $errorLogFile -Tail 20 -ErrorAction SilentlyContinue
 Remove-Item $pidFile -Force -ErrorAction SilentlyContinue
+Write-Error "Dev server did not listen on port $port within $startupTimeoutSeconds seconds." -ErrorAction Continue
 exit 1
 <% } %>

package/lib/__templates__/vite/scripts/dev.sh

@@ -1,14 +1,20 @@
 #!/bin/bash
 set -Eeuo pipefail
 
+# Resolve the source project from this script, then let the Web runner choose its local mirror.
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd -P)"
+if [[ "${COZE_WEB_LOCAL_ACTIVE:-}" != "${PROJECT_ROOT}" ]]; then
+  exec node "${SCRIPT_DIR}/local-workspace.cjs" dev "$@"
+fi
+COZE_WORKSPACE_PATH="${PROJECT_ROOT}"
+
 <% if (process.env.NODE_ENV === 'test') { %>
 # 测试环境：支持环境变量覆盖端口
 PORT="${PORT:-<%= port %>}"
-COZE_WORKSPACE_PATH="${COZE_WORKSPACE_PATH:-$(pwd)}"
 DEPLOY_RUN_PORT="${DEPLOY_RUN_PORT:-${PORT}}"
 <% } else { %>
 PORT=<%= port %>
-COZE_WORKSPACE_PATH="${COZE_WORKSPACE_PATH:-$(pwd)}"
 DEPLOY_RUN_PORT="${DEPLOY_RUN_PORT:-${PORT}}"
 <% } %>
 
@@ -38,18 +44,22 @@ kill_port_if_listening
 echo "Starting express + Vite dev server on port ${DEPLOY_RUN_PORT}..."
 
 # 测试环境保持服务为前台进程，便于 e2e 收集输出并停止进程。
-exec env PORT="${DEPLOY_RUN_PORT}" pnpm tsx watch server/server.ts
+exec env PORT="${DEPLOY_RUN_PORT}" node "${SCRIPT_DIR}/local-workspace.cjs" watch pnpm tsx watch server/server.ts
 <% } else { %>
 LOG_DIR="${COZE_LOG_DIR:-${COZE_WORKSPACE_PATH}/logs}"
 LOG_FILE="${LOG_DIR}/server.log"
 PID_FILE="${LOG_DIR}/server.pid"
 
 # detached 出去的进程没人负责回收，超过这个时长就自己退出，避免端口与内存长期泄露。
-MAX_RUNTIME_SECONDS=1200
+MAX_RUNTIME_SECONDS=3600
+
+timeout_watchdog_enabled() {
+  [[ -z "${COZE_EVAL:-}" && -z "${COZE_PROJECT_TYPE:-}" ]]
+}
 
 # 真正被 detach 的是这层 bash wrapper：它是进程组 leader，组内 watchdog 到点回收整组
 # （wrapper -> pnpm -> tsx -> node）；被包的进程自己先退出时也顺手清空进程组，不留残余。
-RUN_WITH_TIMEOUT='
+RUN_WITH_TIMEOUT="$(declare -f timeout_watchdog_enabled)"'
 timeout_seconds=$1
 shift
 
@@ -57,6 +67,7 @@ shift
 child_pid=$!
 
 # 先忽略 TERM，才能在向整组发 TERM（自己也在组里）之后存活下来补一发 KILL。
+if timeout_watchdog_enabled; then
 ( trap "" TERM
   sleep "${timeout_seconds}"
   echo "[dev] 后台进程运行超过 ${timeout_seconds}s，回收进程组 $$。"
@@ -64,6 +75,7 @@ child_pid=$!
   sleep 5
   kill -KILL -- "-$$" 2>/dev/null || true
 ) &
+fi
 
 wait "${child_pid}"
 kill -KILL -- "-$$" 2>/dev/null || true
@@ -130,7 +142,7 @@ mkdir -p "${LOG_DIR}"
 
 export PORT="${DEPLOY_RUN_PORT}"
 server_pid="$(spawn_detached "${COZE_WORKSPACE_PATH}" "${LOG_FILE}" \
-  "$(command -v pnpm)" tsx watch server/server.ts)"
+  "$(command -v node)" "${SCRIPT_DIR}/local-workspace.cjs" watch "$(command -v pnpm)" tsx watch server/server.ts)"
 echo "${server_pid}" > "${PID_FILE}"
 
 sleep 1
@@ -142,7 +154,9 @@ if [[ -z "${server_pid}" ]] || ! kill -0 "${server_pid}" 2>/dev/null; then
 fi
 
 echo "Dev server started (PID: ${server_pid})."
-echo "Auto stop after ${MAX_RUNTIME_SECONDS}s."
+if timeout_watchdog_enabled; then
+  echo "Auto stop after ${MAX_RUNTIME_SECONDS}s."
+fi
 echo "Log file: ${LOG_FILE}"
 echo "PID file: ${PID_FILE}"
 <% } %>