@expo-harmony/patch-project 55.1.27-harmony.1 → 55.1.27-harmony.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo-harmony/patch-project",
-  "version": "55.1.27-harmony.1",
+  "version": "55.1.27-harmony.2",
   "keywords": [
     "react-native",
     "expo",
@@ -24,6 +24,9 @@
     "prepare": "yarn build",
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
+  "bin": {
+    "expo-harmony-patch-project": "build/cli/index.js"
+  },
   "exports": {
     ".": {
       "types": "./build/withPatchPlugin.d.ts",
@@ -52,13 +55,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "description": "Preserve manual Harmony native changes with CNG patches",
-  "bin": {
-    "expo-harmony-patch-project": "build/cli/index.js"
-  },
-  "files": [
-    "app.plugin.js",
-    "build"
-  ]
+  }
 }

package/src/cli/index.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+
+import { HarmonyPatchError } from '../errors';
+import { patchProjectAsync } from './patchProjectAsync';
+
+async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      help: { type: 'boolean', short: 'h' },
+      clean: { type: 'boolean' },
+      platform: { type: 'string', short: 'p', default: 'harmony' },
+    },
+  });
+  if (values.help) {
+    console.log(`Usage: npx @expo-harmony/patch-project [project] [options]
+
+Preserve manual Harmony native changes as CNG patches.
+
+Options:
+  --clean                 Delete harmony/ after successfully saving the patch
+  -p, --platform <name>    harmony or all (default: harmony)
+  -h, --help               Show this help`);
+    return;
+  }
+  if (positionals.length > 1 || !['harmony', 'all'].includes(values.platform)) {
+    throw new HarmonyPatchError('ERR_HARMONY_CONFIG_INVALID', 'Expected one project directory and --platform harmony or all.');
+  }
+
+  const root = await fs.realpath(path.resolve(positionals[0] || '.'));
+  await fs.access(path.join(root, 'package.json'));
+
+  process.env.EXPO_HARMONY = '1';
+  process.env.EXPO_METRO_TARGET = 'harmony';
+
+  const file = await patchProjectAsync(root, { clean: values.clean });
+
+  console.log(file ? `Saved Harmony patch: ${file}` : 'No manual changes detected; removed previous Harmony patches.');
+  if (file) console.log('Add "@expo-harmony/patch-project" to your app config plugins to apply patches during prebuild.');
+}
+
+main().catch((cause) => {
+  console.error(`[${cause.code || 'ERR_HARMONY_PATCH_FAILED'}] ${cause.message}`);
+  process.exitCode = 1;
+});

package/src/cli/patchProjectAsync.ts

@@ -0,0 +1,47 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { assertSafeCleanTarget, withGeneratedProjectAsync, withHarmonyProjectLockAsync } from '@expo-harmony/cli/internal/prebuild';
+import { atomicWrite, HarmonyPaths } from '@expo-harmony/config-plugins';
+
+import { HarmonyPatchError } from '../errors';
+import { generatePatchAsync } from '../gitPatch';
+import { getPatchFilesAsync } from '../patches';
+
+export async function patchProjectAsync(root: string, options: { clean?: boolean } = {}) {
+  return withHarmonyProjectLockAsync(root, 'patch-project', async () => {
+    const native = await HarmonyPaths.resolveHarmonyPath(root, 'harmony');
+    let stat;
+    try {
+      stat = await fs.lstat(native);
+    } catch (cause) {
+      throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'Cannot read the harmony directory. Run prebuild first.', {
+        cause, file: native,
+      });
+    }
+
+    if (!stat.isDirectory() || !(await fs.readdir(native)).length) {
+      throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'The harmony directory must exist and contain a native project. Run prebuild first.');
+    }
+    if (options.clean) await assertSafeCleanTarget(root);
+
+    const directory = await HarmonyPaths.resolveHarmonyPath(root, 'cng-patches');
+    const previous = await getPatchFilesAsync(directory);
+    const result = await withGeneratedProjectAsync(
+      root, { clean: true, skipPatches: true }, async (expected, checksum) => ({
+        patch: await generatePatchAsync(path.join(expected, 'harmony'), native),
+        file: path.join(directory, `harmony+${checksum}.patch`),
+      })
+    );
+
+    if (result.patch.trim()) await atomicWrite(result.file, result.patch);
+    for (const name of previous) {
+      const file = await HarmonyPaths.resolveHarmonyPath(directory, name);
+      if (!result.patch.trim() || file !== result.file) await fs.rm(file);
+    }
+
+    if (options.clean) await fs.rm(native, { recursive: true });
+
+    return result.patch.trim() ? result.file : null;
+  });
+}

