@microsoft/power-apps-native-host 0.2.22 → 0.3.0

package/scripts/upgrade/system.js

@@ -0,0 +1,244 @@
+'use strict';
+
+const childProcess = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { isLocked, setLockProvider, withLock } = require('@ster5/global-mutex');
+const { parsePatch } = require('diff');
+const { resolveWorkspaceRoot } = require('resolve-workspace-root');
+const writeFileAtomic = require('write-file-atomic');
+const { assertSafeFilePath, readJson } = require('./runtime');
+
+const UPGRADE_LOCK_PATH = '.powerapps-native/upgrade';
+const UPGRADE_JOURNAL_PATH = '.powerapps-native/upgrade-journal.json';
+setLockProvider('native');
+
+function detectPackageManager(projectRoot) {
+  const workspaceRoot = resolveWorkspaceRoot(projectRoot) || projectRoot;
+  for (const current of workspaceRoot === projectRoot ? [projectRoot] : [workspaceRoot, projectRoot]) {
+    const locks = [
+      ['npm', 'package-lock.json'], ['npm', 'npm-shrinkwrap.json'], ['yarn', 'yarn.lock'],
+      ['pnpm', 'pnpm-lock.yaml'], ['bun', 'bun.lock'], ['bun', 'bun.lockb'],
+    ].filter(([, lock]) => fs.existsSync(path.join(current, lock)));
+    const managers = [...new Set(locks.map(([manager]) => manager))];
+    if (managers.length > 1) throw new Error(`Multiple package-manager lockfiles found in ${current}: ${locks.map(([, lock]) => lock).join(', ')}`);
+    const packagePath = path.join(current, 'package.json');
+    const declaredManager = fs.existsSync(packagePath)
+      ? String(readJson(packagePath).packageManager || '').split('@')[0]
+      : '';
+    if (managers.length === 1) {
+      if (declaredManager && ['npm', 'pnpm', 'bun', 'yarn'].includes(declaredManager) && declaredManager !== managers[0]) {
+        throw new Error(`packageManager declares ${declaredManager}, but ${locks[0][1]} selects ${managers[0]} in ${current}`);
+      }
+      return supportedManager(managers[0], current);
+    }
+    if (['npm', 'pnpm', 'bun', 'yarn'].includes(declaredManager)) return supportedManager(declaredManager, current);
+  }
+  return { name: 'npm', root: projectRoot };
+}
+
+function supportedManager(name, root) {
+  if (name === 'yarn') throw new Error('Yarn is not currently supported; use npm, pnpm, or Bun');
+  return { name, root };
+}
+
+function run(command, args, cwd, capture = false) {
+  const result = childProcess.spawnSync(command, args, { cwd, encoding: 'utf8', stdio: capture ? 'pipe' : 'inherit' });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    if (capture && result.stderr) process.stderr.write(result.stderr);
+    throw new Error(`${command} ${args.join(' ')} failed with exit code ${result.status}`);
+  }
+  return result.stdout;
+}
+
+function expoInstallArgs(packageManager) {
+  return ['install', '--fix', ...(packageManager === 'bun' ? [] : [`--${packageManager}`])];
+}
+
+function packageInstallArgs(packageManager) {
+  return ['install', ...(packageManager === 'npm' ? ['--force'] : [])];
+}
+
+function installAndValidate(projectRoot, packageManager, expoDoctorVersion) {
+  const manager = typeof packageManager === 'string' ? { name: packageManager, root: projectRoot } : packageManager;
+  run(manager.name, packageInstallArgs(manager.name), manager.root);
+  const binName = process.platform === 'win32' ? 'expo.cmd' : 'expo';
+  const localBin = path.join(projectRoot, 'node_modules', '.bin', binName);
+  const rootBin = path.join(manager.root, 'node_modules', '.bin', binName);
+  const expoBin = fs.existsSync(localBin) ? localBin : rootBin;
+  if (!fs.existsSync(expoBin)) throw new Error('Expo CLI was not installed after package installation');
+  run(expoBin, expoInstallArgs(manager.name), projectRoot);
+  run(expoBin, ['install', '--check'], projectRoot);
+  run(expoBin, ['config', '--type', 'prebuild', '--json'], projectRoot, true);
+  if (!expoDoctorVersion) throw new Error('Compatibility profile is missing expoDoctorVersion');
+  const commands = { npm: ['npx', ['--yes']], pnpm: ['pnpm', ['dlx']], bun: ['bunx', []] };
+  const [command, args] = commands[manager.name];
+  run(command, [...args, `expo-doctor@${expoDoctorVersion}`], projectRoot);
+}
+
+function writeAtomic(filePath, content, mode) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const targetMode = mode ? (typeof mode === 'number' ? mode : Number.parseInt(String(mode).slice(-3), 8)) : undefined;
+  writeFileAtomic.sync(filePath, content, { mode: targetMode });
+}
+
+function snapshotFiles(filePaths) {
+  return new Map([...new Set(filePaths)].map(filePath => {
+    if (!fs.existsSync(filePath)) return [filePath, null];
+    const stat = fs.lstatSync(filePath);
+    if (stat.isSymbolicLink()) throw new Error(`Cannot snapshot symbolic link: ${filePath}`);
+    return [filePath, { content: fs.readFileSync(filePath), mode: stat.mode & 0o777 }];
+  }));
+}
+
+function restoreFiles(snapshot) {
+  for (const [filePath, entry] of snapshot) {
+    if (entry === null) fs.rmSync(filePath, { force: true });
+    else {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, entry.content);
+      fs.chmodSync(filePath, entry.mode);
+    }
+  }
+}
+
+async function withUpgradeLock(projectRoot, action) {
+  ensureControlDirectory(projectRoot);
+  const fileToLock = path.join(projectRoot, UPGRADE_LOCK_PATH);
+  try {
+    return await withLock({ fileToLock, stale: 30000, retries: 0 }, action);
+  } catch (error) {
+    if (/already being held/i.test(error.message)) throw new Error('Another upgrade is running');
+    throw error;
+  } finally {
+    if (!await isLocked(fileToLock)) fs.rmSync(fileToLock, { force: true });
+  }
+}
+
+async function assertNoActiveUpgrade(projectRoot) {
+  if (await isLocked(path.join(projectRoot, UPGRADE_LOCK_PATH))) throw new Error('Another upgrade is running');
+}
+
+function ensureControlDirectory(projectRoot) {
+  const directory = path.join(projectRoot, '.powerapps-native');
+  assertSafeFilePath(projectRoot, directory);
+  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  if (fs.lstatSync(directory).isSymbolicLink()) throw new Error('.powerapps-native cannot be a symbolic link');
+}
+
+function writeJournal(projectRoot, snapshot) {
+  const files = [...snapshot].map(([filePath, entry]) => ({
+    path: filePath,
+    existed: entry !== null,
+    mode: entry?.mode,
+    content: entry?.content.toString('base64'),
+  }));
+  writeAtomic(path.join(projectRoot, UPGRADE_JOURNAL_PATH), `${JSON.stringify({ schemaVersion: 1, files }, null, 2)}\n`, 0o600);
+}
+
+function recoverInterruptedUpgrade(projectRoot) {
+  const journalPath = path.join(projectRoot, UPGRADE_JOURNAL_PATH);
+  if (!fs.existsSync(journalPath)) return false;
+  const journal = readJson(journalPath);
+  if (journal.schemaVersion !== 1 || !Array.isArray(journal.files)) throw new Error('Upgrade journal is invalid; restore it manually');
+  const manager = detectPackageManager(projectRoot);
+  const allowedLockfiles = new Set(lockfilePaths(manager.root).map(filePath => path.resolve(filePath)));
+  const seen = new Set();
+  const snapshot = new Map(journal.files.map(file => validateJournalEntry(file, projectRoot, manager.root, allowedLockfiles, seen)));
+  restoreFiles(snapshot);
+  fs.rmSync(journalPath, { force: true });
+  console.warn('[upgrade-template] Recovered files from an interrupted upgrade phase.');
+  return true;
+}
+
+function validateJournalEntry(file, projectRoot, managerRoot, allowedLockfiles, seen) {
+  if (!file || typeof file.path !== 'string' || typeof file.existed !== 'boolean') throw new Error('Upgrade journal contains an invalid file entry');
+  const filePath = path.resolve(file.path);
+  const root = path.resolve(projectRoot);
+  if (!(filePath === root || filePath.startsWith(`${root}${path.sep}`) || allowedLockfiles.has(filePath))) throw new Error(`Upgrade journal contains unsafe path: ${file.path}`);
+  assertSafeFilePath(allowedLockfiles.has(filePath) ? managerRoot : projectRoot, filePath);
+  if (fs.existsSync(filePath) && fs.lstatSync(filePath).isSymbolicLink()) throw new Error(`Upgrade journal targets symbolic link: ${file.path}`);
+  if (seen.has(filePath)) throw new Error(`Upgrade journal contains duplicate path: ${file.path}`);
+  seen.add(filePath);
+  if (!file.existed) return [filePath, null];
+  if (!Number.isInteger(file.mode) || file.mode < 0 || file.mode > 0o777 || !isCanonicalBase64(file.content)) throw new Error(`Upgrade journal contains invalid backup data for ${file.path}`);
+  return [filePath, { content: Buffer.from(file.content, 'base64'), mode: file.mode }];
+}
+
+function isCanonicalBase64(value) {
+  return typeof value === 'string' && value.length % 4 === 0 && /^[A-Za-z0-9+/]*={0,2}$/.test(value) && Buffer.from(value, 'base64').toString('base64') === value;
+}
+
+function lockfilePaths(root) {
+  return ['package-lock.json', 'npm-shrinkwrap.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lock', 'bun.lockb'].map(name => path.join(root, name));
+}
+
+function configFilePaths(root) {
+  return ['app.json', 'app.config.json', 'app.config.js', 'app.config.ts', 'babel.config.js', 'metro.config.js', 'tsconfig.json'].map(name => path.join(root, name));
+}
+
+function applyOperations(projectRoot, operations) {
+  for (const operation of operations) {
+    assertSafeFilePath(projectRoot, operation.filePath);
+    if (operation.delete) fs.rmSync(operation.filePath, { force: true });
+    else writeAtomic(operation.filePath, operation.content, operation.mode);
+  }
+}
+
+function executePhase(projectRoot, operations, packageManager, install, validate = installAndValidate, expoDoctorVersion) {
+  const manager = typeof packageManager === 'string' ? { name: packageManager, root: projectRoot } : packageManager;
+  const stateOperations = operations.filter(operation => operation.state);
+  const projectOperations = operations.filter(operation => !operation.state);
+  const snapshot = snapshotFiles([
+    ...operations.map(operation => operation.filePath), path.join(projectRoot, 'package.json'),
+    ...lockfilePaths(manager.root), ...configFilePaths(projectRoot),
+  ]);
+  writeJournal(projectRoot, snapshot);
+  try {
+    applyOperations(projectRoot, projectOperations);
+    if (install) validate(projectRoot, manager, expoDoctorVersion);
+    applyOperations(projectRoot, stateOperations);
+    fs.rmSync(path.join(projectRoot, UPGRADE_JOURNAL_PATH), { force: true });
+  } catch (error) {
+    restoreFiles(snapshot);
+    fs.rmSync(path.join(projectRoot, UPGRADE_JOURNAL_PATH), { force: true });
+    throw new Error(`${error.message}. This migration phase was rolled back; node_modules may require reinstalling.`);
+  }
+}
+
+function writeRejects(operations) {
+  for (const operation of operations.filter(operation => operation.reject)) writeAtomic(operation.filePath, operation.content, operation.mode);
+}
+
+function cleanupRejects(projectRoot, migration) {
+  if (!migration) return;
+  for (const patch of migration.patch.trim() ? parsePatch(migration.patch) : []) {
+    const relativePath = patch.newFileName === '/dev/null' ? patch.oldFileName : patch.newFileName;
+    if (relativePath && relativePath !== '/dev/null') fs.rmSync(`${path.resolve(projectRoot, relativePath)}.power-apps-${migration.id}.rej`, { force: true });
+  }
+}
+
+function reportNativeProjectState(projectRoot) {
+  const nativeDirectories = ['android', 'ios'].filter(name => fs.existsSync(path.join(projectRoot, name)));
+  if (nativeDirectories.length) console.warn(`[upgrade-template] Native directories detected (${nativeDirectories.join(', ')}). They are not modified automatically. Regenerate them with Expo Prebuild only if they are CNG-managed; otherwise apply native upgrade changes manually.`);
+}
+
+function shouldValidate(migration, operations) {
+  return Boolean(migration) || operations.some(operation => !operation.state);
+}
+
+module.exports = {
+  UPGRADE_JOURNAL_PATH,
+  assertNoActiveUpgrade,
+  cleanupRejects,
+  detectPackageManager,
+  executePhase,
+  expoInstallArgs,
+  packageInstallArgs,
+  recoverInterruptedUpgrade,
+  reportNativeProjectState,
+  shouldValidate,
+  withUpgradeLock,
+  writeRejects,
+};