@sentry/wizard 3.5.0 → 3.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/wizard",
-  "version": "3.5.0",
+  "version": "3.7.0",
   "homepage": "https://github.com/getsentry/sentry-wizard",
   "repository": "https://github.com/getsentry/sentry-wizard",
   "description": "Sentry wizard helping you to configure your project",
@@ -26,7 +26,7 @@
     "@clack/core": "0.3.2",
     "@clack/prompts": "0.6.3",
     "@sentry/cli": "^1.72.0",
-    "@sentry/node": "^7.56.0",
+    "@sentry/node": "^7.57.0",
     "axios": "1.3.5",
     "chalk": "^2.4.1",
     "glob": "^7.1.3",

package/src/apple/apple-wizard.ts

@@ -0,0 +1,150 @@
+/* eslint-disable max-lines */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// @ts-ignore - clack is ESM and TS complains about that. It works though
+import clack from '@clack/prompts';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as xcManager from './xcode-manager';
+import * as codeTools from './code-tools';
+import * as bash from '../utils/bash';
+import { WizardOptions } from '../utils/types';
+import * as Sentry from '@sentry/node';
+import { traceStep, withTelemetry } from '../telemetry';
+
+const xcode = require('xcode');
+/* eslint-enable @typescript-eslint/no-unused-vars */
+
+import {
+  askForProjectSelection,
+  askForSelfHosted,
+  askForWizardLogin,
+  askToInstallSentryCLI,
+  SentryProjectData,
+  printWelcome,
+  abort,
+  askForItemSelection,
+} from '../utils/clack-utils';
+
+export async function runAppleWizard(options: WizardOptions): Promise<void> {
+  return withTelemetry(
+    {
+      enabled: options.telemetryEnabled,
+      integration: 'ios',
+    },
+    () => runAppleWizardWithTelementry(options),
+  );
+}
+
+async function runAppleWizardWithTelementry(
+  options: WizardOptions,
+): Promise<void> {
+  printWelcome({
+    wizardName: 'Sentry Apple Wizard',
+    promoCode: options.promoCode,
+  });
+
+  const hasCli = bash.hasSentryCLI();
+  Sentry.setTag('has-cli', hasCli);
+  if (!hasCli) {
+    if (
+      !(await traceStep('Ask for SentryCLI', () => askToInstallSentryCLI()))
+    ) {
+      clack.log.warn(
+        "Without sentry-cli, you won't be able to upload debug symbols to Sentry. You can install it later by following the instructions at https://docs.sentry.io/cli/",
+      );
+      Sentry.setTag('CLI-Installed', false);
+    } else {
+      await bash.installSentryCLI();
+      Sentry.setTag('CLI-Installed', true);
+    }
+  }
+
+  const projectDir = process.cwd();
+  const xcodeProjFiles = findFilesWithExtension(projectDir, '.xcodeproj');
+
+  if (!xcodeProjFiles || xcodeProjFiles.length === 0) {
+    clack.log.error(
+      'No Xcode project found. Please run this command from the root of your project.',
+    );
+    await abort();
+    return;
+  }
+
+  let xcodeProjFile;
+
+  if (xcodeProjFiles.length === 1) {
+    xcodeProjFile = xcodeProjFiles[0];
+    Sentry.setTag('multiple-projects', false);
+  } else {
+    Sentry.setTag('multiple-projects', true);
+    xcodeProjFile = (
+      await traceStep('Choose Xcode project', () =>
+        askForItemSelection(
+          xcodeProjFiles,
+          'Which project do you want to add Sentry to?',
+        ),
+      )
+    ).value;
+  }
+
+  const pbxproj = path.join(projectDir, xcodeProjFile, 'project.pbxproj');
+  if (!fs.existsSync(pbxproj)) {
+    clack.log.error(`No pbxproj found at ${pbxproj}`);
+    await abort();
+    return;
+  }
+
+  const { project, apiKey } = await getSentryProjectAndApiKey(
+    options.promoCode,
+    options.url,
+  );
+
+  traceStep('Update Xcode project', () => {
+    xcManager.updateXcodeProject(pbxproj, project, apiKey, true, true);
+  });
+
+  const projSource = path.join(
+    projectDir,
+    xcodeProjFile.replace('.xcodeproj', ''),
+  );
+  const codeAdded = traceStep('Add code snippet', () => {
+    return codeTools.addCodeSnippetToProject(
+      projSource,
+      project.keys[0].dsn.public,
+    );
+  });
+  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;
+  }
+
+  clack.log.success('Sentry was successfully added to your project!');
+}
+
+//Prompt for Sentry project and API key
+async function getSentryProjectAndApiKey(
+  promoCode?: string,
+  url?: string,
+): Promise<{ project: SentryProjectData; apiKey: { token: string } }> {
+  const { url: sentryUrl } = await askForSelfHosted(url);
+
+  const { projects, apiKeys } = await askForWizardLogin({
+    promoCode: promoCode,
+    url: sentryUrl,
+    platform: 'apple-ios',
+  });
+
+  const selectedProject = await askForProjectSelection(projects);
+  return { project: selectedProject, apiKey: apiKeys };
+}
+
+//find files with the given extension
+function findFilesWithExtension(dir: string, extension: string): string[] {
+  const files = fs.readdirSync(dir);
+  return files.filter((file) => file.endsWith(extension));
+}

