feat(migrate): upgrade existing Vite+ projects across versions

.github/scripts/bun-pkg-pr-new.mjs

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+function usage() {
+  console.error(`Usage:
+  bun-pkg-pr-new.mjs is-bun-project <package.json>
+  bun-pkg-pr-new.mjs patch-package <package.json> <core-url> <vite-plus-url>
+  bun-pkg-pr-new.mjs add-core-dependency <package.json> <core-spec>
+  bun-pkg-pr-new.mjs normalize-vite-paths <project-dir> <tarball-path>`);
+  process.exit(2);
+}
+
+function readPackageJson(packageJsonPath) {
+  const text = fs.readFileSync(packageJsonPath, 'utf8');
+  return {
+    indent: text.match(/\n([\t ]+)"/)?.[1] ?? '  ',
+    pkg: JSON.parse(text),
+  };
+}
+
+function writePackageJson(packageJsonPath, pkg, indent) {
+  fs.writeFileSync(packageJsonPath, `${JSON.stringify(pkg, null, indent)}\n`);
+}
+
+function isBunProject(packageJsonPath) {
+  const { pkg } = readPackageJson(packageJsonPath);
+  const packageManager =
+    typeof pkg.packageManager === 'string' ? pkg.packageManager.split('@')[0] : undefined;
+  const devEngine = pkg.devEngines?.packageManager;
+  const devEngines = Array.isArray(devEngine) ? devEngine : [devEngine];
+  const hasBunDevEngine = devEngines.some((entry) => {
+    const name = typeof entry === 'string' ? entry : entry?.name;
+    return name === 'bun';
+  });
+  process.exit(packageManager === 'bun' || hasBunDevEngine ? 0 : 1);
+}
+
+function patchPackage(packageJsonPath, coreUrl, vitePlusUrl) {
+  const { pkg } = readPackageJson(packageJsonPath);
+  const bundledViteVersion = pkg.bundledVersions?.vite;
+
+  pkg.name = 'vite';
+  pkg.version =
+    typeof bundledViteVersion === 'string' && bundledViteVersion.length > 0
+      ? bundledViteVersion
+      : '8.0.0';
+  pkg.dependencies = {
+    ...pkg.dependencies,
+    '@voidzero-dev/vite-plus-core': coreUrl,
+    'vite-plus': vitePlusUrl,
+  };
+
+  writePackageJson(packageJsonPath, pkg, '  ');
+}
+
+function addCoreDependency(packageJsonPath, coreSpec) {
+  const { indent, pkg } = readPackageJson(packageJsonPath);
+  pkg.devDependencies ??= {};
+  pkg.devDependencies['@voidzero-dev/vite-plus-core'] = coreSpec;
+  writePackageJson(packageJsonPath, pkg, indent);
+}
+
+function normalizeVitePaths(projectDir, tarballPath) {
+  const absoluteSpec = `file:${tarballPath}`;
+  const skippedDirectories = new Set([
+    '.git',
+    '.output',
+    'build',
+    'dist',
+    'node_modules',
+    'vendor',
+  ]);
+
+  function rewriteValue(value, relativeSpec) {
+    if (value === absoluteSpec) {
+      return relativeSpec;
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => rewriteValue(item, relativeSpec));
+    }
+    if (value && typeof value === 'object') {
+      for (const [key, child] of Object.entries(value)) {
+        value[key] = rewriteValue(child, relativeSpec);
+      }
+    }
+    return value;
+  }
+
+  function visit(directory) {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const entryPath = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        if (!skippedDirectories.has(entry.name)) {
+          visit(entryPath);
+        }
+        continue;
+      }
+      if (!entry.isFile() || entry.name !== 'package.json') {
+        continue;
+      }
+
+      const text = fs.readFileSync(entryPath, 'utf8');
+      if (!text.includes(absoluteSpec)) {
+        continue;
+      }
+      const relativePath = path
+        .relative(path.dirname(entryPath), tarballPath)
+        .split(path.sep)
+        .join('/');
+      const relativeSpec = `file:${relativePath.startsWith('.') ? relativePath : `./${relativePath}`}`;
+      const pkg = rewriteValue(JSON.parse(text), relativeSpec);
+      const indent = text.match(/\n([\t ]+)"/)?.[1] ?? '  ';
+      writePackageJson(entryPath, pkg, indent);
+    }
+  }
+
+  visit(projectDir);
+}
+
+const [command, ...args] = process.argv.slice(2);
+
+switch (command) {
+  case 'is-bun-project':
+    if (args.length !== 1) {
+      usage();
+    }
+    isBunProject(...args);
+    break;
+  case 'patch-package':
+    if (args.length !== 3) {
+      usage();
+    }
+    patchPackage(...args);
+    break;
+  case 'add-core-dependency':
+    if (args.length !== 2) {
+      usage();
+    }
+    addCoreDependency(...args);
+    break;
+  case 'normalize-vite-paths':
+    if (args.length !== 2) {
+      usage();
+    }
+    normalizeVitePaths(...args);
+    break;
+  default:
+    usage();
+}

