@crumbsdk/react-native 0.0.1-rc.3 → 0.0.1-rc.5

package/tools/ios.cjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+const path = require('node:path');
+const fs = require('node:fs');
+const { spawnSync, execFileSync } = require('node:child_process');
+const { readConfig, isStrict } = require('./config.cjs');
+const { prepareRelease } = require('./release.cjs');
+const { uploadRelease } = require('./upload.cjs');
+
+function plistValue(env, key) {
+  const candidates = [
+    env.TARGET_BUILD_DIR && env.INFOPLIST_PATH
+      ? path.resolve(env.TARGET_BUILD_DIR, env.INFOPLIST_PATH)
+      : undefined,
+    env.INFOPLIST_FILE
+      ? path.resolve(env.PROJECT_DIR, env.INFOPLIST_FILE)
+      : undefined,
+  ];
+  for (const file of candidates) {
+    if (!file || !fs.existsSync(file)) continue;
+    try {
+      const value = execFileSync(
+        '/usr/libexec/PlistBuddy',
+        ['-c', `Print :${key}`, file],
+        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }
+      ).trim();
+      return value.replace(
+        /\$\(([^)]+)\)|\$\{([^}]+)\}/g,
+        (expression, a, b) => env[a || b] || expression
+      );
+    } catch {
+      /* Try the build's other plist source. */
+    }
+  }
+  return undefined;
+}
+
+function main() {
+  const env = { ...process.env };
+  const root = path.resolve(
+    env.PROJECT_ROOT || path.join(env.PROJECT_DIR || process.cwd(), '..')
+  );
+  const config = readConfig(root);
+  const enabled =
+    config.sourceMaps.enabled &&
+    !/Debug/i.test(env.CONFIGURATION || '') &&
+    env.SKIP_BUNDLING !== '1';
+  let manifest;
+  if (enabled) {
+    if (!env.DERIVED_FILE_DIR)
+      throw new Error('Run the Crumb iOS hook from an Xcode build.');
+    manifest = prepareRelease(
+      path.join(env.DERIVED_FILE_DIR, 'crumb', env.TARGET_NAME || 'app')
+    );
+    env.CRUMB_RELEASE_MANIFEST = manifest;
+    env.SOURCEMAP_FILE = path.join(path.dirname(manifest), 'bundle.map');
+  }
+  const [command, ...args] = process.argv.slice(2);
+  if (!command)
+    throw new Error('The original Xcode bundle command is required.');
+  const build = spawnSync(command, args, { env, stdio: 'inherit' });
+  if (build.error || build.status !== 0) {
+    process.exitCode = build.status || 1;
+    return;
+  }
+  if (!manifest) return;
+  const bundle = path.join(
+    env.CONFIGURATION_BUILD_DIR,
+    env.UNLOCALIZED_RESOURCES_FOLDER_PATH,
+    `${env.BUNDLE_NAME || 'main'}.jsbundle`
+  );
+  uploadRelease(
+    {
+      root,
+      manifest,
+      platform: 'ios',
+      appVersion: plistValue(env, 'CFBundleShortVersionString'),
+      nativeBuild: plistValue(env, 'CFBundleVersion'),
+      bundle,
+      sourceMap: env.SOURCEMAP_FILE,
+    },
+    { strict: isStrict(config) }
+  );
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error(`Crumb: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+module.exports = { plistValue };

package/tools/node.cjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+const { spawnSync } = require('node:child_process');
+const { readConfig } = require('./config.cjs');
+const [manifest, ...args] = process.argv.slice(2);
+if (!manifest || !args.length) {
+  console.error(
+    'Crumb build wrapper requires release metadata and the original Node command.'
+  );
+  process.exitCode = 1;
+} else {
+  const result = spawnSync(process.execPath, [...process.execArgv, ...args], {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      CRUMB_RELEASE_MANIFEST: readConfig(process.cwd()).sourceMaps.enabled
+        ? manifest
+        : '',
+    },
+  });
+  process.exitCode = result.status === null ? 1 : result.status;
+}

package/tools/release.cjs

@@ -0,0 +1,65 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { randomUUID, createHash } = require('node:crypto');
+
+function prepareRelease(directory) {
+  fs.mkdirSync(directory, { recursive: true });
+  const bundleVersion = randomUUID();
+  const polyfill = path.join(directory, 'crumb-release.js');
+  fs.writeFileSync(
+    polyfill,
+    `globalThis.__CRUMB_BUNDLE_VERSION__ = ${JSON.stringify(bundleVersion)};\n`
+  );
+  const manifest = path.join(directory, 'release.json');
+  fs.writeFileSync(
+    manifest,
+    JSON.stringify({ version: 1, bundleVersion, polyfill })
+  );
+  return manifest;
+}
+
+function readRelease(file) {
+  const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (
+    value.version !== 1 ||
+    typeof value.bundleVersion !== 'string' ||
+    !/^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/.test(value.bundleVersion) ||
+    typeof value.polyfill !== 'string' ||
+    !path.isAbsolute(value.polyfill)
+  ) {
+    throw new Error(
+      'Crumb release metadata is invalid. Rebuild using the configured Crumb build hook.'
+    );
+  }
+  return value;
+}
+
+function hashFile(file) {
+  return createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function verifyMapIdentity(file, bundleVersion) {
+  if (fs.statSync(file).size > 25 * 1024 * 1024)
+    throw new Error('Source map exceeds the 25 MiB upload limit.');
+  const map = JSON.parse(fs.readFileSync(file, 'utf8'));
+  function contains(value, depth = 0) {
+    if (!value || depth > 8) return false;
+    return (
+      (Array.isArray(value.sourcesContent) &&
+        value.sourcesContent.some(
+          (source) =>
+            typeof source === 'string' &&
+            source.includes('__CRUMB_BUNDLE_VERSION__') &&
+            source.includes(JSON.stringify(bundleVersion))
+        )) ||
+      (Array.isArray(value.sections) &&
+        value.sections.some((section) => contains(section.map, depth + 1)))
+    );
+  }
+  if (!contains(map))
+    throw new Error(
+      'The final map does not contain this build’s Crumb identity. Check the Metro integration and rebuild; no artifacts were uploaded.'
+    );
+}
+
+module.exports = { prepareRelease, readRelease, hashFile, verifyMapIdentity };

package/tools/setup.cjs

@@ -0,0 +1,291 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { readConfig, validateOrigin } = require('./config.cjs');
+const {
+  configureXcodeProject,
+  configureGradle,
+} = require('../plugin/build-hooks.cjs');
+
+const metroMarker = '// crumb-metro';
+
+function setupPlan(root, { sourceMaps, uploadUrl } = {}) {
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(root, 'package.json'), 'utf8')
+  );
+  const dependencies = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (!dependencies['react-native'])
+    throw new Error('Run crumb setup from the React Native app directory.');
+  const expo = Boolean(dependencies.expo);
+  const manager = [
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    'bun.lock',
+    'bun.lockb',
+    'package-lock.json',
+  ].find((name) => fs.existsSync(path.join(root, name)));
+  const changes = [];
+  const instructions = [];
+  const edit = (name, content) => {
+    const file = path.join(root, name);
+    const before = fs.existsSync(file)
+      ? fs.readFileSync(file, 'utf8')
+      : undefined;
+    if (before !== content) changes.push({ name, file, before, content });
+  };
+  const config = readConfig(root);
+  if (sourceMaps !== undefined) config.sourceMaps.enabled = sourceMaps;
+  if (config.sourceMaps.enabled)
+    config.sourceMaps.uploadUrl = validateOrigin(
+      uploadUrl || config.sourceMaps.uploadUrl
+    );
+  edit('crumb.config.json', JSON.stringify(config, null, 2) + '\n');
+  if (!dependencies['react-native-nitro-modules']) {
+    const version =
+      require('../package.json').peerDependencies['react-native-nitro-modules'];
+    const add =
+      manager === 'yarn.lock'
+        ? 'yarn add'
+        : manager === 'pnpm-lock.yaml'
+          ? 'pnpm add'
+          : manager?.startsWith('bun')
+            ? 'bun add'
+            : 'npm install';
+    instructions.push(
+      `Install the required native peer: ${add} react-native-nitro-modules@${JSON.stringify(version)}`
+    );
+  }
+  if (expo) {
+    if (
+      ['app.config.ts', 'app.config.js', 'app.config.mjs'].some((name) =>
+        fs.existsSync(path.join(root, name))
+      )
+    ) {
+      instructions.push(
+        'Add @crumbsdk/react-native to plugins in your dynamic Expo config. Existing dynamic configuration was preserved.'
+      );
+    } else {
+      const appFile = path.join(root, 'app.json');
+      const app = fs.existsSync(appFile)
+        ? JSON.parse(fs.readFileSync(appFile, 'utf8'))
+        : { expo: {} };
+      if (!app.expo)
+        throw new Error(
+          'app.json does not contain an Expo configuration. Add the Crumb plugin manually.'
+        );
+      const plugins = app.expo.plugins || [];
+      if (
+        !plugins.some(
+          (item) =>
+            (Array.isArray(item) ? item[0] : item) === '@crumbsdk/react-native'
+        )
+      ) {
+        app.expo.plugins = [...plugins, '@crumbsdk/react-native'];
+        edit('app.json', JSON.stringify(app, null, 2) + '\n');
+      }
+    }
+    instructions.push(
+      'Run your normal Expo prebuild/development build to apply native configuration. Expo Go cannot load the native SDK.'
+    );
+  } else {
+    const podfile = path.join(root, 'ios/Podfile');
+    if (fs.existsSync(podfile)) {
+      let contents = fs.readFileSync(podfile, 'utf8');
+      if (!contents.includes('crumb_native_pods!')) {
+        if (
+          /pod\s+['"](?:CrumbSDK(?:Core|UI)?|PLCrashReporter)['"]/.test(
+            contents
+          )
+        ) {
+          throw new Error(
+            'Remove manual Crumb/PLCrashReporter pod declarations before using bundled native dependencies.'
+          );
+        }
+        if (/^.*use_native_modules!.*$/m.test(contents)) {
+          contents = contents.replace(
+            /^.*use_native_modules!.*$/m,
+            (line) =>
+              `${line}\n  require File.join(File.dirname(\`node --print "require.resolve('@crumbsdk/react-native/package.json')"\`.strip), 'scripts', 'ios')\n  crumb_native_pods!`
+          );
+          edit('ios/Podfile', contents);
+        } else
+          instructions.push(
+            'Register crumb_native_pods! inside your app target using the manual iOS instructions.'
+          );
+      }
+      instructions.push(
+        'Install the iOS pods using your project’s usual command.'
+      );
+    }
+  }
+  if (config.sourceMaps.enabled) {
+    const ignoreFile = path.join(root, '.gitignore');
+    const ignore = fs.existsSync(ignoreFile)
+      ? fs.readFileSync(ignoreFile, 'utf8')
+      : '';
+    if (!ignore.split(/\r?\n/).includes('/.crumb/'))
+      edit(
+        '.gitignore',
+        `${ignore}\n# Crumb local release artifacts (never commit source maps)\n/.crumb/\n`
+      );
+    const metroFiles = [
+      'metro.config.js',
+      'metro.config.cjs',
+      'metro.config.mjs',
+      'metro.config.ts',
+    ].filter((name) => fs.existsSync(path.join(root, name)));
+    if (metroFiles.length > 1)
+      throw new Error(
+        'Multiple Metro configurations found. Wrap the active configuration with withCrumb manually.'
+      );
+    const metroName =
+      metroFiles[0] ||
+      (pkg.type === 'module' ? 'metro.config.cjs' : 'metro.config.js');
+    const before = metroFiles[0]
+      ? fs.readFileSync(path.join(root, metroName), 'utf8')
+      : undefined;
+    if (
+      before &&
+      !before.includes(metroMarker) &&
+      !before.includes('@crumbsdk/react-native/metro')
+    ) {
+      if (
+        metroName.endsWith('.mjs') ||
+        metroName.endsWith('.ts') ||
+        (pkg.type === 'module' && metroName.endsWith('.js')) ||
+        !before.includes('module.exports')
+      ) {
+        instructions.push(
+          'Wrap your existing Metro config with withCrumb from @crumbsdk/react-native/metro. This configuration format was preserved.'
+        );
+      } else
+        edit(
+          metroName,
+          `${before}\n${metroMarker}\nmodule.exports = require('@crumbsdk/react-native/metro').withCrumb(module.exports);\n`
+        );
+    } else if (!before) {
+      edit(
+        metroName,
+        `const { getDefaultConfig } = require('${expo ? 'expo/metro-config' : '@react-native/metro-config'}');\n${metroMarker}\nmodule.exports = require('@crumbsdk/react-native/metro').withCrumb(getDefaultConfig(__dirname));\n`
+      );
+    }
+    if (!expo) {
+      const gradle = path.join(root, 'android/app/build.gradle');
+      if (fs.existsSync(gradle))
+        edit(
+          'android/app/build.gradle',
+          configureGradle(fs.readFileSync(gradle, 'utf8'))
+        );
+      else
+        instructions.push(
+          'Apply tools/crumb.gradle in your Android application module using the manual instructions.'
+        );
+      const ios = path.join(root, 'ios');
+      const projects = fs.existsSync(ios)
+        ? fs.readdirSync(ios).filter((name) => name.endsWith('.xcodeproj'))
+        : [];
+      if (projects.length === 1) {
+        const name = `ios/${projects[0]}/project.pbxproj`;
+        const project = require('xcode').project(path.join(root, name));
+        project.parseSync();
+        configureXcodeProject(project);
+        // Avoid formatting unrelated project sections on repeat setup.
+        if (
+          !fs
+            .readFileSync(path.join(root, name), 'utf8')
+            .includes('crumb-release-build')
+        )
+          edit(name, project.writeSync());
+      } else
+        instructions.push(
+          'Configure the app’s Xcode bundle phase using the manual instructions; no unique project was selected.'
+        );
+    }
+    instructions.push(
+      'Set CRUMB_SOURCE_MAP_TOKEN as a build secret. Never put it in this config, app initialization, or EXPO_PUBLIC_* variables.'
+    );
+    instructions.push(
+      'Enable diagnostics.javascriptCrashCapture.enabled in Crumb.start. Remove manual release.bundleVersion when using generated build identity.'
+    );
+  }
+  instructions.push(
+    'Keep the native minimum targets at iOS 15.1 and Android API 26 or higher; retain any higher framework requirement.'
+  );
+  instructions.push(
+    'Initialize Crumb with the SDK configuration from your dashboard, then send a test report.'
+  );
+  return { framework: expo ? 'Expo' : 'React Native', changes, instructions };
+}
+
+function applyPlan(plan) {
+  // Check every file before changing any: a preview must not overwrite later user edits.
+  for (const change of plan.changes) {
+    const current = fs.existsSync(change.file)
+      ? fs.readFileSync(change.file, 'utf8')
+      : undefined;
+    if (current !== change.before)
+      throw new Error(
+        `Setup stopped because ${change.name} changed after preview. Run setup again.`
+      );
+  }
+  for (const change of plan.changes) {
+    fs.mkdirSync(path.dirname(change.file), { recursive: true });
+    fs.writeFileSync(change.file, change.content);
+  }
+}
+
+function doctor(root) {
+  const config = readConfig(root);
+  const checks = [];
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(root, 'package.json'), 'utf8')
+  );
+  for (const name of ['@crumbsdk/react-native', 'react-native-nitro-modules']) {
+    try {
+      require.resolve(`${name}/package.json`, { paths: [root] });
+      checks.push({ check: name, status: 'ready' });
+    } catch {
+      checks.push({
+        check: name,
+        status: 'missing',
+        action: 'Install the dependency in this app.',
+      });
+    }
+  }
+  if (config.sourceMaps.enabled) {
+    const metro = [
+      'metro.config.js',
+      'metro.config.cjs',
+      'metro.config.mjs',
+      'metro.config.ts',
+    ].some((name) => {
+      const file = path.join(root, name);
+      return (
+        fs.existsSync(file) &&
+        fs.readFileSync(file, 'utf8').includes('@crumbsdk/react-native/metro')
+      );
+    });
+    checks.push({
+      check: 'Metro release integration',
+      status: metro ? 'configured' : 'missing',
+      action:
+        'Run crumb setup or wrap your existing Metro config with withCrumb.',
+    });
+    checks.push({
+      check: 'Upload credential in this environment',
+      status: process.env.CRUMB_SOURCE_MAP_TOKEN ? 'present' : 'missing',
+      action:
+        'Set the build secret in the environment that runs release builds.',
+    });
+  }
+  return {
+    framework:
+      pkg.dependencies?.expo || pkg.devDependencies?.expo
+        ? 'Expo'
+        : 'React Native',
+    sourceMaps: config.sourceMaps.enabled,
+    checks,
+    note: 'Local checks do not confirm uploaded maps or readable crashes. Build a release and verify a test crash in the dashboard.',
+  };
+}
+
+module.exports = { setupPlan, applyPlan, doctor };

