@coze-arch/cli 0.1.8-alpha.a5ed27 → 0.1.8-alpha.a87968

package/lib/__templates__/vite/scripts/prepare-node-modules.sh

@@ -98,6 +98,7 @@ 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
@@ -118,12 +119,15 @@ cleanup_legacy_workspace() {
   done < <(find "$workspace_dir" -mindepth 1 -maxdepth 1 -print0)
 }
 
+# caches is reserved for the sibling prepare scripts of this project. They keep
+# regenerable framework output there (the Next helper points .next/dev into it), and that
+# output has to outlive an install, so this cleanup must not read it as leftover.
 cleanup_legacy_shadow_project() {
   local entry name
   while IFS= read -r -d '' entry; do
     name="$(basename "$entry")"
     case "$name" in
-      node_modules|client|server) continue ;;
+      node_modules|client|server|caches|.install-state) continue ;;
     esac
     rm -rf "$entry"
   done < <(find "$WORK_DIR" -mindepth 1 -maxdepth 1 -print0)
@@ -141,6 +145,162 @@ link_install_entry() {
   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
@@ -190,16 +350,26 @@ link_node_modules() {
 cleanup_legacy_shadow_project
 copy_install_metadata
 
-echo "[node_modules] Installing dependencies in $WORK_DIR"
-if ! (cd "$WORK_DIR" && pnpm install "$@"); then
-  exit 1
-fi
+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
 
-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"
+  # 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"

package/lib/cli.js

@@ -2114,7 +2114,7 @@ const EventBuilder = {
 };
 
 var name = "@coze-arch/cli";
-var version = "0.1.8-alpha.a5ed27";
+var version = "0.1.8-alpha.a87968";
 var description = "coze coding devtools cli";
 var license = "MIT";
 var author = "fanwenjie.fe@bytedance.com";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coze-arch/cli",
-  "version": "0.1.8-alpha.a5ed27",
+  "version": "0.1.8-alpha.a87968",
   "private": false,
   "description": "coze coding devtools cli",
   "license": "MIT",

package/lib/__templates__/taro/.cozeproj/scripts/build-on-local-disk.sh

@@ -1,194 +0,0 @@
-#!/usr/bin/env bash
-# Run one-shot Taro builds from a local shadow workspace when the project lives
-# on Coze Drive. This avoids repeated compiler stat/read traffic against the
-# network filesystem while keeping final artifacts in the project directory.
-set -Eeuo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-ROOT_DIR="$(cd "$SCRIPT_DIR/../.." && pwd -P)"
-PROJECT_ROOT="$(cd "${COZE_WORKSPACE_PATH:-$ROOT_DIR}" && pwd -P)"
-
-if [ "$#" -eq 0 ]; then
-  set -- pnpm build
-fi
-
-is_under_root() {
-  local path="$1"
-  local root="$2"
-  [ -n "$root" ] || return 1
-  case "$path" in
-    "$root"|"$root"/*) return 0 ;;
-    *) return 1 ;;
-  esac
-}
-
-is_coze_drive_workspace() {
-  local path="$1"
-  local root
-  local candidates=()
-
-  if [ -n "${COZE_DRIVE_ROOT:-}" ]; then
-    candidates+=("$COZE_DRIVE_ROOT")
-  fi
-  candidates+=("/Coze/Drive")
-
-  for root in "${candidates[@]}"; do
-    if [ -d "$root" ]; then
-      root="$(cd "$root" && pwd -P)"
-    else
-      root="${root%/}"
-    fi
-    if is_under_root "$path" "$root"; then
-      return 0
-    fi
-  done
-
-  return 1
-}
-
-prepare_dependencies() {
-  if [ "${COZE_SKIP_PREPARE_NODE_MODULES:-0}" = "1" ]; then
-    return
-  fi
-  echo "[local-build] Preparing dependencies..."
-  bash "$ROOT_DIR/.cozeproj/scripts/prepare-node-modules.sh" --prefer-frozen-lockfile --prefer-offline
-}
-
-if ! is_coze_drive_workspace "$PROJECT_ROOT"; then
-  prepare_dependencies
-  cd "$PROJECT_ROOT"
-  "$@"
-  exit $?
-fi
-
-command -v rsync >/dev/null 2>&1 || {
-  echo "[local-build] rsync is required for Coze Drive local builds" >&2
-  exit 1
-}
-
-prepare_dependencies
-
-BUILD_ROOT="${COZE_LOCAL_BUILD_ROOT:-/tmp/coze-taro-build}"
-PROJECT_ID="$(basename "$PROJECT_ROOT")-$(printf '%s' "$PROJECT_ROOT" | cksum | awk '{print $1}')"
-WORK_DIR="$BUILD_ROOT/$PROJECT_ID"
-LOCAL_WORKSPACE="$WORK_DIR/workspace"
-LOCK_DIR="$WORK_DIR.lock"
-
-mkdir -p "$BUILD_ROOT"
-if is_coze_drive_workspace "$(cd "$BUILD_ROOT" && pwd -P)"; then
-  echo "[local-build] COZE_LOCAL_BUILD_ROOT must not be on Coze Drive: $BUILD_ROOT" >&2
-  exit 1
-fi
-
-while ! mkdir "$LOCK_DIR" 2>/dev/null; do
-  echo "[local-build] Waiting for another local build for this project..."
-  sleep 1
-done
-
-cleanup() {
-  if [ -n "${SOURCE_SYNC_PID:-}" ]; then
-    kill "$SOURCE_SYNC_PID" 2>/dev/null || true
-  fi
-  rm -rf "$LOCAL_WORKSPACE"
-  rmdir "$WORK_DIR" 2>/dev/null || true
-  rmdir "$LOCK_DIR" 2>/dev/null || true
-}
-trap cleanup EXIT
-
-mkdir -p "$LOCAL_WORKSPACE"
-
-sync_source_to_local() {
-  rsync -rlgoD --checksum --delete \
-  --exclude '/.git/' \
-  --exclude '/node_modules/' \
-  --exclude '/server/node_modules/' \
-  --exclude '/logs/' \
-  --exclude '/dist/' \
-  --exclude '/dist-web/' \
-  --exclude '/dist-tt/' \
-  --exclude '/server/dist/' \
-  --exclude '/.next/' \
-  --exclude '/.nuxt/' \
-  --exclude '/.output/' \
-  --exclude '/coverage/' \
-  "$PROJECT_ROOT/" "$LOCAL_WORKSPACE/"
-}
-
-echo "[local-build] Syncing source to $LOCAL_WORKSPACE"
-sync_source_to_local
-
-link_node_modules() {
-  local source_node_modules="$1"
-  local shadow_parent="$2"
-  local shadow_node_modules="$shadow_parent/node_modules"
-  local target
-
-  if [ ! -e "$source_node_modules" ] && [ ! -L "$source_node_modules" ]; then
-    return
-  fi
-
-  if [ -L "$source_node_modules" ]; then
-    target="$(readlink "$source_node_modules")"
-  else
-    target="$source_node_modules"
-  fi
-
-  mkdir -p "$shadow_parent"
-  rm -rf "$shadow_node_modules"
-  ln -s "$target" "$shadow_node_modules"
-}
-
-link_node_modules "$PROJECT_ROOT/node_modules" "$LOCAL_WORKSPACE"
-for workspace in server; do
-  if [ -f "$PROJECT_ROOT/$workspace/package.json" ]; then
-    link_node_modules "$PROJECT_ROOT/$workspace/node_modules" "$LOCAL_WORKSPACE/$workspace"
-  fi
-done
-
-SOURCE_SYNC_PID=""
-if [ "${COZE_SYNC_SOURCE_TO_LOCAL:-0}" = "1" ]; then
-  (
-    while true; do
-      sleep "${COZE_SYNC_INTERVAL_SECONDS:-1}"
-      sync_source_to_local
-    done
-  ) &
-  SOURCE_SYNC_PID=$!
-fi
-
-rm -rf \
-  "$LOCAL_WORKSPACE/dist" \
-  "$LOCAL_WORKSPACE/dist-web" \
-  "$LOCAL_WORKSPACE/dist-tt" \
-  "$LOCAL_WORKSPACE/server/dist"
-
-echo "[local-build] Building on local disk..."
-(
-  cd "$LOCAL_WORKSPACE"
-  export COZE_WORKSPACE_PATH="$LOCAL_WORKSPACE"
-  "$@"
-)
-
-sync_output_back() {
-  local output_name="$1"
-  local local_output="$LOCAL_WORKSPACE/$output_name"
-  local project_output="$PROJECT_ROOT/$output_name"
-
-  if [ ! -e "$local_output" ]; then
-    return
-  fi
-
-  if [ -L "$project_output" ] || [ -e "$project_output" ]; then
-    rm -rf "$project_output"
-  fi
-
-  mkdir -p "$(dirname "$project_output")"
-  rsync -a --delete "$local_output/" "$project_output/"
-}
-
-echo "[local-build] Syncing build artifacts back to $PROJECT_ROOT"
-sync_output_back dist
-sync_output_back dist-web
-sync_output_back dist-tt
-sync_output_back server/dist
-echo "[local-build] Build artifacts are ready in the project directory"