@opennextjs/cloudflare 1.5.3 → 1.6.0

package/dist/cli/commands/build.d.ts

@@ -0,0 +1,7 @@
+import type yargs from "yargs";
+/**
+ * Add the `build` command to yargs configuration.
+ *
+ * Consumes 1 positional parameter.
+ */
+export declare function addBuildCommand<T extends yargs.Argv>(y: T): yargs.Argv<{}>;

package/dist/cli/commands/build.js

@@ -0,0 +1,38 @@
+import { build as buildImpl } from "../build/build.js";
+import { compileConfig, getNormalizedOptions, nextAppDir, printHeaders, readWranglerConfig, withWranglerOptions, withWranglerPassthroughArgs, } from "./utils.js";
+/**
+ * Implementation of the `opennextjs-cloudflare build` command.
+ *
+ * @param args
+ */
+async function buildCommand(args) {
+    printHeaders("build");
+    const { config, buildDir } = await compileConfig();
+    const options = getNormalizedOptions(config, buildDir);
+    const wranglerConfig = readWranglerConfig(args);
+    await buildImpl(options, config, { ...args, minify: !args.noMinify, sourceDir: nextAppDir }, wranglerConfig);
+}
+/**
+ * Add the `build` command to yargs configuration.
+ *
+ * Consumes 1 positional parameter.
+ */
+export function addBuildCommand(y) {
+    return y.command("build", "Build an OpenNext Cloudflare worker", (c) => withWranglerOptions(c)
+        .option("skipNextBuild", {
+        type: "boolean",
+        alias: ["skipBuild", "s"],
+        default: ["1", "true", "yes"].includes(String(process.env.SKIP_NEXT_APP_BUILD)),
+        desc: "Skip building the Next.js app",
+    })
+        .option("noMinify", {
+        type: "boolean",
+        default: false,
+        desc: "Disable worker minification",
+    })
+        .option("skipWranglerConfigCheck", {
+        type: "boolean",
+        default: ["1", "true", "yes"].includes(String(process.env.SKIP_WRANGLER_CONFIG_CHECK)),
+        desc: "Skip checking for a Wrangler config",
+    }), (args) => buildCommand(withWranglerPassthroughArgs(args)));
+}

package/dist/cli/commands/deploy.d.ts

@@ -1,6 +1,16 @@
-import { BuildOptions } from "@opennextjs/aws/build/helper.js";
-import type { OpenNextConfig } from "../../api/config.js";
-export declare function deploy(options: BuildOptions, config: OpenNextConfig, deployOptions: {
-    passthroughArgs: string[];
-    cacheChunkSize?: number;
-}): Promise<void>;
+import type yargs from "yargs";
+import type { WithWranglerArgs } from "./utils.js";
+/**
+ * Implementation of the `opennextjs-cloudflare deploy` command.
+ *
+ * @param args
+ */
+export declare function deployCommand(args: WithWranglerArgs<{
+    cacheChunkSize: number;
+}>): Promise<void>;
+/**
+ * Add the `deploy` command to yargs configuration.
+ *
+ * Consumes 1 positional parameter.
+ */
+export declare function addDeployCommand<T extends yargs.Argv>(y: T): yargs.Argv<{}>;

package/dist/cli/commands/deploy.js

@@ -1,22 +1,33 @@
 import { DEPLOYMENT_MAPPING_ENV_NAME } from "../templates/skew-protection.js";
-import { getWranglerEnvironmentFlag, runWrangler } from "../utils/run-wrangler.js";
+import { runWrangler } from "../utils/run-wrangler.js";
 import { getEnvFromPlatformProxy, quoteShellMeta } from "./helpers.js";
-import { populateCache } from "./populate-cache.js";
+import { populateCache, withPopulateCacheOptions } from "./populate-cache.js";
 import { getDeploymentMapping } from "./skew-protection.js";
