@sentry/wizard 3.10.0 → 3.12.0

package/src/utils/clack-utils.ts

@@ -7,12 +7,17 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { setInterval } from 'timers';
 import { URL } from 'url';
-import { promisify } from 'util';
 import * as Sentry from '@sentry/node';
-import { windowedSelect } from './vendor/clack-custom-select';
 import { hasPackageInstalled, PackageDotJson } from './package-json';
 import { SentryProjectData, WizardOptions } from './types';
 import { traceStep } from '../telemetry';
+import {
+  detectPackageManger,
+  PackageManager,
+  installPackageWithPackageManager,
+  packageManagers,
+} from './package-manager';
+import { debug } from './debug';
 
 const opn = require('opn') as (
   url: string,
@@ -20,6 +25,7 @@ const opn = require('opn') as (
 
 export const SENTRY_DOT_ENV_FILE = '.env.sentry-build-plugin';
 export const SENTRY_CLI_RC_FILE = '.sentryclirc';
+export const SENTRY_PROPERTIES_FILE = 'sentry.properties';
 
 const SAAS_URL = 'https://sentry.io/';
 
@@ -30,6 +36,38 @@ interface WizardProjectData {
   projects: SentryProjectData[];
 }
 
+export interface CliSetupConfig {
+  filename: string;
+  name: string;
+
+  likelyAlreadyHasAuthToken(contents: string): boolean;
+  tokenContent(authToken: string): string;
+
+  likelyAlreadyHasOrgAndProject(contents: string): boolean;
+  orgAndProjContent(org: string, project: string): string;
+}
+
+export const sourceMapsCliSetupConfig: CliSetupConfig = {
+  filename: SENTRY_CLI_RC_FILE,
+  name: 'source maps',
+  likelyAlreadyHasAuthToken: function (contents: string): boolean {
+    return !!(contents.includes('[auth]') && contents.match(/token=./g));
+  },
+  tokenContent: function (authToken: string): string {
+    return `[auth]\ntoken=${authToken}`;
+  },
+  likelyAlreadyHasOrgAndProject: function (contents: string): boolean {
+    return !!(
+      contents.includes('[defaults]') &&
+      contents.match(/org=./g) &&
+      contents.match(/project=./g)
+    );
+  },
+  orgAndProjContent: function (org: string, project: string): string {
+    return `[defaults]\norg=${org}\nproject=${project}`;
+  },
+};
+
 export async function abort(message?: string, status?: number): Promise<never> {
   clack.outro(message ?? 'Wizard setup cancelled.');
   const sentryHub = Sentry.getCurrentHub();
@@ -134,119 +172,13 @@ export async function askToInstallSentryCLI(): Promise<boolean> {
   );
 }
 
-export async function askForWizardLogin(options: {
-  url: string;
-  promoCode?: string;
-  platform?:
-    | 'javascript-nextjs'
-    | 'javascript-remix'
-    | 'javascript-sveltekit'
-    | 'apple-ios';
-}): Promise<WizardProjectData> {
-  Sentry.setTag('has-promo-code', !!options.promoCode);
-
-  let hasSentryAccount = await clack.confirm({
-    message: 'Do you already have a Sentry account?',
-  });
-
-  hasSentryAccount = await abortIfCancelled(hasSentryAccount);
-
-  Sentry.setTag('already-has-sentry-account', hasSentryAccount);
-
-  let wizardHash: string;
-  try {
-    wizardHash = (
-      await axios.get<{ hash: string }>(`${options.url}api/0/wizard/`)
-    ).data.hash;
-  } catch {
-    if (options.url !== SAAS_URL) {
-      clack.log.error('Loading Wizard failed. Did you provide the right URL?');
-      await abort(
-        chalk.red(
-          'Please check your configuration and try again.\n\n   Let us know if you think this is an issue with the wizard or Sentry: https://github.com/getsentry/sentry-wizard/issues',
-        ),
-      );
-    } else {
-      clack.log.error('Loading Wizard failed.');
-      await abort(
-        chalk.red(
-          'Please try again in a few minutes and let us know if this issue persists: https://github.com/getsentry/sentry-wizard/issues',
-        ),
-      );
-    }
-  }
-
-  const loginUrl = new URL(
-    `${options.url}account/settings/wizard/${wizardHash!}/`,
-  );
-
-  if (!hasSentryAccount) {
-    loginUrl.searchParams.set('signup', '1');
-    if (options.platform) {
-      loginUrl.searchParams.set('project_platform', options.platform);
-    }
-  }
-
-  if (options.promoCode) {
-    loginUrl.searchParams.set('code', options.promoCode);
-  }
-
-  const urlToOpen = loginUrl.toString();
-  clack.log.info(
-    `${chalk.bold(
-      `If the browser window didn't open automatically, please open the following link to ${
-        hasSentryAccount ? 'log' : 'sign'
-      } into Sentry:`,
-    )}\n\n${chalk.cyan(urlToOpen)}`,
-  );
-
-  opn(urlToOpen).catch(() => {
-    // opn throws in environments that don't have a browser (e.g. remote shells) so we just noop here
-  });
-
-  const loginSpinner = clack.spinner();
-
-  loginSpinner.start('Waiting for you to log in using the link above');
-
-  const data = await new Promise<WizardProjectData>((resolve) => {
-    const pollingInterval = setInterval(() => {
-      axios
-        .get<WizardProjectData>(`${options.url}api/0/wizard/${wizardHash}/`)
-        .then((result) => {
-          resolve(result.data);
-          clearTimeout(timeout);
-          clearInterval(pollingInterval);
-          void axios.delete(`${options.url}api/0/wizard/${wizardHash}/`);
-        })
-        .catch(() => {
-          // noop - just try again
-        });
-    }, 500);
-
-    const timeout = setTimeout(() => {
-      clearInterval(pollingInterval);
-      loginSpinner.stop(
-        'Login timed out. No worries - it happens to the best of us.',
-      );
-
-      Sentry.setTag('opened-wizard-link', false);
-      void abort('Please restart the Wizard and log in to complete the setup.');
-    }, 180_000);
-  });
-
-  loginSpinner.stop('Login complete.');
-  Sentry.setTag('opened-wizard-link', true);
-
-  return data;
-}
-
 export async function askForItemSelection(
   items: string[],
   message: string,
 ): Promise<{ value: string; index: number }> {
   const selection: { value: string; index: number } | symbol =
     await abortIfCancelled(
-      windowedSelect({
+      clack.select({
         maxItems: 12,
         message: message,
         options: items.map((item, index) => {
@@ -261,29 +193,6 @@ export async function askForItemSelection(
   return selection;
 }
 
-export async function askForProjectSelection(
-  projects: SentryProjectData[],
-): Promise<SentryProjectData> {
-  const selection: SentryProjectData | symbol = await abortIfCancelled(
-    windowedSelect({
-      maxItems: 12,
-      message: 'Select your Sentry project.',
-      options: projects.map((project) => {
-        return {
-          value: project,
-          label: `${project.organization.slug}/${project.slug}`,
-        };
-      }),
-    }),
-  );
-
-  Sentry.setTag('project', selection.slug);
-  Sentry.setTag('project-platform', selection.platform);
-  Sentry.setUser({ id: selection.organization.slug });
-
-  return selection;
-}
-
 export async function installPackage({
   packageName,
   alreadyInstalled,
@@ -314,17 +223,11 @@ export async function installPackage({
   sdkInstallSpinner.start(
     `${alreadyInstalled ? 'Updating' : 'Installing'} ${chalk.bold.cyan(
       packageName,
-    )} with ${chalk.bold(packageManager)}.`,
+    )} with ${chalk.bold(packageManager.label)}.`,
   );
 
   try {
-    if (packageManager === 'yarn') {
-      await promisify(childProcess.exec)(`yarn add ${packageName}@latest`);
-    } else if (packageManager === 'pnpm') {
-      await promisify(childProcess.exec)(`pnpm add ${packageName}@latest`);
-    } else if (packageManager === 'npm') {
-      await promisify(childProcess.exec)(`npm install ${packageName}@latest`);
-    }
+    await installPackageWithPackageManager(packageManager, packageName);
   } catch (e) {
     sdkInstallSpinner.stop('Installation failed.');
     clack.log.error(
@@ -341,189 +244,119 @@ export async function installPackage({
   sdkInstallSpinner.stop(
     `${alreadyInstalled ? 'Updated' : 'Installed'} ${chalk.bold.cyan(
       packageName,
-    )} with ${chalk.bold(packageManager)}.`,
+    )} with ${chalk.bold(packageManager.label)}.`,
   );
 }
 
-/**
- * Asks users if they are using SaaS or self-hosted Sentry and returns the validated URL.
- *
- * If users started the wizard with a --url arg, that URL is used as the default and we skip
- * the self-hosted question. However, the passed url is still validated and in case it's
- * invalid, users are asked to enter a new one until it is valid.
- *
- * @param urlFromArgs the url passed via the --url arg
- */
-export async function askForSelfHosted(urlFromArgs?: string): Promise<{
-  url: string;
-  selfHosted: boolean;
-}> {
-  if (!urlFromArgs) {
-    const choice: 'saas' | 'self-hosted' | symbol = await abortIfCancelled(
-      clack.select({
-        message: 'Are you using Sentry SaaS or self-hosted Sentry?',
-        options: [
-          { value: 'saas', label: 'Sentry SaaS (sentry.io)' },
-          {
-            value: 'self-hosted',
-            label: 'Self-hosted/on-premise/single-tenant',
-          },
-        ],
-      }),
-    );
-
-    if (choice === 'saas') {
-      Sentry.setTag('url', SAAS_URL);
-      Sentry.setTag('self-hosted', false);
-      return { url: SAAS_URL, selfHosted: false };
-    }
-  }
-
-  let validUrl: string | undefined;
-  let tmpUrlFromArgs = urlFromArgs;
-
-  while (validUrl === undefined) {
-    const url =
-      tmpUrlFromArgs ||
-      (await abortIfCancelled(
-        clack.text({
-          message: `Please enter the URL of your ${
-            urlFromArgs ? '' : 'self-hosted '
-          }Sentry instance.`,
-          placeholder: 'https://sentry.io/',
-        }),
-      ));
-    tmpUrlFromArgs = undefined;
-
-    try {
-      validUrl = new URL(url).toString();
-
-      // We assume everywhere else that the URL ends in a slash
-      if (!validUrl.endsWith('/')) {
-        validUrl += '/';
-      }
-    } catch {
-      clack.log.error(
-        'Please enter a valid URL. (It should look something like "https://sentry.mydomain.com/")',
-      );
-    }
-  }
-
-  const isSelfHostedUrl = new URL(validUrl).host !== new URL(SAAS_URL).host;
-
-  Sentry.setTag('url', validUrl);
-  Sentry.setTag('self-hosted', isSelfHostedUrl);
-
-  return { url: validUrl, selfHosted: true };
-}
-
 async function addOrgAndProjectToSentryCliRc(
   org: string,
   project: string,
+  setupConfig: CliSetupConfig,
 ): Promise<void> {
-  const clircContents = fs.readFileSync(
-    path.join(process.cwd(), SENTRY_CLI_RC_FILE),
+  const configContents = fs.readFileSync(
+    path.join(process.cwd(), setupConfig.filename),
     'utf8',
   );
 
-  const likelyAlreadyHasOrgAndProject = !!(
-    clircContents.includes('[defaults]') &&
-    clircContents.match(/org=./g) &&
-    clircContents.match(/project=./g)
-  );
-
-  if (likelyAlreadyHasOrgAndProject) {
+  if (setupConfig.likelyAlreadyHasOrgAndProject(configContents)) {
     clack.log.warn(
       `${chalk.bold(
-        SENTRY_CLI_RC_FILE,
+        setupConfig.filename,
       )} already has org and project. Will not add them.`,
     );
   } else {
     try {
       await fs.promises.appendFile(
-        path.join(process.cwd(), SENTRY_CLI_RC_FILE),
-        `\n[defaults]\norg=${org}\nproject=${project}\n`,
+        path.join(process.cwd(), setupConfig.filename),
+        `\n${setupConfig.orgAndProjContent(org, project)}\n`,
       );
     } catch (e) {
       clack.log.warn(
         `${chalk.bold(
-          SENTRY_CLI_RC_FILE,
+          setupConfig.filename,
         )} could not be updated with org and project.`,
       );
     }
   }
 }
 
-export async function addSentryCliRc(
+export async function addSentryCliConfig(
   authToken: string,
+  setupConfig: CliSetupConfig = sourceMapsCliSetupConfig,
   orgSlug?: string,
   projectSlug?: string,
 ): Promise<void> {
-  const clircExists = fs.existsSync(
-    path.join(process.cwd(), SENTRY_CLI_RC_FILE),
+  const configExists = fs.existsSync(
+    path.join(process.cwd(), setupConfig.filename),
   );
-  if (clircExists) {
-    const clircContents = fs.readFileSync(
-      path.join(process.cwd(), SENTRY_CLI_RC_FILE),
+  if (configExists) {
+    const configContents = fs.readFileSync(
+      path.join(process.cwd(), setupConfig.filename),
       'utf8',
     );
 
-    const likelyAlreadyHasAuthToken = !!(
-      clircContents.includes('[auth]') && clircContents.match(/token=./g)
-    );
-
-    if (likelyAlreadyHasAuthToken) {
+    if (setupConfig.likelyAlreadyHasAuthToken(configContents)) {
       clack.log.warn(
         `${chalk.bold(
-          SENTRY_CLI_RC_FILE,
+          setupConfig.filename,
         )} already has auth token. Will not add one.`,
       );
     } else {
       try {
         await fs.promises.writeFile(
-          path.join(process.cwd(), SENTRY_CLI_RC_FILE),
-          `${clircContents}\n[auth]\ntoken=${authToken}\n`,
+          path.join(process.cwd(), setupConfig.filename),
+          `${configContents}\n${setupConfig.tokenContent(authToken)}\n`,
           { encoding: 'utf8', flag: 'w' },
         );
         clack.log.success(
-          `Added auth token to ${chalk.bold(
-            SENTRY_CLI_RC_FILE,
-          )} for you to test uploading source maps locally.`,
+          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(
-            SENTRY_CLI_RC_FILE,
-          )}. Uploading source maps during build will likely not work locally.`,
+            setupConfig.filename,
+          )}. Uploading ${
+            setupConfig.name
+          } during build will likely not work locally.`,
         );
       }
     }
   } else {
     try {
       await fs.promises.writeFile(
-        path.join(process.cwd(), SENTRY_CLI_RC_FILE),
-        `[auth]\ntoken=${authToken}\n`,
+        path.join(process.cwd(), setupConfig.filename),
+        `${setupConfig.tokenContent(authToken)}\n`,
         { encoding: 'utf8', flag: 'w' },
       );
       clack.log.success(
-        `Created ${chalk.bold(
-          SENTRY_CLI_RC_FILE,
-        )} with auth token for you to test uploading source maps locally.`,
+        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(
-          SENTRY_CLI_RC_FILE,
-        )} with auth token. Uploading source maps during build will likely not work locally.`,
+          setupConfig.filename,
+        )} with auth token. Uploading ${
+          setupConfig.name
+        } during build will likely not work locally.`,
       );
     }
   }
 
   if (orgSlug && projectSlug) {
-    await addOrgAndProjectToSentryCliRc(orgSlug, projectSlug);
+    await addOrgAndProjectToSentryCliRc(orgSlug, projectSlug, setupConfig);
   }
 
-  await addAuthTokenFileToGitIgnore(SENTRY_CLI_RC_FILE);
+  await addAuthTokenFileToGitIgnore(setupConfig.filename);
 }
 
 export async function addDotEnvSentryBuildPluginFile(
@@ -605,7 +438,9 @@ async function addAuthTokenFileToGitIgnore(filename: string): Promise<void> {
       { encoding: 'utf8' },
     );
     clack.log.success(
-      `Added ${chalk.bold(filename)} to ${chalk.bold('.gitignore')}.`,
+      chalk.greenBright(
+        `Added ${chalk.bold(filename)} to ${chalk.bold('.gitignore')}.`,
+      ),
     );
   } catch {
     clack.log.error(
@@ -661,42 +496,29 @@ export async function getPackageDotJson(): Promise<PackageDotJson> {
   return packageJson || {};
 }
 
-async function getPackageManager(): Promise<string> {
-  const detectedPackageManager = detectPackageManager();
+async function getPackageManager(): Promise<PackageManager> {
+  const detectedPackageManager = detectPackageManger();
 
   if (detectedPackageManager) {
     return detectedPackageManager;
   }
 
-  const selectedPackageManager: string | symbol = await abortIfCancelled(
-    clack.select({
-      message: 'Please select your package manager.',
-      options: [
-        { value: 'npm', label: 'Npm' },
-        { value: 'yarn', label: 'Yarn' },
-        { value: 'pnpm', label: 'Pnpm' },
-      ],
-    }),
-  );
+  const selectedPackageManager: PackageManager | symbol =
+    await abortIfCancelled(
+      clack.select({
+        message: 'Please select your package manager.',
+        options: packageManagers.map((packageManager) => ({
+          value: packageManager,
+          label: packageManager.label,
+        })),
+      }),
+    );
 
-  Sentry.setTag('package-manager', selectedPackageManager);
+  Sentry.setTag('package-manager', selectedPackageManager.name);
 
   return selectedPackageManager;
 }
 
-export function detectPackageManager(): 'yarn' | 'npm' | 'pnpm' | undefined {
-  if (fs.existsSync(path.join(process.cwd(), 'yarn.lock'))) {
-    return 'yarn';
-  }
-  if (fs.existsSync(path.join(process.cwd(), 'package-lock.json'))) {
-    return 'npm';
-  }
-  if (fs.existsSync(path.join(process.cwd(), 'pnpm-lock.yaml'))) {
-    return 'pnpm';
-  }
-  return undefined;
-}
-
 export function isUsingTypeScript() {
   try {
     return fs.existsSync(path.join(process.cwd(), 'tsconfig.json'));
@@ -705,7 +527,26 @@ export function isUsingTypeScript() {
   }
 }
 
-export async function getOrAskForProjectData(options: WizardOptions): Promise<{
+/**
+ * Checks if we already got project data from a previous wizard invocation.
+ * If yes, this data is returned.
+ * Otherwise, we start the login flow and ask the user to select a project.
+ *
+ * Use this function to get project data for the wizard.
+ *
+ * @param options wizard options
+ * @param platform the platform of the wizard
+ * @returns project data (org, project, token, url)
+ */
+export async function getOrAskForProjectData(
+  options: WizardOptions,
+  platform?:
+    | 'javascript-nextjs'
+    | 'javascript-remix'
+    | 'javascript-sveltekit'
+    | 'apple-ios'
+    | 'android',
+): Promise<{
   sentryUrl: string;
   selfHosted: boolean;
   selectedProject: SentryProjectData;
@@ -728,10 +569,18 @@ export async function getOrAskForProjectData(options: WizardOptions): Promise<{
     askForWizardLogin({
       promoCode: options.promoCode,
       url: sentryUrl,
-      platform: 'javascript-nextjs',
+      platform: platform,
     }),
   );
 
+  if (!projects || !projects.length) {
+    clack.log.error(
+      'No projects found. Please create a project in Sentry and try again.',
+    );
+    Sentry.setTag('no-projects-found', true);
+    await abort();
+  }
+
   const selectedProject = await traceStep('select-project', () =>
     askForProjectSelection(projects),
   );
@@ -743,3 +592,356 @@ export async function getOrAskForProjectData(options: WizardOptions): Promise<{
     selectedProject,
   };
 }
+
+/**
+ * Asks users if they are using SaaS or self-hosted Sentry and returns the validated URL.
+ *
+ * If users started the wizard with a --url arg, that URL is used as the default and we skip
+ * the self-hosted question. However, the passed url is still validated and in case it's
+ * invalid, users are asked to enter a new one until it is valid.
+ *
+ * @param urlFromArgs the url passed via the --url arg
+ */
+async function askForSelfHosted(urlFromArgs?: string): Promise<{
+  url: string;
+  selfHosted: boolean;
+}> {
+  if (!urlFromArgs) {
+    const choice: 'saas' | 'self-hosted' | symbol = await abortIfCancelled(
+      clack.select({
+        message: 'Are you using Sentry SaaS or self-hosted Sentry?',
+        options: [
+          { value: 'saas', label: 'Sentry SaaS (sentry.io)' },
+          {
+            value: 'self-hosted',
+            label: 'Self-hosted/on-premise/single-tenant',
+          },
+        ],
+      }),
+    );
+
+    if (choice === 'saas') {
+      Sentry.setTag('url', SAAS_URL);
+      Sentry.setTag('self-hosted', false);
+      return { url: SAAS_URL, selfHosted: false };
+    }
+  }
+
+  let validUrl: string | undefined;
+  let tmpUrlFromArgs = urlFromArgs;
+
+  while (validUrl === undefined) {
+    const url =
+      tmpUrlFromArgs ||
+      (await abortIfCancelled(
+        clack.text({
+          message: `Please enter the URL of your ${
+            urlFromArgs ? '' : 'self-hosted '
+          }Sentry instance.`,
+          placeholder: 'https://sentry.io/',
+        }),
+      ));
+    tmpUrlFromArgs = undefined;
+
+    try {
+      validUrl = new URL(url).toString();
+
+      // We assume everywhere else that the URL ends in a slash
+      if (!validUrl.endsWith('/')) {
+        validUrl += '/';
+      }
+    } catch {
+      clack.log.error(
+        'Please enter a valid URL. (It should look something like "https://sentry.mydomain.com/")',
+      );
+    }
+  }
+
+  const isSelfHostedUrl = new URL(validUrl).host !== new URL(SAAS_URL).host;
+
+  Sentry.setTag('url', validUrl);
+  Sentry.setTag('self-hosted', isSelfHostedUrl);
+
+  return { url: validUrl, selfHosted: true };
+}
+
+async function askForWizardLogin(options: {
+  url: string;
+  promoCode?: string;
+  platform?:
+    | 'javascript-nextjs'
+    | 'javascript-remix'
+    | 'javascript-sveltekit'
+    | 'apple-ios'
+    | 'android';
+}): Promise<WizardProjectData> {
+  Sentry.setTag('has-promo-code', !!options.promoCode);
+
+  let hasSentryAccount = await clack.confirm({
+    message: 'Do you already have a Sentry account?',
+  });
+
+  hasSentryAccount = await abortIfCancelled(hasSentryAccount);
+
+  Sentry.setTag('already-has-sentry-account', hasSentryAccount);
+
+  let wizardHash: string;
+  try {
+    wizardHash = (
+      await axios.get<{ hash: string }>(`${options.url}api/0/wizard/`)
+    ).data.hash;
+  } catch {
+    if (options.url !== SAAS_URL) {
+      clack.log.error('Loading Wizard failed. Did you provide the right URL?');
+      await abort(
+        chalk.red(
+          'Please check your configuration and try again.\n\n   Let us know if you think this is an issue with the wizard or Sentry: https://github.com/getsentry/sentry-wizard/issues',
+        ),
+      );
+    } else {
+      clack.log.error('Loading Wizard failed.');
+      await abort(
+        chalk.red(
+          'Please try again in a few minutes and let us know if this issue persists: https://github.com/getsentry/sentry-wizard/issues',
+        ),
+      );
+    }
+  }
+
+  const loginUrl = new URL(
+    `${options.url}account/settings/wizard/${wizardHash!}/`,
+  );
+
+  if (!hasSentryAccount) {
+    loginUrl.searchParams.set('signup', '1');
+    if (options.platform) {
+      loginUrl.searchParams.set('project_platform', options.platform);
+    }
+  }
+
+  if (options.promoCode) {
+    loginUrl.searchParams.set('code', options.promoCode);
+  }
+
+  const urlToOpen = loginUrl.toString();
+  clack.log.info(
+    `${chalk.bold(
+      `If the browser window didn't open automatically, please open the following link to ${
+        hasSentryAccount ? 'log' : 'sign'
+      } into Sentry:`,
+    )}\n\n${chalk.cyan(urlToOpen)}`,
+  );
+
+  opn(urlToOpen).catch(() => {
+    // opn throws in environments that don't have a browser (e.g. remote shells) so we just noop here
+  });
+
+  const loginSpinner = clack.spinner();
+
+  loginSpinner.start('Waiting for you to log in using the link above');
+
+  const data = await new Promise<WizardProjectData>((resolve) => {
+    const pollingInterval = setInterval(() => {
+      axios
+        .get<WizardProjectData>(`${options.url}api/0/wizard/${wizardHash}/`, {
+          headers: {
+            'Accept-Encoding': 'deflate',
+          },
+        })
+        .then((result) => {
+          resolve(result.data);
+          clearTimeout(timeout);
+          clearInterval(pollingInterval);
+          void axios.delete(`${options.url}api/0/wizard/${wizardHash}/`);
+        })
+        .catch(() => {
+          // noop - just try again
+        });
+    }, 500);
+
+    const timeout = setTimeout(() => {
+      clearInterval(pollingInterval);
+      loginSpinner.stop(
+        'Login timed out. No worries - it happens to the best of us.',
+      );
+
+      Sentry.setTag('opened-wizard-link', false);
+      void abort('Please restart the Wizard and log in to complete the setup.');
+    }, 180_000);
+  });
+
+  loginSpinner.stop('Login complete.');
+  Sentry.setTag('opened-wizard-link', true);
+
+  return data;
+}
+
+async function askForProjectSelection(
+  projects: SentryProjectData[],
+): Promise<SentryProjectData> {
+  const label = (project: SentryProjectData): string => {
+    return `${project.organization.slug}/${project.slug}`;
+  };
+  const sortedProjects = [...projects];
+  sortedProjects.sort((a: SentryProjectData, b: SentryProjectData) => {
+    return label(a).localeCompare(label(b));
+  });
+  const selection: SentryProjectData | symbol = await abortIfCancelled(
+    clack.select({
+      maxItems: 12,
+      message: 'Select your Sentry project.',
+      options: sortedProjects.map((project) => {
+        return {
+          value: project,
+          label: label(project),
+        };
+      }),
+    }),
+  );
+
+  Sentry.setTag('project', selection.slug);
+  Sentry.setTag('project-platform', selection.platform);
+  Sentry.setUser({ id: selection.organization.slug });
+
+  return selection;
+}
+
+/**
+ * Asks users if they have a config file for @param tool (e.g. Vite).
+ * If yes, asks users to specify the path to their config file.
+ *
+ * Use this helper function as a fallback mechanism if the lookup for
+ * a config file with its most usual location/name fails.
+ *
+ * @param toolName Name of the tool for which we're looking for the config file
+ * @param configFileName Name of the most common config file name (e.g. vite.config.js)
+ *
+ * @returns a user path to the config file or undefined if the user doesn't have a config file
+ */
+export async function askForToolConfigPath(
+  toolName: string,
+  configFileName: string,
+): Promise<string | undefined> {
+  const hasConfig = await abortIfCancelled(
+    clack.confirm({
+      message: `Do you have a ${toolName} config file (e.g. ${chalk.cyan(
+        configFileName,
+      )}?`,
+      initialValue: true,
+    }),
+  );
+
+  if (!hasConfig) {
+    return undefined;
+  }
+
+  return await abortIfCancelled(
+    clack.text({
+      message: `Please enter the path to your ${toolName} config file:`,
+      placeholder: path.join('.', configFileName),
+      validate: (value) => {
+        if (!value) {
+          return 'Please enter a path.';
+        }
+
+        try {
+          fs.accessSync(value);
+        } catch {
+          return 'Could not access the file at this path.';
+        }
+      },
+    }),
+  );
+}
+
+/**
+ * Prints copy/paste-able instructions to the console.
+ * Afterwards asks the user if they added the code snippet to their file.
+ *
+ * While there's no point in providing a "no" answer here, it gives users time to fulfill the
+ * task before the wizard continues with additional steps.
+ *
+ * Use this function if you want to show users instructions on how to add/modify
+ * code in their file. This is helpful if automatic insertion failed or is not possible/feasible.
+ *
+ * @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
+ * 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,
+): Promise<void> {
+  clack.log.step(
+    `Add the following code to your ${chalk.cyan(
+      path.basename(filename),
+    )} file:`,
+  );
+
+  // 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}`);
+
+  await abortIfCancelled(
+    clack.select({
+      message: 'Did you apply the snippet above?',
+      options: [{ label: 'Yes, continue!', value: true }],
+      initialValue: true,
+    }),
+  );
+}
+
+/**
+ * Creates a new config file with the given @param filepath and @param codeSnippet.
+ *
+ * Use this function to create a new config file for users. This is useful
+ * when users answered that they don't yet have a config file for a tool.
+ *
+ * (This doesn't mean that they don't yet have some other way of configuring
+ * their tool but we can leave it up to them to figure out how to merge configs
+ * here.)
+ *
+ * @param filepath absolute path to the new config file
+ * @param codeSnippet the snippet to be inserted into the file
+ * @param moreInformation (optional) the message to be printed after the file was created
+ * For example, this can be a link to more information about configuring the tool.
+ *
+ * @returns true on sucess, false otherwise
+ */
+export async function createNewConfigFile(
+  filepath: string,
+  codeSnippet: string,
+  moreInformation?: string,
+): Promise<boolean> {
+  if (!path.isAbsolute(filepath)) {
+    debug(`createNewConfigFile: filepath is not absolute: ${filepath}`);
+    return false;
+  }
+
+  const prettyFilename = chalk.cyan(path.relative(process.cwd(), filepath));
+
+  try {
+    await fs.promises.writeFile(filepath, codeSnippet);
+
+    clack.log.success(`Added new ${prettyFilename} file.`);
+
+    if (moreInformation) {
+      clack.log.info(chalk.gray(moreInformation));
+    }
+
+    return true;
+  } catch (e) {
+    debug(e);
+    clack.log.warn(
+      `Could not create a new ${prettyFilename} file. Please create one manually and follow the instructions below.`,
+    );
+  }
+
+  return false;
+}