Read bundled language packs directly from wp-files (#3214)

## Related issues

- Closes STU-1537 (completes the part deferred from #3125)

## How AI was used in this PR

Claude Code reconstructed the April context (#3125's deferred section,
this PR's original debug instrumentation, and the language-pack copy
races later documented in #3492), re-applied the bundle-read change
cleanly on top of current trunk.

## Proposed Changes

Language packs were the last site dependency still copied from the
read-only CLI bundle into the writable `~/.studio/server-files/` cache
on every CLI invocation. The copy was pure overhead: language packs are
only ever read at site creation, to copy the matching locale's files
into the new site's `wp-content/languages/`, and they only change when
the app ships a new bundle.

This PR has site creation read language packs directly from the bundled
`wp-files/latest/languages/`, and drops the per-invocation copy step —
shaving the remaining recursive dir-walk (~1,400 files) off CLI startup.

Side benefits:

- The copy step needed lockfile serialization (#3492) because concurrent
CLI invocations raced on the shared cache (transient `ENOENT` warnings).
With no copy and no writable cache, that bug class is gone by
construction.
- Site creation now skips the language-pack directory scans entirely for
locales we don't bundle translations for (`WP_LOCALES`).
- The existing `04-cleanup-obsolete-server-files` migration also removes
the now-unused `~/.studio/server-files/language-packs/` (and its
lockfile) on first run after upgrade.

**On the April E2E failures that deferred this:** they never reproduced
locally — neither at the CLI level (3/3 ja-locale sites healthy,
WPLANG=ja, wp-admin 200) nor with the packaged-app Playwright suites
that failed in CI back then. The Playground worker-spawn stack has been
rewritten since (#3602), and the failure was never root-caused, so CI on
this PR is the deciding signal. If mac E2E reds again, this time it
fails on a clean branch with inspectable artifacts.

## Testing Instructions

1. `npm run download-language-packs` (plain `npm install` does not
populate `wp-files/latest/languages`), then `npm run cli:build`.
2. Set a non-English locale (e.g. `"locale": "ja"` in
`~/.studio/shared.json` or via Studio Settings) and create a site.
3. Verify the site's `wp-content/languages/` contains the locale's files
(core + `plugins/` + `themes/`), wp-admin loads in that language, and
Settings → General shows the locale selected under Site Language.
4. Verify `~/.studio/server-files/language-packs/` is deleted on first
CLI run after upgrade and is not recreated.
5. Covered by e2e `localization.test.ts` (locale site creation + WPLANG)
and `blueprints.test.ts` (blueprint provisioning).

Verified locally on macOS arm64: typecheck, eslint, full unit suite
(1963 tests), packaged-app e2e `localization.test.ts` 4/4 (twice) and
`blueprints.test.ts` 6/6.

## Pre-merge Checklist

- [x] Have you checked for TypeScript, React or other console errors?

Author: bcotrim

apps/cli/lib/dependency-management/paths.ts

@@ -62,8 +62,10 @@ export function getSqliteCommandPath(): string {
 	return path.join( getWpFilesPath(), SQLITE_COMMAND_DIRNAME );
 }
 
+// Language packs ship read-only with the CLI bundle and are copied into each site's
+// `wp-content/languages/` directory on site create. No writable cache needed.
 export function getLanguagePacksPath(): string {
-	return path.join( getServerFilesPath(), 'language-packs' );
+	return path.join( getWpFilesPath(), 'latest', 'languages' );
 }
 
 // AI instructions ship read-only with the CLI bundle and are installed into each site's

apps/cli/lib/dependency-management/setup.ts

@@ -1,12 +1,9 @@
 import fs from 'fs';
 import path from 'path';
-import { LOCKFILE_STALE_TIME, LOCKFILE_WAIT_TIME } from '@studio/common/constants';
 import { recursiveCopyDirectory } from '@studio/common/lib/fs-utils';
-import { lockFileAsync, unlockFileAsync } from '@studio/common/lib/lockfile';
 import semver from 'semver';
 import { readCliConfig, updateCliConfigWithPartial } from 'cli/lib/cli-config/core';
-import { getLanguagePacksPath, getWordPressVersionPath, getWpFilesPath } from './paths';
-import { areDirectoriesDifferentBySizeAndMtime } from './utils';
+import { getWordPressVersionPath, getWpFilesPath } from './paths';
 import { getWordPressVersionFromInstallation, updateLatestWordPressVersion } from './wordpress';
 
 // Compare the WordPress version in the bundled `wp-files/latest/wordpress` directory (that ships
@@ -38,40 +35,9 @@ async function copyBundledLatestWpVersion() {
 	}
 }
 
-async function copyBundledLanguagePacks() {
-	const sourceLanguagePacksPath = path.join( getWpFilesPath(), 'latest', 'languages' );
-	if ( ! fs.existsSync( sourceLanguagePacksPath ) ) {
-		return;
-	}
-	const targetLanguagePacksPath = getLanguagePacksPath();
-	const lockPath = `${ targetLanguagePacksPath }.lock`;
-	await fs.promises.mkdir( path.dirname( lockPath ), { recursive: true } );
-	await lockFileAsync( lockPath, {
-		wait: LOCKFILE_WAIT_TIME,
-		stale: LOCKFILE_STALE_TIME,
-	} );
-	try {
-		const isSourceDirectoryDifferent = await areDirectoriesDifferentBySizeAndMtime(
-			sourceLanguagePacksPath,
-			targetLanguagePacksPath
-		);
-		if ( isSourceDirectoryDifferent ) {
-			try {
-				await fs.promises.rm( targetLanguagePacksPath, { recursive: true, force: true } );
-			} catch {
-				// Do nothing if the target directory is missing or corrupted
-			}
-			await recursiveCopyDirectory( sourceLanguagePacksPath, targetLanguagePacksPath );
-		}
-	} finally {
-		await unlockFileAsync( lockPath );
-	}
-}
-
 export async function setupServerFiles() {
 	const steps: [ string, () => Promise< void > ][] = [
 		[ 'WordPress version', copyBundledLatestWpVersion ],
-		[ 'language packs', copyBundledLanguagePacks ],
 	];
 
 	for ( const [ name, step ] of steps ) {

apps/cli/lib/dependency-management/utils.ts

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { pathExists } from '@studio/common/lib/fs-utils';
+import { WP_LOCALES } from '@studio/common/lib/wp-locales';
 import { getLanguagePacksPath } from 'cli/lib/dependency-management/paths';
 
 /**
@@ -51,6 +52,12 @@ export async function copyLanguagePackToSite(
 	sitePath: string,
 	wpLocale: string
 ): Promise< boolean > {
+	// Translations are only bundled for `WP_LOCALES`; skip the readdir() calls over the
+	// ~1,400-entry bundled languages directories when no files could match anyway.
+	if ( ! WP_LOCALES.includes( wpLocale ) ) {
+		return false;
+	}
+
 	const languagePacksDir = getLanguagePacksPath();
 	if ( ! ( await pathExists( languagePacksDir ) ) ) {
 		return false;

apps/cli/lib/language-packs.ts

@@ -7,6 +7,7 @@
  *   - `phpmyadmin/` (phpMyAdmin)
  *   - `wp-cli.phar` (WP-CLI)
  *   - `wordpress-versions/latest/available-site-translations.json`
+ *   - `language-packs/` (WordPress translations, plus its lockfile)
  *
  * Safe to re-run: `needsToRun()` checks for the presence of any obsolete
  * entry, and `run()` tolerates missing paths.
@@ -31,6 +32,8 @@ function getObsoletePaths(): string[] {
 			'latest',
 			'available-site-translations.json'
 		),
+		path.join( serverFilesPath, 'language-packs' ),
+		path.join( serverFilesPath, 'language-packs.lock' ),
 	];
 }