@shopify/cli-hydrogen 7.1.0 → 7.1.2

package/dist/commands/hydrogen/env/push__unstable.test.js

@@ -0,0 +1,383 @@
+import { vi, describe, beforeEach, afterEach, it, expect } from 'vitest';
+import { mockAndCaptureOutput } from '@shopify/cli-kit/node/testing/output';
+import { inTemporaryDirectory, writeFile } from '@shopify/cli-kit/node/fs';
+import { joinPath } from '@shopify/cli-kit/node/path';
+import { renderConfirmationPrompt, renderSelectPrompt } from '@shopify/cli-kit/node/ui';
+import { login } from '../../../lib/auth.js';
+import { getStorefrontEnvVariables } from '../../../lib/graphql/admin/pull-variables.js';
+import { getStorefrontEnvironments } from '../../../lib/graphql/admin/list-environments.js';
+import { pushStorefrontEnvVariables } from '../../../lib/graphql/admin/push-variables.js';
+import { runEnvPush } from './push__unstable.js';
+
+vi.mock("@shopify/cli-kit/node/ui", async () => {
+  const original = await vi.importActual("@shopify/cli-kit/node/ui");
+  return {
+    ...original,
+    renderConfirmationPrompt: vi.fn(),
+    renderSelectPrompt: vi.fn()
+  };
+});
+vi.mock("../link.js");
+vi.mock("../../../lib/auth.js");
+vi.mock("../../../lib/render-errors.js");
+vi.mock("../../../lib/graphql/admin/pull-variables.js");
+vi.mock("../../../lib/graphql/admin/list-environments.js");
+vi.mock("../../../lib/graphql/admin/push-variables.js");
+const ADMIN_SESSION = {
+  token: "abc123",
+  storeFqdn: "my-shop"
+};
+const SHOPIFY_CONFIG = {
+  shop: "my-shop",
+  shopName: "My Shop",
+  email: "email",
+  storefront: {
+    id: "gid://shopify/HydrogenStorefront/2",
+    title: "Existing Link"
+  }
+};
+const PRODUCTION_ENV = {
+  id: "gid://shopify/HydrogenStorefrontEnvironment/1",
+  createdAt: "2024-01-01",
+  branch: "main",
+  name: "Production",
+  type: "PRODUCTION",
+  url: "production.com"
+};
+const PREVIEW_ENV = {
+  id: "gid://shopify/HydrogenStorefrontEnvironment/2",
+  createdAt: "2024-01-01",
+  branch: null,
+  name: "Preview",
+  type: "PREVIEW",
+  url: null
+};
+const CUSTOM_ENV = {
+  id: "gid://shopify/HydrogenStorefrontEnvironment/3",
+  createdAt: "2024-01-01",
+  branch: "staging",
+  name: "Staging",
+  type: "CUSTOM",
+  url: "custom.com"
+};
+const outputMock = mockAndCaptureOutput();
+const processExit = vi.spyOn(process, "exit");
+describe("pushVariables", () => {
+  beforeEach(async () => {
+    processExit.mockImplementation(() => {
+      throw "mockExit";
+    });
+    vi.mocked(login).mockResolvedValue({
+      session: ADMIN_SESSION,
+      config: SHOPIFY_CONFIG
+    });
+    vi.mocked(getStorefrontEnvVariables).mockResolvedValue({
+      id: SHOPIFY_CONFIG.storefront.id,
+      environmentVariables: [
+        {
+          id: "gid://shopify/HydrogenStorefrontEnvironmentVariable/1",
+          key: "PUBLIC_API_TOKEN",
+          value: "abc123",
+          readOnly: true,
+          isSecret: false
+        },
+        {
+          id: "gid://shopify/HydrogenStorefrontEnvironmentVariable/2",
+          key: "PRIVATE_API_TOKEN",
+          value: "",
+          readOnly: true,
+          isSecret: true
+        }
+      ]
+    });
+    vi.mocked(getStorefrontEnvironments).mockResolvedValue({
+      id: SHOPIFY_CONFIG.storefront.id,
+      productionUrl: "prod.com",
+      environments: [PRODUCTION_ENV, PREVIEW_ENV, CUSTOM_ENV]
+    });
+    vi.mocked(pushStorefrontEnvVariables).mockResolvedValue({
+      userErrors: []
+    });
+  });
+  afterEach(() => {
+    outputMock.clear();
+    vi.clearAllMocks();
+    vi.resetAllMocks();
+  });
+  it("calls getStorefrontEnvironments", async () => {
+    vi.mocked(renderConfirmationPrompt).mockResolvedValue(true);
+    await inTemporaryDirectory(async (tmpDir) => {
+      const filePath = joinPath(tmpDir, ".env");
+      await writeFile(filePath, "EXISTING_TOKEN=1\nSECOND_TOKEN=2");
+      await expect(
+        runEnvPush({ path: tmpDir, env: "Preview" })
+      ).resolves.not.toThrow();
+      expect(getStorefrontEnvironments).toHaveBeenCalledWith(
+        ADMIN_SESSION,
+        SHOPIFY_CONFIG.storefront.id
+      );
+    });
+  });
+  it("errors if no environments data", async () => {
+    vi.mocked(getStorefrontEnvironments).mockResolvedValue({
+      id: SHOPIFY_CONFIG.storefront.id,
+      productionUrl: "prod.com",
+      environments: []
+    });
+    await inTemporaryDirectory(async (tmpDir) => {
+      const filePath = joinPath(tmpDir, ".env");
+      await writeFile(filePath, "EXISTING_TOKEN=1\nSECOND_TOKEN=2");
+      await expect(
+        runEnvPush({ path: tmpDir, env: "Preview" })
+      ).rejects.toThrowError("No environments found");
+    });
+  });
+  it("prompts the user to select an environment", async () => {
+    vi.mocked(renderSelectPrompt).mockResolvedValue(PREVIEW_ENV.id);
+    await inTemporaryDirectory(async (tmpDir) => {
+      const filePath = joinPath(tmpDir, ".env");
+      await writeFile(filePath, "EXISTING_TOKEN=1\nSECOND_TOKEN=2");
+      await expect(runEnvPush({ path: tmpDir })).resolves.not.toThrow();
+      expect(renderSelectPrompt).toHaveBeenCalledWith({
+        message: "Select a set of environment variables to overwrite:",
+        choices: [
+          expect.objectContaining({ label: expect.stringContaining("Preview") }),
+          expect.objectContaining({ label: expect.stringContaining("Staging") }),
+          expect.objectContaining({
+            label: expect.stringContaining("Production")
+          })
+        ]
+      });
+    });
+  });
+  describe("when an environment is passed", () => {
+    it("errors when the environment does not match graphql", async () => {
+      await inTemporaryDirectory(async (tmpDir) => {
+        const filePath = joinPath(tmpDir, ".env");
+        await writeFile(filePath, "EXISTING_TOKEN=1\nSECOND_TOKEN=2");
+        await expect(
+          runEnvPush({ path: tmpDir, env: "Something random" })
+        ).rejects.toThrowError("Environment not found");
+      });
+    });
+    it("prompts the user if there are multiple matches", async () => {
+      vi.mocked(renderSelectPrompt).mockResolvedValue(PREVIEW_ENV.id);
+      vi.mocked(getStorefrontEnvironments).mockResolvedValue({
+        id: SHOPIFY_CONFIG.storefront.id,
+        productionUrl: "prod.com",
+        environments: [
+          PRODUCTION_ENV,
+          PREVIEW_ENV,
+          { ...CUSTOM_ENV, name: "Preview" }
+        ]
+      });
+      await inTemporaryDirectory(async (tmpDir) => {
+        const filePath = joinPath(tmpDir, ".env");
+        await writeFile(filePath, "EXISTING_TOKEN=1\nSECOND_TOKEN=2");
+        await expect(
+          runEnvPush({ path: tmpDir, env: "Preview" })
+        ).resolves.not.toThrow();
+        expect(renderSelectPrompt).toHaveBeenCalledWith({
+          message: "There were multiple environments found with the name Preview:",
+          choices: expect.any(Array)
+        });
+      });
+    });
+  });
+  it("exits if variables are identical", async () => {
+    vi.mocked(getStorefrontEnvVariables).mockResolvedValue({
+      id: SHOPIFY_CONFIG.storefront.id,
+      environmentVariables: [
+        {
+          id: "1",
+          key: "EXISTING_TOKEN",
+          value: "1",
+          isSecret: false,
+          readOnly: false
+        },
+        {
+          id: "2",
+          key: "SECOND_TOKEN",
+          value: "2",
+          isSecret: false,
+          readOnly: false
+        }
+      ]
+    });
+    await inTemporaryDirectory(async (tmpDir) => {
+      const filePath = joinPath(tmpDir, ".env");
+      await writeFile(filePath, "EXISTING_TOKEN=1\nSECOND_TOKEN=2");
+      await expect(
+        runEnvPush({ path: tmpDir, env: "Preview" })
+      ).resolves.not.toThrow();
+      expect(outputMock.info()).toMatch(
+        /No changes to your environment variables/
+      );
+    });
+  });
+  it("renders a diff when a variable is updated", async () => {
+    vi.mocked(renderConfirmationPrompt).mockResolvedValue(true);
+    vi.mocked(getStorefrontEnvVariables).mockResolvedValue({
+      id: SHOPIFY_CONFIG.storefront.id,
+      environmentVariables: [
+        {
+          id: "1",
+          key: "EXISTING_TOKEN",
+          value: "1",
+          isSecret: false,
+          readOnly: false
+        },
+        {
+          id: "2",
+          key: "SECOND_TOKEN",
+          value: "updated value",
+          isSecret: false,
+          readOnly: false
+        }
+      ]
+    });
+    await inTemporaryDirectory(async (tmpDir) => {
+      const filePath = joinPath(tmpDir, ".env");
+      await writeFile(filePath, "EXISTING_TOKEN=1\nSECOND_TOKEN=2");
+      await expect(
+        runEnvPush({ path: tmpDir, env: "Preview" })
+      ).resolves.not.toThrow();
+      expect(renderConfirmationPrompt).toHaveBeenCalled();
+    });
+  });
+  it("ignores comparison against secrets", async () => {
+    vi.mocked(renderConfirmationPrompt).mockResolvedValue(true);
+    vi.mocked(getStorefrontEnvVariables).mockResolvedValue({
+      id: SHOPIFY_CONFIG.storefront.id,
+      environmentVariables: [
+        {
+          id: "1",
+          key: "EXISTING_TOKEN",
+          value: "1",
+          isSecret: false,
+          readOnly: false
+        },
+        {
+          id: "2",
+          key: "SECOND_TOKEN",
+          value: "updated value",
+          isSecret: true,
+          readOnly: false
+        }
+      ]
+    });
+    await inTemporaryDirectory(async (tmpDir) => {
+      const filePath = joinPath(tmpDir, ".env");
+      await writeFile(filePath, "EXISTING_TOKEN=1\nSECOND_TOKEN=2");
+      await expect(
+        runEnvPush({ path: tmpDir, env: "Preview" })
+      ).resolves.not.toThrow();
+    });
+    expect(outputMock.info()).toMatch(
+      /No changes to your environment variables/
+    );
+  });
+  it("ignores comparison against read only variables", async () => {
+    vi.mocked(renderConfirmationPrompt).mockResolvedValue(true);
+    vi.mocked(getStorefrontEnvVariables).mockResolvedValue({
+      id: SHOPIFY_CONFIG.storefront.id,
+      environmentVariables: [
+        {
+          id: "1",
+          key: "EXISTING_TOKEN",
+          value: "1",
+          isSecret: false,
+          readOnly: false
+        },
+        {
+          id: "2",
+          key: "SECOND_TOKEN",
+          value: "updated value",
+          isSecret: false,
+          readOnly: true
+        }
+      ]
+    });
+    await inTemporaryDirectory(async (tmpDir) => {
+      const filePath = joinPath(tmpDir, ".env");
+      await writeFile(filePath, "EXISTING_TOKEN=1\nSECOND_TOKEN=2");
+      await expect(
+        runEnvPush({ path: tmpDir, env: "Preview" })
+      ).resolves.not.toThrow();
+      expect(outputMock.info()).toMatch(
+        /No changes to your environment variables/
+      );
+    });
+  });
+  it("exits when diff is not confirmed", async () => {
+    vi.mocked(renderConfirmationPrompt).mockResolvedValue(false);
+    vi.mocked(getStorefrontEnvVariables).mockResolvedValue({
+      id: SHOPIFY_CONFIG.storefront.id,
+      environmentVariables: [
+        {
+          id: "1",
+          key: "EXISTING_TOKEN",
+          value: "1",
+          isSecret: false,
+          readOnly: false
+        },
+        {
+          id: "2",
+          key: "SECOND_TOKEN",
+          value: "updated value",
+          isSecret: false,
+          readOnly: true
+        }
+      ]
+    });
+    await inTemporaryDirectory(async (tmpDir) => {
+      const filePath = joinPath(tmpDir, ".env");
+      await writeFile(filePath, "EXISTING_TOKEN=1\nSECOND_TOKEN=2");
+      await expect(
+        runEnvPush({ path: tmpDir, env: "Preview" })
+      ).resolves.not.toThrow();
+      expect(pushStorefrontEnvVariables).not.toHaveBeenCalled();
+    });
+  });
+  it("calls pushStorefrontEnvVariables when diff is confirmed", async () => {
+    vi.mocked(renderConfirmationPrompt).mockResolvedValue(true);
+    vi.mocked(getStorefrontEnvVariables).mockResolvedValue({
+      id: SHOPIFY_CONFIG.storefront.id,
+      environmentVariables: [
+        {
+          id: "1",
+          key: "EXISTING_TOKEN",
+          value: "1",
+          isSecret: false,
+          readOnly: false
+        },
+        {
+          id: "2",
+          key: "SECOND_TOKEN",
+          value: "2",
+          isSecret: false,
+          readOnly: false
+        }
+      ]
+    });
+    await inTemporaryDirectory(async (tmpDir) => {
+      const filePath = joinPath(tmpDir, ".env");
+      await writeFile(filePath, "EXISTING_TOKEN=1\nSECOND_TOKEN=NEW_VALUE");
+      await expect(
+        runEnvPush({ path: tmpDir, env: "Preview" })
+      ).resolves.not.toThrow();
+      expect(pushStorefrontEnvVariables).toHaveBeenCalledWith(
+        { storeFqdn: "my-shop", token: "abc123" },
+        "gid://shopify/HydrogenStorefront/2",
+        "gid://shopify/HydrogenStorefrontEnvironment/2",
+        [
+          { key: "EXISTING_TOKEN", value: "1" },
+          { key: "SECOND_TOKEN", value: "NEW_VALUE" }
+        ]
+      );
+      expect(outputMock.info()).toMatch(
+        /Environment variables push to Preview was successful/
+      );
+    });
+  });
+});