package/src/errors.ts

@@ -0,0 +1,9 @@
+import { HarmonyConfigPluginError, type HarmonyConfigPluginErrorOptions } from '@expo-harmony/config-plugins';
+
+export class HarmonyPatchError extends HarmonyConfigPluginError {
+  constructor(code: string, message: string, options: HarmonyConfigPluginErrorOptions = {}) {
+    super(code, message, { operation: 'patch-project', ...options });
+
+    this.name = 'HarmonyPatchError';
+  }
+}

package/src/gitPatch.ts

@@ -0,0 +1,264 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+import { atomicWrite, HarmonyPaths } from '@expo-harmony/config-plugins';
+import { canonicalizeAutolinkingArtifacts } from '@expo-harmony/expo-modules-autolinking';
+
+import { HarmonyPatchError } from './errors';
+
+const exec = promisify(execFile);
+
+function isProjectPath(relative: string): boolean {
+  // eslint-disable-next-line no-control-regex -- Control characters are invalid native patch paths.
+  return !!relative && !relative.includes('\\') && !/[\x00-\x1f\x7f]/u.test(relative)
+    && !relative.split('/').some(part => !part || part === '.' || part === '..' || part.toLowerCase() === '.git')
+    && !/^[A-Za-z]:/u.test(relative);
+}
+
+async function git(cwd: string, args: string[]): Promise<string> {
+  // Ambient Git overrides must not redirect commands outside the staging repository.
+  const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('GIT_')));
+
+  try {
+    return (await exec('git', [
+      '-c', 'core.autocrlf=false', '-c', 'core.quotePath=false', '-c', 'core.fileMode=true', ...args,
+    ], {
+      cwd,
+      env: { ...env, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: process.platform === 'win32' ? 'NUL' : '/dev/null' },
+      maxBuffer: 64 * 1024 * 1024,
+    })).stdout;
+  } catch (cause) {
+    throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Git patch operation failed: ${cause.stderr || cause.message}`, { cause, operation: 'patch-project' });
+  }
+}
+
+async function listFiles(source: string): Promise<string[]> {
+  const staging = await fs.mkdtemp(path.join(os.tmpdir(), 'harmony-patch-files-'));
+  try {
+    await git(staging, ['init', '--quiet', '--bare']);
+    const output = await git(staging, [`--work-tree=${path.resolve(source)}`, 'ls-files', '--others', '--exclude-standard', '-z']);
+
+    return output.split('\0').filter(Boolean);
+  } finally {
+    await fs.rm(staging, { recursive: true, force: true });
+  }
+}
+
+async function snapshot(source: string, target: string, files: string[]): Promise<void> {
+  await fs.mkdir(target, { recursive: true });
+
+  for (const name of files) {
+    if (!isProjectPath(name)) throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Invalid native patch path: ${name}.`);
+
+    await HarmonyPaths.resolveHarmonyPath(source, name);
+    const from = path.join(source, name);
+    const to = path.join(target, name);
+    let stat;
+    try {
+      stat = await fs.lstat(from);
+    } catch (cause) {
+      if (cause.code === 'ENOENT') continue;
+
+      throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Cannot inspect ${from}.`, { cause, file: from });
+    }
+    if (!stat.isFile() && !stat.isSymbolicLink()) throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Patch source must be a file: ${from}.`);
+
+    await fs.mkdir(path.dirname(to), { recursive: true });
+    await fs.cp(from, to, { verbatimSymlinks: true });
+  }
+}
+
+async function changedFiles(root: string, patch: string): Promise<string[]> {
+  const stats = await git(root, ['apply', '--numstat', '-z', patch]);
+  const files = stats.split('\0').filter(Boolean).map((row) => {
+    const match = /^(?:\d+|-)\t(?:\d+|-)\t(harmony\/(.+))$/u.exec(row);
+    if (!match || !isProjectPath(match[2])) {
+      throw new HarmonyPatchError(
+        'ERR_HARMONY_PATCH_FAILED',
+        'Patch paths must remain inside the Harmony project and cannot modify Git metadata.'
+      );
+    }
+
+    return match[2];
+  });
+
+  return [...new Set(files)];
+}
+
+export async function generatePatchAsync(baseline: string, current: string): Promise<string> {
+  const staging = await fs.mkdtemp(path.join(os.tmpdir(), 'harmony-patch-diff-'));
+  try {
+    await git(staging, ['init', '--quiet']);
+    const native = path.join(staging, 'harmony');
+    const files = await listFiles(baseline);
+    await snapshot(baseline, native, files);
+
+    // Temporary dependency paths must not appear in patches.
+    const root = await fs.realpath(path.dirname(baseline));
+    const file = path.join(root, '.expo/harmony/autolinking.json');
+    let manifest: string | undefined;
+    try {
+      manifest = await fs.readFile(file, 'utf8');
+    } catch (cause) {
+      if (cause.code !== 'ENOENT') {
+        throw new HarmonyPatchError(
+          cause.code || 'ERR_HARMONY_PATCH_FAILED',
+          cause.message || `Cannot read autolinking manifest ${file}.`,
+          { cause, file, operation: 'patch-project' }
+        );
+      }
+    }
+
+    if (manifest) {
+      const file = path.join(native, HarmonyPaths.HARMONY_PATHS.rootOhPackage);
+      const canonical = canonicalizeAutolinkingArtifacts({
+        manifestSource: manifest,
+        ohPackageSource: await fs.readFile(file, 'utf8'),
+        generatedProjectRoot: root,
+        canonicalProjectRoot: await fs.realpath(path.dirname(current)),
+        harmonyProjectPath: await fs.realpath(current),
+      });
+      await fs.writeFile(file, canonical.ohPackageSource);
+    }
+
+    await git(staging, ['add', '-f', '--all', '--', 'harmony']);
+    await fs.rm(native, { recursive: true });
+    await snapshot(current, native, [...new Set([...files, ...await listFiles(current)])]);
+
+    // Intent-to-add includes new text and binary files without changing baseline entries.
+    const untracked = (await git(staging, ['ls-files', '--others', '-z', '--', 'harmony'])).split('\0').filter(Boolean);
+    if (untracked.length) await git(staging, ['add', '-f', '-N', '--', ...untracked]);
+
+    return await git(staging, [
+      'diff', '--binary', '--ignore-space-at-eol', '--no-renames', '--no-color', '--no-ext-diff', '--no-textconv', '--', 'harmony',
+    ]);
+  } finally {
+    await fs.rm(staging, { recursive: true, force: true });
+  }
+}
+
+export interface PatchResult {
+  files: string[];
+  created: string[];
+}
+
+export async function getPatchChangedLinesAsync(file: string): Promise<number> {
+  const stats = await git(path.dirname(file), ['apply', '--numstat', file]);
+
+  return stats.split('\n').reduce((total, row) => {
+    const [added, deleted] = row.split('\t', 2).map(Number);
+    return total + (Number.isFinite(added) ? added : 0) + (Number.isFinite(deleted) ? deleted : 0);
+  }, 0);
+}
+
+export async function applyPatchAsync(root: string, content: string): Promise<PatchResult> {
+  if (!content.trim()) return { files: [], created: [] };
+  if (/^(?:old mode|new mode|new file mode|deleted file mode) (?!100644$|100755$|120000$)/mu.test(content)
+    || /^(?:rename|copy) (?:from|to) /mu.test(content)) {
+    throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'Use file or symlink patches; regenerate renames as delete/add changes.');
+  }
+
+  const staging = await fs.mkdtemp(path.join(os.tmpdir(), 'harmony-patch-apply-'));
+  try {
+    await git(staging, ['init', '--quiet']);
+    const patch = path.join(staging, 'changes.patch');
+    await fs.writeFile(patch, content);
+    const files = await changedFiles(staging, patch);
+    const native = await HarmonyPaths.resolveHarmonyPath(root, 'harmony');
+
+    await snapshot(native, path.join(staging, 'harmony'), files);
+
+    const chunks = content.split(/(?=^diff --git )/mu).filter(chunk => chunk.startsWith('diff --git '));
+    if (!chunks.length) {
+      throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'Expected a Git patch generated by npx @expo-harmony/patch-project.');
+    }
+
+    const sections = new Map<string, string>();
+    for (const chunk of chunks) {
+      await fs.writeFile(patch, chunk);
+      const names = await changedFiles(staging, patch);
+      if (names.length !== 1) throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'Each patch section must modify one file.');
+
+      sections.set(names[0], (sections.get(names[0]) ?? '') + chunk);
+    }
+
+    const created: string[] = [];
+    for (const [name, source] of sections) {
+      if (/^new file mode /mu.test(source) && !/^deleted file mode /mu.test(source)) created.push(name);
+      await fs.writeFile(patch, source);
+
+      try {
+        await git(staging, ['apply', '--ignore-whitespace', '--check', patch]);
+      } catch (cause) {
+        // Other mods may regenerate only some files. Accept already-applied
+        // sections independently, while validating the complete patch in staging.
+        try {
+          await git(staging, ['apply', '--ignore-whitespace', '--reverse', '--check', patch]);
+        } catch {
+          throw new HarmonyPatchError(cause.code, cause.message, {
+            cause, file: patch, operation: cause.operation,
+          });
+        }
+
+        continue;
+      }
+
+      await git(staging, ['apply', '--ignore-whitespace', '--binary', patch]);
+    }
+
+    if (sections.size !== files.length || files.some(file => !sections.has(file))) {
+      throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'Patch section paths do not match its file summary.');
+    }
+
+    const writes: Array<{ target: string; content?: Uint8Array; link?: string; mode?: number }> = [];
+    for (const file of files) {
+      const target = await HarmonyPaths.resolveHarmonyPath(native, file);
+      const staged = path.join(staging, 'harmony', file);
+      let stat;
+      try {
+        stat = await fs.lstat(staged);
+      } catch (cause) {
+        if (cause.code !== 'ENOENT') {
+          throw new HarmonyPatchError(
+            cause.code || 'ERR_HARMONY_PATCH_FAILED',
+            cause.message || `Cannot inspect staged patch output ${file}.`,
+            { cause, file: staged, operation: 'patch-project' }
+          );
+        }
+      }
+
+      if (stat?.isSymbolicLink()) {
+        const link = await fs.readlink(staged);
+        if (path.isAbsolute(link) || !HarmonyPaths.isInside(native, path.resolve(path.dirname(target), link))) {
+          throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Patch symlink must remain inside the Harmony project: ${file}.`);
+        }
+
+        await HarmonyPaths.resolveHarmonyPath(native, path.relative(native, path.resolve(path.dirname(target), link)));
+        writes.push({ target, link });
+      } else if (stat?.isFile()) {
+        writes.push({ target, content: Uint8Array.from(await fs.readFile(staged)), mode: stat.mode & 0o777 });
+      } else if (!stat) writes.push({ target });
+      else throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Patch output must be a file: ${file}.`);
+    }
+
+    for (const { target, content, link, mode } of writes) {
+      if (content) {
+        await atomicWrite(target, content);
+        await fs.chmod(target, mode);
+      } else {
+        await fs.rm(target, { force: true });
+        if (link !== undefined) {
+          await fs.mkdir(path.dirname(target), { recursive: true });
+          await fs.symlink(link, target);
+        }
+      }
+    }
+
+    return { files, created };
+  } finally {
+    await fs.rm(staging, { recursive: true, force: true });
+  }
+}