package/src/apple/code-tools.ts

@@ -0,0 +1,81 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as templates from './templates';
+import * as Sentry from '@sentry/node';
+
+const swiftAppLaunchRegex = /(func\s+application\s*\(_\sapplication:[^,]+,\s*didFinishLaunchingWithOptions[^,]+:[^)]+\)\s+->\s+Bool\s+{)|(init\s*\([^)]*\)\s*{)/im;
+const objcAppLaunchRegex = /-\s*\(BOOL\)\s*application:\s*\(UIApplication\s*\*\)\s*application\s+didFinishLaunchingWithOptions:\s*\(NSDictionary\s*\*\)\s*launchOptions\s*{/im;
+const swiftUIRegex = /struct[^:]+:\s*App\s*{/im;
+
+function isAppDelegateFile(filePath: string): boolean {
+    const appLaunchRegex = filePath.toLowerCase().endsWith(".swift") ? swiftAppLaunchRegex : objcAppLaunchRegex;
+
+    const fileContent = fs.readFileSync(filePath, 'utf8');
+    return appLaunchRegex.test(fileContent) || swiftUIRegex.test(fileContent);
+}
+
+function findAppDidFinishLaunchingWithOptions(dir: string): string | null {
+    const files = fs.readdirSync(dir);
+    //iterate over subdirectories later, 
+    //the appdelegate usually is in the top level
+    const dirs: string[] = [];
+
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        if (file.endsWith(".swift") || file.endsWith(".m") || file.endsWith(".mm")) {
+            if (isAppDelegateFile(filePath)) {
+                return filePath;
+            }
+        } else if (!file.startsWith(".") && !file.endsWith(".xcodeproj") && !file.endsWith(".xcassets") && fs.lstatSync(filePath).isDirectory()) {
+            dirs.push(file);
+        }
+    }
+
+    for (const dr of dirs) {
+        const result = findAppDidFinishLaunchingWithOptions(path.join(dir, dr));
+        if (result) return result;
+    }
+    return null;
+}
+
+export function addCodeSnippetToProject(projPath: string, dsn: string): boolean {
+    const appDelegate = findAppDidFinishLaunchingWithOptions(projPath);
+    if (!appDelegate) {
+        return false;
+    }
+
+    const fileContent = fs.readFileSync(appDelegate, 'utf8');
+    const isSwift = appDelegate.toLowerCase().endsWith(".swift");
+    const appLaunchRegex = isSwift ? swiftAppLaunchRegex : objcAppLaunchRegex;
+    const importStatement = isSwift ? "import Sentry\n" : "@import Sentry;\n";
+    const checkForSentryInit = isSwift ? "SentrySDK.start" : "[SentrySDK start";
+    let codeSnippet = isSwift ? templates.getSwiftSnippet(dsn) : templates.getObjcSnippet(dsn);
+
+    Sentry.setTag("code-language", isSwift ? "swift" : "objc");
+    Sentry.setTag("ui-engine", swiftUIRegex.test(fileContent) ? "swiftui" : "uikit");
+
+    if (fileContent.includes(checkForSentryInit)) {
+        //already initialized
+        return true;
+    }
+
+    let match = appLaunchRegex.exec(fileContent);
+    if (!match) {
+        const swiftUIMatch = swiftUIRegex.exec(fileContent)
+        if (!swiftUIMatch) {
+            return false;
+        }
+        //Is SwiftUI with no init
+        match = swiftUIMatch;
+        codeSnippet = `    init() {\n${codeSnippet}    }`;
+    }
+
+    const insertIndex = match.index + match[0].length;
+    const newFileContent = (fileContent.indexOf(importStatement) >= 0 ? "" : importStatement) +
+        fileContent.slice(0, insertIndex) + "\n" +
+        codeSnippet +
+        fileContent.slice(insertIndex);
+    fs.writeFileSync(appDelegate, newFileContent, 'utf8');
+
+    return true;
+}

package/src/apple/templates.ts

@@ -0,0 +1,39 @@
+export function getRunScriptTemplate(
+    orgSlug: string,
+    projectSlug: string,
+    apiKey: string,
+    uploadSource = true,
+): string {
+    // eslint-disable-next-line no-useless-escape
+    return `# This script is responsable to upload debug symbols and source context for Sentry.\\nif which sentry-cli >/dev/null; then\\nexport SENTRY_ORG=${orgSlug}\\nexport SENTRY_PROJECT=${projectSlug}\\nexport SENTRY_AUTH_TOKEN=${apiKey}\\nERROR=$(sentry-cli debug-files upload ${uploadSource ? "--include-sources " : ""}\"$DWARF_DSYM_FOLDER_PATH\" 2>&1 >/dev/null)\\nif [ ! $? -eq 0 ]; then\\necho \"warning: sentry-cli - $ERROR\"\\nfi\\nelse\\necho \"warning: sentry-cli not installed, download from https://github.com/getsentry/sentry-cli/releases\"\\nfi\\n`;
+}
+
+export const scriptInputPath = "\"${DWARF_DSYM_FOLDER_PATH}/${DWARF_DSYM_FILE_NAME}/Contents/Resources/DWARF/${TARGET_NAME}\"";
+
+export function getSwiftSnippet(dsn: string): string {
+    return `        SentrySDK.start { options in
+            options.dsn = "${dsn}"
+            options.debug = true // Enabled debug when first installing is always helpful
+            options.enableTracing = true 
+
+            // Uncomment the following lines to add more data to your events
+            // options.attachScreenshot = true // This adds a screenshot to the error events
+            // options.attachViewHierarchy = true // This adds the view hierarchy to the error events
+        }
+        // Remove the next line after confirming that your Sentry integration is working.
+        SentrySDK.capture(message: "This app uses Sentry! :)")\n`;
+}
+
+export function getObjcSnippet(dsn: string): string {
+    return `    [SentrySDK startWithConfigureOptions:^(SentryOptions * options) {
+        options.dsn = @"${dsn}";
+        options.debug = YES; // Enabled debug when first installing is always helpful
+        options.enableTracing = YES;
+
+        //Uncomment the following lines to add more data to your events
+        //options.attachScreenshot = YES; //This will add a screenshot to the error events
+        //options.attachViewHierarchy = YES; //This will add the view hierarchy to the error events
+    }];
+    //Remove the next line after confirming that your Sentry integration is working.
+    [SentrySDK captureMessage:@"This app uses Sentry!"];\n`;
+}

package/src/apple/xcode-manager.ts

@@ -0,0 +1,147 @@
+/* eslint-disable max-lines */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { SentryCli } from '../../lib/Helper/SentryCli';
+// @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 templates from './templates';
+const xcode = require('xcode');
+
+import { SentryProjectData } from '../utils/clack-utils';
+/* eslint-enable @typescript-eslint/no-unused-vars */
+
+function setDebugInformationFormat(proj: any): void {
+    const xcObjects = proj.hash.project.objects;
+    const target = proj.getFirstTarget().firstTarget;
+
+    xcObjects.XCConfigurationList[target.buildConfigurationList].buildConfigurations.forEach((buildConfig: { value: string }) => {
+        xcObjects.XCBuildConfiguration[buildConfig.value].buildSettings.DEBUG_INFORMATION_FORMAT = "\"dwarf-with-dsym\"";
+    });
+}
+
+function addSentrySPM(proj: any): void {
+    const xcObjects = proj.hash.project.objects;
+
+    const sentryFrameworkUUID = proj.generateUuid() as string;
+    const sentrySPMUUID = proj.generateUuid() as string;
+
+    //Check whether xcObjects already have sentry framework
+    if (xcObjects.PBXFrameworksBuildPhase) {
+        for (const key in xcObjects.PBXFrameworksBuildPhase || {}) {
+            if (!key.endsWith("_comment")) {
+                const frameworks = xcObjects.PBXFrameworksBuildPhase[key].files;
+                for (const framework of frameworks) {
+                    if (framework.comment === "Sentry in Frameworks") {
+                        return;
+                    }
+                }
+            }
+        }
+    }
+
+    xcObjects.PBXBuildFile[sentryFrameworkUUID] = {
+        isa: "PBXBuildFile",
+        productRef: sentrySPMUUID,
+        productRef_comment: "Sentry",
+    };
+    xcObjects.PBXBuildFile[sentryFrameworkUUID + "_comment"] = "Sentry in Frameworks";
+
+    for (const key in xcObjects.PBXFrameworksBuildPhase || {}) {
+        if (!key.endsWith("_comment")) {
+            const frameworks = xcObjects.PBXFrameworksBuildPhase[key].files;
+            frameworks.push({
+                value: sentryFrameworkUUID,
+                comment: "Sentry in Frameworks",
+            });
+        }
+    }
+
+    const target = proj.getFirstTarget().firstTarget;
+    if (!target.packageProductDependencies) {
+        target.packageProductDependencies = [];
+    }
+    target.packageProductDependencies.push({
+        value: sentrySPMUUID,
+        comment: "Sentry",
+    });
+
+    const sentrySwiftPackageUUID = proj.generateUuid() as string;
+    const xcProject = proj.getFirstProject().firstProject;
+    if (!xcProject.packageReferences) {
+        xcProject.packageReferences = [];
+    }
+    xcProject.packageReferences.push({
+        value: sentrySwiftPackageUUID,
+        comment: "XCRemoteSwiftPackageReference \"sentry-cocoa\"",
+    });
+
+    xcObjects.XCRemoteSwiftPackageReference = {};
+    xcObjects.XCRemoteSwiftPackageReference[sentrySwiftPackageUUID] = {
+        isa: "XCRemoteSwiftPackageReference",
+        repositoryURL: "\"https://github.com/getsentry/sentry-cocoa/\"",
+        requirement: {
+            kind: "upToNextMajorVersion",
+            minimumVersion: "8.0.0",
+        }
+    };
+    xcObjects.XCRemoteSwiftPackageReference[sentrySwiftPackageUUID + "_comment"] = "XCRemoteSwiftPackageReference \"sentry-cocoa\"";
+
+    xcObjects.XCSwiftPackageProductDependency = {};
+    xcObjects.XCSwiftPackageProductDependency[sentrySPMUUID] =
+    {
+        isa: "XCSwiftPackageProductDependency",
+        package: sentrySwiftPackageUUID,
+        package_comment: "XCRemoteSwiftPackageReference \"sentry-cocoa\"",
+        productName: "Sentry",
+    };
+    xcObjects.XCSwiftPackageProductDependency[sentrySPMUUID + "_comment"] = "Sentry";
+}
+
+function addUploadSymbolsScript(xcodeProject: any, sentryProject: SentryProjectData, apiKeys: { token: string }, uploadSource = true): void {
+    const xcObjects = xcodeProject.hash.project.objects;
+
+    for (const scriptKey in xcObjects.PBXShellScriptBuildPhase || {}) {
+        if (!scriptKey.endsWith("_comment")) {
+            const script = xcObjects.PBXShellScriptBuildPhase[scriptKey].shellScript;
+            //Sentry script already exists, update it
+            if (script.includes("sentry-cli")) {
+                delete xcObjects.PBXShellScriptBuildPhase[scriptKey];
+                delete xcObjects.PBXShellScriptBuildPhase[scriptKey + "_comment"];
+                break;
+            }
+        }
+    }
+
+    xcodeProject.addBuildPhase(
+        [],
+        'PBXShellScriptBuildPhase',
+        'Upload Debug Symbols to Sentry',
+        null,
+        {
+            inputFileListPaths: [],
+            outputFileListPaths: [],
+            inputPaths: [templates.scriptInputPath],
+            shellPath: '/bin/sh',
+            shellScript: templates.getRunScriptTemplate(sentryProject.organization.slug, sentryProject.slug, apiKeys.token, uploadSource)
+        },
+    );
+}
+
+export function updateXcodeProject(projectPath: string, sentryProject: SentryProjectData, apiKeys: { token: string }, addSPMReference: boolean, uploadSource = true): void {
+    const proj = xcode.project(projectPath);
+    proj.parseSync();
+    addUploadSymbolsScript(proj, sentryProject, apiKeys, uploadSource);
+    if (uploadSource) {
+        setDebugInformationFormat(proj);
+    }
+    if (addSPMReference) {
+        addSentrySPM(proj);
+    }
+    const newContent = proj.writeSync();
+    fs.writeFileSync(projectPath, newContent);
+}

package/src/nextjs/nextjs-wizard.ts

@@ -18,6 +18,7 @@ import {
   ensurePackageIsInstalled,
   getPackageDotJson,
   installPackage,
+  isUsingTypeScript,
   printWelcome,
 } from '../utils/clack-utils';
 import { WizardOptions } from '../utils/types';
@@ -59,14 +60,7 @@ export async function runNextjsWizard(options: WizardOptions): Promise<void> {
     alreadyInstalled: !!packageJson?.dependencies?.['@sentry/nextjs'],
   });
 