package/dist/commands/hydrogen/generate/route.js

@@ -22,8 +22,8 @@ class GenerateRoute extends Command {
       description: "The param name in Remix routes for the i18n locale, if any. Example: `locale` becomes ($locale).",
       env: "SHOPIFY_HYDROGEN_FLAG_ADAPTER"
     }),
-    force: commonFlags.force,
-    path: commonFlags.path
+    ...commonFlags.force,
+    ...commonFlags.path
   };
   static hidden;
   static args = {

package/dist/commands/hydrogen/init.d.ts

@@ -0,0 +1,69 @@
+import * as _oclif_core_lib_interfaces_parser_js from '@oclif/core/lib/interfaces/parser.js';
+import Command from '@shopify/cli-kit/node/base-command';
+
+declare const GENERATOR_SETUP_ASSETS_SUB_DIRS: readonly ["tailwind", "css-modules", "vanilla-extract", "postcss", "vite"];
+type AssetDir = (typeof GENERATOR_SETUP_ASSETS_SUB_DIRS)[number];
+
+type CssStrategy = Exclude<AssetDir, 'vite'>;
+
+declare const I18N_CHOICES: readonly ["subfolders", "domains", "subdomains", "none"];
+type I18nChoice = (typeof I18N_CHOICES)[number];
+
+declare const STYLING_CHOICES: readonly [...CssStrategy[], "none"];
+type StylingChoice = (typeof STYLING_CHOICES)[number];
+
+type InitOptions = {
+    path?: string;
+    template?: string;
+    language?: Language;
+    mockShop?: boolean;
+    styling?: StylingChoice;
+    i18n?: I18nChoice;
+    token?: string;
+    force?: boolean;
+    routes?: boolean;
+    shortcut?: boolean;
+    installDeps?: boolean;
+    git?: boolean;
+};
+declare const LANGUAGES: {
+    readonly js: "JavaScript";
+    readonly ts: "TypeScript";
+};
+type Language = keyof typeof LANGUAGES;
+
+declare class Init extends Command {
+    static description: string;
+    static flags: {
+        routes: _oclif_core_lib_interfaces_parser_js.BooleanFlag<boolean>;
+        git: _oclif_core_lib_interfaces_parser_js.BooleanFlag<boolean>;
+        shortcut: _oclif_core_lib_interfaces_parser_js.BooleanFlag<boolean>;
+        markets: _oclif_core_lib_interfaces_parser_js.OptionFlag<string | undefined, _oclif_core_lib_interfaces_parser_js.CustomOptions>;
+        styling: _oclif_core_lib_interfaces_parser_js.OptionFlag<string | undefined, _oclif_core_lib_interfaces_parser_js.CustomOptions>;
+        'mock-shop': _oclif_core_lib_interfaces_parser_js.BooleanFlag<boolean>;
+        'install-deps': _oclif_core_lib_interfaces_parser_js.BooleanFlag<boolean>;
+        path: _oclif_core_lib_interfaces_parser_js.OptionFlag<string | undefined, _oclif_core_lib_interfaces_parser_js.CustomOptions>;
+        language: _oclif_core_lib_interfaces_parser_js.OptionFlag<string | undefined, _oclif_core_lib_interfaces_parser_js.CustomOptions>;
+        template: _oclif_core_lib_interfaces_parser_js.OptionFlag<string | undefined, _oclif_core_lib_interfaces_parser_js.CustomOptions>;
+        force: _oclif_core_lib_interfaces_parser_js.BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+declare function runInit(options?: InitOptions): Promise<{
+    language?: "js" | "ts" | undefined;
+    packageManager: "npm" | "pnpm" | "yarn" | "bun" | "unknown";
+    cssStrategy?: CssStrategy | undefined;
+    cliCommand: "h2" | "pnpm shopify hydrogen" | "yarn shopify hydrogen" | "bun shopify hydrogen" | "npx shopify hydrogen";
+    depsInstalled: boolean;
+    depsError?: Error | undefined;
+    i18n?: "subfolders" | "domains" | "subdomains" | undefined;
+    i18nError?: Error | undefined;
+    routes?: Record<string, string | string[]> | undefined;
+    routesError?: Error | undefined;
+    location: string;
+    name: string;
+    directory: string;
+    storefrontTitle?: string | undefined;
+} | undefined>;
+
+export { Init as default, runInit };

package/dist/commands/hydrogen/init.js

@@ -16,7 +16,7 @@ const FLAG_MAP = { f: "force" };
 class Init extends Command {
   static description = "Creates a new Hydrogen storefront.";
   static flags = {
-    force: commonFlags.force,
+    ...commonFlags.force,
     path: Flags.string({
       description: "The path to the directory of the new Hydrogen storefront.",
       env: "SHOPIFY_HYDROGEN_FLAG_PATH"
@@ -30,15 +30,15 @@ class Init extends Command {
       description: "Scaffolds project based on an existing template or example from the Hydrogen repository.",
       env: "SHOPIFY_HYDROGEN_FLAG_TEMPLATE"
     }),
-    "install-deps": commonFlags.installDeps,
+    ...commonFlags.installDeps,
     "mock-shop": Flags.boolean({
       description: "Use mock.shop as the data source for the storefront.",
       default: false,
       env: "SHOPIFY_HYDROGEN_FLAG_MOCK_DATA"
     }),
-    styling: commonFlags.styling,
-    markets: commonFlags.markets,
-    shortcut: commonFlags.shortcut,
+    ...commonFlags.styling,
+    ...commonFlags.markets,
+    ...commonFlags.shortcut,
     routes: Flags.boolean({
       description: "Generate routes for all pages.",
       env: "SHOPIFY_HYDROGEN_FLAG_ROUTES",

package/dist/commands/hydrogen/init.test.js

@@ -114,9 +114,9 @@ describe("init", () => {
             language: "ts",
             template: "https://github.com/some/repo"
           })
-        ).resolves;
+        ).resolves.ok;
       });
-      expect(outputMock.error()).toMatch("--template");
+      await vi.waitFor(() => expect(outputMock.error()).toMatch("--template"));
       expect(processExit).toHaveBeenCalledWith(1);
       processExit.mockRestore();
     });

package/dist/commands/hydrogen/link.js

@@ -16,8 +16,8 @@ import { handleStorefrontSelection } from '../../lib/onboarding/common.js';
 class Link extends Command {
   static description = "Link a local project to one of your shop's Hydrogen storefronts.";
   static flags = {
-    force: commonFlags.force,
-    path: commonFlags.path,
+    ...commonFlags.force,
+    ...commonFlags.path,
     storefront: Flags.string({
       description: `The name of a Hydrogen Storefront (e.g. "Jane's Apparel")`,
       env: "SHOPIFY_HYDROGEN_STOREFRONT"

package/dist/commands/hydrogen/list.js

@@ -13,7 +13,7 @@ import { getCliCommand } from '../../lib/shell.js';
 class List extends Command {
   static description = "Returns a list of Hydrogen storefronts available on a given shop.";
   static flags = {
-    path: commonFlags.path
+    ...commonFlags.path
   };
   async run() {
     const { flags } = await this.parse(List);

package/dist/commands/hydrogen/login.js

@@ -1,19 +1,12 @@
-import { Flags } from '@oclif/core';
 import Command from '@shopify/cli-kit/node/base-command';
-import { normalizeStoreFqdn } from '@shopify/cli-kit/node/context/fqdn';
 import { commonFlags } from '../../lib/flags.js';
 import { login, renderLoginSuccess } from '../../lib/auth.js';
 
 class Login extends Command {
   static description = "Login to your Shopify account.";
   static flags = {
-    path: commonFlags.path,
-    shop: Flags.string({
-      char: "s",
-      description: "Shop URL. It can be the shop prefix (janes-apparel) or the full myshopify.com URL (janes-apparel.myshopify.com, https://janes-apparel.myshopify.com).",
-      env: "SHOPIFY_SHOP",
-      parse: async (input) => normalizeStoreFqdn(input)
-    })
+    ...commonFlags.path,
+    ...commonFlags.shop
   };
   async run() {
     const { flags } = await this.parse(Login);

package/dist/commands/hydrogen/logout.js

@@ -6,7 +6,7 @@ import { logout } from '../../lib/auth.js';
 class Logout extends Command {
   static description = "Logout of your local session.";
   static flags = {
-    path: commonFlags.path
+    ...commonFlags.path
   };
   async run() {
     const { flags } = await this.parse(Logout);

package/dist/commands/hydrogen/preview.js

@@ -6,17 +6,20 @@ import { startMiniOxygen } from '../../lib/mini-oxygen/index.js';
 import { getAllEnvironmentVariables } from '../../lib/environment-variables.js';
 import { getConfig } from '../../lib/shopify-config.js';
 import { findPort } from '../../lib/find-port.js';
+import { fileExists } from '@shopify/cli-kit/node/fs';
+import { joinPath } from '@shopify/cli-kit/node/path';
+import { getViteConfig } from '../../lib/vite-config.js';
 
 class Preview extends Command {
   static description = "Runs a Hydrogen storefront in an Oxygen worker for production.";
   static flags = {
-    path: commonFlags.path,
-    port: commonFlags.port,
+    ...commonFlags.path,
+    ...commonFlags.port,
     worker: deprecated("--worker", { isBoolean: true }),
-    "legacy-runtime": commonFlags.legacyRuntime,
-    "env-branch": commonFlags.envBranch,
-    "inspector-port": commonFlags.inspectorPort,
-    debug: commonFlags.debug
+    ...commonFlags.legacyRuntime,
+    ...commonFlags.envBranch,
+    ...commonFlags.inspectorPort,
+    ...commonFlags.debug
   };
   async run() {
     const { flags } = await this.parse(Preview);
@@ -36,7 +39,12 @@ async function runPreview({
   if (!process.env.NODE_ENV)
     process.env.NODE_ENV = "production";
   muteDevLogs({ workerReload: false });
-  const { root, buildPathWorkerFile, buildPathClient } = getProjectPaths(appPath);
+  let { root, buildPathWorkerFile, buildPathClient } = getProjectPaths(appPath);
+  if (!await fileExists(joinPath(root, buildPathWorkerFile))) {
+    const maybeResult = await getViteConfig(root).catch(() => null);
+    if (maybeResult)
+      buildPathWorkerFile = maybeResult.serverOutFile;
+  }
   const { shop, storefront } = await getConfig(root);
   const fetchRemote = !!shop && !!storefront?.id;
   const env = await getAllEnvironmentVariables({ root, fetchRemote, envBranch });

package/dist/commands/hydrogen/setup/css.js

@@ -10,9 +10,9 @@ import { SETUP_CSS_STRATEGIES, renderCssPrompt, setupCssStrategy, CSS_STRATEGY_N
 class SetupCSS extends Command {
   static description = "Setup CSS strategies for your project.";
   static flags = {
-    path: commonFlags.path,
-    force: commonFlags.force,
-    "install-deps": overrideFlag(commonFlags.installDeps, { default: true })
+    ...commonFlags.path,
+    ...commonFlags.force,
+    ...overrideFlag(commonFlags.installDeps, { "install-deps": { default: true } })
   };
   static args = {
     strategy: Args.string({

package/dist/commands/hydrogen/setup/markets.js

@@ -9,7 +9,7 @@ import { SETUP_I18N_STRATEGIES, renderI18nPrompt, setupI18nStrategy, I18N_STRATE
 class SetupMarkets extends Command {
   static description = "Setup support for multiple markets in your project.";
   static flags = {
-    path: commonFlags.path
+    ...commonFlags.path
   };
   static args = {
     strategy: Args.string({
@@ -21,14 +21,14 @@ class SetupMarkets extends Command {
   async run() {
     const { flags, args } = await this.parse(SetupMarkets);
     const directory = flags.path ? resolvePath(flags.path) : process.cwd();
-    await runSetupI18n({
+    await runSetupMarkets({
       ...flagsToCamelObject(flags),
       strategy: args.strategy,
       directory
     });
   }
 }
-async function runSetupI18n({
+async function runSetupMarkets({
   strategy: flagStrategy,
   directory
 }) {
@@ -50,4 +50,4 @@ async function runSetupI18n({
   });
 }
 
-export { SetupMarkets as default, runSetupI18n };
+export { SetupMarkets as default, runSetupMarkets };