-export async function deploy(options, config, deployOptions) {
+import { getNormalizedOptions, printHeaders, readWranglerConfig, retrieveCompiledConfig, withWranglerPassthroughArgs, } from "./utils.js";
+/**
+ * Implementation of the `opennextjs-cloudflare deploy` command.
+ *
+ * @param args
+ */
+export async function deployCommand(args) {
+    printHeaders("deploy");
+    const { config } = await retrieveCompiledConfig();
+    const options = getNormalizedOptions(config);
+    const wranglerConfig = readWranglerConfig(args);
     const envVars = await getEnvFromPlatformProxy({
-        // TODO: Pass the configPath, update everywhere applicable
-        environment: getWranglerEnvironmentFlag(deployOptions.passthroughArgs),
+        configPath: args.configPath,
+        environment: args.env,
     });
     const deploymentMapping = await getDeploymentMapping(options, config, envVars);
-    await populateCache(options, config, {
+    await populateCache(options, config, wranglerConfig, {
         target: "remote",
-        environment: getWranglerEnvironmentFlag(deployOptions.passthroughArgs),
-        cacheChunkSize: deployOptions.cacheChunkSize,
+        environment: args.env,
+        configPath: args.configPath,
+        cacheChunkSize: args.cacheChunkSize,
     });
     runWrangler(options, [
         "deploy",
-        ...deployOptions.passthroughArgs,
+        ...args.wranglerArgs,
         ...(deploymentMapping
             ? [`--var ${DEPLOYMENT_MAPPING_ENV_NAME}:${quoteShellMeta(JSON.stringify(deploymentMapping))}`]
             : []),
@@ -24,3 +35,11 @@ export async function deploy(options, config, deployOptions) {
         logging: "all",
     });
 }
+/**
+ * Add the `deploy` command to yargs configuration.
+ *
+ * Consumes 1 positional parameter.
+ */
+export function addDeployCommand(y) {
+    return y.command("deploy", "Deploy a built OpenNext app to Cloudflare Workers", (c) => withPopulateCacheOptions(c), (args) => deployCommand(withWranglerPassthroughArgs(args)));
+}

package/dist/cli/commands/populate-cache.d.ts

@@ -1,5 +1,7 @@
 import type { BuildOptions } from "@opennextjs/aws/build/helper.js";
 import type { OpenNextConfig } from "@opennextjs/aws/types/open-next.js";
+import type { Unstable_Config as WranglerConfig } from "wrangler";
+import type yargs from "yargs";
 import type { WranglerTarget } from "../utils/run-wrangler.js";
 export type CacheAsset = {
     isFetch: boolean;
@@ -8,8 +10,24 @@ export type CacheAsset = {
     buildId: string;
 };
 export declare function getCacheAssets(opts: BuildOptions): CacheAsset[];
-export declare function populateCache(options: BuildOptions, config: OpenNextConfig, populateCacheOptions: {
+type PopulateCacheOptions = {
     target: WranglerTarget;
     environment?: string;
+    configPath?: string;
     cacheChunkSize?: number;
-}): Promise<void>;
+};
+export declare function populateCache(options: BuildOptions, config: OpenNextConfig, wranglerConfig: WranglerConfig, populateCacheOptions: PopulateCacheOptions): Promise<void>;
+/**
+ * Add the `populateCache` command to yargs configuration, with nested commands for `local` and `remote`.
+ *
+ * Consumes 2 positional parameters.
+ */
+export declare function addPopulateCacheCommand<T extends yargs.Argv>(y: T): yargs.Argv<{}>;
+export declare function withPopulateCacheOptions<T extends yargs.Argv>(args: T): yargs.Argv<{
+    configPath: string | undefined;
+} & {
+    env: string | undefined;
+} & {
+    cacheChunkSize: number;
+}>;
+export {};

package/dist/cli/commands/populate-cache.js

@@ -3,7 +3,6 @@ import path from "node:path";
 import logger from "@opennextjs/aws/logger.js";
 import { globSync } from "glob";
 import { tqdm } from "ts-tqdm";
-import { unstable_readConfig } from "wrangler";
 import { BINDING_NAME as KV_CACHE_BINDING_NAME, NAME as KV_CACHE_NAME, PREFIX_ENV_NAME as KV_CACHE_PREFIX_ENV_NAME, } from "../../api/overrides/incremental-cache/kv-incremental-cache.js";
 import { BINDING_NAME as R2_CACHE_BINDING_NAME, NAME as R2_CACHE_NAME, PREFIX_ENV_NAME as R2_CACHE_PREFIX_ENV_NAME, } from "../../api/overrides/incremental-cache/r2-incremental-cache.js";
 import { CACHE_DIR as STATIC_ASSETS_CACHE_DIR, NAME as STATIC_ASSETS_CACHE_NAME, } from "../../api/overrides/incremental-cache/static-assets-incremental-cache.js";
@@ -12,6 +11,7 @@ import { BINDING_NAME as D1_TAG_BINDING_NAME, NAME as D1_TAG_NAME, } from "../..
 import { normalizePath } from "../build/utils/normalize-path.js";
 import { runWrangler } from "../utils/run-wrangler.js";
 import { getEnvFromPlatformProxy, quoteShellMeta } from "./helpers.js";
+import { getNormalizedOptions, printHeaders, readWranglerConfig, retrieveCompiledConfig, withWranglerOptions, withWranglerPassthroughArgs, } from "./utils.js";
 async function resolveCacheName(value) {
     return typeof value === "function" ? (await value()).name : value;
 }
@@ -51,9 +51,8 @@ export function getCacheAssets(opts) {
     }
     return assets;
 }
-async function populateR2IncrementalCache(options, populateCacheOptions) {
+async function populateR2IncrementalCache(options, config, populateCacheOptions) {
     logger.info("\nPopulating R2 incremental cache...");
-    const config = unstable_readConfig({ env: populateCacheOptions.environment });
     const binding = config.r2_buckets.find(({ binding }) => binding === R2_CACHE_BINDING_NAME);
     if (!binding) {
         throw new Error(`No R2 binding ${JSON.stringify(R2_CACHE_BINDING_NAME)} found!`);
@@ -82,9 +81,8 @@ async function populateR2IncrementalCache(options, populateCacheOptions) {
     }
     logger.info(`Successfully populated cache with ${assets.length} assets`);
 }
-async function populateKVIncrementalCache(options, populateCacheOptions) {
+async function populateKVIncrementalCache(options, config, populateCacheOptions) {
     logger.info("\nPopulating KV incremental cache...");
-    const config = unstable_readConfig({ env: populateCacheOptions.environment });
     const binding = config.kv_namespaces.find(({ binding }) => binding === KV_CACHE_BINDING_NAME);
     if (!binding) {
         throw new Error(`No KV binding ${JSON.stringify(KV_CACHE_BINDING_NAME)} found!`);
@@ -116,9 +114,8 @@ async function populateKVIncrementalCache(options, populateCacheOptions) {
     }
     logger.info(`Successfully populated cache with ${assets.length} assets`);
 }
-function populateD1TagCache(options, populateCacheOptions) {
+function populateD1TagCache(options, config, populateCacheOptions) {
     logger.info("\nCreating D1 table if necessary...");
-    const config = unstable_readConfig({ env: populateCacheOptions.environment });
     const binding = config.d1_databases.find(({ binding }) => binding === D1_TAG_BINDING_NAME);
     if (!binding) {
         throw new Error(`No D1 binding ${JSON.stringify(D1_TAG_BINDING_NAME)} found!`);
@@ -135,7 +132,7 @@ function populateStaticAssetsIncrementalCache(options) {
     cpSync(path.join(options.outputDir, "cache"), path.join(options.outputDir, "assets", STATIC_ASSETS_CACHE_DIR), { recursive: true });
     logger.info(`Successfully populated static assets cache`);
 }
-export async function populateCache(options, config, populateCacheOptions) {
+export async function populateCache(options, config, wranglerConfig, populateCacheOptions) {
     const { incrementalCache, tagCache } = config.default.override ?? {};
     if (!existsSync(options.outputDir)) {
         logger.error("Unable to populate cache: Open Next build not found");
@@ -145,10 +142,10 @@ export async function populateCache(options, config, populateCacheOptions) {
         const name = await resolveCacheName(incrementalCache);
         switch (name) {
             case R2_CACHE_NAME:
-                await populateR2IncrementalCache(options, populateCacheOptions);
+                await populateR2IncrementalCache(options, wranglerConfig, populateCacheOptions);
                 break;
             case KV_CACHE_NAME:
-                await populateKVIncrementalCache(options, populateCacheOptions);
+                await populateKVIncrementalCache(options, wranglerConfig, populateCacheOptions);
                 break;
             case STATIC_ASSETS_CACHE_NAME:
                 populateStaticAssetsIncrementalCache(options);
@@ -161,10 +158,45 @@ export async function populateCache(options, config, populateCacheOptions) {
         const name = await resolveCacheName(tagCache);
         switch (name) {
             case D1_TAG_NAME:
-                populateD1TagCache(options, populateCacheOptions);
+                populateD1TagCache(options, wranglerConfig, populateCacheOptions);
                 break;
             default:
                 logger.info("Tag cache does not need populating");
         }
     }
 }
+/**
+ * Implementation of the `opennextjs-cloudflare populateCache` command.
+ *
+ * @param args
+ */
+async function populateCacheCommand(target, args) {
+    printHeaders(`populate cache - ${target}`);
+    const { config } = await retrieveCompiledConfig();
+    const options = getNormalizedOptions(config);
+    const wranglerConfig = readWranglerConfig(args);
+    await populateCache(options, config, wranglerConfig, {
+        target,
+        environment: args.env,
+        configPath: args.configPath,
+        cacheChunkSize: args.cacheChunkSize,
+    });
+}
+/**
+ * Add the `populateCache` command to yargs configuration, with nested commands for `local` and `remote`.
+ *
+ * Consumes 2 positional parameters.
+ */
+export function addPopulateCacheCommand(y) {
+    return y.command("populateCache", "Populate the cache for a built Next.js app", (c) => c
+        .command("local", "Local dev server cache", (c) => withPopulateCacheOptions(c), (args) => populateCacheCommand("local", withWranglerPassthroughArgs(args)))
+        .command("remote", "Remote Cloudflare Worker cache", (c) => withPopulateCacheOptions(c), (args) => populateCacheCommand("remote", withWranglerPassthroughArgs(args)))
+        .demandCommand(1, 1));
+}
+export function withPopulateCacheOptions(args) {
+    return withWranglerOptions(args).options("cacheChunkSize", {
+        type: "number",
+        default: 25,
+        desc: "Number of entries per chunk when populating the cache",
+    });
+}

package/dist/cli/commands/preview.d.ts

@@ -1,6 +1,16 @@
-import { BuildOptions } from "@opennextjs/aws/build/helper.js";
-import type { OpenNextConfig } from "../../api/config.js";
-export declare function preview(options: BuildOptions, config: OpenNextConfig, previewOptions: {
-    passthroughArgs: string[];
-    cacheChunkSize?: number;
-}): Promise<void>;
+import type yargs from "yargs";
+import type { WithWranglerArgs } from "./utils.js";
+/**
+ * Implementation of the `opennextjs-cloudflare preview` command.
+ *
+ * @param args
+ */
+export declare function previewCommand(args: WithWranglerArgs<{
+    cacheChunkSize: number;
+}>): Promise<void>;
+/**
+ * Add the `preview` command to yargs configuration.
+ *
+ * Consumes 1 positional parameter.
+ */
+export declare function addPreviewCommand<T extends yargs.Argv>(y: T): yargs.Argv<{}>;

package/dist/cli/commands/preview.js

@@ -1,10 +1,29 @@
-import { getWranglerEnvironmentFlag, runWrangler } from "../utils/run-wrangler.js";
-import { populateCache } from "./populate-cache.js";
-export async function preview(options, config, previewOptions) {
-    await populateCache(options, config, {
+import { runWrangler } from "../utils/run-wrangler.js";
+import { populateCache, withPopulateCacheOptions } from "./populate-cache.js";
+import { getNormalizedOptions, printHeaders, readWranglerConfig, retrieveCompiledConfig, withWranglerPassthroughArgs, } from "./utils.js";
+/**
+ * Implementation of the `opennextjs-cloudflare preview` command.
+ *
+ * @param args
+ */
+export async function previewCommand(args) {
+    printHeaders("preview");
+    const { config } = await retrieveCompiledConfig();
+    const options = getNormalizedOptions(config);
+    const wranglerConfig = readWranglerConfig(args);
+    await populateCache(options, config, wranglerConfig, {
         target: "local",
-        environment: getWranglerEnvironmentFlag(previewOptions.passthroughArgs),
-        cacheChunkSize: previewOptions.cacheChunkSize,
+        environment: args.env,
+        configPath: args.configPath,
+        cacheChunkSize: args.cacheChunkSize,
     });
-    runWrangler(options, ["dev", ...previewOptions.passthroughArgs], { logging: "all" });
+    runWrangler(options, ["dev", ...args.wranglerArgs], { logging: "all" });
+}
+/**
+ * Add the `preview` command to yargs configuration.
+ *
+ * Consumes 1 positional parameter.
+ */
+export function addPreviewCommand(y) {
+    return y.command("preview", "Preview a built OpenNext app with a Wrangler dev server", (c) => withPopulateCacheOptions(c), (args) => previewCommand(withWranglerPassthroughArgs(args)));
 }

package/dist/cli/commands/upload.d.ts

@@ -1,6 +1,16 @@
-import { BuildOptions } from "@opennextjs/aws/build/helper.js";
-import type { OpenNextConfig } from "../../api/config.js";
-export declare function upload(options: BuildOptions, config: OpenNextConfig, uploadOptions: {
-    passthroughArgs: string[];
-    cacheChunkSize?: number;
-}): Promise<void>;
+import type yargs from "yargs";
+import type { WithWranglerArgs } from "./utils.js";
+/**
+ * Implementation of the `opennextjs-cloudflare upload` command.
+ *
+ * @param args
+ */
+export declare function uploadCommand(args: WithWranglerArgs<{
+    cacheChunkSize: number;
+}>): Promise<void>;
+/**
+ * Add the `upload` command to yargs configuration.
+ *
+ * Consumes 1 positional parameter.
+ */
+export declare function addUploadCommand<T extends yargs.Argv>(y: T): yargs.Argv<{}>;

package/dist/cli/commands/upload.js

@@ -1,24 +1,43 @@
 import { DEPLOYMENT_MAPPING_ENV_NAME } from "../templates/skew-protection.js";
-import { getWranglerEnvironmentFlag, runWrangler } from "../utils/run-wrangler.js";
+import { runWrangler } from "../utils/run-wrangler.js";
 import { getEnvFromPlatformProxy, quoteShellMeta } from "./helpers.js";
-import { populateCache } from "./populate-cache.js";
+import { populateCache, withPopulateCacheOptions } from "./populate-cache.js";
 import { getDeploymentMapping } from "./skew-protection.js";
-export async function upload(options, config, uploadOptions) {
+import { getNormalizedOptions, printHeaders, readWranglerConfig, retrieveCompiledConfig, withWranglerPassthroughArgs, } from "./utils.js";
+/**
+ * Implementation of the `opennextjs-cloudflare upload` command.
+ *
+ * @param args
+ */
+export async function uploadCommand(args) {
+    printHeaders("upload");
+    const { config } = await retrieveCompiledConfig();
+    const options = getNormalizedOptions(config);
+    const wranglerConfig = readWranglerConfig(args);
     const envVars = await getEnvFromPlatformProxy({
-        // TODO: Pass the configPath, update everywhere applicable
-        environment: getWranglerEnvironmentFlag(uploadOptions.passthroughArgs),
+        configPath: args.configPath,
+        environment: args.env,
     });
     const deploymentMapping = await getDeploymentMapping(options, config, envVars);
-    await populateCache(options, config, {
+    await populateCache(options, config, wranglerConfig, {
         target: "remote",
-        environment: getWranglerEnvironmentFlag(uploadOptions.passthroughArgs),
-        cacheChunkSize: uploadOptions.cacheChunkSize,
+        environment: args.env,
+        configPath: args.configPath,
+        cacheChunkSize: args.cacheChunkSize,
     });
     runWrangler(options, [
         "versions upload",
-        ...uploadOptions.passthroughArgs,
+        ...args.wranglerArgs,
         ...(deploymentMapping
             ? [`--var ${DEPLOYMENT_MAPPING_ENV_NAME}:${quoteShellMeta(JSON.stringify(deploymentMapping))}`]
             : []),
     ], { logging: "all" });
 }
+/**
+ * Add the `upload` command to yargs configuration.
+ *
+ * Consumes 1 positional parameter.
+ */
+export function addUploadCommand(y) {
+    return y.command("upload", "Upload a built OpenNext app to Cloudflare Workers", (c) => withPopulateCacheOptions(c), (args) => uploadCommand(withWranglerPassthroughArgs(args)));
+}

package/dist/cli/commands/utils.d.ts

@@ -0,0 +1,81 @@
+import type yargs from "yargs";
+import type { OpenNextConfig } from "../../api/config.js";
+export type WithWranglerArgs<T = unknown> = T & {
+    wranglerArgs: string[];
+    configPath: string | undefined;
+    env: string | undefined;
+};
+export declare const nextAppDir: string;
+/**
+ * Print headers and warnings for the CLI.
+ *
+ * @param command
+ */
+export declare function printHeaders(command: string): void;
+/**
+ * Compile the OpenNext config, and ensure it is for Cloudflare.
+ *
+ * @returns OpenNext config.
+ */
+export declare function compileConfig(): Promise<{
+    config: import("@opennextjs/aws/types/open-next.js").OpenNextConfig;
+    buildDir: string;
+}>;
+/**
+ * Retrieve a compiled OpenNext config, and ensure it is for Cloudflare.
+ *
+ * @returns OpenNext config.
+ */
+export declare function retrieveCompiledConfig(): Promise<{
+    config: any;
+}>;
+/**
+ * Normalize the OpenNext options and set the logging level.
+ *
+ * @param config
+ * @param buildDir Directory to use when building the application
+ * @returns Normalized options.
+ */
+export declare function getNormalizedOptions(config: OpenNextConfig, buildDir?: string): {
+    appBuildOutputPath: string;
+    appPackageJsonPath: string;
+    appPath: string;
+    appPublicPath: string;
+    buildDir: string;
+    config: import("@opennextjs/aws/types/open-next.js").OpenNextConfig;
+    debug: boolean;
+    minify: boolean;
+    monorepoRoot: string;
+    nextVersion: string;
+    openNextVersion: string;
+    openNextDistDir: string;
+    outputDir: string;
+    packager: "bun" | "npm" | "yarn" | "pnpm";
+    tempBuildDir: string;
+};
+/**
+ * Read the Wrangler config.
+ *
+ * @param args Wrangler environment and config path.
+ * @returns Wrangler config.
+ */
+export declare function readWranglerConfig(args: WithWranglerArgs): import("wrangler").Unstable_Config;
+/**
+ * Adds flags for the wrangler config path and environment to the yargs configuration.
+ */
+export declare function withWranglerOptions<T extends yargs.Argv>(args: T): yargs.Argv<{
+    configPath: string | undefined;
+} & {
+    env: string | undefined;
+}>;
+/**
+ *
+ * @param args
+ * @returns The inputted args, and an array of arguments that can be given to wrangler commands, including the `--config` and `--env` args.
+ */
+export declare function withWranglerPassthroughArgs<T extends yargs.ArgumentsCamelCase<{
+    configPath: string | undefined;
+    env: string | undefined;
+}>>(args: T): T & {
+    wranglerArgs: string[];
+};

package/dist/cli/commands/utils.js

@@ -0,0 +1,105 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { compileOpenNextConfig } from "@opennextjs/aws/build/compileConfig.js";
+import { normalizeOptions } from "@opennextjs/aws/build/helper.js";
+import { printHeader, showWarningOnWindows } from "@opennextjs/aws/build/utils.js";
+import logger from "@opennextjs/aws/logger.js";
+import { unstable_readConfig } from "wrangler";
+import { createOpenNextConfigIfNotExistent, ensureCloudflareConfig } from "../build/utils/index.js";
+export const nextAppDir = process.cwd();
+/**
+ * Print headers and warnings for the CLI.
+ *
+ * @param command
+ */
+export function printHeaders(command) {
+    printHeader(`Cloudflare ${command}`);
+    showWarningOnWindows();
+}
+/**
+ * Compile the OpenNext config, and ensure it is for Cloudflare.
+ *
+ * @returns OpenNext config.
+ */
+export async function compileConfig() {
+    await createOpenNextConfigIfNotExistent(nextAppDir);
+    const { config, buildDir } = await compileOpenNextConfig(nextAppDir, undefined, { compileEdge: true });
+    ensureCloudflareConfig(config);
+    return { config, buildDir };
+}
+/**
+ * Retrieve a compiled OpenNext config, and ensure it is for Cloudflare.
+ *
+ * @returns OpenNext config.
+ */
+export async function retrieveCompiledConfig() {
+    const configPath = path.join(nextAppDir, ".open-next/.build/open-next.config.edge.mjs");
+    if (!existsSync(configPath)) {
+        logger.error("Could not find compiled Open Next config, did you run the build command?");
+        process.exit(1);
+    }
+    const config = await import(configPath).then((mod) => mod.default);
+    ensureCloudflareConfig(config);
+    return { config };
+}
+/**
+ * Normalize the OpenNext options and set the logging level.
+ *
+ * @param config
+ * @param buildDir Directory to use when building the application
+ * @returns Normalized options.
+ */
+export function getNormalizedOptions(config, buildDir = nextAppDir) {
+    const require = createRequire(import.meta.url);
+    const openNextDistDir = path.dirname(require.resolve("@opennextjs/aws/index.js"));
+    const options = normalizeOptions(config, openNextDistDir, buildDir);
+    logger.setLevel(options.debug ? "debug" : "info");
+    return options;
+}
+/**
+ * Read the Wrangler config.
+ *
+ * @param args Wrangler environment and config path.
+ * @returns Wrangler config.
+ */
+export function readWranglerConfig(args) {
+    return unstable_readConfig({ env: args.env, config: args.configPath });
+}
+/**
+ * Adds flags for the wrangler config path and environment to the yargs configuration.
+ */
+export function withWranglerOptions(args) {
+    return args
+        .options("configPath", {
+        type: "string",
+        alias: ["config", "c"],
+        desc: "Path to Wrangler configuration file",
+    })
+        .options("env", {
+        type: "string",
+        alias: "e",
+        desc: "Wrangler environment to use for operations",
+    });
+}
+/**
+ *
+ * @param args
+ * @returns An array of arguments that can be given to wrangler commands, including the `--config` and `--env` args.
+ */
+function getWranglerArgs(args) {
+    return [
+        ...(args.configPath ? ["--config", args.configPath] : []),
+        ...(args.env ? ["--env", args.env] : []),
+        // Note: the first args in `_` will be the commands.
+        ...args._.slice(args._[0] === "populateCache" ? 2 : 1).map((a) => `${a}`),
+    ];
+}
+/**
+ *
+ * @param args
+ * @returns The inputted args, and an array of arguments that can be given to wrangler commands, including the `--config` and `--env` args.
+ */
+export function withWranglerPassthroughArgs(args) {
+    return { ...args, wranglerArgs: getWranglerArgs(args) };
+}

package/dist/cli/index.d.ts

@@ -1,2 +1,10 @@
 #!/usr/bin/env node
-export {};
+export declare function runCommand(): {
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+} | Promise<{
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+}>;

package/dist/cli/index.js

@@ -1,51 +1,19 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
-import path from "node:path";
-import { compileOpenNextConfig } from "@opennextjs/aws/build/compileConfig.js";
-import { normalizeOptions } from "@opennextjs/aws/build/helper.js";
-import { printHeader, showWarningOnWindows } from "@opennextjs/aws/build/utils.js";
-import logger from "@opennextjs/aws/logger.js";
-import { unstable_readConfig } from "wrangler";
-import { getArgs } from "./args.js";
-import { build } from "./build/build.js";
-import { createOpenNextConfigIfNotExistent, ensureCloudflareConfig } from "./build/utils/index.js";
-import { deploy } from "./commands/deploy.js";
-import { populateCache } from "./commands/populate-cache.js";
-import { preview } from "./commands/preview.js";
-import { upload } from "./commands/upload.js";
-import { getWranglerConfigFlag, getWranglerEnvironmentFlag } from "./utils/run-wrangler.js";
-const nextAppDir = process.cwd();
-async function runCommand(args) {
-    printHeader(`Cloudflare ${args.command}`);
-    showWarningOnWindows();
-    const baseDir = nextAppDir;
-    const require = createRequire(import.meta.url);
-    const openNextDistDir = path.dirname(require.resolve("@opennextjs/aws/index.js"));
-    // TODO: retrieve the compiled version if command != build
-    await createOpenNextConfigIfNotExistent(baseDir);
-    const { config, buildDir } = await compileOpenNextConfig(baseDir, undefined, {
-        compileEdge: true,
-    });
-    ensureCloudflareConfig(config);
-    // Initialize options
-    const options = normalizeOptions(config, openNextDistDir, buildDir);
-    logger.setLevel(options.debug ? "debug" : "info");
-    switch (args.command) {
-        case "build": {
-            const argv = process.argv.slice(2);
-            const wranglerEnv = getWranglerEnvironmentFlag(argv);
-            const wranglerConfigFile = getWranglerConfigFlag(argv);
-            const wranglerConfig = unstable_readConfig({ env: wranglerEnv, config: wranglerConfigFile });
-            return build(options, config, { ...args, sourceDir: baseDir }, wranglerConfig);
-        }
-        case "preview":
-            return preview(options, config, args);
-        case "deploy":
-            return deploy(options, config, args);
-        case "upload":
-            return upload(options, config, args);
-        case "populateCache":
-            return populateCache(options, config, args);
-    }
+import yargs from "yargs";
+import { addBuildCommand } from "./commands/build.js";
+import { addDeployCommand } from "./commands/deploy.js";
+import { addPopulateCacheCommand } from "./commands/populate-cache.js";
+import { addPreviewCommand } from "./commands/preview.js";
+import { addUploadCommand } from "./commands/upload.js";
+export function runCommand() {
+    const y = yargs(process.argv.slice(2).filter((arg) => arg !== "--"))
+        .scriptName("opennextjs-cloudflare")
+        .parserConfiguration({ "unknown-options-as-args": true });
+    addBuildCommand(y);
+    addPreviewCommand(y);
+    addDeployCommand(y);
+    addUploadCommand(y);
+    addPopulateCacheCommand(y);
+    return y.demandCommand(1, 1).parse();
 }
-await runCommand(getArgs());
+await runCommand();

package/dist/cli/templates/images.js

@@ -175,4 +175,3 @@ export function detectContentType(buffer) {
         return BMP;
     }
 }
-/* eslint-enable no-var */

package/dist/cli/templates/init.js

@@ -119,4 +119,3 @@ function populateProcessEnv(url, env) {
         process.env.DEPLOYMENT_ID = __DEPLOYMENT_ID__;
     }
 }
-/* eslint-enable no-var */

package/dist/cli/templates/skew-protection.js

@@ -51,7 +51,9 @@ export function maybeGetSkewProtectionResponse(request) {
         const hostname = `${versionDomain}-${process.env.CF_WORKER_NAME}.${process.env.CF_PREVIEW_DOMAIN}.workers.dev`;
         url.hostname = hostname;
         const requestToOlderDeployment = new Request(url, request);
-        return fetch(requestToOlderDeployment);
+        // Remove the origin header to prevent an error with POST requests
+        const headers = new Headers(request.headers);
+        headers.delete("origin");
+        return fetch(requestToOlderDeployment, { headers });
     }
 }
-/* eslint-enable no-var */

package/dist/cli/utils/run-wrangler.d.ts

@@ -7,28 +7,4 @@ type WranglerOptions = {
 };
 export declare function runWrangler(options: BuildOptions, args: string[], wranglerOpts?: WranglerOptions): void;
 export declare function isWranglerTarget(v: string | undefined): v is WranglerTarget;
-/**
- * Returns the value of the flag.
- *
- * The value is retrieved for `<argName> value` or `<argName>=value`.
- *
- * @param args List of args
- * @param argName The arg name with leading dashes, i.e. `--env` or `-e`
- * @returns The value or undefined when not found
- */
-export declare function getFlagValue(args: string[], ...argNames: string[]): string | undefined;
-/**
- * Find the value of the environment flag (`--env` / `-e`) used by Wrangler.
- *
- * @param args - CLI arguments.
- * @returns Value of the environment flag or undefined when not found
- */
-export declare function getWranglerEnvironmentFlag(args: string[]): string | undefined;
-/**
- * Find the value of the config flag (`--config` / `-c`) used by Wrangler.
- *
- * @param args - CLI arguments.
- * @returns Value of the config flag or undefined when not found
- */
-export declare function getWranglerConfigFlag(args: string[]): string | undefined;
 export {};

package/dist/cli/utils/run-wrangler.js

@@ -66,49 +66,3 @@ export function runWrangler(options, args, wranglerOpts = {}) {
 export function isWranglerTarget(v) {
     return !!v && ["local", "remote"].includes(v);
 }
-/**
- * Returns the value of the flag.
- *
- * The value is retrieved for `<argName> value` or `<argName>=value`.
- *
- * @param args List of args
- * @param argName The arg name with leading dashes, i.e. `--env` or `-e`
- * @returns The value or undefined when not found
- */
-export function getFlagValue(args, ...argNames) {
-    if (argNames.some((name) => !name.startsWith("-"))) {
-        // Names should start with "-" or "--"
-        throw new Error(`Invalid arg names: ${argNames}`);
-    }
-    for (const argName of argNames) {
-        for (let i = 0; i <= args.length; i++) {
-            const arg = args[i];
-            if (!arg)
-                continue;
-            if (arg === argName) {
-                return args[i + 1];
-            }
-            if (arg.startsWith(argName)) {
-                return arg.split("=")[1];
-            }
-        }
-    }
-}
-/**
- * Find the value of the environment flag (`--env` / `-e`) used by Wrangler.
- *
- * @param args - CLI arguments.
- * @returns Value of the environment flag or undefined when not found
- */
-export function getWranglerEnvironmentFlag(args) {
-    return getFlagValue(args, "--env", "-e");
-}
-/**
- * Find the value of the config flag (`--config` / `-c`) used by Wrangler.
- *
- * @param args - CLI arguments.
- * @returns Value of the config flag or undefined when not found
- */
-export function getWranglerConfigFlag(args) {
-    return getFlagValue(args, "--config", "-c");
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.5.3",
+  "version": "1.6.0",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -47,7 +47,8 @@
     "cloudflare": "^4.4.1",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0",
-    "ts-tqdm": "^0.8.6"
+    "ts-tqdm": "^0.8.6",
+    "yargs": "^18.0.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20250224.0",
@@ -56,9 +57,10 @@
     "@types/mock-fs": "^4.13.4",
     "@types/node": "^22.2.0",
     "@types/picomatch": "^4.0.0",
+    "@types/yargs": "^17.0.33",
     "diff": "^8.0.2",
     "esbuild": "^0.25.4",
-    "eslint": "^9.11.1",
+    "eslint": "^9.31.0",
     "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "eslint-plugin-unicorn": "^55.0.0",
@@ -68,7 +70,7 @@
     "picomatch": "^4.0.2",
     "rimraf": "^6.0.1",
     "typescript": "^5.7.3",
-    "typescript-eslint": "^8.7.0",
+    "typescript-eslint": "^8.37.0",
     "vitest": "^2.1.1"
   },
   "peerDependencies": {

package/dist/cli/args.d.ts

@@ -1,21 +0,0 @@
-import type { ParseArgsConfig } from "node:util";
-import type { WranglerTarget } from "./utils/run-wrangler.js";
-export type Arguments = ({
-    command: "build";
-    skipNextBuild: boolean;
-    skipWranglerConfigCheck: boolean;
-    minify: boolean;
-} | {
-    command: "preview" | "deploy" | "upload";
-    passthroughArgs: string[];
-    cacheChunkSize?: number;
-} | {
-    command: "populateCache";
-    target: WranglerTarget;
-    environment?: string;
-    cacheChunkSize?: number;
-}) & {
-    outputDir?: string;
-};
-export declare function getArgs(): Arguments;
-export declare function getPassthroughArgs<T extends ParseArgsConfig>(args: string[], { options }: T): string[];

package/dist/cli/args.js

@@ -1,91 +0,0 @@
-import { mkdirSync, statSync } from "node:fs";
-import { resolve } from "node:path";
-import { parseArgs } from "node:util";
-import { getWranglerEnvironmentFlag, isWranglerTarget } from "./utils/run-wrangler.js";
-// Config for parsing CLI arguments
-const config = {
-    allowPositionals: true,
-    strict: false,
-    options: {
-        skipBuild: { type: "boolean", short: "s", default: false },
-        output: { type: "string", short: "o" },
-        noMinify: { type: "boolean", default: false },
-        skipWranglerConfigCheck: { type: "boolean", default: false },
-        cacheChunkSize: { type: "string" },
-    },
-};
-export function getArgs() {
-    const { positionals, values } = parseArgs(config);
-    const outputDir = typeof values.output === "string" ? resolve(values.output) : undefined;
-    if (outputDir)
-        assertDirArg(outputDir, "output", true);
-    switch (positionals[0]) {
-        case "build":
-            return {
-                command: "build",
-                outputDir,
-                skipNextBuild: !!values.skipBuild || ["1", "true", "yes"].includes(String(process.env.SKIP_NEXT_APP_BUILD)),
-                skipWranglerConfigCheck: !!values.skipWranglerConfigCheck ||
-                    ["1", "true", "yes"].includes(String(process.env.SKIP_WRANGLER_CONFIG_CHECK)),
-                minify: !values.noMinify,
-            };
-        case "preview":
-        case "deploy":
-        case "upload":
-            return {
-                command: positionals[0],
-                outputDir,
-                passthroughArgs: getPassthroughArgs(process.argv, config),
-                ...(values.cacheChunkSize && { cacheChunkSize: Number(values.cacheChunkSize) }),
-            };
-        case "populateCache":
-            if (!isWranglerTarget(positionals[1])) {
-                throw new Error(`Error: invalid target for populating the cache, expected 'local' | 'remote'`);
-            }
-            return {
-                command: "populateCache",
-                outputDir,
-                target: positionals[1],
-                environment: getWranglerEnvironmentFlag(process.argv),
-                ...(values.cacheChunkSize && { cacheChunkSize: Number(values.cacheChunkSize) }),
-            };
-        default:
-            throw new Error("Error: invalid command, expected 'build' | 'preview' | 'deploy' | 'upload' | 'populateCache'");
-    }
-}
-export function getPassthroughArgs(args, { options = {} }) {
-    const passthroughArgs = [];
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === "--") {
-            passthroughArgs.push(...args.slice(i + 1));
-            return passthroughArgs;
-        }
-        // look for `--arg(=value)`, `-arg(=value)`
-        const [, name] = /^--?(\w[\w-]*)(=.+)?$/.exec(args[i]) ?? [];
-        if (name && !(name in options)) {
-            passthroughArgs.push(args[i]);
-            // Array args can have multiple values
-            // ref https://github.com/yargs/yargs-parser/blob/main/README.md#greedy-arrays
-            while (i < args.length - 1 && !args[i + 1]?.startsWith("-")) {
-                passthroughArgs.push(args[++i]);
-            }
-        }
-    }
-    return passthroughArgs;
-}
-function assertDirArg(path, argName, make) {
-    let dirStats;
-    try {
-        dirStats = statSync(path);
-    }
-    catch {
-        if (!make) {
-            throw new Error(`Error: the provided${argName ? ` "${argName}"` : ""} input is not a valid path`);
-        }
-        mkdirSync(path);
-        return;
-    }
-    if (!dirStats.isDirectory()) {
-        throw new Error(`Error: the provided${argName ? ` "${argName}"` : ""} input is not a directory`);
-    }
-}