@capgo/capacitor-patch 8.0.0

package/scripts/capacitor-patch/catalog.mjs

@@ -0,0 +1,15 @@
+import fs from 'node:fs';
+
+const catalogUrl = new URL('../../patches/catalog.json', import.meta.url);
+
+export function loadBuiltinCatalog() {
+  return readCatalogFile(catalogUrl);
+}
+
+export function readCatalogFile(file) {
+  const catalog = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (!Array.isArray(catalog)) {
+    throw new Error('Patch catalog must be an array.');
+  }
+  return catalog;
+}

package/scripts/capacitor-patch/cli.mjs

@@ -0,0 +1,129 @@
+import path from 'node:path';
+
+import { loadBuiltinCatalog } from './catalog.mjs';
+import { getPluginConfig, loadCapacitorExtConfig } from './config.mjs';
+import { printPatchResults, runCapacitorPatch, selectPatches } from './runner.mjs';
+
+export async function main(argv = process.argv.slice(2)) {
+  const { command, options } = parseArgs(argv);
+
+  if (command === 'help' || options.help) {
+    printHelp();
+    return;
+  }
+
+  const rootDir = path.resolve(options.root ?? process.cwd());
+  const extConfig = await loadCapacitorExtConfig(rootDir, process.env);
+  const patchConfig = {
+    ...getPluginConfig(extConfig),
+    strict: options.strict ?? getPluginConfig(extConfig).strict,
+  };
+
+  if (command === 'list') {
+    listPatches(loadBuiltinCatalog(), patchConfig, options);
+    return;
+  }
+
+  if (command === 'apply' || command === 'doctor') {
+    const phases = options.phase === 'all' ? ['package', 'native'] : [options.phase ?? 'package'];
+    let selectedCount = 0;
+    for (const phase of phases) {
+      const result = await runCapacitorPatch({
+        rootDir,
+        extConfig,
+        patchConfig,
+        phase,
+        platformName: options.platform,
+        dryRun: command === 'doctor',
+      });
+      selectedCount += result.selectedCount;
+      printPatchResults(result, { quietWhenEmpty: true });
+    }
+    if (selectedCount === 0) {
+      console.log('[CapacitorPatch] No patches selected. Enable plugins.CapacitorPatch.recommended or list patch IDs.');
+    }
+    return;
+  }
+
+  throw new Error(`Unknown command: ${command}`);
+}
+
+function listPatches(catalog, patchConfig, options) {
+  const rows = [];
+
+  for (const phase of ['package', 'native']) {
+    const selected = selectPatches(catalog, patchConfig, phase);
+    const selectedIds = new Set(selected.patches.map((entry) => entry.patch.id));
+
+    for (const patch of catalog.filter((item) => item.phase === phase)) {
+      if (!options.all && !selectedIds.has(patch.id)) {
+        continue;
+      }
+
+      rows.push({
+        id: patch.id,
+        phase: patch.phase,
+        recommended: patch.recommended === true ? 'yes' : 'no',
+        selected: selectedIds.has(patch.id) ? 'yes' : 'no',
+        title: patch.title ?? '',
+      });
+    }
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+
+  if (rows.length === 0) {
+    console.log('[CapacitorPatch] No patches to list.');
+    return;
+  }
+
+  for (const row of rows) {
+    console.log(`${row.id}\t${row.phase}\trecommended:${row.recommended}\tselected:${row.selected}\t${row.title}`);
+  }
+}
+
+function parseArgs(argv) {
+  const options = {
+    phase: 'all',
+  };
+  let command = 'help';
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (index === 0 && !value.startsWith('-')) {
+      command = value;
+      continue;
+    }
+
+    if (value === '--root') {
+      options.root = argv[++index];
+    } else if (value === '--phase') {
+      options.phase = argv[++index];
+    } else if (value === '--platform') {
+      options.platform = argv[++index];
+    } else if (value === '--strict') {
+      options.strict = true;
+    } else if (value === '--all') {
+      options.all = true;
+    } else if (value === '--json') {
+      options.json = true;
+    } else if (value === '--help' || value === '-h') {
+      options.help = true;
+    } else {
+      throw new Error(`Unknown option: ${value}`);
+    }
+  }
+
+  return { command, options };
+}
+
+function printHelp() {
+  console.log(`Usage:
+  capgo-capacitor-patch list [--all] [--json]
+  capgo-capacitor-patch apply [--root <dir>] [--phase package|native|all] [--platform ios|android] [--strict]
+  capgo-capacitor-patch doctor [--root <dir>] [--phase package|native|all] [--platform ios|android] [--strict]
+`);
+}

