@shopify/cli-hydrogen 5.0.2 → 5.1.0

package/dist/lib/setups/i18n/templates/subfolders.ts

@@ -0,0 +1,28 @@
+import type {LanguageCode, CountryCode} from '../mock-i18n-types.js';
+
+export type I18nLocale = {
+  language: LanguageCode;
+  country: CountryCode;
+  pathPrefix: string;
+};
+
+function getLocaleFromRequest(request: Request): I18nLocale {
+  const url = new URL(request.url);
+  const firstPathPart = url.pathname.split('/')[1]?.toUpperCase() ?? '';
+
+  let pathPrefix = '';
+  let language: LanguageCode = 'EN';
+  let country: CountryCode = 'US';
+
+  if (/^[A-Z]{2}-[A-Z]{2}$/i.test(firstPathPart)) {
+    pathPrefix = '/' + firstPathPart;
+    [language, country] = firstPathPart.split('-') as [
+      LanguageCode,
+      CountryCode,
+    ];
+  }
+
+  return {language, country, pathPrefix};
+}
+
+export {getLocaleFromRequest};

package/dist/lib/setups/routes/generate.js

@@ -0,0 +1,244 @@
+import { readdir } from 'fs/promises';
+import { fileExists, mkdir, copyFile, readFile, writeFile } from '@shopify/cli-kit/node/fs';
+import { joinPath, relativizePath, dirname, relativePath, resolvePath, basename } from '@shopify/cli-kit/node/path';
+import { AbortError } from '@shopify/cli-kit/node/error';
+import { renderConfirmationPrompt } from '@shopify/cli-kit/node/ui';
+import { transpileFile } from '../../../lib/transpile-ts.js';
+import { getCodeFormatOptions, formatCode } from '../../../lib/format-code.js';
+import { getTemplateAppFile, GENERATOR_ROUTE_DIR, getStarterDir } from '../../../lib/build.js';
+import { getV2Flags, convertTemplateToRemixVersion, convertRouteToV1 } from '../../../lib/remix-version-interop.js';
+import { getRemixConfig } from '../../../lib/config.js';
+import { findFileWithExtension } from '../../file.js';
+
+const NO_LOCALE_PATTERNS = [/robots\.txt/];
+const ROUTE_MAP = {
+  home: ["_index", "$"],
+  page: "pages*",
+  cart: "cart",
+  products: "products*",
+  collections: "collections*",
+  policies: "policies*",
+  blogs: "blogs*",
+  account: "account*",
+  search: ["search", "api.predictive-search"],
+  robots: "[robots.txt]",
+  sitemap: "[sitemap.xml]"
+};
+let allRouteTemplateFiles = [];
+async function getResolvedRoutes(routeKeys = Object.keys(ROUTE_MAP)) {
+  if (allRouteTemplateFiles.length === 0) {
+    allRouteTemplateFiles = (await readdir(getTemplateAppFile(GENERATOR_ROUTE_DIR))).map((item) => item.replace(/\.tsx?$/, ""));
+  }
+  const routeGroups = {};
+  const resolvedRouteFiles = [];
+  for (const key of routeKeys) {
+    routeGroups[key] = [];
+    const value = ROUTE_MAP[key];
+    if (!value) {
+      throw new AbortError(
+        `No route found for ${key}. Try one of ${ALL_ROUTE_CHOICES.join()}.`
+      );
+    }
+    const routes = Array.isArray(value) ? value : [value];
+    for (const route of routes) {
+      const routePrefix = route.replace("*", "");
+      routeGroups[key].push(
+        ...allRouteTemplateFiles.filter((file) => file.startsWith(routePrefix))
+      );
+    }
+    resolvedRouteFiles.push(...routeGroups[key]);
+  }
+  return { routeGroups, resolvedRouteFiles };
+}
+const ALL_ROUTE_CHOICES = [...Object.keys(ROUTE_MAP), "all"];
+async function generateRoutes(options) {
+  const { routeGroups, resolvedRouteFiles } = options.routeName === "all" ? await getResolvedRoutes() : await getResolvedRoutes([options.routeName]);
+  const { rootDirectory, appDirectory, future, tsconfigPath } = await getRemixConfig(options.directory);
+  const routesArray = resolvedRouteFiles.flatMap(
+    (item) => GENERATOR_ROUTE_DIR + "/" + item
+  );
+  const v2Flags = await getV2Flags(rootDirectory, future);
+  const formatOptions = await getCodeFormatOptions(rootDirectory);
+  const localePrefix = await getLocalePrefix(
+    appDirectory,
+    options,
+    v2Flags.isV2RouteConvention
+  );
+  const typescript = options.typescript ?? !!tsconfigPath;
+  const transpilerOptions = typescript ? void 0 : await getJsTranspilerOptions(rootDirectory);
+  const routes = [];
+  for (const route of routesArray) {
+    routes.push(
+      await generateProjectFile(route, {
+        ...options,
+        typescript,
+        localePrefix,
+        rootDirectory,
+        appDirectory,
+        formatOptions,
+        transpilerOptions,
+        v2Flags
+      })
+    );
+  }
+  return {
+    routes,
+    routeGroups,
+    isTypescript: typescript,
+    transpilerOptions,
+    v2Flags,
+    formatOptions
+  };
+}
+async function getLocalePrefix(appDirectory, { localePrefix, routeName }, isV2RouteConvention = true) {
+  if (localePrefix)
+    return localePrefix;
+  if (localePrefix !== void 0 || routeName === "all")
+    return;
+  const existingFiles = await readdir(joinPath(appDirectory, "routes")).catch(
+    () => []
+  );
+  const homeRouteWithLocaleRE = isV2RouteConvention ? /^\(\$(\w+)\)\._index.[jt]sx?$/ : /^\(\$(\w+)\)$/;
+  const homeRouteWithLocale = existingFiles.find(
+    (file) => homeRouteWithLocaleRE.test(file)
+  );
+  if (homeRouteWithLocale) {
+    return homeRouteWithLocale.match(homeRouteWithLocaleRE)?.[1];
+  }
+}
+async function generateProjectFile(routeFrom, {
+  rootDirectory,
+  appDirectory,
+  typescript,
+  force,
+  adapter,
+  templatesRoot = getStarterDir(),
+  transpilerOptions,
+  formatOptions,
+  localePrefix,
+  v2Flags = {},
+  signal
+}) {
+  const extension = (routeFrom.match(/(\.[jt]sx?)$/) ?? [])[1] ?? ".tsx";
+  routeFrom = routeFrom.replace(extension, "");
+  const routeTemplatePath = getTemplateAppFile(
+    routeFrom + extension,
+    templatesRoot
+  );
+  const allFilesToGenerate = await findRouteDependencies(
+    routeTemplatePath,
+    getTemplateAppFile("", templatesRoot)
+  );
+  const routeDestinationPath = joinPath(
+    appDirectory,
+    getDestinationRoute(routeFrom, localePrefix, v2Flags) + (typescript ? extension : extension.replace(".ts", ".js"))
+  );
+  const result = {
+    operation: "created",
+    sourceRoute: routeFrom,
+    destinationRoute: relativizePath(routeDestinationPath, rootDirectory)
+  };
+  if (!force && await fileExists(routeDestinationPath)) {
+    const shouldOverwrite = await renderConfirmationPrompt({
+      message: `The file ${result.destinationRoute} already exists. Do you want to replace it?`,
+      defaultValue: false,
+      confirmationMessage: "Yes",
+      cancellationMessage: "No",
+      abortSignal: signal
+    });
+    if (!shouldOverwrite)
+      return { ...result, operation: "skipped" };
+    result.operation = "replaced";
+  }
+  for (const filePath of allFilesToGenerate) {
+    const isRoute = filePath.startsWith(GENERATOR_ROUTE_DIR + "/");
+    const destinationPath = isRoute ? routeDestinationPath : joinPath(
+      appDirectory,
+      filePath.replace(/\.ts(x?)$/, `.${typescript ? "ts$1" : "js$1"}`)
+    );
+    if (!await fileExists(dirname(destinationPath))) {
+      await mkdir(dirname(destinationPath));
+    }
+    if (!/\.[jt]sx?$/.test(filePath)) {
+      await copyFile(
+        getTemplateAppFile(filePath, templatesRoot),
+        destinationPath
+      );
+      continue;
+    }
+    let templateContent = convertTemplateToRemixVersion(
+      await readFile(getTemplateAppFile(filePath, templatesRoot)),
+      v2Flags
+    );
+    if (!typescript) {
+      templateContent = transpileFile(templateContent, transpilerOptions);
+    }
+    if (adapter) {
+      templateContent = templateContent.replace(
+        /@shopify\/remix-oxygen/g,
+        adapter
+      );
+    }
+    templateContent = formatCode(
+      templateContent,
+      formatOptions,
+      destinationPath
+    );
+    await writeFile(destinationPath, templateContent);
+  }
+  return result;
+}
+function getDestinationRoute(routeFrom, localePrefix, v2Flags) {
+  const routePath = routeFrom.replace(GENERATOR_ROUTE_DIR + "/", "");
+  const filePrefix = localePrefix && !NO_LOCALE_PATTERNS.some((pattern) => pattern.test(routePath)) ? `($${localePrefix})` + (v2Flags.isV2RouteConvention ? "." : "/") : "";
+  return GENERATOR_ROUTE_DIR + "/" + filePrefix + (v2Flags.isV2RouteConvention ? routePath : convertRouteToV1(routePath));
+}
+async function findRouteDependencies(routeFilePath, appDirectory) {
+  const filesToCheck = /* @__PURE__ */ new Set([routeFilePath]);
+  const fileDependencies = /* @__PURE__ */ new Set([relativePath(appDirectory, routeFilePath)]);
+  for (const filePath of filesToCheck) {
+    const importMatches = (await readFile(filePath, { encoding: "utf8" })).matchAll(/^(import|export)\s+.*?\s+from\s+['"](.*?)['"];?$/gims);
+    for (let [, , match] of importMatches) {
+      if (!match || !/^(\.|~)/.test(match))
+        continue;
+      match = match.replace(
+        "~",
+        relativePath(dirname(filePath), appDirectory) || "."
+      );
+      const resolvedMatchPath = resolvePath(dirname(filePath), match);
+      const absoluteFilepath = (await findFileWithExtension(
+        dirname(resolvedMatchPath),
+        basename(resolvedMatchPath)
+      )).filepath || resolvedMatchPath;
+      if (!absoluteFilepath.includes(`/${GENERATOR_ROUTE_DIR}/`)) {
+        fileDependencies.add(relativePath(appDirectory, absoluteFilepath));
+        if (/\.[jt]sx?$/.test(absoluteFilepath)) {
+          filesToCheck.add(absoluteFilepath);
+        }
+      }
+    }
+  }
+  return [...fileDependencies];
+}
+async function getJsTranspilerOptions(rootDirectory) {
+  const jsConfigPath = joinPath(rootDirectory, "jsconfig.json");
+  if (!await fileExists(jsConfigPath))
+    return;
+  return JSON.parse(
+    (await readFile(jsConfigPath, { encoding: "utf8" })).replace(
+      /^\s*\/\/.*$/gm,
+      ""
+    )
+  )?.compilerOptions;
+}
+async function renderRoutePrompt(options) {
+  const generateAll = await renderConfirmationPrompt({
+    message: "Scaffold all standard route files? " + Object.keys(ROUTE_MAP).join(", "),
+    confirmationMessage: "Yes",
+    cancellationMessage: "No",
+    ...options
+  });
+  return generateAll ? "all" : [];
+}
+
+export { ALL_ROUTE_CHOICES, generateProjectFile, generateRoutes, getResolvedRoutes, renderRoutePrompt };

package/dist/lib/setups/routes/generate.test.js

@@ -0,0 +1,313 @@
+import { describe, beforeEach, vi, it, expect } from 'vitest';
+import { temporaryDirectoryTask } from 'tempy';
+import { getResolvedRoutes, generateRoutes, generateProjectFile } from './generate.js';
+import { renderConfirmationPrompt } from '@shopify/cli-kit/node/ui';
+import { fileExists, readFile, mkdir, writeFile } from '@shopify/cli-kit/node/fs';
+import { joinPath, dirname } from '@shopify/cli-kit/node/path';
+import { getTemplateAppFile } from '../../../lib/build.js';
+import { getRemixConfig } from '../../../lib/config.js';
+
+const readProjectFile = (dirs, fileBasename, ext = "tsx") => readFile(joinPath(dirs.appDirectory, `${fileBasename}.${ext}`));
+describe("generate/route", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.mock("@shopify/cli-kit/node/output");
+    vi.mock("@shopify/cli-kit/node/ui");
+    vi.mock("../../config.js", async () => ({ getRemixConfig: vi.fn() }));
+  });
+  describe("generateRoutes", () => {
+    it("generates all routes with correct configuration", async () => {
+      const { resolvedRouteFiles } = await getResolvedRoutes();
+      expect(
+        resolvedRouteFiles.find((item) => /account_?\.login/.test(item))
+      ).toBeTruthy();
+      await temporaryDirectoryTask(async (tmpDir) => {
+        const directories = await createHydrogenFixture(tmpDir, {
+          files: [
+            ["jsconfig.json", JSON.stringify({ compilerOptions: { test: "js" } })],
+            [".prettierrc.json", JSON.stringify({ singleQuote: false })]
+          ],
+          templates: resolvedRouteFiles.map(
+            (filepath) => ["routes/" + filepath + ".tsx", ""]
+          )
+        });
+        vi.mocked(getRemixConfig).mockResolvedValue(directories);
+        const result = await generateRoutes({
+          routeName: "all",
+          directory: directories.rootDirectory,
+          templatesRoot: directories.templatesRoot
+        });
+        expect(result).toMatchObject(
+          expect.objectContaining({
+            isTypescript: false,
+            transpilerOptions: { test: "js" },
+            formatOptions: { singleQuote: false },
+            routes: expect.any(Array)
+          })
+        );
+        expect(result.routes).toHaveLength(
+          Object.values(resolvedRouteFiles).length
+        );
+      });
+    });
+    it("figures out the locale if a home route already exists", async () => {
+      await temporaryDirectoryTask(async (tmpDir) => {
+        const route = "routes/pages.$handle";
+        const directories = await createHydrogenFixture(tmpDir, {
+          files: [
+            ["tsconfig.json", JSON.stringify({ compilerOptions: { test: "ts" } })],
+            ["app/routes/($locale)._index.tsx", "export const test = true;"]
+          ],
+          templates: [[route + ".tsx", `const str = "hello world"`]]
+        });
+        vi.mocked(getRemixConfig).mockResolvedValue({
+          ...directories,
+          tsconfigPath: "somewhere",
+          future: {
+            v2_routeConvention: true
+          }
+        });
+        const result = await generateRoutes({
+          routeName: ["page"],
+          directory: directories.rootDirectory,
+          templatesRoot: directories.templatesRoot
+        });
+        expect(result).toMatchObject(
+          expect.objectContaining({
+            isTypescript: true,
+            transpilerOptions: void 0,
+            routes: expect.any(Array),
+            formatOptions: expect.any(Object)
+          })
+        );
+        expect(result.routes).toHaveLength(1);
+        expect(result.routes[0]).toMatchObject({
+          destinationRoute: expect.stringContaining("($locale).pages.$handle")
+        });
+      });
+    });
+  });
+  describe("generateProjectFile", () => {
+    it("generates a route file for Remix v1", async () => {
+      await temporaryDirectoryTask(async (tmpDir) => {
+        const route = "routes/pages.$handle";
+        const directories = await createHydrogenFixture(tmpDir, {
+          files: [],
+          templates: [[route + ".tsx", `const str = "hello world"`]]
+        });
+        await generateProjectFile(route, {
+          ...directories,
+          v2Flags: {
+            isV2RouteConvention: false
+          }
+        });
+        expect(
+          await readProjectFile(directories, route.replace(".", "/"), "jsx")
+        ).toContain(`const str = 'hello world'`);
+      });
+    });
+    it("generates a route file for Remix v2", async () => {
+      await temporaryDirectoryTask(async (tmpDir) => {
+        const route = "routes/custom.path.$handle._index";
+        const directories = await createHydrogenFixture(tmpDir, {
+          files: [],
+          templates: [[route + ".tsx", `const str = "hello world"`]]
+        });
+        await generateProjectFile(route, {
+          ...directories,
+          v2Flags: { isV2RouteConvention: true }
+        });
+        expect(await readProjectFile(directories, route, "jsx")).toContain(
+          `const str = 'hello world'`
+        );
+      });
+    });
+    it("generates route files with locale prefix", async () => {
+      await temporaryDirectoryTask(async (tmpDir) => {
+        const routeCode = `const str = 'hello world'`;
+        const directories = await createHydrogenFixture(tmpDir, {
+          files: [],
+          templates: [
+            ["routes/_index.tsx", routeCode],
+            ["routes/pages.$handle.tsx", routeCode],
+            ["routes/[robots.txt].tsx", routeCode],
+            ["routes/[sitemap.xml].tsx", routeCode]
+          ]
+        });
+        const localePrefix = "locale";
+        await generateProjectFile("routes/_index", {
+          ...directories,
+          v2Flags: { isV2RouteConvention: true },
+          localePrefix,
+          typescript: true
+        });
+        await generateProjectFile("routes/pages.$handle", {
+          ...directories,
+          v2Flags: { isV2RouteConvention: false },
+          localePrefix,
+          typescript: true
+        });
+        await generateProjectFile("routes/[sitemap.xml]", {
+          ...directories,
+          v2Flags: { isV2RouteConvention: true },
+          localePrefix,
+          typescript: true
+        });
+        await generateProjectFile("routes/[robots.txt]", {
+          ...directories,
+          v2Flags: { isV2RouteConvention: true },
+          localePrefix,
+          typescript: true
+        });
+        await expect(
+          readProjectFile(directories, `routes/($locale)._index`)
+        ).resolves.toContain(routeCode);
+        await expect(
+          readProjectFile(directories, `routes/($locale).[sitemap.xml]`)
+        ).resolves.toContain(routeCode);
+        await expect(
+          readProjectFile(directories, `routes/[robots.txt]`)
+        ).resolves.toContain(routeCode);
+        await expect(
+          readProjectFile(directories, `routes/($locale)/pages/$handle`)
+        ).resolves.toContain(routeCode);
+      });
+    });
+    it("produces a typescript file when typescript argument is true", async () => {
+      await temporaryDirectoryTask(async (tmpDir) => {
+        const route = "routes/pages.$handle";
+        const directories = await createHydrogenFixture(tmpDir, {
+          files: [],
+          templates: [[route + ".tsx", 'const str = "hello typescript"']]
+        });
+        await generateProjectFile(route, {
+          ...directories,
+          typescript: true,
+          v2Flags: { isV2RouteConvention: true }
+        });
+        expect(await readProjectFile(directories, route)).toContain(
+          `const str = 'hello typescript'`
+        );
+      });
+    });
+    it("prompts the user if there the file already exists", async () => {
+      await temporaryDirectoryTask(async (tmpDir) => {
+        vi.mocked(renderConfirmationPrompt).mockImplementationOnce(
+          async () => true
+        );
+        const route = "routes/page.$handle";
+        const directories = await createHydrogenFixture(tmpDir, {
+          files: [[`app/${route}.jsx`, 'const str = "I exist"']],
+          templates: [[route + ".tsx", 'const str = "hello world"']]
+        });
+        await generateProjectFile(route, {
+          ...directories,
+          v2Flags: { isV2RouteConvention: true }
+        });
+        expect(renderConfirmationPrompt).toHaveBeenCalledWith(
+          expect.objectContaining({
+            message: expect.stringContaining("already exists")
+          })
+        );
+      });
+    });
+    it("does not prompt the user if the force property is true", async () => {
+      await temporaryDirectoryTask(async (tmpDir) => {
+        vi.mocked(renderConfirmationPrompt).mockImplementationOnce(
+          async () => true
+        );
+        const route = "routes/page.$pageHandle";
+        const directories = await createHydrogenFixture(tmpDir, {
+          files: [[`app/${route}.jsx`, 'const str = "I exist"']],
+          templates: [[route + ".tsx", 'const str = "hello world"']]
+        });
+        await generateProjectFile(route, {
+          ...directories,
+          force: true
+        });
+        expect(renderConfirmationPrompt).not.toHaveBeenCalled();
+      });
+    });
+    it("generates all the route dependencies", async () => {
+      await temporaryDirectoryTask(async (tmpDir) => {
+        const templates = [
+          [
+            "routes/pages.$pageHandle.tsx",
+            `import Dep from 'some-node-dep';
+import AnotherRoute from './AnotherRoute';
+import Form from '~/components/Form';
+import {
+
+
+Button} from '../components/Button';
+import {stuff} from '../utils';
+import {serverOnly} from '../something.server';
+import styles from '../styles/app.css';
+export {Dep, AnotherRoute, Form, Button, stuff, serverOnly, styles};
+`
+          ],
+          [
+            "components/Form.tsx",
+            `import {Button} from './Button';
+import {Text} from './Text';
+export {Button, Text};
+`
+          ],
+          ["components/Button.tsx", `export const Button = '';
+`],
+          ["components/Text.tsx", `export const Text = '';
+`],
+          ["utils/index.ts", `export {stuff} from './stuff';
+`],
+          ["utils/stuff.ts", `export const stuff = '';
+`],
+          ["something.server.ts", `export const serverOnly = '';
+`],
+          ["styles/app.css", `.red{color:red;}`]
+        ];
+        const directories = await createHydrogenFixture(tmpDir, { templates });
+        vi.mocked(getRemixConfig).mockResolvedValue(directories);
+        await generateProjectFile("routes/pages.$pageHandle", {
+          ...directories,
+          v2Flags: { isV2RouteConvention: true },
+          force: true
+        });
+        await Promise.all(
+          templates.map(async ([file, content]) => {
+            const actualFile = joinPath(
+              directories.appDirectory,
+              file.replace(".ts", ".js")
+            );
+            await expect(fileExists(actualFile)).resolves.toBeTruthy();
+            await expect(readFile(actualFile)).resolves.toEqual(
+              content.replace(/\{\n+/, "{")
+            );
+          })
+        );
+      });
+    });
+  });
+});
+async function createHydrogenFixture(directory, {
+  files = [],
+  templates = []
+}) {
+  const projectDir = "project";
+  for (const item of files) {
+    const [filePath, fileContent] = item;
+    const fullFilePath = joinPath(directory, projectDir, filePath);
+    await mkdir(dirname(fullFilePath));
+    await writeFile(fullFilePath, fileContent);
+  }
+  for (const item of templates) {
+    const [filePath, fileContent] = item;
+    const fullFilePath = getTemplateAppFile(filePath, directory);
+    await mkdir(dirname(fullFilePath));
+    await writeFile(fullFilePath, fileContent);
+  }
+  return {
+    rootDirectory: joinPath(directory, projectDir),
+    appDirectory: joinPath(directory, projectDir, "app"),
+    templatesRoot: directory
+  };
+}