package/src/patches.ts

@@ -0,0 +1,13 @@
+import fs from 'node:fs/promises';
+
+import { HarmonyPatchError } from './errors';
+
+export async function getPatchFilesAsync(root: string): Promise<string[]> {
+  try {
+    return (await fs.readdir(root)).filter(name => name.startsWith('harmony') && name.endsWith('.patch')).sort();
+  } catch (cause) {
+    if (cause.code === 'ENOENT') return [];
+
+    throw new HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Cannot read patch directory ${root}.`, { cause, file: root });
+  }
+}

package/src/withPatchPlugin.ts

@@ -0,0 +1,69 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { createRunOncePlugin, HarmonyPaths, recordManagedFile, registerHarmonyConfigPlugin, type HarmonyConfigPlugin } from '@expo-harmony/config-plugins';
+import { withProjectPatch } from '@expo-harmony/config-plugins/internal';
+import { WarningAggregator, type ModPlatform } from '@expo/config-plugins';
+
+import { HarmonyPatchError } from './errors';
+import { applyPatchAsync, getPatchChangedLinesAsync } from './gitPatch';
+import { getPatchFilesAsync } from './patches';
+
+export interface PatchPluginProps {
+  patchRoot?: string;
+  changedLinesLimit?: number;
+}
+
+const owner = '@expo-harmony/patch-project';
+
+const withPatchPlugin: HarmonyConfigPlugin<PatchPluginProps | void> = (config, props) => {
+  const options = props || {};
+  const limit = options.changedLinesLimit ?? 300;
+  if ((options.patchRoot !== undefined && (typeof options.patchRoot !== 'string' || !options.patchRoot.trim()))
+    || !Number.isFinite(limit) || limit < 0) {
+    throw new HarmonyPatchError('ERR_HARMONY_CONFIG_INVALID', 'patchRoot must be a non-empty directory path and changedLinesLimit must be a non-negative number.');
+  }
+
+  registerHarmonyConfigPlugin(config, owner);
+
+  return withProjectPatch(config, async (mod) => {
+    if (mod.modRequest.introspect || process.env.EXPO_HARMONY_SKIP_PATCHES === '1') return mod;
+
+    const root = mod.modRequest.projectRoot;
+    const directory = await HarmonyPaths.resolveHarmonyPath(root, options.patchRoot ?? 'cng-patches');
+    const files = await getPatchFilesAsync(directory);
+    if (!files.length) return mod;
+
+    const checksum = mod._internal?.templateChecksum;
+    const name = `harmony+${checksum}.patch`;
+    if (!checksum || !files.includes(name)) {
+      WarningAggregator.addWarningForPlatform('harmony' as ModPlatform, owner, `No patch matches the current template${checksum ? ` (${checksum})` : ''}. Existing Harmony patches were not applied. Review and regenerate them with npx @expo-harmony/patch-project.`);
+
+      return mod;
+    }
+    if (files.length > 1) {
+      WarningAggregator.addWarningForPlatform('harmony' as ModPlatform, owner, `Multiple Harmony patches found; only ${name} will be applied.`);
+    }
+
+    const file = await HarmonyPaths.resolveHarmonyPath(directory, name);
+    const source = await fs.readFile(file, 'utf8');
+    if (!source.trim()) return mod;
+
+    const changed = await getPatchChangedLinesAsync(file);
+    if (changed > limit) {
+      WarningAggregator.addWarningForPlatform('harmony' as ModPlatform, owner, `${name} has ${changed} changed lines, exceeding the warning limit of ${limit}. Consider a config plugin for larger changes.`);
+    }
+
+    const result = await applyPatchAsync(root, source);
+    registerHarmonyConfigPlugin(mod, owner, { files: result.created });
+    for (const relative of result.files) {
+      const file = path.join(mod.modRequest.platformProjectRoot, relative);
+      const managed = mod._internal?.harmonyManagedFiles?.find(item => item.path === `harmony/${relative}`);
+      recordManagedFile(mod, file, managed?.owner ?? (result.created.includes(relative) ? owner : 'patch'));
+    }
+
+    return mod;
+  });
+};
+
+export default createRunOncePlugin(withPatchPlugin, owner);

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "declaration": true,
+    "lib": ["ES2022"],
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "build",
+    "rootDir": "src",
+    "skipLibCheck": true,
+    "strict": true,
+    "noImplicitAny": false,
+    "strictNullChecks": false,
+    "useUnknownInCatchVariables": false,
+    "target": "ES2022",
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["build"]
+}