package/tools/upload.cjs

@@ -0,0 +1,137 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { readConfig, isStrict } = require('./config.cjs');
+const { readRelease, hashFile, verifyMapIdentity } = require('./release.cjs');
+
+function uploaderPath() {
+  return path.join(
+    path.dirname(require.resolve('@crumbsdk/source-maps/package.json')),
+    'dist/cli.js'
+  );
+}
+
+function uploadRelease(
+  { root, manifest, platform, appVersion, nativeBuild, bundle, sourceMap },
+  options = {}
+) {
+  const config = readConfig(root);
+  if (!config.sourceMaps.enabled) return { status: 'disabled' };
+  const dryRun = options.dryRun || process.env.CRUMB_SOURCE_MAP_DRY_RUN === '1';
+  try {
+    const release = readRelease(manifest);
+    verifyMapIdentity(sourceMap, release.bundleVersion);
+    for (const value of [appVersion, nativeBuild]) {
+      if (
+        typeof value !== 'string' ||
+        !/^[A-Za-z0-9][A-Za-z0-9._+-]{0,63}$/.test(value)
+      ) {
+        throw new Error(
+          'The final native version/build could not be determined. Use the advanced uploader with the exact built release.'
+        );
+      }
+    }
+    if (!['ios', 'android'].includes(platform))
+      throw new Error('The release platform must be ios or android.');
+    const archive = options.retained
+      ? path.dirname(manifest)
+      : path.join(
+          path.dirname(manifest),
+          'retained',
+          release.bundleVersion,
+          platform
+        );
+    fs.mkdirSync(archive, { recursive: true });
+    function retain(source, name) {
+      const destination = path.join(archive, name);
+      if (fs.existsSync(destination)) {
+        if (hashFile(source) !== hashFile(destination))
+          throw new Error(
+            'Retained release artifacts conflict with this build. Use a new release identity.'
+          );
+      } else fs.copyFileSync(source, destination, fs.constants.COPYFILE_EXCL);
+      return destination;
+    }
+    bundle = retain(bundle, 'bundle');
+    sourceMap = retain(sourceMap, 'bundle.map');
+    manifest = retain(manifest, 'release.json');
+    const retained = {
+      root,
+      manifest,
+      platform,
+      appVersion,
+      nativeBuild,
+      bundle,
+      sourceMap,
+      bundleSha256: hashFile(bundle),
+      sourceMapSha256: hashFile(sourceMap),
+    };
+    const receipt = path.join(
+      path.dirname(manifest),
+      `upload-${platform}-${appVersion}-${nativeBuild}.json`
+    );
+    fs.writeFileSync(receipt, JSON.stringify(retained, null, 2));
+    const args = [
+      uploaderPath(),
+      'upload',
+      '--platform',
+      platform,
+      '--app-version',
+      appVersion,
+      '--native-build',
+      nativeBuild,
+      '--bundle-version',
+      release.bundleVersion,
+      '--bundle',
+      bundle,
+      '--source-map',
+      sourceMap,
+      '--expected-bundle-sha256',
+      retained.bundleSha256,
+      '--expected-source-map-sha256',
+      retained.sourceMapSha256,
+      '--url',
+      config.sourceMaps.uploadUrl,
+    ];
+    if (dryRun) args.push('--dry-run');
+    const result = spawnSync(process.execPath, args, {
+      encoding: 'utf8',
+      timeout: 240000,
+    });
+    if (result.error || result.status !== 0) {
+      throw new Error(
+        `Source maps were not uploaded. Check CRUMB_SOURCE_MAP_TOKEN and the upload origin, then retry with crumb retry --receipt ${JSON.stringify(receipt)}.`
+      );
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status !== (dryRun ? 'dry_run' : 'verified'))
+      throw new Error(
+        'The uploader did not confirm the artifacts. Run crumb doctor and retry.'
+      );
+    console.log(
+      dryRun
+        ? 'Crumb: release artifacts validated locally; no upload performed.'
+        : 'Crumb: source-map artifacts uploaded and verified. Confirm a test crash in the dashboard.'
+    );
+    return output;
+  } catch (error) {
+    if (options.strict || isStrict(config)) throw error;
+    console.warn(`Crumb warning: ${error.message}`);
+    return { status: 'unavailable' };
+  }
+}
+
+function retryUpload(receipt) {
+  const retained = JSON.parse(fs.readFileSync(receipt, 'utf8'));
+  if (
+    hashFile(retained.bundle) !== retained.bundleSha256 ||
+    hashFile(retained.sourceMap) !== retained.sourceMapSha256
+  ) {
+    throw new Error(
+      'Retained artifacts have changed. Restore the exact original files; do not upload a rebuilt bundle under the old identity.'
+    );
+  }
+  return uploadRelease(retained, { strict: true, retained: true });
+}
+
+module.exports = { uploadRelease, retryUpload };