@sentry/wizard 3.12.0 → 3.14.0

package/src/utils/clack-utils.ts

@@ -5,6 +5,7 @@ import chalk from 'chalk';
 import * as childProcess from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 import { setInterval } from 'timers';
 import { URL } from 'url';
 import * as Sentry from '@sentry/node';
@@ -125,41 +126,95 @@ export function printWelcome(options: {
 
   let welcomeText =
     options.message ||
-    'This Wizard will help you set up Sentry for your application.\nThank you for using Sentry :)';
+    `The ${options.wizardName} will help you set up Sentry for your application.\nThank you for using Sentry :)`;
 
   if (options.promoCode) {
-    welcomeText += `\n\nUsing promo-code: ${options.promoCode}`;
+    welcomeText = `${welcomeText}\n\nUsing promo-code: ${options.promoCode}`;
   }
 
   if (wizardPackage.version) {
-    welcomeText += `\n\nVersion: ${wizardPackage.version}`;
+    welcomeText = `${welcomeText}\n\nVersion: ${wizardPackage.version}`;
   }
 
   if (options.telemetryEnabled) {
-    welcomeText += `\n\nYou are using the Sentry Wizard with telemetry enabled. This helps us improve the Wizard.\nYou can disable it at any time by running \`sentry-wizard --disable-telemetry\`.`;
+    welcomeText = `${welcomeText}
+
+This wizard sends telemetry data and crash reports to Sentry. This helps us improve the Wizard.
+You can turn this off at any time by running ${chalk.cyanBright(
+      'sentry-wizard --disable-telemetry',
+    )}.`;
   }
 
   clack.note(welcomeText);
 }
 
-export async function confirmContinueEvenThoughNoGitRepo(): Promise<void> {
+export async function confirmContinueIfNoOrDirtyGitRepo(): Promise<void> {
+  return traceStep('check-git-status', async () => {
+    if (!isInGitRepo()) {
+      const continueWithoutGit = await abortIfCancelled(
+        clack.confirm({
+          message:
+            'You are not inside a git repository. The wizard will create and update files. Do you want to continue anyway?',
+        }),
+      );
+
+      Sentry.setTag('continue-without-git', continueWithoutGit);
+
+      if (!continueWithoutGit) {
+        await abort(undefined, 0);
+      }
+    }
+
+    const uncommittedOrUntrackedFiles = getUncommittedOrUntrackedFiles();
+    if (uncommittedOrUntrackedFiles.length) {
+      clack.log.warn(
+        `You have uncommitted or untracked files in your repo:
+
+${uncommittedOrUntrackedFiles.join('\n')}
+
+The wizard will create and update files.`,
+      );
+      const continueWithDirtyRepo = await abortIfCancelled(
+        clack.confirm({
+          message: 'Do you want to continue anyway?',
+        }),
+      );
+
+      Sentry.setTag('continue-with-dirty-repo', continueWithDirtyRepo);
+
+      if (!continueWithDirtyRepo) {
+        await abort(undefined, 0);
+      }
+    }
+  });
+}
+
+function isInGitRepo() {
   try {
     childProcess.execSync('git rev-parse --is-inside-work-tree', {
       stdio: 'ignore',
     });
+    return true;
   } catch {
-    const continueWithoutGit = await abortIfCancelled(
-      clack.confirm({
-        message:
-          'You are not inside a git repository. The wizard will create and update files. Do you still want to continue?',
-      }),
-    );
+    return false;
+  }
+}
 
-    Sentry.setTag('continue-without-git', continueWithoutGit);
+function getUncommittedOrUntrackedFiles(): string[] {
+  try {
+    const gitStatus = childProcess
+      .execSync('git status --porcelain=v1')
+      .toString();
 
-    if (!continueWithoutGit) {
-      await abort(undefined, 0);
-    }
+    const files = gitStatus
+      .split(os.EOL)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((f) => `- ${f.split(/\s+/)[1]}`);
+
+    return files;
+  } catch {
+    return [];
   }
 }
 
@@ -202,161 +257,127 @@ export async function installPackage({
   alreadyInstalled: boolean;
   askBeforeUpdating?: boolean;
 }): Promise<void> {
-  if (alreadyInstalled && askBeforeUpdating) {
-    const shouldUpdatePackage = await abortIfCancelled(
-      clack.confirm({
-        message: `The ${chalk.bold.cyan(
-          packageName,
-        )} package is already installed. Do you want to update it to the latest version?`,
-      }),
-    );
+  return traceStep('install-package', async () => {
+    if (alreadyInstalled && askBeforeUpdating) {
+      const shouldUpdatePackage = await abortIfCancelled(
+        clack.confirm({
+          message: `The ${chalk.bold.cyan(
+            packageName,
+          )} package is already installed. Do you want to update it to the latest version?`,
+        }),
+      );
 
-    if (!shouldUpdatePackage) {
-      return;
+      if (!shouldUpdatePackage) {
+        return;
+      }
     }
-  }
 
-  const sdkInstallSpinner = clack.spinner();
+    const sdkInstallSpinner = clack.spinner();
 
-  const packageManager = await getPackageManager();
-
-  sdkInstallSpinner.start(
-    `${alreadyInstalled ? 'Updating' : 'Installing'} ${chalk.bold.cyan(
-      packageName,
-    )} with ${chalk.bold(packageManager.label)}.`,
-  );
+    const packageManager = await getPackageManager();
 
-  try {
-    await installPackageWithPackageManager(packageManager, packageName);
-  } catch (e) {
-    sdkInstallSpinner.stop('Installation failed.');
-    clack.log.error(
-      `${chalk.red(
-        'Encountered the following error during 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',
-      )}`,
+    sdkInstallSpinner.start(
+      `${alreadyInstalled ? 'Updating' : 'Installing'} ${chalk.bold.cyan(
+        packageName,
+      )} with ${chalk.bold(packageManager.label)}.`,
     );
-    await abort();
-  }
-
-  sdkInstallSpinner.stop(
-    `${alreadyInstalled ? 'Updated' : 'Installed'} ${chalk.bold.cyan(
-      packageName,
-    )} with ${chalk.bold(packageManager.label)}.`,
-  );
-}
 
-async function addOrgAndProjectToSentryCliRc(
-  org: string,
-  project: string,
-  setupConfig: CliSetupConfig,
-): Promise<void> {
-  const configContents = fs.readFileSync(
-    path.join(process.cwd(), setupConfig.filename),
-    'utf8',
-  );
-
-  if (setupConfig.likelyAlreadyHasOrgAndProject(configContents)) {
-    clack.log.warn(
-      `${chalk.bold(
-        setupConfig.filename,
-      )} already has org and project. Will not add them.`,
-    );
-  } else {
     try {
-      await fs.promises.appendFile(
-        path.join(process.cwd(), setupConfig.filename),
-        `\n${setupConfig.orgAndProjContent(org, project)}\n`,
-      );
+      await installPackageWithPackageManager(packageManager, packageName);
     } catch (e) {
-      clack.log.warn(
-        `${chalk.bold(
-          setupConfig.filename,
-        )} could not be updated with org and project.`,
+      sdkInstallSpinner.stop('Installation failed.');
+      clack.log.error(
+        `${chalk.red(
+          'Encountered the following error during 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',
+        )}`,
       );
+      await abort();
     }
-  }
+
+    sdkInstallSpinner.stop(
+      `${alreadyInstalled ? 'Updated' : 'Installed'} ${chalk.bold.cyan(
+        packageName,
+      )} with ${chalk.bold(packageManager.label)}.`,
+    );
+  });
 }
 
 export async function addSentryCliConfig(
   authToken: string,
   setupConfig: CliSetupConfig = sourceMapsCliSetupConfig,
-  orgSlug?: string,
-  projectSlug?: string,
 ): Promise<void> {
-  const configExists = fs.existsSync(
-    path.join(process.cwd(), setupConfig.filename),
-  );
-  if (configExists) {
-    const configContents = fs.readFileSync(
+  return traceStep('add-sentry-cli-config', async () => {
+    const configExists = fs.existsSync(
       path.join(process.cwd(), setupConfig.filename),
-      'utf8',
     );
-
-    if (setupConfig.likelyAlreadyHasAuthToken(configContents)) {
-      clack.log.warn(
-        `${chalk.bold(
-          setupConfig.filename,
-        )} already has auth token. Will not add one.`,
+    if (configExists) {
+      const configContents = fs.readFileSync(
+        path.join(process.cwd(), setupConfig.filename),
+        'utf8',
       );
+
+      if (setupConfig.likelyAlreadyHasAuthToken(configContents)) {
+        clack.log.warn(
+          `${chalk.bold(
+            setupConfig.filename,
+          )} already has auth token. Will not add one.`,
+        );
+      } else {
+        try {
+          await fs.promises.writeFile(
+            path.join(process.cwd(), setupConfig.filename),
+            `${configContents}\n${setupConfig.tokenContent(authToken)}\n`,
+            { encoding: 'utf8', flag: 'w' },
+          );
+          clack.log.success(
+            chalk.greenBright(
+              `Added auth token to ${chalk.bold(
+                setupConfig.filename,
+              )} for you to test uploading ${setupConfig.name} locally.`,
+            ),
+          );
+        } catch {
+          clack.log.warning(
+            `Failed to add auth token to ${chalk.bold(
+              setupConfig.filename,
+            )}. Uploading ${
+              setupConfig.name
+            } during build will likely not work locally.`,
+          );
+        }
+      }
     } else {
       try {
         await fs.promises.writeFile(
           path.join(process.cwd(), setupConfig.filename),
-          `${configContents}\n${setupConfig.tokenContent(authToken)}\n`,
+          `${setupConfig.tokenContent(authToken)}\n`,
           { encoding: 'utf8', flag: 'w' },
         );
         clack.log.success(
           chalk.greenBright(
-            `Added auth token to ${chalk.bold(
+            `Created ${chalk.bold(
               setupConfig.filename,
-            )} for you to test uploading ${setupConfig.name} locally.`,
+            )} with auth token for you to test uploading ${
+              setupConfig.name
+            } locally.`,
           ),
         );
       } catch {
         clack.log.warning(
-          `Failed to add auth token to ${chalk.bold(
+          `Failed to create ${chalk.bold(
             setupConfig.filename,
-          )}. Uploading ${
+          )} with auth token. Uploading ${
             setupConfig.name
           } during build will likely not work locally.`,
         );
       }
     }
-  } else {
-    try {
-      await fs.promises.writeFile(
-        path.join(process.cwd(), setupConfig.filename),
-        `${setupConfig.tokenContent(authToken)}\n`,
-        { encoding: 'utf8', flag: 'w' },
-      );
-      clack.log.success(
-        chalk.greenBright(
-          `Created ${chalk.bold(
-            setupConfig.filename,
-          )} with auth token for you to test uploading ${
-            setupConfig.name
-          } locally.`,
-        ),
-      );
-    } catch {
-      clack.log.warning(
-        `Failed to create ${chalk.bold(
-          setupConfig.filename,
-        )} with auth token. Uploading ${
-          setupConfig.name
-        } during build will likely not work locally.`,
-      );
-    }
-  }
 
-  if (orgSlug && projectSlug) {
-    await addOrgAndProjectToSentryCliRc(orgSlug, projectSlug, setupConfig);
-  }
-
-  await addAuthTokenFileToGitIgnore(setupConfig.filename);
+    await addAuthTokenFileToGitIgnore(setupConfig.filename);
+  });
 }
 
 export async function addDotEnvSentryBuildPluginFile(
@@ -451,23 +472,40 @@ async function addAuthTokenFileToGitIgnore(filename: string): Promise<void> {
   }
 }
 
+/**
+ * Checks if @param packageId is listed as a dependency in @param packageJson.
+ * If not, it will ask users if they want to continue without the package.
+ *
+ * Use this function to check if e.g. a the framework of the SDK is installed
+ *
+ * @param packageJson the package.json object
+ * @param packageId the npm name of the package
+ * @param packageName a human readable name of the package
+ */
 export async function ensurePackageIsInstalled(
   packageJson: PackageDotJson,
   packageId: string,
   packageName: string,
-) {
-  if (!hasPackageInstalled(packageId, packageJson)) {
-    const continueWithoutPackage = await abortIfCancelled(
-      clack.confirm({
-        message: `${packageName} does not seem to be installed. Do you still want to continue?`,
-        initialValue: false,
-      }),
-    );
+): Promise<void> {
+  return traceStep('ensure-package-installed', async () => {
+    const installed = hasPackageInstalled(packageId, packageJson);
+
+    Sentry.setTag(`${packageName.toLowerCase()}-installed`, installed);
 
-    if (!continueWithoutPackage) {
-      await abort(undefined, 0);
+    if (!installed) {
+      Sentry.setTag(`${packageName.toLowerCase()}-installed`, false);
+      const continueWithoutPackage = await abortIfCancelled(
+        clack.confirm({
+          message: `${packageName} does not seem to be installed. Do you still want to continue?`,
+          initialValue: false,
+        }),
+      );
+
+      if (!continueWithoutPackage) {
+        await abort(undefined, 0);
+      }
     }
-  }
+  });
 }
 
 export async function getPackageDotJson(): Promise<PackageDotJson> {
@@ -487,7 +525,9 @@ export async function getPackageDotJson(): Promise<PackageDotJson> {
     packageJson = JSON.parse(packageJsonFileContents);
   } catch {
     clack.log.error(
-      'Unable to parse your package.json. Make sure it has a valid format!',
+      `Unable to parse your ${chalk.cyan(
+        'package.json',
+      )}. Make sure it has a valid format!`,
     );
 
     await abort();
@@ -826,7 +866,7 @@ export async function askForToolConfigPath(
     clack.confirm({
       message: `Do you have a ${toolName} config file (e.g. ${chalk.cyan(
         configFileName,
-      )}?`,
+      )})?`,
       initialValue: true,
     }),
   );
@@ -866,27 +906,35 @@ export async function askForToolConfigPath(
  *
  * @param filename the name of the file to which the code snippet should be applied.
  * If a path is provided, only the filename will be used.
- * @param codeSnippet the snippet to be printed.
- * Make sure to follow the diff-like format of highlighting lines that require changes
- * and showing unchanged lines in gray.
  *
- * TODO: Link to wizard spec (develop) once it is live
+ * @param codeSnippet the snippet to be printed. Use {@link makeCodeSnippet}  to create the
+ * diff-like format for visually highlighting unchanged or modified lines of code.
+ *
+ * @param hint (optional) a hint to be printed after the main instruction to add
+ * the code from @param codeSnippet to their @param filename.
+ *
+ * More guidelines on copy/paste instructions:
+ * @see {@link https://develop.sentry.dev/sdk/setup-wizards/#copy--paste-snippets}
+ *
  * TODO: refactor copy paste instructions across different wizards to use this function.
  *       this might require adding a custom message parameter to the function
  */
 export async function showCopyPasteInstructions(
   filename: string,
   codeSnippet: string,
+  hint?: string,
 ): Promise<void> {
   clack.log.step(
     `Add the following code to your ${chalk.cyan(
       path.basename(filename),
-    )} file:`,
+    )} file:${hint ? chalk.dim(` (${chalk.dim(hint)})`) : ''}`,
   );
 
+  // Padding the code snippet to be printed with a \n at the beginning and end
+  // This makes it easier to distinguish the snippet from the rest of the output
   // Intentionally logging directly to console here so that the code can be copied/pasted directly
   // eslint-disable-next-line no-console
-  console.log(`\n${codeSnippet}`);
+  console.log(`\n${codeSnippet}\n`);
 
   await abortIfCancelled(
     clack.select({
@@ -897,6 +945,47 @@ export async function showCopyPasteInstructions(
   );
 }
 
+/**
+ * Callback that exposes formatting helpers for a code snippet.
+ * @param unchanged - Formats text as old code.
+ * @param plus - Formats text as new code.
+ * @param minus - Formats text as removed code.
+ */
+type CodeSnippetFormatter = (
+  unchanged: (txt: string) => string,
+  plus: (txt: string) => string,
+  minus: (txt: string) => string,
+) => string;
+
+/**
+ * Crafts a code snippet that can be used to e.g.
+ * - print copy/paste instructions to the console
+ * - create a new config file.
+ *
+ * @param colors set this to true if you want the final snippet to be colored.
+ * This is useful for printing the snippet to the console as part of copy/paste instructions.
+ *
+ * @param callback the callback that returns the formatted code snippet.
+ * It exposes takes the helper functions for marking code as unchaned, new or removed.
+ * These functions no-op if no special formatting should be applied
+ * and otherwise apply the appropriate formatting/coloring.
+ * (@see {@link CodeSnippetFormatter})
+ *
+ * @see {@link showCopyPasteInstructions} for the helper with which to display the snippet in the console.
+ *
+ * @returns a string containing the final, formatted code snippet.
+ */
+export function makeCodeSnippet(
+  colors: boolean,
+  callback: CodeSnippetFormatter,
+): string {
+  const unchanged = (txt: string) => (colors ? chalk.grey(txt) : txt);
+  const plus = (txt: string) => (colors ? chalk.greenBright(txt) : txt);
+  const minus = (txt: string) => (colors ? chalk.redBright(txt) : txt);
+
+  return callback(unchanged, plus, minus);
+}
+
 /**
  * Creates a new config file with the given @param filepath and @param codeSnippet.
  *

package/src/utils/package-manager.ts

@@ -4,53 +4,65 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { promisify } from 'util';
 
+import * as Sentry from '@sentry/node';
+import { traceStep } from '../telemetry';
+
 export interface PackageManager {
   name: string;
   label: string;
   lockFile: string;
   installCommand: string;
   buildCommand: string;
+  /* The command that the package manager uses to run a script from package.json */
+  runScriptCommand: string;
 }
 
-const bun: PackageManager = {
+export const BUN: PackageManager = {
   name: 'bun',
   label: 'Bun',
   lockFile: 'bun.lockb',
   installCommand: 'bun add',
-  buildCommand: 'bun build',
+  buildCommand: 'bun run build',
+  runScriptCommand: 'bun run',
 };
-const yarn: PackageManager = {
+export const YARN: PackageManager = {
   name: 'yarn',
   label: 'Yarn',
   lockFile: 'yarn.lock',
   installCommand: 'yarn add',
   buildCommand: 'yarn build',
+  runScriptCommand: 'yarn',
 };
-const pnpm: PackageManager = {
+export const PNPM: PackageManager = {
   name: 'pnpm',
   label: 'PNPM',
   lockFile: 'pnpm-lock.yaml',
   installCommand: 'pnpm add',
   buildCommand: 'pnpm build',
+  runScriptCommand: 'pnpm',
 };
-const npm: PackageManager = {
+export const NPM: PackageManager = {
   name: 'npm',
   label: 'NPM',
   lockFile: 'package-lock.json',
   installCommand: 'npm add',
   buildCommand: 'npm run build',
+  runScriptCommand: 'npm run',
 };
 
-export const packageManagers = [bun, yarn, pnpm, npm];
+export const packageManagers = [BUN, YARN, PNPM, NPM];
 
 export function detectPackageManger(): PackageManager | null {
-  for (const packageManager of packageManagers) {
-    if (fs.existsSync(path.join(process.cwd(), packageManager.lockFile))) {
-      return packageManager;
+  return traceStep('detect-package-manager', () => {
+    for (const packageManager of packageManagers) {
+      if (fs.existsSync(path.join(process.cwd(), packageManager.lockFile))) {
+        Sentry.setTag('package-manager', packageManager.name);
+        return packageManager;
+      }
     }
-  }
-  // We make the default NPM - it's weird if we don't find any lock file
-  return null;
+    Sentry.setTag('package-manager', 'not-detected');
+    return null;
+  });
 }
 
 export async function installPackageWithPackageManager(

package/test/sourcemaps/tools/sentry-cli.test.ts

@@ -0,0 +1,51 @@
+import * as fs from 'fs';
+
+import { addSentryCommandToBuildCommand } from '../../../src/sourcemaps/tools/sentry-cli';
+
+import * as packageManagerHelpers from '../../../src/utils/package-manager';
+
+const writeFileSpy = jest
+  .spyOn(fs.promises, 'writeFile')
+  .mockImplementation(() => Promise.resolve());
+
+jest.mock('@clack/prompts', () => {
+  return {
+    log: {
+      info: jest.fn(),
+      success: jest.fn(),
+    },
+    confirm: jest.fn().mockResolvedValue(true),
+    isCancel: jest.fn().mockReturnValue(false),
+  };
+});
+
+describe('addSentryCommandToBuildCommand', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  it.each([
+    [
+      packageManagerHelpers.NPM,
+      packageManagerHelpers.PNPM,
+      packageManagerHelpers.YARN,
+      packageManagerHelpers.BUN,
+    ],
+  ])('adds the cli command to the script command (%s)', async (_, pacMan) => {
+    jest
+      .spyOn(packageManagerHelpers, 'detectPackageManger')
+      .mockReturnValue(pacMan);
+    const packageJson = {
+      scripts: {
+        build: 'tsc',
+      },
+      version: '1.0.0',
+    };
+    await addSentryCommandToBuildCommand(packageJson);
+    expect(writeFileSpy).toHaveBeenCalledWith(
+      expect.stringContaining('package.json'),
+      expect.stringContaining(
+        `tsc && ${pacMan.runScriptCommand} sentry:sourcemaps`,
+      ),
+    );
+  });
+});