@sentry/wizard 3.10.0 → 3.11.0

package/lib/Constants.ts

@@ -2,6 +2,7 @@
 export enum Integration {
   reactNative = 'reactNative',
   ios = 'ios',
+  android = 'android',
   cordova = 'cordova',
   electron = 'electron',
   nextjs = 'nextjs',
@@ -35,6 +36,8 @@ export function getPlatformDescription(type: string): string {
 
 export function getIntegrationDescription(type: string): string {
   switch (type) {
+    case Integration.android:
+      return 'Android';
     case Integration.reactNative:
       return 'React Native';
     case Integration.cordova:
@@ -58,6 +61,8 @@ export function getIntegrationDescription(type: string): string {
 
 export function mapIntegrationToPlatform(type: string): string | undefined {
   switch (type) {
+    case Integration.android:
+      return 'android';
     case Integration.reactNative:
       return 'react-native';
     case Integration.cordova:

package/lib/Steps/ChooseIntegration.ts

@@ -1,6 +1,5 @@
 import type { Answers } from 'inquirer';
 import { prompt } from 'inquirer';
-import { dim } from 'picocolors';
 
 import {
   Args,
@@ -18,6 +17,8 @@ import { Apple } from './Integrations/Apple';
 import { SvelteKitShim } from './Integrations/SvelteKitShim';
 import { hasPackageInstalled } from '../../src/utils/package-json';
 import { Remix } from './Integrations/Remix';
+import { Android } from './Integrations/Android';
+import { dim } from '../Helper/Logging';
 
 let projectPackage: any = {};
 
@@ -38,6 +39,9 @@ export class ChooseIntegration extends BaseStep {
 
     let integration = null;
     switch (integrationPrompt.integration) {
+      case Integration.android:
+        integration = new Android(this._argv);
+        break;
       case Integration.cordova:
         integration = new Cordova(sanitizeUrl(this._argv));
         break;
@@ -97,7 +101,7 @@ export class ChooseIntegration extends BaseStep {
       return { integration: this._argv.integration };
     } else {
       if (this._argv.quiet) {
-        throw new Error('You need to choose a integration');
+        throw new Error('You need to choose a platform');
       }
 
       const detectedDefaultSelection = this.tryDetectingIntegration();
@@ -106,7 +110,7 @@ export class ChooseIntegration extends BaseStep {
         {
           choices: getIntegrationChoices(),
           default: detectedDefaultSelection,
-          message: 'What integration do you want to set up?',
+          message: 'What platform do you want to set up?',
           name: 'integration',
           type: 'list',
         },

package/lib/Steps/Integrations/Android.ts

@@ -0,0 +1,23 @@
+import { Answers } from 'inquirer';
+import { BaseIntegration } from './BaseIntegration';
+import { Args } from '../../Constants';
+import { runAndroidWizard } from '../../../src/android/android-wizard';
+
+export class Android extends BaseIntegration {
+  public constructor(protected _argv: Args) {
+    super(_argv);
+  }
+
+  public async emit(_answers: Answers): Promise<Answers> {
+    await runAndroidWizard({
+      promoCode: this._argv.promoCode,
+      url: this._argv.url,
+      telemetryEnabled: !this._argv.disableTelemetry,
+    });
+    return {};
+  }
+
+  public shouldConfigure(_answers: Answers): Promise<Answers> {
+    return this._shouldConfigure;
+  }
+}

package/lib/Steps/Integrations/ReactNative.ts

@@ -16,7 +16,10 @@ import {
 } from '../../Helper/File';
 import { dim, green, l, nl, red } from '../../Helper/Logging';
 import { checkPackageVersion } from '../../Helper/Package';
-import { getPackageManagerChoice } from '../../Helper/PackageManager';
+import {
+  detectPackageManger,
+  installPackageWithPackageManager,
+} from '../../../src/utils/package-manager';
 import { SentryCli } from '../../Helper/SentryCli';
 import { MobileProject } from './MobileProject';
 import { BottomBar } from '../../Helper/BottomBar';
@@ -60,7 +63,7 @@ export class ReactNative extends MobileProject {
     nl();
 
     let userAnswers: Answers = { continue: true };
-    const packageManager = getPackageManagerChoice();
+    const packageManager = detectPackageManger();
 
     const hasCompatibleReactNativeVersion = checkPackageVersion(
       this._readAppPackage(),
@@ -86,7 +89,10 @@ export class ReactNative extends MobileProject {
 
     if (packageManager) {
       BottomBar.show(`Adding ${SENTRY_REACT_NATIVE_PACKAGE}...`);
-      await packageManager.installPackage(SENTRY_REACT_NATIVE_PACKAGE);
+      await installPackageWithPackageManager(
+        packageManager,
+        SENTRY_REACT_NATIVE_PACKAGE,
+      );
       BottomBar.hide();
       green(`✓ Added \`${SENTRY_REACT_NATIVE_PACKAGE}\``);
     }

package/lib/Steps/PromptForParameters.ts

@@ -50,11 +50,11 @@ export class PromptForParameters extends BaseStep {
     const dsn = await prompt([
       {
         message: 'DSN:',
-        name: 'secret',
+        name: 'public',
         type: 'input',
         // eslint-disable-next-line @typescript-eslint/unbound-method
         validate: this._validateDSN,
-        when: this._shouldAsk(answers, 'config.dsn.secret', () => {
+        when: this._shouldAsk(answers, 'config.dsn.public', () => {
           dim('Please copy/paste your DSN');
           dim(`It can be found here: ${url}`);
         }),
@@ -120,7 +120,16 @@ export class PromptForParameters extends BaseStep {
   }
 
   private _validateAuthToken(input: string): boolean | string {
-    if (!input.match(/[0-9a-f]{64}/g)) {
+    const isOrgToken = input.startsWith('sntrys_');
+
+    if (isOrgToken) {
+      if (!isValidOrgToken(input)) {
+        return 'Make sure you correctly copied your auth token. It should start with "sntrys_"';
+      }
+      return true;
+    }
+
+    if (!input.match(/(sntrys_)?[0-9a-f]{64}/g)) {
       return 'Make sure you copied the correct auth token, it should be 64 hex chars';
     }
     return true;
@@ -149,3 +158,39 @@ export class PromptForParameters extends BaseStep {
     return true;
   }
 }
+
+type MaybeOrgAuthToken = {
+  iat?: number;
+  url?: string;
+  org?: string;
+  region_url?: string;
+};
+
+/**
+ * Trying to parse and decode an org auth token. Based on:
+ * - https://github.com/getsentry/rfcs/blob/main/text/0091-ci-upload-tokens.md#parsing-tokens
+ * - https://github.com/getsentry/rfcs/blob/main/text/0091-ci-upload-tokens.md#token-facts
+ */
+function isValidOrgToken(input: string): boolean {
+  if (!input.startsWith('sntrys_')) {
+    return false;
+  }
+
+  const tokenParts = input.split('_');
+  if (tokenParts.length < 3) {
+    return false;
+  }
+
+  try {
+    const payload = tokenParts[1];
+    const decodedPayload = Buffer.from(payload, 'base64').toString();
+    const jsonPayload = JSON.parse(decodedPayload) as MaybeOrgAuthToken;
+    if (!jsonPayload.iat || !jsonPayload.url || !jsonPayload.org) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+
+  return true;
+}

package/lib/Steps/SentryProjectSelector.ts

@@ -21,7 +21,9 @@ export class SentryProjectSelector extends BaseStep {
       _.has(answers, 'wizard.projects') &&
       answers.wizard.projects.length === 0
     ) {
-      throw new Error('no projects');
+      throw new Error(
+        'No Projects found. Please create a new Project in Sentry and try again.',
+      );
     }
 
     let selectedProject = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/wizard",
-  "version": "3.10.0",
+  "version": "3.11.0",
   "homepage": "https://github.com/getsentry/sentry-wizard",
   "repository": "https://github.com/getsentry/sentry-wizard",
   "description": "Sentry wizard helping you to configure your project",
@@ -23,8 +23,8 @@
     "definition": "dist/index.d.ts"
   },
   "dependencies": {
-    "@clack/core": "0.3.2",
-    "@clack/prompts": "0.6.3",
+    "@clack/core": "0.3.3",
+    "@clack/prompts": "0.7.0",
     "@sentry/cli": "^1.72.0",
     "@sentry/node": "^7.57.0",
     "axios": "1.3.5",
@@ -38,6 +38,7 @@
     "read-env": "^1.3.0",
     "semver": "^7.5.3",
     "xcode": "3.0.1",
+    "xml-js": "^1.6.11",
     "yargs": "^16.2.0"
   },
   "devDependencies": {

package/src/android/android-wizard.ts

@@ -0,0 +1,196 @@
+/* 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 path from 'path';
+import * as gradle from './gradle';
+import * as manifest from './manifest';
+import * as codetools from './code-tools';
+import {
+  CliSetupConfig,
+  SENTRY_PROPERTIES_FILE,
+  abort,
+  addSentryCliConfig,
+  confirmContinueEvenThoughNoGitRepo,
+  getOrAskForProjectData,
+  printWelcome,
+} from '../utils/clack-utils';
+import { WizardOptions } from '../utils/types';
+import { traceStep, withTelemetry } from '../telemetry';
+import chalk from 'chalk';
+
+const proguardMappingCliSetupConfig: CliSetupConfig = {
+  filename: SENTRY_PROPERTIES_FILE,
+  name: 'proguard mappings',
+  likelyAlreadyHasAuthToken(contents: string): boolean {
+    return !!contents.match(/auth\.token=./g);
+  },
+  tokenContent(authToken: string): string {
+    return `auth.token=${authToken}`;
+  },
+  likelyAlreadyHasOrgAndProject(contents: string): boolean {
+    return !!(
+      contents.match(/defaults\.org=./g) &&
+      contents.match(/defaults\.project=./g)
+    );
+  },
+  orgAndProjContent(org: string, project: string): string {
+    return `defaults.org=${org}\ndefaults.project=${project}`;
+  },
+};
+
+export async function runAndroidWizard(options: WizardOptions): Promise<void> {
+  return withTelemetry(
+    {
+      enabled: options.telemetryEnabled,
+      integration: 'android',
+    },
+    () => runAndroidWizardWithTelemetry(options),
+  );
+}
+
+async function runAndroidWizardWithTelemetry(
+  options: WizardOptions,
+): Promise<void> {
+  printWelcome({
+    wizardName: 'Sentry Android Wizard',
+    promoCode: options.promoCode,
+  });
+
+  await confirmContinueEvenThoughNoGitRepo();
+
+  const projectDir = process.cwd();
+  const buildGradleFiles = findFilesWithExtensions(projectDir, [
+    '.gradle',
+    'gradle.kts',
+  ]);
+
+  if (!buildGradleFiles || buildGradleFiles.length === 0) {
+    clack.log.error(
+      'No Gradle project found. Please run this command from the root of your project.',
+    );
+    await abort();
+    return;
+  }
+
+  const appFile = await traceStep('Select App File', () =>
+    gradle.selectAppFile(buildGradleFiles),
+  );
+
+  const { selectedProject, authToken } = await getOrAskForProjectData(
+    options,
+    'android',
+  );
+
+  // ======== STEP 1. Add Sentry Gradle Plugin to build.gradle(.kts) ============
+  clack.log.step(
+    `Adding ${chalk.bold('Sentry Gradle plugin')} to your app's ${chalk.cyan(
+      'build.gradle',
+    )} file.`,
+  );
+  const pluginAdded = await traceStep('Add Gradle Plugin', () =>
+    gradle.addGradlePlugin(
+      appFile,
+      selectedProject.organization.slug,
+      selectedProject.slug,
+    ),
+  );
+  if (!pluginAdded) {
+    clack.log.warn(
+      "Could not add Sentry Gradle plugin to your app's build.gradle file. You'll have to add it manually.\nPlease follow the instructions at https://docs.sentry.io/platforms/android/#install",
+    );
+  }
+
+  // ======== STEP 2. Configure Sentry SDK via AndroidManifest ============
+  clack.log.step(
+    `Configuring Sentry SDK via ${chalk.cyan('AndroidManifest.xml')}`,
+  );
+  const appDir = path.dirname(appFile);
+  const manifestFile = path.join(appDir, 'src', 'main', 'AndroidManifest.xml');
+
+  const manifestUpdated = traceStep('Update Android Manifest', () =>
+    manifest.addManifestSnippet(
+      manifestFile,
+      selectedProject.keys[0].dsn.public,
+    ),
+  );
+  if (!manifestUpdated) {
+    clack.log.warn(
+      "Could not configure the Sentry SDK. You'll have to do it manually.\nPlease follow the instructions at https://docs.sentry.io/platforms/android/#configure",
+    );
+  }
+
+  // ======== STEP 3. Patch Main Activity with a test error snippet ============
+  clack.log.step(
+    `Patching ${chalk.bold('Main Activity')} with a test error snippet.`,
+  );
+  const mainActivity = traceStep('Find Main Activity', () =>
+    manifest.getMainActivity(manifestFile),
+  );
+  let packageName = mainActivity.packageName;
+  if (!packageName) {
+    // if no package name in AndroidManifest, look into gradle script
+    packageName = gradle.getNamespace(appFile);
+  }
+  const activityName = mainActivity.activityName;
+  if (!activityName || !packageName) {
+    clack.log.warn(
+      "Could not find Activity with intent action MAIN. You'll have to manually verify the setup.\nPlease follow the instructions at https://docs.sentry.io/platforms/android/#verify",
+    );
+  } else {
+    const packageNameStable = packageName;
+    const activityFile = traceStep('Find Main Activity Source File', () =>
+      codetools.findActivitySourceFile(appDir, packageNameStable, activityName),
+    );
+
+    const activityPatched = traceStep('Patch Main Activity', () =>
+      codetools.patchMainActivity(activityFile),
+    );
+    if (!activityPatched) {
+      clack.log.warn(
+        "Could not patch main activity. You'll have to manually verify the setup.\nPlease follow the instructions at https://docs.sentry.io/platforms/android/#verify",
+      );
+    }
+  }
+
+  // ======== STEP 4. Add sentry-cli config file ============
+  clack.log.step(
+    `Configuring ${chalk.bold('proguard mappings upload')} via the ${chalk.cyan(
+      'sentry.properties',
+    )} file.`,
+  );
+  await traceStep('Add SentryCli Config', () =>
+    addSentryCliConfig(authToken, proguardMappingCliSetupConfig),
+  );
+
+  // ======== OUTRO ========
+  clack.outro(`
+${chalk.greenBright('Successfully installed the Sentry Android SDK!')}
+
+${chalk.cyan(
+  'You can validate your setup by launching your application and checking Sentry issues page afterwards',
+)}
+
+Check out the SDK documentation for further configuration:
+https://docs.sentry.io/platforms/android/
+  `);
+}
+
+//find files with the given extension
+function findFilesWithExtensions(
+  dir: string,
+  extensions: string[],
+  filesWithExtensions: string[] = [],
+): string[] {
+  const cwd = process.cwd();
+  const files = fs.readdirSync(dir, { withFileTypes: true });
+  for (const file of files) {
+    if (file.isDirectory()) {
+      const childDir = path.join(dir, file.name);
+      findFilesWithExtensions(childDir, extensions, filesWithExtensions);
+    } else if (extensions.some((ext) => file.name.endsWith(ext))) {
+      filesWithExtensions.push(path.relative(cwd, path.join(dir, file.name)));
+    }
+  }
+  return filesWithExtensions;
+}

package/src/android/code-tools.ts

@@ -0,0 +1,156 @@
+import * as fs from 'fs';
+import * as path from 'path';
+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 {
+  sentryImport,
+  sentryImportKt,
+  testErrorSnippet,
+  testErrorSnippetKt,
+} from './templates';
+import { findFile } from '../utils/ast-utils';
+
+/**
+ * Looks in src/main/java or src/main/kotlin for the specified {@link packageName} and
+ * {@link activityName} by concatenating them. For example:
+ *
+ * src/
+ *   main/
+ *     java/ or kotlin/
+ *       my.package.name/
+ *         ui/
+ *           MainActivity.kt
+ *
+ * src/main/java can contain both .java and .kt sources, whilst src/main/kotlin only .kt
+ *
+ * @param appDir
+ * @param packageName
+ * @param activityName
+ * @returns path to the Main Activity
+ */
+export function findActivitySourceFile(
+  appDir: string,
+  packageName: string,
+  activityName: string,
+): string | undefined {
+  const javaSrcDir = path.join(appDir, 'src', 'main', 'java');
+  let possibleActivityPath;
+  // if activity name starts with a dot, this means we need to concat packagename with it, otherwise
+  // the package name is already specified in the activity name itself
+  const packageNameParts = activityName.startsWith('.')
+    ? packageName.split('.')
+    : [];
+  const activityNameParts = activityName.split('.');
+
+  if (fs.existsSync(javaSrcDir)) {
+    possibleActivityPath = findFile(
+      path.join(javaSrcDir, ...packageNameParts, ...activityNameParts),
+      ['.kt', '.java'],
+    );
+  }
+
+  if (!possibleActivityPath || !fs.existsSync(possibleActivityPath)) {
+    const kotlinSrcDir = path.join(appDir, 'src', 'main', 'kotlin');
+    if (fs.existsSync(kotlinSrcDir)) {
+      possibleActivityPath = findFile(
+        path.join(kotlinSrcDir, ...packageNameParts, ...activityNameParts),
+        ['.kt'],
+      );
+    }
+  }
+  return possibleActivityPath;
+}
+
+/**
+ * Patches Main Activity with the test error code snippet by the specified path {@link activityFile}.
+ * Finds activity's `onCreate` method, adds the snippet and necessary imports.
+ *
+ * ```kotlin
+ * import something
+ * import something.something
+ * import io.sentry.Sentry <-- this is added by us
+ *
+ * override fun onCreate(savedInstanceState: Bundle?) {
+ *   super.onCreate(savedInstanceState)
+ *   // the snippet goes here <--
+ *   doSomething()
+ * }
+ * ```
+ *
+ * @param activityFile
+ * @returns true if successfully patched, false otherwise
+ */
+export function patchMainActivity(activityFile: string | undefined): boolean {
+  if (!activityFile || !fs.existsSync(activityFile)) {
+    clack.log.warn('No main activity source file found in filesystem.');
+    Sentry.captureException('No main activity source file');
+    return false;
+  }
+
+  const activityContent = fs.readFileSync(activityFile, 'utf8');
+
+  if (/import\s+io\.sentry\.Sentry;?/i.test(activityContent)) {
+    // sentry is already configured
+    clack.log.success(
+      chalk.greenBright(
+        `${chalk.bold(
+          'Main Activity',
+        )} is already patched with test error snippet.`,
+      ),
+    );
+    return true;
+  }
+
+  const importRegex = /import\s+[\w.]+;?/gim;
+  let importsMatch = importRegex.exec(activityContent);
+  let importIndex = 0;
+  while (importsMatch) {
+    importIndex = importsMatch.index + importsMatch[0].length + 1;
+    importsMatch = importRegex.exec(activityContent);
+  }
+  let newActivityContent;
+  if (activityFile.endsWith('.kt')) {
+    newActivityContent =
+      activityContent.slice(0, importIndex) +
+      sentryImportKt +
+      activityContent.slice(importIndex);
+  } else {
+    newActivityContent =
+      activityContent.slice(0, importIndex) +
+      sentryImport +
+      activityContent.slice(importIndex);
+  }
+
+  const onCreateMatch = /super\.onCreate\(.*?\);?/i.exec(newActivityContent);
+  if (!onCreateMatch) {
+    clack.log.warn('No onCreate method found in main activity.');
+    Sentry.captureException('No onCreate method');
+    return false;
+  }
+
+  const onCreateIndex = onCreateMatch.index + onCreateMatch[0].length;
+  if (activityFile.endsWith('.kt')) {
+    newActivityContent =
+      newActivityContent.slice(0, onCreateIndex) +
+      testErrorSnippetKt +
+      newActivityContent.slice(onCreateIndex);
+  } else {
+    newActivityContent =
+      newActivityContent.slice(0, onCreateIndex) +
+      testErrorSnippet +
+      newActivityContent.slice(onCreateIndex);
+  }
+  fs.writeFileSync(activityFile, newActivityContent, 'utf8');
+
+  clack.log.success(
+    chalk.greenBright(
+      `Patched ${chalk.bold(
+        'Main Activity',
+      )} with the Sentry test error snippet.`,
+    ),
+  );
+
+  return true;
+}