@playcraft/devkit 1.0.31-beta.1 → 1.0.31-beta.11

package/core/engines/cocos/theme-assets.js

@@ -1,3 +1,162 @@
-"use strict";const fs=require("fs");const path=require("path");const JSON5=require("json5");const{getBase64FromFile,getAllFilesFromDir}=require("./fs");const{THEME_ASSET_EXT}=require("./constants");const{validateThemeData}=require("../../utils/validateThemeData");function detectCurrentTheme(projectRoot,themeConfig){const entryFile=themeConfig&&themeConfig.entryFile||"src/theme/index.ts";const entryPath=path.join(projectRoot,entryFile);if(!fs.existsSync(entryPath))return null;const content=fs.readFileSync(entryPath,"utf8");const match=content.match(/from\s+['"]\.\/([^'"]+)['"]/);return match?match[1]:null}function collectDirAssets(assetsDir,keyPrefix){const map={};if(!fs.existsSync(assetsDir))return map;const root=assetsDir.replace(/\\/g,"/");for(const filePath of getAllFilesFromDir(assetsDir)){if(!THEME_ASSET_EXT.test(filePath))continue;const rel=filePath.replace(/\\/g,"/").slice(root.length).replace(/^\//,"");map[`${keyPrefix}${rel}`]=getBase64FromFile(filePath)}return map}function collectReferencedFiles(projectRoot,sourceDir,themeName,mergedData,assetRecord){if(!mergedData||typeof mergedData!=="object")return;const themeRoot=path.join(projectRoot,sourceDir,themeName);for(const value of Object.values(mergedData)){if(typeof value==="string"){if(assetRecord[value])continue;const rel=value.replace(/^\.\//,"");const candidates=[path.join(themeRoot,rel),path.join(themeRoot,"assets",path.basename(rel)),path.resolve(projectRoot,rel)];const abs=candidates.find(p=>fs.existsSync(p)&&fs.statSync(p).isFile()&&THEME_ASSET_EXT.test(p));if(abs)assetRecord[value]=getBase64FromFile(abs)}else if(value&&typeof value==="object"&&!Array.isArray(value)){collectReferencedFiles(projectRoot,sourceDir,themeName,value,assetRecord)}}}function loadThemeI18n(projectRoot,sourceDir,themeName){const p=path.join(projectRoot,sourceDir,themeName,"theme.i18n.runtime.json5");if(!fs.existsSync(p))return{};try{return JSON5.parse(fs.readFileSync(p,"utf8"))||{}}catch{return{}}}/**
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const JSON5 = require('json5');
+const { getBase64FromFile, getAllFilesFromDir, sniffAudioMime } = require('./fs');
+const { THEME_ASSET_EXT } = require('./constants');
+const { validateThemeData } = require('../../utils/validateThemeData');
+
+function detectCurrentTheme(projectRoot, themeConfig) {
+  const entryFile = (themeConfig && themeConfig.entryFile) || 'src/theme/index.ts';
+  const entryPath = path.join(projectRoot, entryFile);
+  if (!fs.existsSync(entryPath)) return null;
+  const content = fs.readFileSync(entryPath, 'utf8');
+  const match = content.match(/from\s+['"]\.\/([^'"]+)['"]/);
+  return match ? match[1] : null;
+}
+
+function isInlinableThemeAsset(filePath) {
+  if (THEME_ASSET_EXT.test(filePath)) return true;
+  try {
+    return Boolean(sniffAudioMime(fs.readFileSync(filePath)));
+  } catch {
+    return false;
+  }
+}
+
+function collectDirAssets(assetsDir, keyPrefix) {
+  const map = {};
+  if (!fs.existsSync(assetsDir)) return map;
+  const root = assetsDir.replace(/\\/g, '/');
+  for (const filePath of getAllFilesFromDir(assetsDir)) {
+    if (!isInlinableThemeAsset(filePath)) continue;
+    const rel = filePath.replace(/\\/g, '/').slice(root.length).replace(/^\//, '');
+    map[`${keyPrefix}${rel}`] = getBase64FromFile(filePath);
+  }
+  return map;
+}
+
+function collectReferencedFiles(projectRoot, sourceDir, themeName, mergedData, assetRecord) {
+  if (!mergedData || typeof mergedData !== 'object') return;
+  const themeRoot = path.join(projectRoot, sourceDir, themeName);
+  for (const value of Object.values(mergedData)) {
+    if (typeof value === 'string') {
+      if (assetRecord[value]) continue;
+      const rel = value.replace(/^\.\//, '');
+      const candidates = [
+        path.join(themeRoot, rel),
+        path.join(themeRoot, 'assets', path.basename(rel)),
+        path.resolve(projectRoot, rel),
+      ];
+      const abs = candidates.find((p) => fs.existsSync(p) && fs.statSync(p).isFile() && isInlinableThemeAsset(p));
+      if (abs) assetRecord[value] = getBase64FromFile(abs);
+    } else if (value && typeof value === 'object' && !Array.isArray(value)) {
+      collectReferencedFiles(projectRoot, sourceDir, themeName, value, assetRecord);
+    }
+  }
+}
+
+function loadThemeI18n(projectRoot, sourceDir, themeName) {
+  const p = path.join(projectRoot, sourceDir, themeName, 'theme.i18n.runtime.json5');
+  if (!fs.existsSync(p)) return {};
+  try {
+    return JSON5.parse(fs.readFileSync(p, 'utf8')) || {};
+  } catch {
+    return {};
+  }
+}
+
+/**
  * Read src/theme json5 + theme/assets the same way Phaser webpack inlines them.
- */function loadThemePayload(projectRoot,themeName,themeConfig={}){const sourceDir=themeConfig.sourceDir||"src/theme";const{mergedData,errors}=validateThemeData(themeName,projectRoot,themeConfig);if(errors){throw new Error(`Theme "${themeName}" validation failed:\n${errors.join("\n")}`)}const assetsDir=path.join(projectRoot,sourceDir,themeName,"assets");const assetRecordByPath=collectDirAssets(assetsDir,"./assets/");collectReferencedFiles(projectRoot,sourceDir,themeName,mergedData,assetRecordByPath);return{themeName,mergedData:mergedData||{},i18nOverride:loadThemeI18n(projectRoot,sourceDir,themeName),assetRecordByPath}}function writeGeneratedThemeModule(filePath,payload){const header="/* eslint-disable */\n"+"// Generated from src/theme by playable-scripts. Do not edit.\n";const body=`export const THEME_DATA = ${JSON.stringify(payload.mergedData,null,2)} as Record<string, unknown>;\n`+`export const THEME_I18N_OVERRIDE = ${JSON.stringify(payload.i18nOverride,null,2)} as Record<string, Record<string, string>>;\n`+`export const THEME_ASSETS = ${JSON.stringify(payload.assetRecordByPath)} as Record<string, string>;\n`;const next=header+body;if(fs.existsSync(filePath)&&fs.readFileSync(filePath,"utf8")===next){return false}fs.mkdirSync(path.dirname(filePath),{recursive:true});fs.writeFileSync(filePath,next);return true}function syncGeneratedTheme(projectRoot,options={}){const themeConfig=options.themeConfig||{sourceDir:"src/theme",entryFile:"src/theme/index.ts"};const themeName=options.themeName||detectCurrentTheme(projectRoot,themeConfig);if(!themeName)return null;const payload=loadThemePayload(projectRoot,themeName,themeConfig);const rel=options.generatedRel||"assets/scripts/platform/theme.generated.ts";const changed=writeGeneratedThemeModule(path.join(projectRoot,rel),payload);return{themeName,payload,generatedRel:rel,changed}}module.exports={detectCurrentTheme,loadThemePayload,writeGeneratedThemeModule,syncGeneratedTheme,collectDirAssets};
+ */
+function loadThemePayload(projectRoot, themeName, themeConfig = {}) {
+  const sourceDir = themeConfig.sourceDir || 'src/theme';
+  const { mergedData, errors } = validateThemeData(themeName, projectRoot, themeConfig);
+  if (errors) {
+    throw new Error(`Theme "${themeName}" validation failed:\n${errors.join('\n')}`);
+  }
+
+  const assetsDir = path.join(projectRoot, sourceDir, themeName, 'assets');
+  const assetRecordByPath = collectDirAssets(assetsDir, './assets/');
+  collectReferencedFiles(projectRoot, sourceDir, themeName, mergedData, assetRecordByPath);
+
+  return {
+    themeName,
+    mergedData: mergedData || {},
+    i18nOverride: loadThemeI18n(projectRoot, sourceDir, themeName),
+    assetRecordByPath,
+  };
+}
+
+function copyThemeAssetsToResources(projectRoot, themeName) {
+  const srcDir = path.join(projectRoot, 'src/theme', themeName, 'assets');
+  const destDir = path.join(projectRoot, 'assets/resources/textures');
+  if (!fs.existsSync(srcDir) || !fs.existsSync(destDir)) return false;
+  let changed = false;
+  for (const name of fs.readdirSync(srcDir)) {
+    if (!/\.(png|webp|jpe?g)$/i.test(name)) continue;
+    const dest = path.join(destDir, name);
+    if (!fs.existsSync(dest)) continue;
+    const from = path.join(srcDir, name);
+    const next = fs.readFileSync(from);
+    const prev = fs.readFileSync(dest);
+    if (Buffer.compare(next, prev) === 0) continue;
+    fs.writeFileSync(dest, next);
+    changed = true;
+  }
+  return changed;
+}
+
+function themeAssetStamp(dir) {
+  if (!fs.existsSync(dir)) return '';
+  try {
+    return fs
+      .readdirSync(dir)
+      .filter((name) => THEME_ASSET_EXT.test(name))
+      .map((name) => {
+        const st = fs.statSync(path.join(dir, name));
+        return `${name}:${st.size}:${Math.round(st.mtimeMs)}`;
+      })
+      .join('|');
+  } catch {
+    return '';
+  }
+}
+
+function writeGeneratedThemeModule(filePath, payload) {
+  const header =
+    '/* eslint-disable */\n' +
+    '// Generated from src/theme by playable-scripts. Do not edit.\n';
+  const body =
+    `export const THEME_DATA = ${JSON.stringify(payload.mergedData, null, 2)} as Record<string, unknown>;\n` +
+    `export const THEME_I18N_OVERRIDE = ${JSON.stringify(payload.i18nOverride, null, 2)} as Record<string, Record<string, string>>;\n` +
+    `export const THEME_ASSETS = ${JSON.stringify(payload.assetRecordByPath)} as Record<string, string>;\n`;
+  const next = header + body;
+  if (fs.existsSync(filePath) && fs.readFileSync(filePath, 'utf8') === next) {
+    return false;
+  }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, next);
+  return true;
+}
+
+function syncGeneratedTheme(projectRoot, options = {}) {
+  const themeConfig = options.themeConfig || { sourceDir: 'src/theme', entryFile: 'src/theme/index.ts' };
+  const themeName = options.themeName || detectCurrentTheme(projectRoot, themeConfig);
+  if (!themeName) return null;
+  const payload = loadThemePayload(projectRoot, themeName, themeConfig);
+  const rel = options.generatedRel || 'assets/scripts/platform/theme.generated.ts';
+  const copied = copyThemeAssetsToResources(projectRoot, themeName);
+  const changed = writeGeneratedThemeModule(path.join(projectRoot, rel), payload);
+  return { themeName, payload, generatedRel: rel, changed: changed || copied };
+}
+
+module.exports = {
+  detectCurrentTheme,
+  loadThemePayload,
+  writeGeneratedThemeModule,
+  syncGeneratedTheme,
+  collectDirAssets,
+  themeAssetStamp,
+};

package/core/engines/cocos/writable-cli.js

@@ -0,0 +1,250 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function exists(p) {
+  try {
+    return Boolean(p) && fs.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+
+function isWritableDir(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    const probe = path.join(dir, `.write-probe-${process.pid}`);
+    fs.writeFileSync(probe, 'ok');
+    fs.unlinkSync(probe);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function which(bin) {
+  if (!bin) return '';
+  if (path.isAbsolute(bin) && exists(bin)) return bin;
+  const result = spawnSync(process.platform === 'win32' ? 'where' : 'which', [bin], {
+    encoding: 'utf8',
+  });
+  const line = (result.stdout || '').split(/\r?\n/).map((s) => s.trim()).find(Boolean);
+  if (!line) return '';
+  try {
+    return fs.realpathSync(line);
+  } catch {
+    return line;
+  }
+}
+
+function climbToCliRoot(start) {
+  let dir = start;
+  try {
+    if (exists(start) && fs.statSync(start).isFile()) dir = path.dirname(start);
+  } catch {
+    return '';
+  }
+  for (let i = 0; i < 6; i++) {
+    if (exists(path.join(dir, 'packages', 'engine', 'package.json'))
+      || exists(path.join(dir, 'packages', 'engine', 'cc.config.json'))
+      || exists(path.join(dir, 'packages', 'engine'))) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return '';
+}
+
+function resolveCocosCliRoot(env = process.env) {
+  if (env.COCOS_CLI_ROOT && exists(env.COCOS_CLI_ROOT)) {
+    return path.resolve(env.COCOS_CLI_ROOT);
+  }
+  const bin = which(env.COCOS_CLI || 'cocos');
+  if (bin) {
+    const root = climbToCliRoot(bin);
+    if (root) return root;
+  }
+  const fallbacks = [
+    '/opt/cocos-cli',
+    '/usr/local/cocos-cli',
+    path.join(env.HOME || '', 'cocos-cli'),
+  ];
+  return fallbacks.find((p) => p && exists(path.join(p, 'packages', 'engine'))) || '';
+}
+
+function copyTree(src, dest) {
+  if (exists(dest)) return;
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  const al = spawnSync('cp', ['-al', src, dest], { encoding: 'utf8' });
+  if (al.status === 0 && exists(dest)) return;
+  const a = spawnSync('cp', ['-a', src, dest], { encoding: 'utf8' });
+  if (a.status === 0 && exists(dest)) return;
+  if (typeof fs.cpSync === 'function') {
+    fs.cpSync(src, dest, { recursive: true });
+    return;
+  }
+  throw new Error(`[cocos] failed to copy ${src} → ${dest}: ${(al.stderr || a.stderr || '').trim()}`);
+}
+
+function symlinkOrSkip(from, to) {
+  if (exists(to)) return;
+  fs.symlinkSync(from, to);
+}
+
+function overlayEngine(srcEngine, destEngine) {
+  fs.mkdirSync(destEngine, { recursive: true });
+  for (const name of fs.readdirSync(srcEngine)) {
+    if (name === 'bin' || name === 'editor') continue;
+    symlinkOrSkip(path.join(srcEngine, name), path.join(destEngine, name));
+  }
+  const srcBin = path.join(srcEngine, 'bin');
+  const srcEditor = path.join(srcEngine, 'editor');
+  if (exists(srcBin)) copyTree(srcBin, path.join(destEngine, 'bin'));
+  else fs.mkdirSync(path.join(destEngine, 'bin'), { recursive: true });
+  if (exists(srcEditor)) copyTree(srcEditor, path.join(destEngine, 'editor'));
+  else fs.mkdirSync(path.join(destEngine, 'editor', 'library'), { recursive: true });
+  fs.mkdirSync(path.join(destEngine, 'bin', 'temp'), { recursive: true });
+  fs.mkdirSync(path.join(destEngine, 'editor', 'library'), { recursive: true });
+}
+
+function shimLinuxFbxConverter(cliRoot) {
+  if (process.platform !== 'linux') return false;
+  const binDir = path.join(cliRoot, 'node_modules', '@cocos', 'fbx-gltf-conv', 'bin');
+  const linux = path.join(binDir, 'linux', 'FBX-glTF-conv');
+  const darwin = path.join(binDir, 'darwin', 'FBX-glTF-conv');
+  if (!exists(linux) || !exists(darwin)) return false;
+  try {
+    fs.unlinkSync(darwin);
+    fs.copyFileSync(linux, darwin);
+    fs.chmodSync(darwin, 0o755);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function writeBinWrapper(destRoot) {
+  const candidates = [
+    path.join(destRoot, 'src', 'cli.js'),
+    path.join(destRoot, 'dist', 'cli.js'),
+    path.join(destRoot, 'cli.js'),
+  ];
+  const cliJs = candidates.find(exists);
+  if (!cliJs) {
+    throw new Error(`[cocos] overlay missing cli entry under ${destRoot}`);
+  }
+  const binDir = path.join(destRoot, 'bin');
+  fs.mkdirSync(binDir, { recursive: true });
+  const bin = path.join(binDir, 'cocos');
+  fs.writeFileSync(bin, `#!/usr/bin/env node\nrequire(${JSON.stringify(cliJs)});\n`);
+  fs.chmodSync(bin, 0o755);
+  return bin;
+}
+
+function overlayNodeModules(srcNm, destNm) {
+  fs.mkdirSync(destNm, { recursive: true });
+  for (const name of fs.readdirSync(srcNm)) {
+    if (name === '@cocos') continue;
+    symlinkOrSkip(path.join(srcNm, name), path.join(destNm, name));
+  }
+  const srcCocos = path.join(srcNm, '@cocos');
+  if (!exists(srcCocos)) return;
+  const destCocos = path.join(destNm, '@cocos');
+  fs.mkdirSync(destCocos, { recursive: true });
+  for (const name of fs.readdirSync(srcCocos)) {
+    if (name === 'fbx-gltf-conv') {
+      copyTree(path.join(srcCocos, name), path.join(destCocos, name));
+      continue;
+    }
+    symlinkOrSkip(path.join(srcCocos, name), path.join(destCocos, name));
+  }
+}
+
+function overlayCocosCli(srcRoot, destRoot) {
+  fs.mkdirSync(destRoot, { recursive: true });
+  const skip = new Set(['src', 'dist', 'packages', 'bin', 'node_modules']);
+  for (const name of fs.readdirSync(srcRoot)) {
+    if (skip.has(name)) continue;
+    symlinkOrSkip(path.join(srcRoot, name), path.join(destRoot, name));
+  }
+
+  if (exists(path.join(srcRoot, 'src'))) copyTree(path.join(srcRoot, 'src'), path.join(destRoot, 'src'));
+  if (exists(path.join(srcRoot, 'dist'))) copyTree(path.join(srcRoot, 'dist'), path.join(destRoot, 'dist'));
+  if (exists(path.join(srcRoot, 'node_modules'))) {
+    overlayNodeModules(path.join(srcRoot, 'node_modules'), path.join(destRoot, 'node_modules'));
+  }
+
+  const srcPkgs = path.join(srcRoot, 'packages');
+  const destPkgs = path.join(destRoot, 'packages');
+  fs.mkdirSync(destPkgs, { recursive: true });
+  if (exists(srcPkgs)) {
+    for (const name of fs.readdirSync(srcPkgs)) {
+      if (name === 'engine') continue;
+      symlinkOrSkip(path.join(srcPkgs, name), path.join(destPkgs, name));
+    }
+    overlayEngine(path.join(srcPkgs, 'engine'), path.join(destPkgs, 'engine'));
+  }
+
+  const bin = writeBinWrapper(destRoot);
+  shimLinuxFbxConverter(destRoot);
+  return bin;
+}
+
+function engineNeedsOverlay(cliRoot) {
+  const engine = path.join(cliRoot, 'packages', 'engine');
+  if (!exists(engine)) return false;
+  return !isWritableDir(path.join(engine, 'bin', 'temp'))
+    || !isWritableDir(path.join(engine, 'editor', 'library'));
+}
+
+/**
+ * Linux 沙箱里 /opt/cocos-cli/packages/engine 只读时，把 CLI 映到项目 temp，
+ * 让 GlobalPaths.enginePath（join(__dirname, '../packages/engine')）落在可写目录。
+ */
+function prepareWritableCocosCli(projectRoot, env = process.env) {
+  const srcRoot = resolveCocosCliRoot(env);
+  if (!srcRoot) {
+    return { overlaid: false, cliRoot: '', env: {} };
+  }
+  if (!engineNeedsOverlay(srcRoot)) {
+    return { overlaid: false, cliRoot: srcRoot, env: { COCOS_ENGINE: path.join(srcRoot, 'packages', 'engine') } };
+  }
+
+  const destRoot = path.join(projectRoot, 'temp', 'cocos-cli');
+  const destEngine = path.join(destRoot, 'packages', 'engine');
+  const destBin = path.join(destRoot, 'bin', 'cocos');
+  if (!(exists(destBin) && exists(destEngine) && isWritableDir(path.join(destEngine, 'bin', 'temp')))) {
+    if (exists(destRoot)) fs.rmSync(destRoot, { recursive: true, force: true });
+    overlayCocosCli(srcRoot, destRoot);
+  } else {
+    shimLinuxFbxConverter(destRoot);
+  }
+
+  console.log(`[cocos] engine not writable (${srcRoot}); overlay ${path.relative(projectRoot, destRoot)}`);
+  return {
+    overlaid: true,
+    cliRoot: destRoot,
+    env: {
+      COCOS_CLI: destBin,
+      COCOS_CLI_ROOT: destRoot,
+      COCOS_ENGINE: destEngine,
+    },
+  };
+}
+
+module.exports = {
+  exists,
+  isWritableDir,
+  which,
+  climbToCliRoot,
+  resolveCocosCliRoot,
+  overlayCocosCli,
+  overlayEngine,
+  shimLinuxFbxConverter,
+  engineNeedsOverlay,
+  prepareWritableCocosCli,
+};

package/core/engines/cocos/writable-cli.test.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const { describe, it, before, after, beforeEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const {
+  overlayCocosCli,
+  engineNeedsOverlay,
+  prepareWritableCocosCli,
+  shimLinuxFbxConverter,
+} = require('./writable-cli.js');
+
+function writeFile(file, body) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, body);
+}
+
+function makeCliTree(root) {
+  writeFile(path.join(root, 'src', 'cli.js'), 'console.log("cli");\n');
+  writeFile(
+    path.join(root, 'src', 'global.js'),
+    'const { join } = require("path");\nmodule.exports = { GlobalPaths: { enginePath: join(__dirname, "..", "packages", "engine") } };\n',
+  );
+  writeFile(path.join(root, 'packages', 'engine', 'cc.config.json'), '{}\n');
+  writeFile(path.join(root, 'packages', 'engine', 'bin', 'keep.txt'), 'cache\n');
+  writeFile(path.join(root, 'packages', 'engine', 'editor', 'library', '.internal'), 'meta\n');
+  writeFile(path.join(root, 'packages', 'other', 'pkg.json'), '{}\n');
+  writeFile(path.join(root, 'node_modules', '@cocos', 'fbx-gltf-conv', 'bin', 'linux', 'FBX-glTF-conv'), 'linux-bin');
+  writeFile(path.join(root, 'node_modules', '@cocos', 'fbx-gltf-conv', 'bin', 'darwin', 'FBX-glTF-conv'), 'darwin-bin');
+  writeFile(path.join(root, 'bin', 'cocos'), '#!/usr/bin/env node\nrequire("../src/cli.js");\n');
+  fs.chmodSync(path.join(root, 'bin', 'cocos'), 0o755);
+}
+
+describe('writable cocos-cli overlay', () => {
+  let root;
+
+  beforeEach(() => {
+    if (root && fs.existsSync(root)) fs.rmSync(root, { recursive: true, force: true });
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cocos-cli-overlay-'));
+  });
+
+  after(() => {
+    if (root && fs.existsSync(root)) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('reports overlay when engine bin/temp is not writable', () => {
+    const cli = path.join(root, 'opt-cli');
+    makeCliTree(cli);
+    fs.chmodSync(path.join(cli, 'packages', 'engine', 'bin'), 0o555);
+    assert.equal(engineNeedsOverlay(cli), true);
+    fs.chmodSync(path.join(cli, 'packages', 'engine', 'bin'), 0o755);
+  });
+
+  it('maps GlobalPaths.enginePath onto a writable overlay', () => {
+    const cli = path.join(root, 'opt-cli');
+    makeCliTree(cli);
+    const dest = path.join(root, 'overlay');
+    const bin = overlayCocosCli(cli, dest);
+    assert.equal(fs.existsSync(bin), true);
+
+    const enginePath = path.join(dest, 'packages', 'engine');
+    fs.mkdirSync(path.join(enginePath, 'bin', 'temp'), { recursive: true });
+    fs.writeFileSync(path.join(enginePath, 'bin', 'temp', 'ok.txt'), '1');
+    assert.equal(fs.readFileSync(path.join(enginePath, 'bin', 'keep.txt'), 'utf8'), 'cache\n');
+
+    const globalJs = path.join(dest, 'src', 'global.js');
+    delete require.cache[require.resolve(globalJs)];
+    const resolved = require(globalJs).GlobalPaths.enginePath;
+    assert.equal(resolved, enginePath);
+
+    const srcDarwin = path.join(cli, 'node_modules', '@cocos', 'fbx-gltf-conv', 'bin', 'darwin', 'FBX-glTF-conv');
+    const destDarwin = path.join(dest, 'node_modules', '@cocos', 'fbx-gltf-conv', 'bin', 'darwin', 'FBX-glTF-conv');
+    assert.equal(fs.readFileSync(srcDarwin, 'utf8'), 'darwin-bin');
+    if (process.platform === 'linux') {
+      assert.equal(fs.readFileSync(destDarwin, 'utf8'), 'linux-bin');
+    }
+  });
+
+  it('replaces darwin FBX converter with the linux binary', () => {
+    const cli = path.join(root, 'opt-cli');
+    makeCliTree(cli);
+    if (process.platform !== 'linux') {
+      const original = process.platform;
+      Object.defineProperty(process, 'platform', { value: 'linux' });
+      try {
+        assert.equal(shimLinuxFbxConverter(cli), true);
+      } finally {
+        Object.defineProperty(process, 'platform', { value: original });
+      }
+    } else {
+      assert.equal(shimLinuxFbxConverter(cli), true);
+    }
+    const darwin = path.join(cli, 'node_modules', '@cocos', 'fbx-gltf-conv', 'bin', 'darwin', 'FBX-glTF-conv');
+    assert.equal(fs.readFileSync(darwin, 'utf8'), 'linux-bin');
+  });
+
+  it('prepareWritableCocosCli overlays a locked engine into project temp', () => {
+    const cli = path.join(root, 'opt-cli');
+    makeCliTree(cli);
+    fs.chmodSync(path.join(cli, 'packages', 'engine', 'bin'), 0o555);
+    const project = path.join(root, 'game');
+    fs.mkdirSync(project);
+    const result = prepareWritableCocosCli(project, { COCOS_CLI_ROOT: cli });
+    assert.equal(result.overlaid, true);
+    assert.equal(fs.existsSync(result.env.COCOS_CLI), true);
+    fs.mkdirSync(path.join(result.env.COCOS_ENGINE, 'bin', 'temp'), { recursive: true });
+    fs.writeFileSync(path.join(result.env.COCOS_ENGINE, 'bin', 'temp', 'ok.txt'), '1');
+    fs.chmodSync(path.join(cli, 'packages', 'engine', 'bin'), 0o755);
+  });
+});

package/core/engines/web/index.js

@@ -1 +1,20 @@
-"use strict";const{allowedExtensions,webpackCommonConfig}=require("./webpack.common.js");const{runBuild,makeWebpackBuildConfig}=require("./webpack.build.js");const{runDev,makeWebpackDevConfig}=require("./webpack.dev.js");const{runViteDev,makeViteDevConfig,json5Plugin,assetInlinePlugin,fontFamilyPlugin}=require("./vite.dev.js");module.exports={allowedExtensions,webpackCommonConfig,runBuild,makeWebpackBuildConfig,runDev,makeWebpackDevConfig,runViteDev,makeViteDevConfig,json5Plugin,assetInlinePlugin,fontFamilyPlugin};
+'use strict';
+
+const { allowedExtensions, webpackCommonConfig } = require('./webpack.common.js');
+const { runBuild, makeWebpackBuildConfig } = require('./webpack.build.js');
+const { runDev, makeWebpackDevConfig } = require('./webpack.dev.js');
+const { runViteDev, makeViteDevConfig, json5Plugin, assetInlinePlugin, fontFamilyPlugin } = require('./vite.dev.js');
+
+module.exports = {
+  allowedExtensions,
+  webpackCommonConfig,
+  runBuild,
+  makeWebpackBuildConfig,
+  runDev,
+  makeWebpackDevConfig,
+  runViteDev,
+  makeViteDevConfig,
+  json5Plugin,
+  assetInlinePlugin,
+  fontFamilyPlugin,
+};