react-native-debug-toolkit 3.3.2 → 3.3.3

package/scripts/embed-android.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const APPLY_FROM_MARKER =
+  '// react-native-debug-toolkit: debug bundle embed';
+const APPLY_FROM_LINE =
+  APPLY_FROM_MARKER +
+  '\napply from: "../../node_modules/react-native-debug-toolkit/scripts/android-debug-bundle.gradle"';
+
+function findBuildGradle(projectRoot) {
+  const gradlePath = path.join(projectRoot, 'android', 'app', 'build.gradle');
+  const gradleKtsPath = path.join(
+    projectRoot,
+    'android',
+    'app',
+    'build.gradle.kts'
+  );
+
+  if (fs.existsSync(gradleKtsPath)) {
+    return 'android/app/build.gradle.kts';
+  }
+  if (fs.existsSync(gradlePath)) {
+    return 'android/app/build.gradle';
+  }
+  return null;
+}
+
+function ensureAssetsDir(projectRoot) {
+  const assetsDir = path.join(
+    projectRoot,
+    'android',
+    'app',
+    'src',
+    'main',
+    'assets'
+  );
+  if (!fs.existsSync(assetsDir)) {
+    fs.mkdirSync(assetsDir, { recursive: true });
+    console.log('  Created android/app/src/main/assets/');
+  }
+}
+
+function injectGradleApply(projectRoot, buildGradleRelPath, entryFile, options) {
+  const fullPath = path.join(projectRoot, buildGradleRelPath);
+  let content = fs.readFileSync(fullPath, 'utf-8');
+
+  // Idempotent check
+  if (content.includes(APPLY_FROM_MARKER)) {
+    console.log(
+      `  ${buildGradleRelPath}: apply-from already present. Skipping.`
+    );
+    return { buildGradle: buildGradleRelPath, entryFile };
+  }
+
+  // Set entry file as ext property if non-default
+  let entryFileExt = '';
+  if (entryFile && entryFile !== 'index.js') {
+    entryFileExt = `\nproject.ext.debugToolkitEntryFile = '${entryFile}'`;
+  }
+
+  content += '\n\n' + APPLY_FROM_LINE + entryFileExt + '\n';
+  fs.writeFileSync(fullPath, content);
+
+  ensureAssetsDir(projectRoot);
+  console.log(`  ${buildGradleRelPath}: Injected apply-from for debug bundle.`);
+
+  return { buildGradle: buildGradleRelPath, entryFile };
+}
+
+function undoGradleApply(projectRoot, config) {
+  if (!config.android) {
+    console.log('  No Android configuration found. Skipping.');
+    return;
+  }
+
+  const fullPath = path.join(projectRoot, config.android.buildGradle);
+  if (!fs.existsSync(fullPath)) {
+    console.log(`  ${config.android.buildGradle} not found. Skipping.`);
+    return;
+  }
+
+  let content = fs.readFileSync(fullPath, 'utf-8');
+  if (!content.includes(APPLY_FROM_MARKER)) {
+    console.log('  apply-from not found. Skipping.');
+    return;
+  }
+
+  // Remove the marker line, apply-from line, and optional entryFile ext
+  const lines = content.split('\n');
+  const filtered = lines.filter((line) => {
+    if (line === APPLY_FROM_MARKER) return false;
+    if (
+      line.startsWith('apply from:') &&
+      line.includes('react-native-debug-toolkit/scripts/android-debug-bundle.gradle')
+    )
+      return false;
+    if (line.startsWith("project.ext.debugToolkitEntryFile = '")) return false;
+    return true;
+  });
+
+  // Trim trailing empty lines introduced by our injection
+  while (filtered.length > 0 && filtered[filtered.length - 1].trim() === '') {
+    filtered.pop();
+  }
+
+  fs.writeFileSync(fullPath, filtered.join('\n') + '\n');
+  console.log('  Removed apply-from from build.gradle.');
+}
+
+module.exports = {
+  findBuildGradle,
+  injectGradleApply,
+  undoGradleApply,
+};