-  let isUsingTypescript = false;
-  try {
-    isUsingTypescript = fs.existsSync(
-      path.join(process.cwd(), 'tsconfig.json'),
-    );
-  } catch {
-    // noop - Default to assuming user is not using typescript
-  }
+  const typeScriptDetected = isUsingTypeScript();
 
   const configVariants = ['server', 'client', 'edge'] as const;
 
@@ -114,7 +108,7 @@ export async function runNextjsWizard(options: WizardOptions): Promise<void> {
 
     if (shouldWriteFile) {
       await fs.promises.writeFile(
-        path.join(process.cwd(), isUsingTypescript ? tsConfig : jsConfig),
+        path.join(process.cwd(), typeScriptDetected ? tsConfig : jsConfig),
         getSentryConfigContents(
           selectedProject.keys[0].dsn.public,
           configVariant,
@@ -122,7 +116,9 @@ export async function runNextjsWizard(options: WizardOptions): Promise<void> {
         { encoding: 'utf8', flag: 'w' },
       );
       clack.log.success(
-        `Created fresh ${chalk.bold(isUsingTypescript ? tsConfig : jsConfig)}.`,
+        `Created fresh ${chalk.bold(
+          typeScriptDetected ? tsConfig : jsConfig,
+        )}.`,
       );
     }
   }