package/scripts/capacitor-patch/config.mjs

@@ -0,0 +1,72 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+export const PLUGIN_CONFIG_KEY = 'CapacitorPatch';
+
+export function parseCapacitorConfig(rawValue) {
+  if (!rawValue) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(rawValue);
+  } catch (error) {
+    throw new Error(`Unable to parse CAPACITOR_CONFIG: ${error.message}`);
+  }
+}
+
+export function normalizePatchConfig(rawConfig = {}) {
+  return {
+    recommended: rawConfig.recommended === true,
+    patches: normalizeStringArray(rawConfig.patches),
+    disabled: normalizeStringArray(rawConfig.disabled),
+    strict: rawConfig.strict === true,
+  };
+}
+
+export function getPluginConfig(extConfig = {}) {
+  return normalizePatchConfig(extConfig.plugins?.[PLUGIN_CONFIG_KEY]);
+}
+
+export async function loadCapacitorExtConfig(rootDir, env = process.env) {
+  if (env.CAPACITOR_CONFIG) {
+    return parseCapacitorConfig(env.CAPACITOR_CONFIG);
+  }
+
+  const fromCli = await loadConfigWithCapacitorCli(rootDir);
+  if (fromCli) {
+    return fromCli;
+  }
+
+  const jsonConfigPath = path.join(rootDir, 'capacitor.config.json');
+  if (fs.existsSync(jsonConfigPath)) {
+    return JSON.parse(fs.readFileSync(jsonConfigPath, 'utf8'));
+  }
+
+  return {};
+}
+
+async function loadConfigWithCapacitorCli(rootDir) {
+  const require = createRequire(import.meta.url);
+  const cwd = process.cwd();
+
+  try {
+    const { loadConfig } = require('@capacitor/cli/dist/config');
+    process.chdir(rootDir);
+    const config = await loadConfig();
+    return config.app?.extConfig ?? {};
+  } catch {
+    return null;
+  } finally {
+    process.chdir(cwd);
+  }
+}
+
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value.filter((item) => typeof item === 'string' && item.length > 0);
+}

package/scripts/capacitor-patch/diff.mjs