package/scripts/embed-expo.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function isExpoProject(projectRoot) {
+  // app.json with expo field
+  const appJsonPath = path.join(projectRoot, 'app.json');
+  if (fs.existsSync(appJsonPath)) {
+    try {
+      const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf-8'));
+      if (appJson.expo) return true;
+    } catch (_) {}
+  }
+
+  // app.config.js or app.config.ts
+  if (
+    fs.existsSync(path.join(projectRoot, 'app.config.js')) ||
+    fs.existsSync(path.join(projectRoot, 'app.config.ts'))
+  ) {
+    return true;
+  }
+
+  // expo in package.json dependencies
+  const pkgPath = path.join(projectRoot, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.expo) return true;
+    } catch (_) {}
+  }
+
+  return false;
+}
+
+function isExpoGo(projectRoot) {
+  // Expo Go doesn't support embedded bundles
+  // If no ios/ or android/ dirs, likely Expo Go
+  const hasNativeDirs =
+    fs.existsSync(path.join(projectRoot, 'ios')) ||
+    fs.existsSync(path.join(projectRoot, 'android'));
+
+  if (!hasNativeDirs) {
+    return true;
+  }
+  return false;
+}
+
+function isPrebuilt(projectRoot) {
+  // Dev client / bare workflow after prebuild
+  return (
+    fs.existsSync(path.join(projectRoot, 'ios')) &&
+    fs.existsSync(path.join(projectRoot, 'android'))
+  );
+}
+
+function getExpoEntryPoint(projectRoot) {
+  const appJsonPath = path.join(projectRoot, 'app.json');
+  if (fs.existsSync(appJsonPath)) {
+    try {
+      const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf-8'));
+      if (appJson.expo && appJson.expo.entryPoint) {
+        return appJson.expo.entryPoint;
+      }
+    } catch (_) {}
+  }
+
+  // Expo default with .expo virtual entry
+  const virtualEntry = path.join(
+    projectRoot,
+    '.expo',
+    '.virtual-metro-entry'
+  );
+  if (fs.existsSync(virtualEntry)) {
+    return '.expo/.virtual-metro-entry';
+  }
+
+  return null;
+}
+
+function checkExpo(projectRoot, options) {
+  const expo = isExpoProject(projectRoot);
+  if (!expo) {
+    return { expo: false, skip: false };
+  }
+
+  if (isExpoGo(projectRoot)) {
+    return {
+      expo: true,
+      skip: true,
+      reason:
+        'Expo Go does not support embedded bundles. Use expo-dev-client or run npx expo prebuild first.',
+    };
+  }
+
+  if (!isPrebuilt(projectRoot)) {
+    return {
+      expo: true,
+      skip: true,
+      reason:
+        'Native directories not found. Run npx expo prebuild first, then retry.',
+    };
+  }
+
+  return { expo: true, skip: false, entryPoint: getExpoEntryPoint(projectRoot) };
+}
+
+module.exports = { isExpoProject, checkExpo, getExpoEntryPoint };