package/dist/lib/shell.js

@@ -6,7 +6,7 @@ import { getPackageManager } from '@shopify/cli-kit/node/node-package-manager';
 import { execAsync } from './process.js';
 
 const ALIAS_NAME = "h2";
-const isWindows = () => process.platform === "win32";
+const isWindows = () => os.platform() === "win32";
 const isGitBash = () => !!process.env.MINGW_PREFIX;
 function resolveFromHome(filepath) {
   if (filepath[0] === "~") {
@@ -107,15 +107,62 @@ async function hasCliAlias() {
     return false;
   }
 }
-async function getCliCommand() {
-  if (await hasCliAlias()) {
+async function createPlatformShortcut() {
+  const shortcuts = isWindows() && !isGitBash() ? await createShortcutsForWindows() : await createShortcutsForUnix();
+  return shortcuts;
+}
+const BASH_ZSH_COMMAND = `
+# Shopify Hydrogen alias to local projects
+alias ${ALIAS_NAME}='$(npm prefix -s)/node_modules/.bin/shopify hydrogen'`;
+const FISH_FUNCTION = `
+function ${ALIAS_NAME} --wraps='shopify hydrogen' --description 'Shortcut for the Hydrogen CLI'
+   set npmPrefix (npm prefix -s)
+   $npmPrefix/node_modules/.bin/shopify hydrogen $argv
+end
+`;
+async function createShortcutsForUnix() {
+  const shells = [];
+  if (await shellWriteAlias("zsh", ALIAS_NAME, BASH_ZSH_COMMAND)) {
+    shells.push("zsh");
+  }
+  if (await shellWriteAlias("bash", ALIAS_NAME, BASH_ZSH_COMMAND)) {
+    shells.push("bash");
+  }
+  if (await shellWriteAlias("fish", ALIAS_NAME, FISH_FUNCTION)) {
+    shells.push("fish");
+  }
+  return shells;
+}
+const PS_FUNCTION = `function Invoke-Local-H2 {$npmPrefix = npm prefix -s; Invoke-Expression "$npmPrefix\\node_modules\\.bin\\shopify.ps1 hydrogen $Args"}; Set-Alias -Name ${ALIAS_NAME} -Value Invoke-Local-H2`;
+const PS_APPEND_PROFILE_COMMAND = `
+if (!(Test-Path -Path $PROFILE)) {
+  New-Item -ItemType File -Path $PROFILE -Force
+}
+
+$profileContent = Get-Content -Path $PROFILE
+if (!$profileContent -or $profileContent -NotLike '*Invoke-Local-H2*') {
+  Add-Content -Path $PROFILE -Value '${PS_FUNCTION}'
+}
+`;
+async function createShortcutsForWindows() {
+  const shells = [];
+  if (await shellRunScript(PS_APPEND_PROFILE_COMMAND, "powershell.exe")) {
+    shells.push("PowerShell");
+  }
+  if (await shellRunScript(PS_APPEND_PROFILE_COMMAND, "pwsh.exe")) {
+    shells.push("PowerShell 7+");
+  }
+  return shells;
+}
+async function getCliCommand(directory = process.cwd(), forcePkgManager) {
+  if (!forcePkgManager && await hasCliAlias()) {
     return ALIAS_NAME;
   }
   let cli = "npx";
-  const pkgManager = await getPackageManager(process.cwd()).catch(() => null);
+  const pkgManager = forcePkgManager ?? await getPackageManager(directory).catch(() => null);
   if (pkgManager === "pnpm" || pkgManager === "yarn")
     cli = pkgManager;
   return `${cli} shopify hydrogen`;
 }
 
-export { ALIAS_NAME, getCliCommand, isGitBash, isWindows, shellRunScript, shellWriteAlias };
+export { ALIAS_NAME, createPlatformShortcut, getCliCommand, isGitBash, isWindows, shellRunScript, shellWriteAlias };