@shopify/cli-hydrogen 7.0.1 → 7.1.1

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

@@ -0,0 +1,190 @@
+import Command from '@shopify/cli-kit/node/base-command';
+import { diffLines } from 'diff';
+import { Flags } from '@oclif/core';
+import { commonFlags, flagsToCamelObject } from '../../../lib/flags.js';
+import { login } from '../../../lib/auth.js';
+import { getCliCommand } from '../../../lib/shell.js';
+import { resolvePath } from '@shopify/cli-kit/node/path';
+import { renderConfirmationPrompt, renderSelectPrompt, renderInfo, renderSuccess } from '@shopify/cli-kit/node/ui';
+import { outputContent, outputToken, outputWarn } from '@shopify/cli-kit/node/output';
+import { renderMissingLink } from '../../../lib/render-errors.js';
+import { getStorefrontEnvironments } from '../../../lib/graphql/admin/list-environments.js';
+import { linkStorefront } from '../link.js';
+import { getStorefrontEnvVariables } from '../../../lib/graphql/admin/pull-variables.js';
+import { pushStorefrontEnvVariables } from '../../../lib/graphql/admin/push-variables.js';
+import { AbortError } from '@shopify/cli-kit/node/error';
+import { readAndParseDotEnv } from '@shopify/cli-kit/node/dot-env';
+
+class EnvPush extends Command {
+  static description = "Push environment variables from the local .env file to your linked Hydrogen storefront.";
+  static hidden = true;
+  static flags = {
+    ...commonFlags.env,
+    "env-file": Flags.string({
+      description: "Specify the environment variable file name. Default value is '.env'.",
+      env: "SHOPIFY_HYDROGEN_ENVIRONMENT_FILENAME"
+    }),
+    ...commonFlags.path
+  };
+  async run() {
+    const { flags } = await this.parse(EnvPush);
+    await runEnvPush({ ...flagsToCamelObject(flags) });
+  }
+}
+async function runEnvPush({
+  env: environmentName,
+  envFile = ".env",
+  path = process.cwd()
+}) {
+  let validatedEnvironment = {};
+  const dotEnvPath = resolvePath(path, envFile);
+  const { variables: localVariables } = await readAndParseDotEnv(dotEnvPath);
+  const [{ session, config }, cliCommand] = await Promise.all([
+    login(path),
+    getCliCommand()
+  ]);
+  if (!config.storefront?.id) {
+    renderMissingLink({ session, cliCommand });
+    const runLink = await renderConfirmationPrompt({
+      message: outputContent`Run ${outputToken.genericShellCommand(
+        `${cliCommand} link`
+      )}?`.value
+    });
+    if (!runLink)
+      return;
+    config.storefront = await linkStorefront(path, session, config, {
+      cliCommand
+    });
+  }
+  if (!config.storefront?.id)
+    return;
+  const { environments: environmentsData } = await getStorefrontEnvironments(session, config.storefront.id) ?? {};
+  if (!environmentsData) {
+    throw new AbortError("Failed to fetch environments");
+  }
+  const environments = [
+    ...environmentsData.filter((environment) => environment.type === "PREVIEW"),
+    ...environmentsData.filter((environment) => environment.type === "CUSTOM"),
+    ...environmentsData.filter(
+      (environment) => environment.type === "PRODUCTION"
+    )
+  ];
+  if (environments.length === 0) {
+    throw new AbortError("No environments found");
+  }
+  if (environmentName) {
+    const matchedEnvironments = environments.filter(
+      ({ name }) => name === environmentName
+    );
+    if (matchedEnvironments.length === 0) {
+      throw new AbortError(
+        "Environment not found",
+        `We could not find an environment matching the name '${environmentName}'.`
+      );
+    } else if (matchedEnvironments.length === 1) {
+      const { id, name, branch, type } = matchedEnvironments[0] ?? {};
+      validatedEnvironment = { id, name, branch, type };
+    } else {
+      const selection = await renderSelectPrompt({
+        message: `There were multiple environments found with the name ${environmentName}:`,
+        choices: [
+          ...matchedEnvironments.map(({ id: id2, name: name2, branch: branch2, type: type2, url }) => ({
+            label: `${name2} (${branch2}) ${type2} ${url}`,
+            value: id2
+          }))
+        ]
+      });
+      const { id, name, branch, type } = matchedEnvironments.find(({ id: id2 }) => id2 === selection) ?? {};
+      validatedEnvironment = { id, name, branch, type };
+    }
+  } else {
+    const choices = [
+      ...environments.map(({ id: id2, name: name2, branch: branch2 }) => ({
+        label: branch2 ? `${name2} (${branch2})` : name2,
+        value: id2
+      }))
+    ];
+    const pushToBranchSelection = await renderSelectPrompt({
+      message: "Select a set of environment variables to overwrite:",
+      choices
+    });
+    const { id, name, branch, type } = environments.find(({ id: id2 }) => id2 === pushToBranchSelection) ?? {};
+    validatedEnvironment = { id, name, branch, type };
+  }
+  const { environmentVariables = [] } = await getStorefrontEnvVariables(
+    session,
+    config.storefront.id,
+    validatedEnvironment.branch ?? void 0
+  ) ?? {};
+  const remoteVars = environmentVariables.filter(
+    ({ isSecret, readOnly }) => !isSecret && !readOnly
+  );
+  const comparableRemoteVars = remoteVars.sort((a, b) => a.key.localeCompare(b.key)).map(({ key, value }) => `${key}=${value}`).join("\n") + "\n";
+  const compareableLocalVars = Object.keys(localVariables).sort((a, b) => a.localeCompare(b)).reduce((acc, key) => {
+    const { isSecret, readOnly } = environmentVariables.find((variable) => variable.key === key) ?? {};
+    if (isSecret || readOnly)
+      return acc;
+    return [...acc, `${key}=${localVariables[key]}`];
+  }, []).join("\n") + "\n";
+  if (!validatedEnvironment.name)
+    throw new AbortError("Missing environment name");
+  const remoteReadOnlyOrSecrets = environmentVariables.reduce(
+    (acc, { isSecret, readOnly, key }) => {
+      if (!isSecret && !readOnly)
+        return acc;
+      const localVar = localVariables[key];
+      const remoteVar = environmentVariables.find(
+        (variable) => variable.key === key
+      );
+      if (localVar === remoteVar?.value)
+        return acc;
+      return [...acc, key];
+    },
+    []
+  );
+  if (remoteReadOnlyOrSecrets.length) {
+    outputWarn(
+      `Variables that are read only or contain secret values cannot be pushed from the CLI: ${remoteReadOnlyOrSecrets.join(
+        ", "
+      )}.
+`
+    );
+  }
+  if (compareableLocalVars === comparableRemoteVars) {
+    renderInfo({
+      body: "No changes to your environment variables."
+    });
+    return;
+  } else {
+    const diff = diffLines(comparableRemoteVars, compareableLocalVars);
+    const confirmPush = await renderConfirmationPrompt({
+      confirmationMessage: "Yes, confirm changes",
+      cancellationMessage: "No, make changes later",
+      message: outputContent`We'll make the following changes to your environment variables for ${validatedEnvironment.name}:
+
+${outputToken.linesDiff(diff)}
+Continue?`.value
+    });
+    if (!confirmPush)
+      return;
+  }
+  if (!validatedEnvironment.id)
+    throw new AbortError("Missing environment ID");
+  const { userErrors } = await pushStorefrontEnvVariables(
+    session,
+    config.storefront.id,
+    validatedEnvironment.id,
+    Object.entries(localVariables).map(([key, value]) => ({ key, value }))
+  );
+  if (userErrors.length) {
+    throw new AbortError(
+      "Failed to upload and save environment variables.",
+      userErrors[0]?.message
+    );
+  }
+  renderSuccess({
+    body: `Environment variables push to ${validatedEnvironment.name ?? "Preview"} was successful.`
+  });
+}
+
+export { EnvPush as default, runEnvPush };

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

@@ -18,8 +18,12 @@ class GenerateRoute extends Command {
       description: "Generate TypeScript files",
       env: "SHOPIFY_HYDROGEN_FLAG_TYPESCRIPT"
     }),
-    force: commonFlags.force,
-    path: commonFlags.path
+    "locale-param": Flags.string({
+      description: "The param name in Remix routes for the i18n locale, if any. Example: `locale` becomes ($locale).",
+      env: "SHOPIFY_HYDROGEN_FLAG_ADAPTER"
+    }),
+    ...commonFlags.force,
+    ...commonFlags.path
   };
   static hidden;
   static args = {
@@ -40,7 +44,8 @@ class GenerateRoute extends Command {
     await runGenerate({
       ...flags,
       directory,
-      routeName
+      routeName,
+      localePrefix: flags["locale-param"]
     });
   }
 }

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",