.github/scripts/ensure-pkg-pr-new-pnpm-version.mjs

@@ -0,0 +1,199 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const LATEST_PNPM_10_VERSION = '10.34.4';
+const SAFE_PNPM_11_VERSION = '11.9.0';
+const SUPPORTED_PACKAGE_MANAGERS = new Set(['pnpm', 'yarn', 'npm', 'bun']);
+
+function parseExactVersion(version) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+  if (!match) {
+    return undefined;
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4]?.split('.'),
+  };
+}
+
+function compareIdentifiers(left, right) {
+  const leftNumber = /^\d+$/.test(left) ? Number(left) : undefined;
+  const rightNumber = /^\d+$/.test(right) ? Number(right) : undefined;
+  if (leftNumber !== undefined && rightNumber !== undefined) {
+    return leftNumber - rightNumber;
+  }
+  if (leftNumber !== undefined) {
+    return -1;
+  }
+  if (rightNumber !== undefined) {
+    return 1;
+  }
+  return left.localeCompare(right);
+}
+
+function compareVersions(left, right) {
+  for (const key of ['major', 'minor', 'patch']) {
+    if (left[key] !== right[key]) {
+      return left[key] - right[key];
+    }
+  }
+  if (!left.prerelease && !right.prerelease) {
+    return 0;
+  }
+  if (!left.prerelease) {
+    return 1;
+  }
+  if (!right.prerelease) {
+    return -1;
+  }
+  const length = Math.max(left.prerelease.length, right.prerelease.length);
+  for (let index = 0; index < length; index++) {
+    const leftIdentifier = left.prerelease[index];
+    const rightIdentifier = right.prerelease[index];
+    if (leftIdentifier === undefined) {
+      return -1;
+    }
+    if (rightIdentifier === undefined) {
+      return 1;
+    }
+    const compared = compareIdentifiers(leftIdentifier, rightIdentifier);
+    if (compared !== 0) {
+      return compared;
+    }
+  }
+  return 0;
+}
+
+function safePnpmVersionFor(version) {
+  const parsed = parseExactVersion(version);
+  if (!parsed) {
+    return undefined;
+  }
+
+  // pnpm before 10.2.0 rewrites non-semver overrides into peerDependencies,
+  // causing pkg.pr.new URLs to fail peer-spec validation. Stay on the same
+  // major and use the latest v10 release containing pnpm/pnpm#9000.
+  if (parsed.major === 10 && compareVersions(parsed, parseExactVersion('10.2.0')) < 0) {
+    return LATEST_PNPM_10_VERSION;
+  }
+
+  const pnpm11Lower = parseExactVersion('11.0.0');
+  const pnpm11Upper = parseExactVersion(SAFE_PNPM_11_VERSION);
+  if (compareVersions(parsed, pnpm11Lower) >= 0 && compareVersions(parsed, pnpm11Upper) < 0) {
+    return SAFE_PNPM_11_VERSION;
+  }
+
+  return undefined;
+}
+
+function parsePackageManagerSpec(spec) {
+  const match = /^([^@]+)@(.+)$/.exec(spec);
+  return match ? { name: match[1], version: match[2] } : undefined;
+}
+
+function devEngineEntries(pkg) {
+  const value = pkg.devEngines?.packageManager;
+  if (Array.isArray(value)) {
+    return value.filter((entry) => entry && typeof entry === 'object');
+  }
+  return value && typeof value === 'object' ? [value] : [];
+}
+
+function selectedDevEngineEntry(pkg) {
+  return devEngineEntries(pkg).find(
+    (entry) => typeof entry.name === 'string' && SUPPORTED_PACKAGE_MANAGERS.has(entry.name),
+  );
+}
+
+function serializeLike(source, pkg) {
+  const indentMatch = source.match(/\n([\t ]+)"/);
+  const indent = indentMatch?.[1].startsWith('\t') ? '\t' : (indentMatch?.[1].length ?? 2);
+  const newline = source.includes('\r\n') ? '\r\n' : '\n';
+  const finalNewline = /\r?\n$/.test(source) ? newline : '';
+  return JSON.stringify(pkg, null, indent).replaceAll('\n', newline) + finalNewline;
+}
+
+function replacePackageManagerSpec(source, previousSpec, targetVersion) {
+  const pattern = /("packageManager"\s*:\s*)("(?:\\.|[^"\\])*")/g;
+  return source.replace(pattern, (match, prefix, value) => {
+    if (JSON.parse(value) !== previousSpec) {
+      return match;
+    }
+    return `${prefix}${JSON.stringify(`pnpm@${targetVersion}`)}`;
+  });
+}
+
+export function ensureSafePkgPrNewPnpmVersion(source) {
+  const pkg = JSON.parse(source);
+  const previousVersions = [];
+  let packageManagerSpec;
+  let targetVersion;
+  let devEnginesChanged = false;
+
+  if (typeof pkg.packageManager === 'string') {
+    const parsed = parsePackageManagerSpec(pkg.packageManager);
+    targetVersion = parsed?.name === 'pnpm' ? safePnpmVersionFor(parsed.version) : undefined;
+    if (!targetVersion) {
+      return { changed: false, source, previousVersions };
+    }
+    packageManagerSpec = pkg.packageManager;
+    previousVersions.push(parsed.version);
+    pkg.packageManager = `pnpm@${targetVersion}`;
+
+    // Keep exact pnpm devEngines constraints in sync with the authoritative
+    // packageManager field so the two declarations do not conflict.
+    for (const entry of devEngineEntries(pkg)) {
+      if (
+        entry.name === 'pnpm' &&
+        typeof entry.version === 'string' &&
+        safePnpmVersionFor(entry.version)
+      ) {
+        previousVersions.push(entry.version);
+        entry.version = targetVersion;
+        devEnginesChanged = true;
+      }
+    }
+  } else {
+    const selected = selectedDevEngineEntry(pkg);
+    targetVersion =
+      selected?.name === 'pnpm' && typeof selected.version === 'string'
+        ? safePnpmVersionFor(selected.version)
+        : undefined;
+    if (!targetVersion || selected?.name !== 'pnpm' || typeof selected.version !== 'string') {
+      return { changed: false, source, previousVersions };
+    }
+    previousVersions.push(selected.version);
+    selected.version = targetVersion;
+    devEnginesChanged = true;
+  }
+
+  const updatedSource = devEnginesChanged
+    ? serializeLike(source, pkg)
+    : replacePackageManagerSpec(source, packageManagerSpec, targetVersion);
+  return {
+    changed: true,
+    source: updatedSource,
+    previousVersions: [...new Set(previousVersions)],
+    version: targetVersion,
+  };
+}
+
+const invokedPath = process.argv[1] ? pathToFileURL(path.resolve(process.argv[1])).href : undefined;
+if (invokedPath === import.meta.url) {
+  const packageJsonPath = process.argv[2];
+  if (!packageJsonPath) {
+    console.error('Usage: ensure-pkg-pr-new-pnpm-version.mjs <package.json>');
+    process.exit(2);
+  }
+  const source = fs.readFileSync(packageJsonPath, 'utf8');
+  const result = ensureSafePkgPrNewPnpmVersion(source);
+  if (result.changed) {
+    fs.writeFileSync(packageJsonPath, result.source);
+    console.log(
+      `Updating project pnpm ${result.previousVersions.join(', ')} -> ${result.version} to avoid pkg.pr.new install failures`,
+    );
+  }
+}