package/scripts/embed-ios.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const pbxproj = require('pbxproj');
+
+const BUNDLE_PHASE_NAME = 'Bundle React Native code and images';
+const FORCE_BUNDLING_LINE = 'export FORCE_BUNDLING=1';
+const CONFIG_FILE = '.debug-toolkit-embed.json';
+
+function findXcodeproj(projectRoot) {
+  const iosDir = path.join(projectRoot, 'ios');
+  if (!fs.existsSync(iosDir)) {
+    return null;
+  }
+  const entries = fs.readdirSync(iosDir).filter(
+    (e) => e.endsWith('.xcodeproj') && e !== 'Pods.xcodeproj'
+  );
+  if (entries.length === 0) {
+    return null;
+  }
+  return entries;
+}
+
+function findPbxproj(xcodeprojPath) {
+  const pbxPath = path.join(xcodeprojPath, 'project.pbxproj');
+  if (!fs.existsSync(pbxPath)) {
+    throw new Error(`project.pbxproj not found at ${pbxPath}`);
+  }
+  return pbxPath;
+}
+
+function getBundleScriptPhase(pbxFile) {
+  const proj = new pbxproj(pbxFile).parseSync();
+  const sections = proj.hash.project.objects.PBXShellScriptBuildPhase;
+  if (!sections) {
+    return null;
+  }
+  for (const [key, section] of Object.entries(sections)) {
+    if (
+      section.name === BUNDLE_PHASE_NAME ||
+      section.name === `"${BUNDLE_PHASE_NAME}"`
+    ) {
+      return { id: key, section, proj, pbxFile };
+    }
+  }
+  return null;
+}
+
+function injectForceBundling(projectRoot, xcodeprojRelPath, entryFile, options) {
+  const xcodeprojPath = path.join(projectRoot, xcodeprojRelPath);
+  const pbxFile = findPbxproj(xcodeprojPath);
+  const result = getBundleScriptPhase(pbxFile);
+  if (!result) {
+    throw new Error(
+      `"${BUNDLE_PHASE_NAME}" script phase not found in ${xcodeprojRelPath}`
+    );
+  }
+
+  const scriptBody = result.section.shellScript;
+  // Already injected — idempotent
+  if (scriptBody && scriptBody.includes(FORCE_BUNDLING_LINE)) {
+    console.log(`  ${xcodeprojRelPath}: FORCE_BUNDLING already set. Skipping.`);
+    return { xcodeproj: xcodeprojRelPath, scriptPhaseId: result.id, entryFile };
+  }
+
+  // Decode shellScript (it's usually a quoted string)
+  let decoded = scriptBody;
+  try {
+    decoded = JSON.parse(scriptBody);
+  } catch (_) {
+    // Not JSON-encoded, use as-is
+  }
+
+  const newScript = FORCE_BUNDLING_LINE + '\n' + decoded;
+  result.section.shellScript = JSON.stringify(newScript);
+
+  fs.writeFileSync(pbxFile, result.proj.writeSync());
+  console.log(`  ${xcodeprojRelPath}: Injected FORCE_BUNDLING=1`);
+
+  return { xcodeproj: xcodeprojRelPath, scriptPhaseId: result.id, entryFile };
+}
+
+function undoForceBundling(projectRoot, config) {
+  if (!config.ios) {
+    console.log('  No iOS configuration found. Skipping.');
+    return;
+  }
+
+  const xcodeprojPath = path.join(projectRoot, config.ios.xcodeproj);
+  const pbxFile = findPbxproj(xcodeprojPath);
+  const result = getBundleScriptPhase(pbxFile);
+  if (!result) {
+    console.log('  Bundle script phase not found. Skipping.');
+    return;
+  }
+
+  const scriptBody = result.section.shellScript;
+  let decoded = scriptBody;
+  try {
+    decoded = JSON.parse(scriptBody);
+  } catch (_) {}
+
+  if (!decoded.includes(FORCE_BUNDLING_LINE)) {
+    console.log('  FORCE_BUNDLING not found in script. Skipping.');
+    return;
+  }
+
+  const newScript = decoded
+    .split('\n')
+    .filter((line) => line !== FORCE_BUNDLING_LINE)
+    .join('\n');
+  result.section.shellScript = JSON.stringify(newScript);
+
+  fs.writeFileSync(pbxFile, result.proj.writeSync());
+  console.log('  Removed FORCE_BUNDLING=1 from script phase.');
+}
+
+module.exports = { findXcodeproj, injectForceBundling, undoForceBundling };

package/scripts/embed.js