@@ -0,0 +1,216 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export class PatchApplyError extends Error {
+  constructor(message, details = {}) {
+    super(message);
+    this.name = 'PatchApplyError';
+    this.details = details;
+  }
+}
+
+export function applyUnifiedDiff(rootDir, diffText, options = {}) {
+  const reverse = options.reverse === true;
+  const dryRun = options.dryRun === true;
+  const files = parseUnifiedDiff(diffText);
+  const updates = [];
+
+  for (const filePatch of files) {
+    const relativePath = getTargetPath(filePatch, reverse);
+    if (!relativePath) {
+      throw new PatchApplyError('Patch creates or deletes a file without a usable target path.');
+    }
+
+    const absolutePath = path.resolve(rootDir, relativePath);
+    assertInsideRoot(rootDir, absolutePath);
+
+    const exists = fs.existsSync(absolutePath);
+    if (!exists && !isCreateFile(filePatch, reverse)) {
+      throw new PatchApplyError(`Missing patch target: ${relativePath}`, { file: relativePath });
+    }
+
+    const original = exists ? fs.readFileSync(absolutePath, 'utf8') : '';
+    const updated = applyHunks(original, filePatch.hunks, reverse, relativePath);
+    const deleteFile = isDeleteFile(filePatch, reverse);
+
+    if (deleteFile || updated !== original) {
+      updates.push({ absolutePath, relativePath, content: updated, deleteFile });
+    }
+  }
+
+  if (!dryRun) {
+    for (const update of updates) {
+      if (update.deleteFile) {
+        fs.rmSync(update.absolutePath, { force: true });
+      } else {
+        fs.mkdirSync(path.dirname(update.absolutePath), { recursive: true });
+        fs.writeFileSync(update.absolutePath, update.content);
+      }
+    }
+  }
+
+  return {
+    changedFiles: updates.map((update) => update.relativePath),
+  };
+}
+
+export function parseUnifiedDiff(diffText) {
+  const lines = diffText.replace(/\r\n/g, '\n').split('\n');
+  const files = [];
+  let index = 0;
+
+  while (index < lines.length) {
+    if (!lines[index].startsWith('--- ')) {
+      index += 1;
+      continue;
+    }
+
+    const oldPath = parseDiffPath(lines[index]);
+    index += 1;
+
+    if (!lines[index]?.startsWith('+++ ')) {
+      throw new PatchApplyError('Malformed patch: missing +++ file header.');
+    }
+
+    const newPath = parseDiffPath(lines[index]);
+    index += 1;
+    const hunks = [];
+
+    while (index < lines.length && !lines[index].startsWith('--- ')) {
+      if (!lines[index].startsWith('@@ ')) {
+        index += 1;
+        continue;
+      }
+
+      const match = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(lines[index]);
+      if (!match) {
+        throw new PatchApplyError(`Malformed patch hunk: ${lines[index]}`);
+      }
+
+      index += 1;
+      const hunkLines = [];
+      while (index < lines.length && !lines[index].startsWith('@@ ') && !lines[index].startsWith('--- ')) {
+        if (lines[index].startsWith('\\')) {
+          index += 1;
+          continue;
+        }
+        if (lines[index] !== '' || index < lines.length - 1) {
+          hunkLines.push(lines[index]);
+        }
+        index += 1;
+      }
+
+      hunks.push({
+        oldStart: Number(match[1]),
+        oldCount: Number(match[2] ?? '1'),
+        newStart: Number(match[3]),
+        newCount: Number(match[4] ?? '1'),
+        lines: hunkLines,
+      });
+    }
+
+    files.push({ oldPath, newPath, hunks });
+  }
+
+  if (files.length === 0) {
+    throw new PatchApplyError('Patch does not contain any unified diff file headers.');
+  }
+
+  return files;
+}
+
+function applyHunks(content, hunks, reverse, relativePath) {
+  const original = splitContent(content);
+  const lines = [...original.lines];
+  let offset = 0;
+
+  for (const hunk of hunks) {
+    const expected = [];
+    const replacement = [];
+
+    for (const rawLine of hunk.lines) {
+      const marker = rawLine[0];
+      const value = rawLine.slice(1);
+
+      if (marker === ' ') {
+        expected.push(value);
+        replacement.push(value);
+      } else if (marker === '-') {
+        if (reverse) {
+          replacement.push(value);
+        } else {
+          expected.push(value);
+        }
+      } else if (marker === '+') {
+        if (reverse) {
+          expected.push(value);
+        } else {
+          replacement.push(value);
+        }
+      } else {
+        throw new PatchApplyError(`Unsupported patch line marker "${marker}" in ${relativePath}.`);
+      }
+    }
+
+    const start = Math.max(0, (reverse ? hunk.newStart : hunk.oldStart) - 1 + offset);
+    if (!matchesAt(lines, start, expected)) {
+      throw new PatchApplyError(`Patch hunk does not match ${relativePath} at line ${start + 1}.`, {
+        file: relativePath,
+        line: start + 1,
+      });
+    }
+
+    lines.splice(start, expected.length, ...replacement);
+    offset += replacement.length - expected.length;
+  }
+
+  return joinContent(lines, original.finalNewline);
+}
+
+function parseDiffPath(line) {
+  const value = line.slice(4).split('\t')[0].trim();
+  if (value === '/dev/null') {
+    return null;
+  }
+  return value.replace(/^[ab]\//, '');
+}
+
+function getTargetPath(filePatch, reverse) {
+  return reverse ? (filePatch.oldPath ?? filePatch.newPath) : (filePatch.newPath ?? filePatch.oldPath);
+}
+
+function isCreateFile(filePatch, reverse) {
+  return reverse ? filePatch.newPath === null : filePatch.oldPath === null;
+}
+
+function isDeleteFile(filePatch, reverse) {
+  return reverse ? filePatch.oldPath === null : filePatch.newPath === null;
+}
+
+function splitContent(content) {
+  const finalNewline = content.endsWith('\n');
+  const lines = content.split('\n');
+  if (finalNewline) {
+    lines.pop();
+  }
+  return { lines, finalNewline };
+}
+
+function joinContent(lines, finalNewline) {
+  return `${lines.join('\n')}${finalNewline ? '\n' : ''}`;
+}
+
+function matchesAt(lines, start, expected) {
+  if (start < 0 || start + expected.length > lines.length) {
+    return false;
+  }
+
+  return expected.every((line, index) => lines[start + index] === line);
+}
+
+function assertInsideRoot(rootDir, absolutePath) {
+  const relative = path.relative(path.resolve(rootDir), absolutePath);
+  if (relative.startsWith('..') || path.isAbsolute(relative)) {
+    throw new PatchApplyError(`Patch target escapes root: ${absolutePath}`);
+  }
+}

package/scripts/capacitor-patch/runner.mjs

@@ -0,0 +1,234 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import semver from 'semver';
+
+import { loadBuiltinCatalog } from './catalog.mjs';
+import { getPluginConfig } from './config.mjs';
+import { PatchApplyError, applyUnifiedDiff } from './diff.mjs';
+
+const packageRoot = fileURLToPath(new URL('../../', import.meta.url));
+
+export async function runCapacitorPatch(options) {
+  const rootDir = path.resolve(options.rootDir ?? process.cwd());
+  const phase = options.phase;
+  const catalog = options.catalog ?? loadBuiltinCatalog();
+  const extConfig = options.extConfig ?? {};
+  const patchConfig = options.patchConfig ?? getPluginConfig(extConfig);
+  const patchBaseDir = path.resolve(options.patchBaseDir ?? packageRoot);
+  const selected = selectPatches(catalog, patchConfig, phase);
+  const results = [];
+
+  for (const unknownId of selected.unknownIds) {
+    results.push({
+      id: unknownId,
+      phase,
+      status: 'failed',
+      reason: 'Patch ID was not found in the catalog.',
+    });
+  }
+
+  for (const entry of selected.patches) {
+    results.push(
+      await applyCatalogPatch({
+        rootDir,
+        patchBaseDir,
+        patch: entry.patch,
+        selectedBy: entry.selectedBy,
+        phase,
+        platformName: options.platformName,
+        strict: patchConfig.strict,
+        dryRun: options.dryRun === true,
+      }),
+    );
+  }
+
+  const failures = results.filter((result) => result.status === 'failed');
+  if (patchConfig.strict && failures.length > 0) {
+    throw new Error(failures.map((failure) => `${failure.id}: ${failure.reason}`).join('\n'));
+  }
+
+  return {
+    phase,
+    selectedCount: selected.patches.length + selected.unknownIds.length,
+    results,
+  };
+}
+
+export function selectPatches(catalog, patchConfig, phase) {
+  const disabled = new Set(patchConfig.disabled);
+  const explicit = new Set(patchConfig.patches);
+  const catalogById = new Map(catalog.map((patch) => [patch.id, patch]));
+  const patches = [];
+
+  for (const patch of catalog) {
+    if (!patch?.id || patch.phase !== phase || disabled.has(patch.id)) {
+      continue;
+    }
+
+    if (explicit.has(patch.id)) {
+      patches.push({ patch, selectedBy: 'explicit' });
+    } else if (patchConfig.recommended && patch.recommended === true) {
+      patches.push({ patch, selectedBy: 'recommended' });
+    }
+  }
+
+  return {
+    patches,
+    unknownIds: patchConfig.patches.filter((id) => !disabled.has(id) && !catalogById.has(id)),
+  };
+}
+
+async function applyCatalogPatch(options) {
+  const { patch, rootDir, patchBaseDir, selectedBy, platformName, strict, dryRun } = options;
+  const baseResult = {
+    id: patch.id,
+    title: patch.title,
+    phase: patch.phase,
+    selectedBy,
+    status: 'skipped',
+    changedFiles: [],
+  };
+
+  if (Array.isArray(patch.platforms) && platformName && !patch.platforms.includes(platformName)) {
+    return {
+      ...baseResult,
+      reason: `Patch is for ${patch.platforms.join(', ')}, current platform is ${platformName}.`,
+    };
+  }
+
+  const target = patch.target ?? {};
+  const targetType = target.type ?? (target.packageName ? 'package' : 'native');
+  const targetRoot = resolveTargetRoot(rootDir, targetType, target);
+  if (!targetRoot) {
+    return {
+      ...baseResult,
+      reason: `Target package ${target.packageName} is not installed.`,
+    };
+  }
+
+  const versionCheck = checkTargetVersion(targetRoot, target);
+  if (!versionCheck.ok) {
+    return {
+      ...baseResult,
+      status: strict ? 'failed' : 'skipped',
+      reason: versionCheck.reason,
+    };
+  }
+
+  const patchFile = path.resolve(patchBaseDir, patch.patchFile);
+  if (!fs.existsSync(patchFile)) {
+    return {
+      ...baseResult,
+      status: 'failed',
+      reason: `Patch file is missing: ${patch.patchFile}`,
+    };
+  }
+
+  const diffText = fs.readFileSync(patchFile, 'utf8');
+
+  try {
+    const applied = applyUnifiedDiff(targetRoot, diffText, { dryRun });
+    const status = dryRun ? 'would-apply' : 'applied';
+
+    return {
+      ...baseResult,
+      status,
+      changedFiles: applied.changedFiles,
+      note:
+        patch.target?.packageName === '@capacitor/cli' && !dryRun
+          ? 'This patch changes @capacitor/cli. Run the next cap command to use the patched CLI code.'
+          : undefined,
+    };
+  } catch (error) {
+    if (error instanceof PatchApplyError && isAlreadyApplied(targetRoot, diffText)) {
+      return {
+        ...baseResult,
+        status: 'already-applied',
+      };
+    }
+
+    return {
+      ...baseResult,
+      status: strict ? 'failed' : 'failed',
+      reason: error?.message ?? String(error),
+    };
+  }
+}
+
+function resolveTargetRoot(rootDir, targetType, target) {
+  if (targetType === 'native') {
+    return rootDir;
+  }
+
+  const packageName = target.packageName;
+  if (!packageName) {
+    return null;
+  }
+
+  const packageRootDir = path.join(rootDir, 'node_modules', ...packageName.split('/'));
+  const packageJson = path.join(packageRootDir, 'package.json');
+  return fs.existsSync(packageJson) ? packageRootDir : null;
+}
+
+function checkTargetVersion(targetRoot, target) {
+  if (!target.versionRange) {
+    return { ok: true };
+  }
+
+  const packageJsonPath = path.join(targetRoot, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    return { ok: false, reason: 'Target package has no package.json for version checking.' };
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const version = packageJson.version;
+  if (!semver.valid(version) || !semver.satisfies(version, target.versionRange, { includePrerelease: true })) {
+    return {
+      ok: false,
+      reason: `Installed version ${version ?? 'unknown'} does not satisfy ${target.versionRange}.`,
+    };
+  }
+
+  return { ok: true };
+}
+
+function isAlreadyApplied(targetRoot, diffText) {
+  try {
+    applyUnifiedDiff(targetRoot, diffText, { reverse: true, dryRun: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function printPatchResults(result, options = {}) {
+  if (options.quietWhenEmpty && result.selectedCount === 0) {
+    return;
+  }
+
+  if (result.selectedCount === 0) {
+    console.log('[CapacitorPatch] No patches selected. Enable plugins.CapacitorPatch.recommended or list patch IDs.');
+    return;
+  }
+
+  for (const item of result.results) {
+    const label = item.title ? `${item.id} (${item.title})` : item.id;
+    if (item.status === 'applied' || item.status === 'would-apply') {
+      const action = item.status === 'would-apply' ? 'Would apply' : 'Applied';
+      console.log(`[CapacitorPatch] ${action} ${label}.`);
+      for (const file of item.changedFiles ?? []) {
+        console.log(`[CapacitorPatch]   ${file}`);
+      }
+      if (item.note) {
+        console.log(`[CapacitorPatch] ${item.note}`);
+      }
+    } else if (item.status === 'already-applied') {
+      console.log(`[CapacitorPatch] Already applied ${label}.`);
+    } else if (item.status === 'skipped') {
+      console.log(`[CapacitorPatch] Skipped ${label}: ${item.reason}`);
+    } else {
+      console.warn(`[CapacitorPatch] Failed ${label}: ${item.reason}`);
+    }
+  }
+}

package/scripts/capacitor-patch-hook.mjs

@@ -0,0 +1,27 @@
+import { getPluginConfig, loadCapacitorExtConfig } from './capacitor-patch/config.mjs';
+import { printPatchResults, runCapacitorPatch } from './capacitor-patch/runner.mjs';
+
+const phase = process.argv[2];
+
+if (phase !== 'package' && phase !== 'native') {
+  console.error('[CapacitorPatch] Expected hook phase "package" or "native".');
+  process.exitCode = 1;
+} else {
+  try {
+    const rootDir = process.env.CAPACITOR_ROOT_DIR ?? process.cwd();
+    const extConfig = await loadCapacitorExtConfig(rootDir, process.env);
+    const patchConfig = getPluginConfig(extConfig);
+    const result = await runCapacitorPatch({
+      rootDir,
+      extConfig,
+      patchConfig,
+      phase,
+      platformName: process.env.CAPACITOR_PLATFORM_NAME,
+    });
+
+    printPatchResults(result, { quietWhenEmpty: true });
+  } catch (error) {
+    console.error(`[CapacitorPatch] ${error?.message ?? error}`);
+    process.exitCode = 1;
+  }
+}