@sentry/wizard 3.14.1 → 3.16.0

package/src/apple/apple-wizard.ts

@@ -109,6 +109,7 @@ async function runAppleWizardWithTelementry(
 
   if (availableTargets.length == 0) {
     clack.log.error(`No suttable target found in ${xcodeProjFile}`);
+    Sentry.setTag('No-Target', true);
     await abort();
     return;
   }
@@ -131,6 +132,7 @@ async function runAppleWizardWithTelementry(
   );
 
   let hasCocoa = cocoapod.usesCocoaPod(projectDir);
+  Sentry.setTag('cocoapod-exists', hasCocoa);
 
   if (hasCocoa) {
     const pm = (
@@ -147,6 +149,7 @@ async function runAppleWizardWithTelementry(
       const podAdded = await traceStep('Add CocoaPods reference', () =>
         cocoapod.addCocoaPods(projectDir),
       );
+      Sentry.setTag('cocoapod-added', podAdded);
       if (!podAdded) {
         clack.log.warn(
           "Could not add Sentry pod to your Podfile. You'll have to add it manually.\nPlease follow the instructions at https://docs.sentry.io/platforms/apple/guides/ios/#install",
@@ -155,11 +158,11 @@ async function runAppleWizardWithTelementry(
     }
   }
 
+  Sentry.setTag('package-manager', hasCocoa ? 'cocoapods' : 'SPM');
   traceStep('Update Xcode project', () => {
     xcProject.updateXcodeProject(project, target, apiKey, !hasCocoa, true);
   });
 
-  Sentry.setTag('package-manager', hasCocoa ? 'cocoapods' : 'SPM');
   const codeAdded = traceStep('Add code snippet', () => {
     const files = xcProject.filesForTarget(target);
     if (files === undefined || files.length == 0) return false;
@@ -170,18 +173,23 @@ async function runAppleWizardWithTelementry(
       project.keys[0].dsn.public,
     );
   });
+
+  Sentry.setTag('Snippet-Added', codeAdded);
+
   if (!codeAdded) {
     clack.log.warn(
       'Added the Sentry dependency to your project but could not add the Sentry code snippet. Please add the code snipped manually by following the docs: https://docs.sentry.io/platforms/apple/guides/ios/#configure',
     );
-    return;
   }
 
-  if (fastlane.fastFile(projectDir)) {
+  const hasFastlane = fastlane.fastFile(projectDir);
+  Sentry.setTag('fastlane-exists', hasFastlane);
+  if (hasFastlane) {
     const addLane = await clack.confirm({
       message:
         'Found a Fastfile in your project. Do you want to configure a lane to upload debug symbols to Sentry?',
     });
+    Sentry.setTag('fastlane-desired', addLane);
     if (addLane) {
       const added = await traceStep('Configure fastlane', () =>
         fastlane.addSentryToFastlane(
@@ -190,6 +198,7 @@ async function runAppleWizardWithTelementry(
           project.slug,
         ),
       );
+      Sentry.setTag('fastlane-added', added);
       if (added) {
         clack.log.step(
           'A new step was added to your fastlane file. Now and you build your project with fastlane, debug symbols and source context will be uploaded to Sentry.',

package/src/apple/cocoapod.ts

@@ -4,6 +4,7 @@ import * as bash from '../utils/bash';
 import * as Sentry from '@sentry/node';
 // @ts-ignore - clack is ESM and TS complains about that. It works though
 import * as clack from '@clack/prompts';
+import chalk from 'chalk';
 
 export function usesCocoaPod(projPath: string): boolean {
   return fs.existsSync(path.join(projPath, 'Podfile'));
@@ -40,21 +41,31 @@ export async function addCocoaPods(projPath: string): Promise<boolean> {
     podContent.slice(insertIndex);
   fs.writeFileSync(podfile, newFileContent, 'utf8');
 
-  const loginSpinner = clack.spinner();
-
   clack.log.step('Sentry pod added to the project podFile.');
-  loginSpinner.start("Running 'pod install'. This may take a few minutes...");
+
+  await podInstall();
+
+  return true;
+}
+
+export async function podInstall(dir = '.') {
+  const installSpinner = clack.spinner();
+  installSpinner.start("Running 'pod install'. This may take a few minutes...");
 
   try {
-    await bash.execute('pod install --silent');
-    loginSpinner.stop('Running "pod install"');
+    await bash.execute(`cd ${dir} && pod repo update`);
+    await bash.execute(`cd ${dir} && pod install --silent`);
+    installSpinner.stop('Pods installed.');
   } catch (e) {
-    loginSpinner.stop('Running "pod install"');
+    installSpinner.stop('Failed to install pods.');
     clack.log.error(
-      'Failed to run "pod install". You can run it manually for more details.',
+      `${chalk.red(
+        'Encountered the following error during pods installation:',
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      )}\n\n${e}\n\n${chalk.dim(
+        'If you think this issue is caused by the Sentry wizard, let us know here:\nhttps://github.com/getsentry/sentry-wizard/issues',
+      )}`,
     );
     Sentry.captureException('Sentry pod install failed.');
   }
-
-  return true;
 }

package/src/nextjs/nextjs-wizard.ts

@@ -87,7 +87,7 @@ export async function runNextjsWizardWithTelemetry(
     createExamplePage(selfHosted, selectedProject, sentryUrl),
   );
 
-  await addSentryCliConfig(authToken);
+  await addSentryCliConfig({ authToken });
 
   const mightBeUsingVercel = fs.existsSync(
     path.join(process.cwd(), 'vercel.json'),

package/src/react-native/glob.ts

@@ -0,0 +1,13 @@
+import glob from 'glob';
+
+export const XCODE_PROJECT = 'ios/*.xcodeproj/project.pbxproj';
+export const APP_BUILD_GRADLE = '**/app/build.gradle';
+
+const IGNORE_PATTERNS = ['node_modules/**', 'ios/Pods/**', '**/Pods/**'];
+export function getFirstMatchedPath(pattern: string): string | undefined {
+  const matches = glob.sync(pattern, {
+    ignore: IGNORE_PATTERNS,
+  });
+
+  return matches[0];
+}

package/src/react-native/gradle.ts

@@ -0,0 +1,26 @@
+import * as fs from 'fs';
+
+const applyFrom = `apply from: new File(["node", "--print", "require.resolve('@sentry/react-native/package.json')"].execute().text.trim(), "../sentry.gradle")`;
+
+export function doesAppBuildGradleIncludeRNSentryGradlePlugin(
+  content: string,
+): boolean {
+  return content.includes('sentry.gradle');
+}
+
+export function addRNSentryGradlePlugin(content: string): string {
+  return content.replace(/^android {/m, (match) => `${applyFrom}\n${match}`);
+}
+
+export function removeRNSentryGradlePlugin(content: string): string {
+  return content.replace(/^\s*apply from:.*sentry\.gradle.*;?\s*?\r?\n/m, '');
+}
+
+export function writeAppBuildGradle(path: string, newContent: string): void {
+  const currentContent = fs.readFileSync(path, 'utf-8');
+  if (newContent === currentContent) {
+    return;
+  }
+
+  fs.writeFileSync(path, newContent, 'utf-8');
+}

package/src/react-native/javascript.ts

@@ -0,0 +1,33 @@
+import { makeCodeSnippet } from '../utils/clack-utils';
+
+export function addSentryInitWithSdkImport(
+  js: string,
+  { dsn }: { dsn: string },
+): string {
+  return js.replace(
+    /^([^]*)(import\s+[^;]*?;$)/m,
+    (match: string) => `${match}
+${getSentryInitPlainTextSnippet(dsn)}`,
+  );
+}
+
+export function doesJsCodeIncludeSdkSentryImport(
+  js: string,
+  { sdkPackageName }: { sdkPackageName: string },
+): boolean {
+  return !!js.match(sdkPackageName);
+}
+
+export function getSentryInitColoredCodeSnippet(dsn: string) {
+  return makeCodeSnippet(true, (_unchanged, plus, _minus) => {
+    return plus(getSentryInitPlainTextSnippet(dsn));
+  });
+}
+
+export function getSentryInitPlainTextSnippet(dsn: string) {
+  return `import * as Sentry from '@sentry/react-native';
+
+Sentry.init({
+  dsn: '${dsn}',
+});`;
+}

package/src/react-native/options.ts

@@ -0,0 +1,5 @@
+import { WizardOptions } from '../utils/types';
+
+export interface ReactNativeWizardOptions extends WizardOptions {
+  uninstall: boolean;
+}

package/src/react-native/react-native-wizard.ts

@@ -0,0 +1,369 @@
+/* eslint-disable max-lines */
+// @ts-ignore - clack is ESM and TS complains about that. It works though
+import clack from '@clack/prompts';
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as process from 'process';
+import {
+  CliSetupConfigContent,
+  addSentryCliConfig,
+  confirmContinueIfNoOrDirtyGitRepo,
+  confirmContinueIfPackageVersionNotSupported,
+  ensurePackageIsInstalled,
+  getOrAskForProjectData,
+  getPackageDotJson,
+  installPackage,
+  printWelcome,
+  propertiesCliSetupConfig,
+  showCopyPasteInstructions,
+} from '../utils/clack-utils';
+import { getPackageVersion, hasPackageInstalled } from '../utils/package-json';
+import { podInstall } from '../apple/cocoapod';
+import { platform } from 'os';
+import {
+  getValidExistingBuildPhases,
+  findBundlePhase,
+  patchBundlePhase,
+  findDebugFilesUploadPhase,
+  addDebugFilesUploadPhase,
+  writeXcodeProject,
+} from './xcode';
+import {
+  doesAppBuildGradleIncludeRNSentryGradlePlugin,
+  addRNSentryGradlePlugin,
+  writeAppBuildGradle,
+} from './gradle';
+import { runReactNativeUninstall } from './uninstall';
+import { APP_BUILD_GRADLE, XCODE_PROJECT, getFirstMatchedPath } from './glob';
+import { ReactNativeWizardOptions } from './options';
+import { SentryProjectData } from '../utils/types';
+import {
+  addSentryInitWithSdkImport,
+  doesJsCodeIncludeSdkSentryImport,
+  getSentryInitColoredCodeSnippet,
+} from './javascript';
+import { traceStep, withTelemetry } from '../telemetry';
+import * as Sentry from '@sentry/node';
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const xcode = require('xcode');
+
+export const RN_SDK_PACKAGE = '@sentry/react-native';
+
+export const RN_PACKAGE = 'react-native';
+export const RN_HUMAN_NAME = 'React Native';
+
+export const SUPPORTED_RN_RANGE = '>=0.69.0';
+
+export type RNCliSetupConfigContent = Pick<
+  Required<CliSetupConfigContent>,
+  'authToken' | 'org' | 'project' | 'url'
+>;
+
+export async function runReactNativeWizard(
+  params: ReactNativeWizardOptions,
+): Promise<void> {
+  return withTelemetry(
+    {
+      enabled: params.telemetryEnabled,
+      integration: 'react-native',
+    },
+    () => runReactNativeWizardWithTelemetry(params),
+  );
+}
+
+export async function runReactNativeWizardWithTelemetry(
+  options: ReactNativeWizardOptions,
+): Promise<void> {
+  if (options.uninstall) {
+    Sentry.setTag('uninstall', true);
+    return runReactNativeUninstall(options);
+  }
+
+  printWelcome({
+    wizardName: 'Sentry React Native Wizard',
+    promoCode: options.promoCode,
+    telemetryEnabled: options.telemetryEnabled,
+  });
+
+  await confirmContinueIfNoOrDirtyGitRepo();
+
+  const packageJson = await getPackageDotJson();
+
+  await ensurePackageIsInstalled(packageJson, RN_PACKAGE, RN_HUMAN_NAME);
+
+  const rnVersion = getPackageVersion(RN_PACKAGE, packageJson);
+  if (rnVersion) {
+    await confirmContinueIfPackageVersionNotSupported({
+      packageName: RN_HUMAN_NAME,
+      packageVersion: rnVersion,
+      packageId: RN_PACKAGE,
+      acceptableVersions: SUPPORTED_RN_RANGE,
+    });
+  }
+
+  const { selectedProject, authToken, sentryUrl } =
+    await getOrAskForProjectData(options, 'react-native');
+  const orgSlug = selectedProject.organization.slug;
+  const projectSlug = selectedProject.slug;
+  const cliConfig: RNCliSetupConfigContent = {
+    authToken,
+    org: orgSlug,
+    project: projectSlug,
+    url: sentryUrl,
+  };
+
+  await installPackage({
+    packageName: RN_SDK_PACKAGE,
+    alreadyInstalled: hasPackageInstalled(RN_SDK_PACKAGE, packageJson),
+  });
+
+  await traceStep('patch-js', () =>
+    addSentryInit({ dsn: selectedProject.keys[0].dsn.public }),
+  );
+
+  if (fs.existsSync('ios')) {
+    Sentry.setTag('patch-ios', true);
+    await traceStep('patch-xcode-files', () => patchXcodeFiles(cliConfig));
+  }
+
+  if (fs.existsSync('android')) {
+    Sentry.setTag('patch-android', true);
+    await traceStep('patch-android-files', () => patchAndroidFiles(cliConfig));
+  }
+
+  const confirmedFirstException = await confirmFirstSentryException(
+    selectedProject,
+  );
+  Sentry.setTag('user-confirmed-first-error', confirmedFirstException);
+
+  if (confirmedFirstException) {
+    clack.outro(
+      `${chalk.green('Everything is set up!')}
+
+   ${chalk.dim(
+     'If you encounter any issues, let us know here: https://github.com/getsentry/sentry-react-native/issues',
+   )}`,
+    );
+  } else {
+    clack.outro(
+      `${chalk.dim(
+        'Let us know here: https://github.com/getsentry/sentry-react-native/issues',
+      )}`,
+    );
+  }
+}
+
+async function addSentryInit({ dsn }: { dsn: string }) {
+  const prefixGlob = '{.,./src}';
+  const suffixGlob = '@(j|t|cj|mj)s?(x)';
+  const universalGlob = `App.${suffixGlob}`;
+  const jsFileGlob = `${prefixGlob}/+(${universalGlob})`;
+  const jsPath = traceStep('find-app-js-file', () =>
+    getFirstMatchedPath(jsFileGlob),
+  );
+  Sentry.setTag('app-js-file-status', jsPath ? 'found' : 'not-found');
+  if (!jsPath) {
+    clack.log.warn(
+      `Could not find main App file using ${chalk.cyan(jsFileGlob)}.`,
+    );
+    await showCopyPasteInstructions(
+      'App.js',
+      getSentryInitColoredCodeSnippet(dsn),
+      'This ensures the Sentry SDK is ready to capture errors.',
+    );
+    return;
+  }
+  const jsRelativePath = path.relative(process.cwd(), jsPath);
+
+  const js = fs.readFileSync(jsPath, 'utf-8');
+  const includesSentry = doesJsCodeIncludeSdkSentryImport(js, {
+    sdkPackageName: RN_SDK_PACKAGE,
+  });
+  if (includesSentry) {
+    Sentry.setTag('app-js-file-status', 'already-includes-sentry');
+    clack.log.warn(
+      `${chalk.cyan(
+        jsRelativePath,
+      )} already includes Sentry. We wont't add it again.`,
+    );
+    return;
+  }
+
+  traceStep('add-sentry-init', () => {
+    const newContent = addSentryInitWithSdkImport(js, { dsn });
+
+    clack.log.success(
+      `Added ${chalk.cyan('Sentry.init')} to ${chalk.cyan(jsRelativePath)}.`,
+    );
+
+    fs.writeFileSync(jsPath, newContent, 'utf-8');
+  });
+
+  Sentry.setTag('app-js-file-status', 'added-sentry-init');
+  clack.log.success(
+    chalk.green(`${chalk.cyan(jsRelativePath)} changes saved.`),
+  );
+}
+
+async function confirmFirstSentryException(project: SentryProjectData) {
+  const projectsIssuesUrl = `${project.organization.links.organizationUrl}/issues/?project=${project.id}`;
+
+  clack.log
+    .step(`To make sure everything is set up correctly, put the following code snippet into your application.
+The snippet will create a button that, when tapped, sends a test event to Sentry.
+
+After that check your project issues:
+
+${chalk.cyan(projectsIssuesUrl)}`);
+
+  // We want the code snippet to be easily copy-pasteable, without any clack artifacts
+  // eslint-disable-next-line no-console
+  console.log(
+    chalk.greenBright(`
+<Button title='Try!' onPress={ () => { Sentry.captureException(new Error('First error')) }}/>
+`),
+  );
+
+  const firstErrorConfirmed = clack.confirm({
+    message: `Have you successfully sent a test event?`,
+  });
+
+  return firstErrorConfirmed;
+}
+
+async function patchXcodeFiles(config: RNCliSetupConfigContent) {
+  await addSentryCliConfig(config, {
+    ...propertiesCliSetupConfig,
+    name: 'source maps and iOS debug files',
+    filename: 'ios/sentry.properties',
+    gitignore: false,
+  });
+
+  if (platform() === 'darwin') {
+    await traceStep('pod-install', () => podInstall('ios'));
+    Sentry.setTag('pods-installed', true);
+  }
+
+  const xcodeProjectPath = traceStep('find-xcode-project', () =>
+    getFirstMatchedPath(XCODE_PROJECT),
+  );
+  Sentry.setTag(
+    'xcode-project-status',
+    xcodeProjectPath ? 'found' : 'not-found',
+  );
+  if (!xcodeProjectPath) {
+    clack.log.warn(
+      `Could not find Xcode project file using ${chalk.cyan(XCODE_PROJECT)}.`,
+    );
+    return;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const [xcodeProject, buildPhasesMap] = traceStep(
+    'parse-xcode-project',
+    () => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+      const project = xcode.project(xcodeProjectPath);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+      project.parseSync();
+
+      const map = getValidExistingBuildPhases(project);
+      return [project, map];
+    },
+  );
+  Sentry.setTag('xcode-project-status', 'parsed');
+
+  traceStep('patch-bundle-phase', () => {
+    const bundlePhase = findBundlePhase(buildPhasesMap);
+    Sentry.setTag(
+      'xcode-bundle-phase-status',
+      bundlePhase ? 'found' : 'not-found',
+    );
+    patchBundlePhase(bundlePhase);
+    Sentry.setTag('xcode-bundle-phase-status', 'patched');
+  });
+
+  traceStep('add-debug-files-upload-phase', () => {
+    const debugFilesUploadPhaseExists =
+      !!findDebugFilesUploadPhase(buildPhasesMap);
+    Sentry.setTag(
+      'xcode-debug-files-upload-phase-status',
+      debugFilesUploadPhaseExists ? 'already-exists' : undefined,
+    );
+    addDebugFilesUploadPhase(xcodeProject, { debugFilesUploadPhaseExists });
+    Sentry.setTag('xcode-debug-files-upload-phase-status', 'added');
+  });
+
+  traceStep('write-xcode-project', () => {
+    writeXcodeProject(xcodeProjectPath, xcodeProject);
+  });
+  Sentry.setTag('xcode-project-status', 'patched');
+}
+
+async function patchAndroidFiles(config: RNCliSetupConfigContent) {
+  await addSentryCliConfig(config, {
+    ...propertiesCliSetupConfig,
+    name: 'source maps and iOS debug files',
+    filename: 'android/sentry.properties',
+    gitignore: false,
+  });
+
+  const appBuildGradlePath = traceStep('find-app-build-gradle', () =>
+    getFirstMatchedPath(APP_BUILD_GRADLE),
+  );
+  Sentry.setTag(
+    'app-build-gradle-status',
+    appBuildGradlePath ? 'found' : 'not-found',
+  );
+  if (!appBuildGradlePath) {
+    clack.log.warn(
+      `Could not find Android ${chalk.cyan(
+        'app/build.gradle',
+      )} file using ${chalk.cyan(APP_BUILD_GRADLE)}.`,
+    );
+    return;
+  }
+
+  const appBuildGradle = traceStep('read-app-build-gradle', () =>
+    fs.readFileSync(appBuildGradlePath, 'utf-8'),
+  );
+  const includesSentry =
+    doesAppBuildGradleIncludeRNSentryGradlePlugin(appBuildGradle);
+  if (includesSentry) {
+    Sentry.setTag('app-build-gradle-status', 'already-includes-sentry');
+    clack.log.warn(
+      `Android ${chalk.cyan('app/build.gradle')} file already includes Sentry.`,
+    );
+    return;
+  }
+
+  const patchedAppBuildGradle = traceStep('add-rn-sentry-gradle-plugin', () =>
+    addRNSentryGradlePlugin(appBuildGradle),
+  );
+  if (!doesAppBuildGradleIncludeRNSentryGradlePlugin(patchedAppBuildGradle)) {
+    Sentry.setTag(
+      'app-build-gradle-status',
+      'failed-to-add-rn-sentry-gradle-plugin',
+    );
+    clack.log.warn(
+      `Could not add Sentry RN Gradle Plugin to ${chalk.cyan(
+        'app/build.gradle',
+      )}.`,
+    );
+    return;
+  }
+
+  Sentry.setTag('app-build-gradle-status', 'added-rn-sentry-gradle-plugin');
+  clack.log.success(
+    `Added Sentry RN Gradle Plugin to ${chalk.bold('app/build.gradle')}.`,
+  );
+
+  traceStep('write-app-build-gradle', () =>
+    writeAppBuildGradle(appBuildGradlePath, patchedAppBuildGradle),
+  );
+  clack.log.success(
+    chalk.green(`Android ${chalk.cyan('app/build.gradle')} saved.`),
+  );
+}

package/src/react-native/uninstall.ts

@@ -0,0 +1,107 @@
+import * as fs from 'fs';
+// @ts-ignore - clack is ESM and TS complains about that. It works though
+import clack from '@clack/prompts';
+import chalk from 'chalk';
+
+import {
+  confirmContinueIfNoOrDirtyGitRepo,
+  printWelcome,
+} from '../utils/clack-utils';
+import {
+  findBundlePhase,
+  getValidExistingBuildPhases,
+  unPatchBundlePhase,
+  unPatchDebugFilesUploadPhase,
+  writeXcodeProject,
+} from './xcode';
+import { APP_BUILD_GRADLE, XCODE_PROJECT, getFirstMatchedPath } from './glob';
+import {
+  doesAppBuildGradleIncludeRNSentryGradlePlugin,
+  removeRNSentryGradlePlugin,
+  writeAppBuildGradle,
+} from './gradle';
+import { ReactNativeWizardOptions } from './options';
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const xcode = require('xcode');
+
+export async function runReactNativeUninstall(
+  options: ReactNativeWizardOptions,
+): Promise<void> {
+  printWelcome({
+    wizardName: 'Sentry React Native Uninstall Wizard',
+    message: 'This wizard will remove Sentry from your React Native project.',
+    telemetryEnabled: options.telemetryEnabled,
+  });
+
+  await confirmContinueIfNoOrDirtyGitRepo();
+
+  unPatchXcodeFiles();
+
+  unPatchAndroidFiles();
+
+  clack.note(
+    `To make sure your project builds after removing Sentry please run:
+
+1. ${chalk.bold('yarn remove @sentry/react-native')}
+2. ${chalk.bold('cd ios && pod install')}
+3. Remove all occurrences of ${chalk.bold(
+      '@sentry/react-native',
+    )} from your application code.`,
+  );
+
+  clack.outro(
+    `${chalk.green('Uninstall is done!')}
+
+   ${chalk.dim(
+     'If you encounter any issues, let us know here: https://github.com/getsentry/sentry-react-native/issues',
+   )}`,
+  );
+}
+
+function unPatchXcodeFiles() {
+  const xcodeProjectPath = getFirstMatchedPath(XCODE_PROJECT);
+  if (!xcodeProjectPath) {
+    clack.log.warn(
+      `Could not find Xcode project file using ${chalk.bold(XCODE_PROJECT)}.`,
+    );
+    return;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+  const xcodeProject = xcode.project(xcodeProjectPath);
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+  xcodeProject.parseSync();
+  const buildPhases = getValidExistingBuildPhases(xcodeProject);
+
+  const bundlePhase = findBundlePhase(buildPhases);
+  unPatchBundlePhase(bundlePhase);
+
+  unPatchDebugFilesUploadPhase(xcodeProject);
+
+  writeXcodeProject(xcodeProjectPath, xcodeProject);
+}
+
+function unPatchAndroidFiles() {
+  const appBuildGradlePath = getFirstMatchedPath(APP_BUILD_GRADLE);
+  if (!appBuildGradlePath) {
+    clack.log.warn(
+      `Could not find Android app/build.gradle file using ${chalk.bold(
+        APP_BUILD_GRADLE,
+      )}.`,
+    );
+    return;
+  }
+
+  const appBuildGradle = fs.readFileSync(appBuildGradlePath, 'utf-8');
+  const includesSentry =
+    doesAppBuildGradleIncludeRNSentryGradlePlugin(appBuildGradle);
+  if (!includesSentry) {
+    clack.log.warn(`Sentry not found in Android app/build.gradle.`);
+    return;
+  }
+
+  const patchedAppBuildGradle = removeRNSentryGradlePlugin(appBuildGradle);
+
+  writeAppBuildGradle(appBuildGradlePath, patchedAppBuildGradle);
+}