@@ -0,0 +1,224 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const ios = require('./embed-ios');
+const android = require('./embed-android');
+const expo = require('./embed-expo');
+
+const CONFIG_FILE = '.debug-toolkit-embed.json';
+
+function readConfig(projectRoot) {
+  const configPath = path.join(projectRoot, CONFIG_FILE);
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+}
+
+function writeConfig(projectRoot, config) {
+  const configPath = path.join(projectRoot, CONFIG_FILE);
+  const payload = { version: 1, ...config };
+  fs.writeFileSync(configPath, JSON.stringify(payload, null, 2) + '\n');
+}
+
+function deleteConfig(projectRoot) {
+  const configPath = path.join(projectRoot, CONFIG_FILE);
+  if (fs.existsSync(configPath)) {
+    fs.unlinkSync(configPath);
+  }
+}
+
+function detectEntryFile(projectRoot) {
+  const candidates = [
+    'index.js',
+    'index.ts',
+    'index.tsx',
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(path.join(projectRoot, candidate))) {
+      return candidate;
+    }
+  }
+
+  // Expo virtual entry
+  if (fs.existsSync(path.join(projectRoot, '.expo', '.virtual-metro-entry'))) {
+    return '.expo/.virtual-metro-entry';
+  }
+
+  return 'index.js';
+}
+
+function prompt(question, options) {
+  if (options && options.yes) {
+    return Promise.resolve(true);
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question + ' [Y/n] ', (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() !== 'n');
+    });
+  });
+}
+
+async function embed(projectRoot, argv) {
+  const args = argv || [];
+  const yes = args.includes('--yes');
+  const platformIdx = args.indexOf('--platform');
+  const platform =
+    platformIdx >= 0 ? args[platformIdx + 1] : null; // 'ios' | 'android'
+
+  console.log('debug-toolkit embed');
+  console.log('---');
+
+  // Check Expo
+  const expoResult = expo.checkExpo(projectRoot, { yes });
+  if (expoResult.expo) {
+    console.log('Detected Expo project.');
+    if (expoResult.skip) {
+      console.log(`  Skipping: ${expoResult.reason}`);
+      if (platform === null || platform === 'ios') {
+        // nothing
+      }
+      return;
+    }
+    console.log('  Native directories found — proceeding.');
+  }
+
+  const existingConfig = readConfig(projectRoot);
+  const config = {};
+
+  // Entry file
+  const entryFile =
+    (expoResult.entryPoint) || detectEntryFile(projectRoot);
+  console.log(`Entry file: ${entryFile}`);
+
+  // iOS
+  if (platform === null || platform === 'ios') {
+    const xcodeprojEntries = ios.findXcodeproj(projectRoot);
+    if (xcodeprojEntries && xcodeprojEntries.length > 0) {
+      let chosen = xcodeprojEntries[0];
+      if (xcodeprojEntries.length > 1) {
+        if (yes) {
+          console.log(
+            `  Multiple Xcode projects found. Using: ${chosen}`
+          );
+        } else {
+          console.log('  Multiple Xcode projects found:');
+          xcodeprojEntries.forEach((e, i) =>
+            console.log(`    ${i + 1}. ${e}`)
+          );
+          const idx = await prompt(
+            `  Select project [1-${xcodeprojEntries.length}]`,
+            { yes }
+          );
+          // Default to first
+          chosen = xcodeprojEntries[0];
+        }
+      }
+
+      const xcodeprojRelPath = path.join('ios', chosen);
+      const shouldEmbed =
+        yes ||
+        (await prompt(
+          `  Inject FORCE_BUNDLING into ${xcodeprojRelPath}?`,
+          { yes }
+        ));
+
+      if (shouldEmbed !== false) {
+        config.ios = ios.injectForceBundling(
+          projectRoot,
+          xcodeprojRelPath,
+          entryFile,
+          { yes }
+        );
+      }
+    } else {
+      console.log('  No Xcode project found. Skipping iOS.');
+    }
+  }
+
+  // Android
+  if (platform === null || platform === 'android') {
+    const buildGradle = android.findBuildGradle(projectRoot);
+    if (buildGradle) {
+      const shouldEmbed =
+        yes ||
+        (await prompt(
+          `  Inject debug bundle task into ${buildGradle}?`,
+          { yes }
+        ));
+
+      if (shouldEmbed !== false) {
+        config.android = android.injectGradleApply(
+          projectRoot,
+          buildGradle,
+          entryFile,
+          { yes }
+        );
+      }
+    } else {
+      console.log('  No Android build.gradle found. Skipping Android.');
+    }
+  }
+
+  // Write config
+  if (Object.keys(config).length > 0) {
+    writeConfig(projectRoot, config);
+    console.log(`\nConfiguration saved to ${CONFIG_FILE}`);
+  }
+
+  console.log('\nDone. Debug builds will now embed a JS bundle.');
+  console.log('Use DevConnect to switch Metro hosts at runtime.');
+}
+
+async function undo(projectRoot, argv) {
+  const args = argv || [];
+  const yes = args.includes('--yes');
+
+  console.log('debug-toolkit embed --undo');
+  console.log('---');
+
+  const config = readConfig(projectRoot);
+  if (!config) {
+    console.log(`No ${CONFIG_FILE} found. Nothing to undo.`);
+    return;
+  }
+
+  const shouldUndo =
+    yes || (await prompt('Remove all debug-toolkit embed injections?', { yes }));
+
+  if (shouldUndo === false) {
+    console.log('Cancelled.');
+    return;
+  }
+
+  ios.undoForceBundling(projectRoot, config);
+  android.undoGradleApply(projectRoot, config);
+
+  deleteConfig(projectRoot);
+  console.log(`\nRemoved ${CONFIG_FILE}.`);
+  console.log('Done.');
+}
+
+function main(argv) {
+  const projectRoot = process.cwd();
+  const args = argv || [];
+
+  if (args.includes('--undo')) {
+    return undo(projectRoot, args);
+  }
+
+  return embed(projectRoot, args);
+}
+
+module.exports = { main, embed, undo };