@sentry/wizard 3.14.1 → 3.16.0

package/src/react-native/xcode.ts

@@ -0,0 +1,228 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import * as fs from 'fs';
+// @ts-ignore - clack is ESM and TS complains about that. It works though
+import clack from '@clack/prompts';
+import chalk from 'chalk';
+
+type BuildPhase = { shellScript: string };
+type BuildPhaseMap = Record<string, BuildPhase>;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getValidExistingBuildPhases(xcodeProject: any): BuildPhaseMap {
+  const map: BuildPhaseMap = {};
+  const raw = xcodeProject.hash.project.objects.PBXShellScriptBuildPhase || {};
+  for (const key in raw) {
+    const val = raw[key];
+    val.isa && (map[key] = val);
+  }
+
+  return map;
+}
+
+export function patchBundlePhase(bundlePhase: BuildPhase | undefined) {
+  if (!bundlePhase) {
+    clack.log.warn(
+      `Could not find ${chalk.cyan(
+        'Bundle React Native code and images',
+      )} build phase.`,
+    );
+    return;
+  }
+
+  const bundlePhaseIncludesSentry = doesBundlePhaseIncludeSentry(bundlePhase);
+  if (bundlePhaseIncludesSentry) {
+    clack.log.warn(
+      `Build phase ${chalk.cyan(
+        'Bundle React Native code and images',
+      )} already includes Sentry.`,
+    );
+    return;
+  }
+
+  const script: string = JSON.parse(bundlePhase.shellScript);
+  bundlePhase.shellScript = JSON.stringify(
+    addSentryToBundleShellScript(script),
+  );
+  clack.log.success(
+    `Patched Build phase ${chalk.cyan('Bundle React Native code and images')}.`,
+  );
+}
+
+export function unPatchBundlePhase(bundlePhase: BuildPhase | undefined) {
+  if (!bundlePhase) {
+    clack.log.warn(
+      `Could not find ${chalk.cyan(
+        'Bundle React Native code and images',
+      )} build phase.`,
+    );
+    return;
+  }
+
+  if (!bundlePhase.shellScript.match(/sentry-cli\s+react-native\s+xcode/i)) {
+    clack.log.success(
+      `Build phase ${chalk.cyan(
+        'Bundle React Native code and images',
+      )} does not include Sentry.`,
+    );
+    return;
+  }
+
+  bundlePhase.shellScript = JSON.stringify(
+    removeSentryFromBundleShellScript(
+      <string>JSON.parse(bundlePhase.shellScript),
+    ),
+  );
+  clack.log.success(
+    `Build phase ${chalk.cyan(
+      'Bundle React Native code and images',
+    )} unpatched successfully.`,
+  );
+}
+
+export function removeSentryFromBundleShellScript(script: string): string {
+  return (
+    script
+      // remove sentry properties export
+      .replace(/^export SENTRY_PROPERTIES=sentry.properties\r?\n/m, '')
+      .replace(
+        /^\/bin\/sh .*?..\/node_modules\/@sentry\/react-native\/scripts\/collect-modules.sh"?\r?\n/m,
+        '',
+      )
+      // unwrap react-native-xcode.sh command.  In case someone replaced it
+      // entirely with the sentry-cli command we need to put the original
+      // version back in.
+      .replace(
+        /\.\.\/node_modules\/@sentry\/cli\/bin\/sentry-cli\s+react-native\s+xcode\s+\$REACT_NATIVE_XCODE/i,
+        '$REACT_NATIVE_XCODE',
+      )
+  );
+}
+
+export function findBundlePhase(buildPhases: BuildPhaseMap) {
+  return Object.values(buildPhases).find((buildPhase) =>
+    buildPhase.shellScript.match(/\/scripts\/react-native-xcode\.sh/i),
+  );
+}
+
+export function doesBundlePhaseIncludeSentry(buildPhase: BuildPhase) {
+  return !!buildPhase.shellScript.match(/sentry-cli\s+react-native\s+xcode/i);
+}
+
+export function addSentryToBundleShellScript(script: string): string {
+  return (
+    'export SENTRY_PROPERTIES=sentry.properties\n' +
+    'export EXTRA_PACKAGER_ARGS="--sourcemap-output $DERIVED_FILE_DIR/main.jsbundle.map"\n' +
+    script.replace(
+      '$REACT_NATIVE_XCODE',
+      () =>
+        // eslint-disable-next-line no-useless-escape
+        '\\"../node_modules/@sentry/cli/bin/sentry-cli react-native xcode $REACT_NATIVE_XCODE\\"',
+    ) +
+    '\n/bin/sh -c "$WITH_ENVIRONMENT ../node_modules/@sentry/react-native/scripts/collect-modules.sh"\n'
+  );
+}
+
+export function addDebugFilesUploadPhase(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  xcodeProject: any,
+  { debugFilesUploadPhaseExists }: { debugFilesUploadPhaseExists: boolean },
+) {
+  if (debugFilesUploadPhaseExists) {
+    clack.log.warn(
+      `Build phase ${chalk.cyan(
+        'Upload Debug Symbols to Sentry',
+      )} already exists.`,
+    );
+    return;
+  }
+
+  xcodeProject.addBuildPhase(
+    [],
+    'PBXShellScriptBuildPhase',
+    'Upload Debug Symbols to Sentry',
+    null,
+    {
+      shellPath: '/bin/sh',
+      shellScript: `
+WITH_ENVIRONMENT="../node_modules/react-native/scripts/xcode/with-environment.sh"
+if [ -f "$WITH_ENVIRONMENT" ]; then
+  . "$WITH_ENVIRONMENT"
+fi
+export SENTRY_PROPERTIES=sentry.properties
+[ "$SENTRY_INCLUDE_NATIVE_SOURCES" = "true" ] && INCLUDE_SOURCES_FLAG="--include-sources" || INCLUDE_SOURCES_FLAG=""
+../node_modules/@sentry/cli/bin/sentry-cli debug-files upload "$INCLUDE_SOURCES_FLAG" "$DWARF_DSYM_FOLDER_PATH"
+`,
+    },
+  );
+  clack.log.success(
+    `Added Build phase ${chalk.cyan('Upload Debug Symbols to Sentry')}.`,
+  );
+}
+
+export function unPatchDebugFilesUploadPhase(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  xcodeProject: any,
+) {
+  const buildPhasesMap =
+    xcodeProject.hash.project.objects.PBXShellScriptBuildPhase || {};
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  const debugFilesUploadPhaseResult = findDebugFilesUploadPhase(buildPhasesMap);
+  if (!debugFilesUploadPhaseResult) {
+    clack.log.success(
+      `Build phase ${chalk.cyan('Upload Debug Symbols to Sentry')} not found.`,
+    );
+    return;
+  }
+
+  const [debugFilesUploadPhaseKey] = debugFilesUploadPhaseResult;
+  const firstTarget: string = xcodeProject.getFirstTarget().uuid;
+  const nativeTargets = xcodeProject.hash.project.objects.PBXNativeTarget;
+
+  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+  delete buildPhasesMap[debugFilesUploadPhaseKey];
+  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+  delete buildPhasesMap[`${debugFilesUploadPhaseKey}_comment`];
+  const phases = nativeTargets[firstTarget].buildPhases;
+  if (phases) {
+    for (let i = 0; i < phases.length; i++) {
+      if (phases[i].value === debugFilesUploadPhaseKey) {
+        phases.splice(i, 1);
+        break;
+      }
+    }
+  }
+  clack.log.success(
+    `Build phase ${chalk.cyan(
+      'Upload Debug Symbols to Sentry',
+    )} removed successfully.`,
+  );
+}
+
+export function findDebugFilesUploadPhase(
+  buildPhasesMap: Record<string, BuildPhase>,
+): [key: string, buildPhase: BuildPhase] | undefined {
+  return Object.entries(buildPhasesMap).find(
+    ([_, buildPhase]) =>
+      typeof buildPhase !== 'string' &&
+      !!buildPhase.shellScript.match(
+        /sentry-cli\s+(upload-dsym|debug-files upload)\b/,
+      ),
+  );
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function writeXcodeProject(xcodeProjectPath: string, xcodeProject: any) {
+  const newContent = xcodeProject.writeSync();
+  const currentContent = fs.readFileSync(xcodeProjectPath, 'utf-8');
+  if (newContent === currentContent) {
+    return;
+  }
+
+  fs.writeFileSync(xcodeProjectPath, newContent, 'utf-8');
+  clack.log.success(
+    chalk.green(`Xcode project ${chalk.cyan(xcodeProjectPath)} changes saved.`),
+  );
+}

package/src/remix/codemods/handle-error.ts

@@ -55,12 +55,42 @@ export function instrumentHandleError(
   ) {
     return false;
   } else {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const implementation = recast.parse(HANDLE_ERROR_TEMPLATE_V2).program
+      .body[0];
+
     // @ts-expect-error - string works here because the AST is proxified by magicast
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
     handleErrorFunction.declaration.body.body.unshift(
       // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       recast.parse(HANDLE_ERROR_TEMPLATE_V2).program.body[0].body.body[0],
     );
+
+    // First parameter is the error
+    //
+    // @ts-expect-error - string works here because the AST is proxified by magicast
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    handleErrorFunction.declaration.params[0] = implementation.params[0];
+
+    // Second parameter is the request inside an object
+    // Merging the object properties to make sure it includes request
+    //
+    // @ts-expect-error - string works here because the AST is proxified by magicast
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    if (handleErrorFunction.declaration.params?.[1]?.properties) {
+      // @ts-expect-error - string works here because the AST is proxified by magicast
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+      handleErrorFunction.declaration.params[1].properties.push(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        implementation.params[1].properties[0],
+      );
+    } else {
+      // Create second parameter if it doesn't exist
+      //
+      // @ts-expect-error - string works here because the AST is proxified by magicast
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      handleErrorFunction.declaration.params[1] = implementation.params[1];
+    }
   }
 
   return true;

package/src/remix/codemods/root-common.ts

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+
+import * as recast from 'recast';
+// @ts-expect-error - clack is ESM and TS complains about that. It works though
+import clack from '@clack/prompts';
+import chalk from 'chalk';
+
+// @ts-expect-error - magicast is ESM and TS complains about that. It works though
+import { builders, ProxifiedModule, generateCode } from 'magicast';
+
+export function wrapAppWithSentry(
+  rootRouteAst: ProxifiedModule,
+  rootFileName: string,
+) {
+  rootRouteAst.imports.$add({
+    from: '@sentry/remix',
+    imported: 'withSentry',
+    local: 'withSentry',
+  });
+
+  recast.visit(rootRouteAst.$ast, {
+    visitExportDefaultDeclaration(path) {
+      if (path.value.declaration.type === 'FunctionDeclaration') {
+        // Move the function declaration just before the default export
+        path.insertBefore(path.value.declaration);
+
+        // Get the name of the function to be wrapped
+        const functionName: string = path.value.declaration.id.name as string;
+
+        // Create the wrapped function call
+        const functionCall = recast.types.builders.callExpression(
+          recast.types.builders.identifier('withSentry'),
+          [recast.types.builders.identifier(functionName)],
+        );
+
+        // Replace the default export with the wrapped function call
+        path.value.declaration = functionCall;
+      } else if (path.value.declaration.type === 'Identifier') {
+        const rootRouteExport = rootRouteAst.exports.default;
+
+        const expressionToWrap = generateCode(rootRouteExport.$ast).code;
+
+        rootRouteAst.exports.default = builders.raw(
+          `withSentry(${expressionToWrap})`,
+        );
+      } else {
+        clack.log.warn(
+          chalk.yellow(
+            `Couldn't instrument ${chalk.bold(
+              rootFileName,
+            )} automatically. Wrap your default export with: ${chalk.dim(
+              'withSentry()',
+            )}\n`,
+          ),
+        );
+      }
+
+      this.traverse(path);
+    },
+  });
+}

package/src/remix/codemods/root-v1.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 
-import * as recast from 'recast';
 import * as path from 'path';
 
 // @ts-expect-error - clack is ESM and TS complains about that. It works though
@@ -8,7 +7,8 @@ import clack from '@clack/prompts';
 import chalk from 'chalk';
 
 // @ts-expect-error - magicast is ESM and TS complains about that. It works though
-import { builders, generateCode, loadFile, writeFile } from 'magicast';
+import { loadFile, writeFile } from 'magicast';
+import { wrapAppWithSentry } from './root-common';
 
 export async function instrumentRootRouteV1(
   rootFileName: string,
@@ -18,57 +18,7 @@ export async function instrumentRootRouteV1(
       path.join(process.cwd(), 'app', rootFileName),
     );
 
-    rootRouteAst.imports.$add({
-      from: '@sentry/remix',
-      imported: 'withSentry',
-      local: 'withSentry',
-    });
-
-    recast.visit(rootRouteAst.$ast, {
-      visitExportDefaultDeclaration(path) {
-        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-        if (path.value.declaration.type === 'FunctionDeclaration') {
-          // Move the function declaration just before the default export
-          path.insertBefore(path.value.declaration);
-
-          // Get the name of the function to be wrapped
-          const functionName: string = path.value.declaration.id.name as string;
-
-          // Create the wrapped function call
-          const functionCall = recast.types.builders.callExpression(
-            recast.types.builders.identifier('withSentry'),
-            [recast.types.builders.identifier(functionName)],
-          );
-
-          // Replace the default export with the wrapped function call
-          path.value.declaration = functionCall;
-        } else if (path.value.declaration.type === 'Identifier') {
-          const rootRouteExport = rootRouteAst.exports.default;
-
-          const expressionToWrap = generateCode(
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            rootRouteExport.$ast,
-          ).code;
-
-          rootRouteAst.exports.default = builders.raw(
-            `withSentry(${expressionToWrap})`,
-          );
-        } else {
-          clack.log.warn(
-            chalk.yellow(
-              `Couldn't instrument ${chalk.bold(
-                rootFileName,
-              )} automatically. Wrap your default export with: ${chalk.dim(
-                'withSentry()',
-              )}\n`,
-            ),
-          );
-        }
-
-        this.traverse(path);
-        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-      },
-    });
+    wrapAppWithSentry(rootRouteAst, rootFileName);
 
     await writeFile(
       rootRouteAst.$ast,

package/src/remix/codemods/root-v2.ts

@@ -1,4 +1,7 @@
+/* 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-unsafe-argument */
 
 import * as recast from 'recast';
 import * as path from 'path';
@@ -9,6 +12,8 @@ import type { ExportNamedDeclaration, Program } from '@babel/types';
 import { loadFile, writeFile } from 'magicast';
 
 import { ERROR_BOUNDARY_TEMPLATE_V2 } from '../templates';
+import { hasSentryContent } from '../utils';
+import { wrapAppWithSentry } from './root-common';
 
 export async function instrumentRootRouteV2(
   rootFileName: string,
@@ -63,18 +68,82 @@ export async function instrumentRootRouteV2(
 
     recast.visit(rootRouteAst.$ast, {
       visitExportDefaultDeclaration(path) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         const implementation = recast.parse(ERROR_BOUNDARY_TEMPLATE_V2).program
           .body[0];
 
         path.insertBefore(
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
           recast.types.builders.exportDeclaration(false, implementation),
         );
 
         this.traverse(path);
       },
     });
+    // If there is already a ErrorBoundary export, and it doesn't have Sentry content
+  } else if (!hasSentryContent(rootFileName, rootRouteAst.$code)) {
+    rootRouteAst.imports.$add({
+      from: '@sentry/remix',
+      imported: 'captureRemixErrorBoundaryError',
+      local: 'captureRemixErrorBoundaryError',
+    });
+
+    wrapAppWithSentry(rootRouteAst, rootFileName);
+
+    recast.visit(rootRouteAst.$ast, {
+      visitExportNamedDeclaration(path) {
+        // Find ErrorBoundary export
+        if (path.value.declaration?.id?.name === 'ErrorBoundary') {
+          const errorBoundaryExport = path.value.declaration;
+
+          let errorIdentifier;
+
+          // check if useRouteError is called
+          recast.visit(errorBoundaryExport, {
+            visitVariableDeclaration(path) {
+              const variableDeclaration = path.value.declarations[0];
+              const initializer = variableDeclaration.init;
+
+              if (
+                initializer.type === 'CallExpression' &&
+                initializer.callee.name === 'useRouteError'
+              ) {
+                errorIdentifier = variableDeclaration.id.name;
+              }
+
+              this.traverse(path);
+            },
+          });
+
+          // We don't have an errorIdentifier, which means useRouteError is not called / imported
+          // We need to add it and capture the error
+          if (!errorIdentifier) {
+            rootRouteAst.imports.$add({
+              from: '@remix-run/react',
+              imported: 'useRouteError',
+              local: 'useRouteError',
+            });
+
+            const useRouteErrorCall = recast.parse(
+              `const error = useRouteError();`,
+            ).program.body[0];
+
+            // Insert at the top of ErrorBoundary body
+            errorBoundaryExport.body.body.splice(0, 0, useRouteErrorCall);
+          }
+
+          const captureErrorCall = recast.parse(
+            `captureRemixErrorBoundaryError(error);`,
+          ).program.body[0];
+
+          // Insert just before the the fallback page is returned
+          errorBoundaryExport.body.body.splice(
+            errorBoundaryExport.body.body.length - 1,
+            0,
+            captureErrorCall,
+          );
+        }
+        this.traverse(path);
+      },
+    });
   }
 
   await writeFile(

package/src/remix/remix-wizard.ts

@@ -11,7 +11,7 @@ import {
   installPackage,
   isUsingTypeScript,
   printWelcome,
-  sourceMapsCliSetupConfig,
+  rcCliSetupConfig,
 } from '../utils/clack-utils';
 import { hasPackageInstalled } from '../utils/package-json';
 import { WizardOptions } from '../utils/types';
@@ -25,6 +25,8 @@ import {
 } from './sdk-setup';
 import { debug } from '../utils/debug';
 import { traceStep, withTelemetry } from '../telemetry';
+import { isHydrogenApp } from './utils';
+import { DEFAULT_URL } from '../../lib/Constants';
 
 export async function runRemixWizard(options: WizardOptions): Promise<void> {
   return withTelemetry(
@@ -66,14 +68,15 @@ async function runRemixWizardWithTelemetry(
   const isTS = isUsingTypeScript();
   const isV2 = isRemixV2(remixConfig, packageJson);
 
-  await addSentryCliConfig(authToken, sourceMapsCliSetupConfig);
+  await addSentryCliConfig({ authToken }, rcCliSetupConfig);
 
   await traceStep('Update build script for sourcemap uploads', async () => {
     try {
       await updateBuildScript({
         org: selectedProject.organization.slug,
         project: selectedProject.name,
-        url: sentryUrl,
+        url: sentryUrl === DEFAULT_URL ? undefined : sentryUrl,
+        isHydrogen: isHydrogenApp(packageJson),
       });
     } catch (e) {
       clack.log
@@ -88,7 +91,7 @@ async function runRemixWizardWithTelemetry(
       await instrumentRootRoute(isV2, isTS);
     } catch (e) {
       clack.log.warn(`Could not instrument root route.
-  Please do it manually using instructions from https://docs.sentry.io/platforms/javascript/guides/remix/`);
+  Please do it manually using instructions from https://docs.sentry.io/platforms/javascript/guides/remix/manual-setup/`);
       debug(e);
     }
   });
@@ -98,7 +101,7 @@ async function runRemixWizardWithTelemetry(
       await initializeSentryOnEntryClient(dsn, isTS);
     } catch (e) {
       clack.log.warn(`Could not initialize Sentry on client entry.
-  Please do it manually using instructions from https://docs.sentry.io/platforms/javascript/guides/remix/`);
+  Please do it manually using instructions from https://docs.sentry.io/platforms/javascript/guides/remix/manual-setup/`);
       debug(e);
     }
   });
@@ -108,7 +111,7 @@ async function runRemixWizardWithTelemetry(
       await initializeSentryOnEntryServer(dsn, isV2, isTS);
     } catch (e) {
       clack.log.warn(`Could not initialize Sentry on server entry.
-  Please do it manually using instructions from https://docs.sentry.io/platforms/javascript/guides/remix/`);
+  Please do it manually using instructions from https://docs.sentry.io/platforms/javascript/guides/remix/manual-setup/`);
       debug(e);
     }
   });

package/src/remix/sdk-setup.ts

@@ -164,6 +164,7 @@ export async function updateBuildScript(args: {
   org: string;
   project: string;
   url?: string;
+  isHydrogen: boolean;
 }): Promise<void> {
   /* eslint-disable @typescript-eslint/no-unsafe-member-access */
   // Add sourcemaps option to build script
@@ -177,17 +178,24 @@ export async function updateBuildScript(args: {
     packageJson.scripts = {};
   }
 
+  const buildCommand = args.isHydrogen
+    ? 'shopify hydrogen build'
+    : 'remix build';
+
+  const instrumentedBuildCommand =
+    `${buildCommand} --sourcemap && sentry-upload-sourcemaps --org ${args.org} --project ${args.project}` +
+    (args.url ? ` --url ${args.url}` : '') +
+    (args.isHydrogen ? ' --buildPath ./dist' : '');
+
   if (!packageJson.scripts.build) {
-    packageJson.scripts.build =
-      `remix build --sourcemap && sentry-upload-sourcemaps --org ${args.org} --project ${args.project}` +
-      (args.url ? ` --url ${args.url}` : '');
+    packageJson.scripts.build = instrumentedBuildCommand;
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-  } else if (packageJson.scripts.build.includes('remix build')) {
+  } else if (packageJson.scripts.build.includes(buildCommand)) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call
     packageJson.scripts.build = packageJson.scripts.build.replace(
-      'remix build',
-      'remix build --sourcemap && sentry-upload-sourcemaps',
+      buildCommand,
+      instrumentedBuildCommand,
     );
   }
 

package/src/remix/templates.ts

@@ -5,11 +5,7 @@ export const ERROR_BOUNDARY_TEMPLATE_V2 = `const ErrorBoundary = () => {
 };
 `;
 
-export const HANDLE_ERROR_TEMPLATE_V2 = `function handleError(error) {
-  if (error instanceof Error) {
-    Sentry.captureRemixErrorBoundaryError(error);
-  } else {
-    Sentry.captureException(error);
-  }
+export const HANDLE_ERROR_TEMPLATE_V2 = `function handleError(error, { request }) {
+  Sentry.captureRemixServerException(error, 'remix.server', request);
 }
 `;

package/src/remix/utils.ts

@@ -5,6 +5,7 @@ import * as path from 'path';
 // @ts-expect-error - clack is ESM and TS complains about that. It works though
 import clack from '@clack/prompts';
 import chalk from 'chalk';
+import { PackageDotJson, hasPackageInstalled } from '../utils/package-json';
 
 // Copied from sveltekit wizard
 export function hasSentryContent(
@@ -39,3 +40,7 @@ export function getInitCallInsertionIndex(
 
   return 0;
 }
+
+export function isHydrogenApp(packageJson: PackageDotJson): boolean {
+  return hasPackageInstalled('@shopify/hydrogen', packageJson);
+}