.github/scripts/repack-vite-pr.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+pr_ref="${1:-1891}"
+project_input="${2:-$PWD}"
+
+case "$pr_ref" in
+  '' | *[![:alnum:]._-]*)
+    echo "error: PR or commit contains unsupported characters: $pr_ref" >&2
+    exit 2
+    ;;
+esac
+
+if [ ! -d "$project_input" ]; then
+  echo "error: project directory does not exist: $project_input" >&2
+  exit 2
+fi
+
+project_dir="$(cd "$project_input" && pwd -P)"
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+output_path="$project_dir/vendor/vite-plus-core-as-vite-$pr_ref.tgz"
+core_url="https://pkg.pr.new/voidzero-dev/vite-plus/@voidzero-dev/vite-plus-core@$pr_ref"
+vite_plus_url="https://pkg.pr.new/voidzero-dev/vite-plus/vite-plus@$pr_ref"
+tmp_dir="$(mktemp -d "${TMPDIR:-/tmp}/vite-plus-core-as-vite.XXXXXX")"
+
+cleanup() {
+  rm -rf "$tmp_dir"
+}
+trap cleanup EXIT
+
+curl -fsSL "$core_url" -o "$tmp_dir/vite-plus-core.tgz"
+mkdir -p "$tmp_dir/unpacked"
+tar -xzf "$tmp_dir/vite-plus-core.tgz" -C "$tmp_dir/unpacked"
+
+package_json="$tmp_dir/unpacked/package/package.json"
+if [ ! -f "$package_json" ]; then
+  echo "error: downloaded package does not contain package/package.json" >&2
+  exit 1
+fi
+
+node "$script_dir/bun-pkg-pr-new.mjs" patch-package "$package_json" "$core_url" "$vite_plus_url"
+
+mkdir -p "$(dirname "$output_path")"
+tar -czf "$output_path" -C "$tmp_dir/unpacked" package
+
+printf '%s\n' "$output_path"