@sentry/wizard 4.0.0 → 4.0.1

package/src/android/gradle.ts

@@ -1,250 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import * as fs from 'fs';
-import { abortIfCancelled, askForItemSelection } from '../utils/clack-utils';
-import {
-  plugin,
-  pluginKts,
-  pluginsBlock,
-  pluginsBlockKts,
-  sourceContext,
-  sourceContextKts,
-} from './templates';
-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';
-import { fetchSdkVersion } from '../utils/release-registry';
-
-/**
- * A Gradle project may contain multiple modules, some of them may be applications, some of them may be libraries.
- * We are only interested in applications. For example:
- *
- * myproject/
- *   app/
- *   lib1/
- *   lib2/
- *   wearApp/
- *
- * In this case^ we are interested in app/ and wearApp/
- *
- * @param buildGradleFiles a list of build.gradle(.kts) paths that contain the com.android.application plugin
- * @returns the selected project for setting up
- */
-export async function selectAppFile(
-  buildGradleFiles: string[],
-): Promise<string> {
-  const appFiles = [];
-  for (let index = 0; index < buildGradleFiles.length; index++) {
-    const file = buildGradleFiles[index];
-    const text = fs.readFileSync(file, 'utf8');
-    if (/\(?["']com\.android\.application["']\)?(?!.*\S)/.test(text)) {
-      appFiles.push(file);
-    }
-  }
-
-  if (appFiles.length === 0) {
-    Sentry.setTag('custom-build-logic', true);
-    const appFile = await abortIfCancelled(
-      clack.text({
-        message: `Unable to find your app's directory. 
-        Please enter the relative path to your app's build.gradle file from the root project`,
-        placeholder: 'app/build.gradle.kts',
-        validate(value) {
-          if (!value.includes('.gradle') || !fs.existsSync(value))
-            return `Not a valid gradle file.`;
-        },
-      }),
-    );
-    return appFile;
-  }
-
-  let appFile;
-  if (appFiles.length === 1) {
-    Sentry.setTag('multiple-projects', false);
-    appFile = appFiles[0];
-  } else {
-    Sentry.setTag('multiple-projects', true);
-    appFile = (
-      await askForItemSelection(
-        appFiles,
-        'Which project do you want to add Sentry to?',
-      )
-    ).value;
-  }
-  Sentry.setTag('custom-build-logic', false);
-  return appFile;
-}
-
-/**
- * Patches a build.gradle(.kts) file that contains `com.android.application` plugin.
- * There are multiple cases we have to handle here:
- *   - An existing `plugins {}` block:
- *     - We just have to add our plugin inside the block
- *   - No existing `plugins {}` block
- *     - We have to add the entire block in the beginning of the file, BUT *after imports*
- *
- * For example (2nd case):
- *
- * ```
- * import net.ltgt.gradle.errorprone.errorprone
- *
- * // our plugins block goes here <--
- * plugins {
- *   id("io.sentry.android.gradle") version "3.12.0"
- * }
- *
- * apply(plugin = "com.android.application")
- *
- * android {
- *   ...
- * }
- * ```
- *
- * In the end we run `./gradlew` to verify the config is build-able and not broken.
- *
- * @param appFile the selected Gradle application project
- * @returns true if successfully added Sentry Gradle config, false otherwise
- */
-export async function addGradlePlugin(
-  appFile: string,
-  orgSlug: string,
-  projectSlug: string,
-): Promise<boolean> {
-  const gradleScript = fs.readFileSync(appFile, 'utf8');
-
-  if (/\(?["']io\.sentry\.android\.gradle["']\)?/.test(gradleScript)) {
-    // sentry gradle plugin is already installed
-    clack.log.success(
-      chalk.greenBright(
-        `${chalk.bold(
-          'Sentry Gradle plugin',
-        )} is already added to the project.`,
-      ),
-    );
-    maybeAddSourceContextConfig(appFile, gradleScript, orgSlug, projectSlug);
-    return true;
-  }
-
-  const pluginVersion = await fetchSdkVersion(
-    'sentry.java.android.gradle-plugin',
-  );
-  const pluginsBlockMatch = /plugins\s*{[^{}]*}/.exec(gradleScript);
-  let newGradleScript;
-  if (!pluginsBlockMatch) {
-    // no "plugins {}" block, we can just add our own after imports
-    const regex = /import\s+[\w.]+/gm;
-    let importsMatch = regex.exec(gradleScript);
-    let insertIndex = 0;
-    while (importsMatch) {
-      insertIndex = importsMatch.index + importsMatch[0].length + 1;
-      importsMatch = regex.exec(gradleScript);
-    }
-
-    if (appFile.endsWith('.kts')) {
-      newGradleScript =
-        gradleScript.slice(0, insertIndex) +
-        pluginsBlockKts(pluginVersion) +
-        gradleScript.slice(insertIndex);
-    } else {
-      newGradleScript =
-        gradleScript.slice(0, insertIndex) +
-        pluginsBlock(pluginVersion) +
-        gradleScript.slice(insertIndex);
-    }
-  } else {
-    const insertIndex =
-      pluginsBlockMatch.index + pluginsBlockMatch[0].length - 1;
-    if (appFile.endsWith('.kts')) {
-      newGradleScript =
-        gradleScript.slice(0, insertIndex) +
-        pluginKts(pluginVersion) +
-        gradleScript.slice(insertIndex);
-    } else {
-      newGradleScript =
-        gradleScript.slice(0, insertIndex) +
-        plugin(pluginVersion) +
-        gradleScript.slice(insertIndex);
-    }
-  }
-  fs.writeFileSync(appFile, newGradleScript, 'utf8');
-
-  maybeAddSourceContextConfig(appFile, newGradleScript, orgSlug, projectSlug);
-
-  const buildSpinner = clack.spinner();
-
-  buildSpinner.start(
-    'Running ./gradlew to verify changes (this may take a few minutes)...',
-  );
-
-  try {
-    await bash.execute('./gradlew');
-    buildSpinner.stop(
-      chalk.greenBright(
-        `${chalk.bold('Sentry Gradle plugin')} added to the project.`,
-      ),
-    );
-  } catch (e) {
-    buildSpinner.stop();
-    Sentry.captureException('Gradle Sync failed');
-    return false;
-  }
-
-  return true;
-}
-
-/**
- * Looks for the applications packageName (namespace) in the specified build.gradle(.kts) file.
- *
- * ```
- * android {
- *   namespace 'my.package.name' <-- this is what we extract
- *
- *   compileSdkVersion = 31
- *   ...
- * }
- * ```
- * @param appFile
- * @returns the packageName(namespace) of the app if available
- */
-export function getNamespace(appFile: string): string | undefined {
-  const gradleScript = fs.readFileSync(appFile, 'utf8');
-
-  const namespaceMatch = /namespace\s*=?\s*['"]([^'"]+)['"]/i.exec(
-    gradleScript,
-  );
-  if (!namespaceMatch || namespaceMatch.length <= 1) {
-    clack.log.warn('Unable to determine application package name.');
-    Sentry.captureException('No package name');
-    return undefined;
-  }
-
-  const namespace = namespaceMatch[1];
-  return namespace;
-}
-
-/**
- * Adds source context configuration to the gradleScript if `sentry {}` block is not yet configured,
- *
- * @param appFile
- * @param gradleScript
- */
-function maybeAddSourceContextConfig(
-  appFile: string,
-  gradleScript: string,
-  orgSlug: string,
-  projectSlug: string,
-) {
-  if (!/sentry\s*\{[^}]*\}/i.test(gradleScript)) {
-    // if no sentry {} block is configured, we add our own with source context enabled
-    if (appFile.endsWith('.kts')) {
-      fs.appendFileSync(
-        appFile,
-        sourceContextKts(orgSlug, projectSlug),
-        'utf8',
-      );
-    } else {
-      fs.appendFileSync(appFile, sourceContext(orgSlug, projectSlug), 'utf8');
-    }
-  }
-}

package/src/android/manifest.ts

@@ -1,180 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import * as fs from 'fs';
-// @ts-ignore - clack is ESM and TS complains about that. It works though
-import * as clack from '@clack/prompts';
-import * as Sentry from '@sentry/node';
-import { manifest } from './templates';
-import xml, { Attributes, ElementCompact } from 'xml-js';
-import chalk from 'chalk';
-
-/**
- * Looks for the closing </application> tag in the manifest and adds the Sentry config after it.
- *
- * For example:
- * ```xml
- * <manifest xmlns:android="http://schemas.android.com/apk/res/android"
- *   xmlns:tools="http://schemas.android.com/tools">
- *
- *   <application>
- *     ...
- *     // this is what we add and more
- *     <meta-data android:name="io.sentry.dsn" android:value="__dsn__" />
- *   </application> <!-- we are looking for this one
- * </manifest>
- * ```
- *
- * @param manifestFile the path to the main AndroidManifest.xml file
- * @param dsn
- * @returns true if successfully patched the manifest, false otherwise
- */
-export function addManifestSnippet(manifestFile: string, dsn: string): boolean {
-  if (!fs.existsSync(manifestFile)) {
-    clack.log.warn('AndroidManifest.xml not found.');
-    Sentry.captureException('No AndroidManifest file');
-    return false;
-  }
-
-  const manifestContent = fs.readFileSync(manifestFile, 'utf8');
-
-  if (/android:name="io\.sentry[^"]*"/i.test(manifestContent)) {
-    // sentry is already configured
-    clack.log.success(chalk.greenBright('Sentry SDK is already configured.'));
-    return true;
-  }
-
-  const applicationMatch = /<\/application>/i.exec(manifestContent);
-  if (!applicationMatch) {
-    clack.log.warn('<application> tag not found within the manifest.');
-    Sentry.captureException('No <application> tag');
-    return false;
-  }
-
-  const insertionIndex = applicationMatch.index;
-  const newContent =
-    manifestContent.slice(0, insertionIndex) +
-    manifest(dsn) +
-    manifestContent.slice(insertionIndex);
-  fs.writeFileSync(manifestFile, newContent, 'utf8');
-
-  clack.log.success(
-    chalk.greenBright(
-      `Updated ${chalk.bold(
-        'AndroidManifest.xml',
-      )} with the Sentry SDK configuration.`,
-    ),
-  );
-
-  return true;
-}
-
-/**
- * There might be multiple <activity> in the manifest, as well as multiple <activity-alias> with category LAUNCHER,
- * but only one main activity with action MAIN. We are looking for this one by parsing xml and walking it.
- *
- * In addition, older Android versions required to specify the packag name in the manifest,
- * while the new ones - in the Gradle config. So we are just sanity checking if the package name
- * is in the manifest and returning it as well.
- *
- * For example:
- *
- * ```xml
- * <manifest xmlns:android="http://schemas.android.com/apk/res/android"
- *   xmlns:tools="http://schemas.android.com/tools"
- *   package="com.example.sample">
- *
- *   <application>
- *     <activity
- *       android:name="ui.MainActivity"
- *       ...other props>
- *        <intent-filter>
- *          <action android:name="android.intent.action.MAIN" /> <!-- we are looking for this one
- *
- *          <category android:name="android.intent.category.LAUNCHER" />
- *        </intent-filter>
- *     </activity>
- *   </application>
- * </manifest>
- * ```
- *
- * @param manifestFile path to the AndroidManifest.xml file
- * @returns package name (if available in the manifest) + the main activity name
- */
-export function getMainActivity(manifestFile: string): {
-  packageName?: string;
-  activityName?: string;
-} {
-  if (!fs.existsSync(manifestFile)) {
-    clack.log.warn('AndroidManifest.xml not found.');
-    Sentry.captureException('No AndroidManifest file');
-    return {};
-  }
-
-  const manifestContent = fs.readFileSync(manifestFile, 'utf8');
-  const converted: ElementCompact = xml.xml2js(manifestContent, {
-    compact: true,
-  });
-  const activities: ElementCompact[] | ElementCompact | undefined =
-    converted.manifest?.application?.activity;
-  const packageName: string | undefined =
-    converted.manifest?._attributes?.['package'];
-
-  if (!activities) {
-    clack.log.warn('No activity found in AndroidManifest.');
-    Sentry.captureException('No Activity');
-    return {};
-  }
-
-  let mainActivity;
-  if (Array.isArray(activities)) {
-    const withIntentFilter = activities.filter((a) => !!a['intent-filter']);
-    mainActivity = withIntentFilter.find((a) => isMainActivity(a));
-  } else if (isMainActivity(activities)) {
-    mainActivity = activities;
-  }
-
-  if (!mainActivity) {
-    clack.log.warn('No main activity found in AndroidManifest.');
-    Sentry.captureException('No Main Activity');
-    return {};
-  }
-
-  const attrs = mainActivity._attributes;
-  const activityName = attrs?.['android:name'] as string | undefined;
-  return { packageName: packageName, activityName: activityName };
-}
-
-function isMainActivity(activity: ElementCompact): boolean {
-  const intentFilters: ElementCompact[] | ElementCompact =
-    activity['intent-filter'];
-  if (Array.isArray(intentFilters)) {
-    return intentFilters.some((i) => {
-      const action: ElementCompact[] | ElementCompact | undefined = i.action;
-      return hasMainAction(action);
-    });
-  } else {
-    const action: ElementCompact[] | ElementCompact | undefined =
-      intentFilters.action;
-    return hasMainAction(action);
-  }
-}
-
-function hasMainAction(
-  action: ElementCompact[] | ElementCompact | undefined,
-): boolean {
-  if (!action) {
-    return false;
-  }
-
-  function isMain(attrs?: Attributes): boolean {
-    return attrs?.['android:name'] === 'android.intent.action.MAIN';
-  }
-
-  if (Array.isArray(action)) {
-    return action.some((c) => {
-      return isMain(c._attributes);
-    });
-  } else {
-    return isMain(action._attributes);
-  }
-}

package/src/android/templates.ts

@@ -1,86 +0,0 @@
-export const pluginsBlock = (version = '3.12.0') => `
-plugins {
-    id 'io.sentry.android.gradle' version '${version}'
-}
-
-`;
-
-export const pluginsBlockKts = (version = '3.12.0') => `
-plugins {
-    id("io.sentry.android.gradle") version "${version}"
-}
-
-`;
-
-export const plugin = (version = '3.12.0') => `
-    id 'io.sentry.android.gradle' version '${version}'
-`;
-
-export const pluginKts = (version = '3.12.0') => `
-    id("io.sentry.android.gradle") version "${version}"
-`;
-
-export const manifest = (dsn: string) => `
-    <!-- Required: set your sentry.io project identifier (DSN) -->
-    <meta-data android:name="io.sentry.dsn" android:value="${dsn}" />
-
-    <!-- enable automatic breadcrumbs for user interactions (clicks, swipes, scrolls) -->
-    <meta-data android:name="io.sentry.traces.user-interaction.enable" android:value="true" />
-    <!-- enable screenshot for crashes (could contain sensitive/PII data) -->
-    <meta-data android:name="io.sentry.attach-screenshot" android:value="true" />
-    <!-- enable view hierarchy for crashes -->
-    <meta-data android:name="io.sentry.attach-view-hierarchy" android:value="true" />
-
-    <!-- enable the performance API by setting a sample-rate, adjust in production env -->
-    <meta-data android:name="io.sentry.traces.sample-rate" android:value="1.0" />
-`;
-
-export const sentryImport = `import io.sentry.Sentry;\n`;
-
-export const sentryImportKt = `import io.sentry.Sentry\n`;
-
-export const testErrorSnippet = `
-    // waiting for view to draw to better represent a captured error with a screenshot
-    findViewById(android.R.id.content).getViewTreeObserver().addOnGlobalLayoutListener(() -> {
-      try {
-        throw new Exception("This app uses Sentry! :)");
-      } catch (Exception e) {
-        Sentry.captureException(e);
-      }
-    });
-`;
-
-export const testErrorSnippetKt = `
-    // waiting for view to draw to better represent a captured error with a screenshot
-    findViewById<android.view.View>(android.R.id.content).viewTreeObserver.addOnGlobalLayoutListener {
-      try {
-        throw Exception("This app uses Sentry! :)")
-      } catch (e: Exception) {
-        Sentry.captureException(e)
-      }
-    }
-`;
-
-export const sourceContext = (orgSlug: string, projectSlug: string) => `
-
-sentry {
-    org = "${orgSlug}"
-    projectName = "${projectSlug}"
-
-    // this will upload your source code to Sentry to show it as part of the stack traces
-    // disable if you don't want to expose your sources
-    includeSourceContext = true
-}
-`;
-
-export const sourceContextKts = (orgSlug: string, projectSlug: string) => `
-
-sentry {
-    org.set("${orgSlug}")
-    projectName.set("${projectSlug}")
-
-    // this will upload your source code to Sentry to show it as part of the stack traces
-    // disable if you don't want to expose your sources
-    includeSourceContext.set(true)
-}
-`;