installed
4.111.0

wrangler pages deploy [directory]

Deploy a directory of static assets as a Pages deployment

POSITIONALS
  directory  The directory of static files to upload  [string]

GLOBAL FLAGS
      --cwd             Run as if Wrangler was started in the specified directory instead of the current working directory  [string]
      --env-file        Path to an .env file to load - can be specified multiple times - values from earlier files are overridden by values in later files  [array]
  -h, --help            Show help  [boolean]
      --install-skills  Install Cloudflare skills for detected AI coding agents before running the command  [boolean] [default: false]
      --profile         Use a specific auth profile  [string]
  -v, --version         Show version number  [boolean]

OPTIONS
      --project-name        The name of the project you want to deploy to  [string]
      --branch              The name of the branch you want to deploy to  [string]
      --commit-hash         The SHA to attach ...

=========== WHOAMI ===========
wrangler whoami

🕵️ Retrieve your user information

GLOBAL FLAGS
  -c, --config          Path to Wrangler configuration file  [string]
      --cwd             Run as if Wrangler was started in the specified directory instead of the current working directory  [string]
  -e, --env             Environment to use for operations, and for selecting .env and .dev.vars files  [string]
      --env-file        Path to an .env file to load - can be specified multiple times - values from earlier files are overridden by values in later files  [array]
  -h, --help            Show help  [boolean]
      --install-skills  Install Cloudflare skills for detected AI coding agents before running the command  [boolean] [default: false]
  -v, --version         Show version number  [boolean]

OPTIONS
      --account  Show membership information for the given account (id or name).  [string]
      --json     Return user information as JSON. ...

=== search for productionBranch/isProduction logic in pages deploy ===
node_modules/wrangler/wrangler-dist/cli.js
node_modules/wrangler/wrangler-dist/cli.d.ts
---
isProduction ? "production" : "preview"
isProduction = project.production_branch === branch
isProduction = true
preview deployment
production branch
production branch: 
production branch name:
production branch of your project
production branch. Specify the production branch for your new Pages project when prompted, or re-run with the required information.
production branch suggestion...
production branch. Use --production-branch <branch> to specify the production branch for your Pages project.

=== account id discovery / multiple accounts ===
account_id
account_id === 
account_id ? {
account_id) {
account_id,
account_id, 
account_id:
account_id: 
account_id;
account_id>\
account_id\
account_id}
account_id) > -1, 
account_id}/abuse-reports/${reportType}
account_id}/access/bookmarks
account_id}/access/bookmarks/${bookmarkId}
account_id}/access/custom_pages
account_id}/access/custom_pages/${customPageId}
account_id}/access/gateway_ca
account_id}/access/gateway_ca/${certificateId}
account_id}/access/identity_providers/${identityProviderId}/scim/groups
account_id}/access/identity_providers/${identityProviderId}/scim/users
account_id}/access/keys
account_id}/access/keys/rotate
account_id}/access/logs/access_requests
account_id}/access/logs/scim/updates
account_id}/access/organizations/doh
account_id}/access/policies
account_id}/access/policies/${policyId}
account_id}/access/policy-tests
account_id}/access/policy-tests/${policyTestId}
account_id}/access/policy-tests/${policyTestId}/...

=== isProduction context ===

=== branch default / git detection in pages deploy ===

298961:isProduction = project.production_branch === branch
=== with surrounding lines (byte-based) ===
isProduction = true;
isProduction = project.production_branch === branch;
isProduction ? "production" : "preview";
=== branch determination ===
branch ?? "not set"}, commitHash: ${commitHash ?? "not set"}, commitDirty: ${commitDirty ?? "not set"}`

    maxFileCountAllowedFromClaims = /* @__PURE__ */ __name((token) => {
      if (typeof vitest !== "undefined" && (token === "<<funfetti-auth-jwt>>" || token === "<<funfetti-auth-jwt2>>" || token === "<<aus-completion-token>>")) {
        return MAX_ASSET_COUNT_DEFAULT;
      }
      try {
        const decodedJwt = decodeJwtPayload(token);
        const maxFileCountAllowed = decodedJwt["max_file_count_allowed"];
        if (typeof maxFileCountAllowed == "number") {
          return maxFileCountAllowed;
        }
        return MAX_ASSET_COUNT_DEFAULT;
      } catch (e9) {
        if (e9 instanceof Error) {
          throw new Error(`Invalid token: ${e9.message}`);
        }
        return MAX_ASSET_COUNT_DEFAULT;
      }
    }, "maxFileCountAllowedFromClaims");
    __name(renderProgress, "renderProgress");
  }
});
async function deploy2({
  directory,
  accountId,
  projectName,
  branch,
  skipCaching,
  commitMessage,
  commitHash,
  commitDirty,
  functionsDirectory: ...

301838:let branch
=== find the pages deploy handler that calls deploy2 ===
299984:args.branch

        if (!Object.keys(aliases2).includes(args.path)) {
          throw new Error("unrecognized module: " + args.path);
        }
        return {
          path: aliases2[args.path],
          external: true
        };
      });
    }
  };
}
var init_alias_external = __esm({
  "src/deployment-bundle/esbuild-plugins/alias-external.ts"() {
    init_import_meta_url();
    __name(esbuildAliasExternalPlugin, "esbuildAliasExternalPlugin");
  }
});
function getPagesEnvironmentVariables(projectName) {
  let branch = "local";
  try {
    branch = childProcess.execSync("git rev-parse --abbrev-ref HEAD", {
      encoding: "utf-8",
      stdio: "pipe"
    }).trim();
  } catch {
  }
  let commitSha = "0000000000000000000000000000000000000000";
  try {
    commitSha = childProcess.execSync("git rev-parse HEAD", {
      encoding: "utf-8",
      stdio: "pipe"
    }).trim();
  } catch {
  }
  let shortSha = commitSha.substring(0, 8);
  try {
    shortSha = childProcess.execSync("git rev-parse ...

          description: "The name of your Pages project",
          demandOption: true
        },
        yes: {
          alias: "y",
          type: "boolean",
          description: 'Answer "yes" to confirm project deletion'
        }
      },
      positionalArgs: ["project-name"],
      async handler(args) {
        const config2 = getConfigCache(
          PAGES_CONFIG_CACHE_FILENAME
        );
        const accountId = await requireAuth(config2);
        const confirmed = args.yes || await confirm2(
          `Are you sure you want to delete "${args.projectName}"? This action cannot be undone.`
        );
        if (confirmed) {
          logger2.log("Deleting", args.projectName);
          await fetchResult2(
            COMPLIANCE_REGION_CONFIG_PUBLIC,
            `/accounts/${accountId}/pages/projects/${args.projectName}`,
            { method: "DELETE" }
          );
          logger2.log("Successfully deleted", args.projectName);
        }
      }
    });
  }
});

// ...

    init_dist2();
    init_dist();
    init_deploy3();
    init_cfetch();
    init_commands3();
    init_config4();
    init_config_cache();
    init_create_command();
    init_dialogs();
    init_logger();
    init_metrics2();
    init_output();
    init_user3();
    init_friendly_validator_errors();
    init_constants();
    init_delegate_to_workers();
    init_errors3();
    init_projects2();
    init_prompt_select_project();
    init_run_workers_deploy();
    init_utils13();
    pagesDeploymentCreateCommand = createAlias({
      aliasOf: "wrangler pages deploy"
    });
    pagesPublishCommand = createAlias({
      aliasOf: "wrangler pages deploy",
      metadata: {
        deprecated: true,
        hidden: true
      }
    });
    pagesDeployCommand = createCommand({
      metadata: {
        description: "Deploy a directory of static assets as a Pages deployment",
        status: "stable",
        owner: "Workers: Authoring and Testing",
        hideGlobalFlags: ["config", ...

        const accountId = await requireAuth({
          ...configCache2,
          ...envAccountId ? { account_id: envAccountId } : {}
        });
        let projectName = args.projectName ?? config2?.name ?? configCache2.project_name;
        let isExistingProject = true;
        if (projectName) {
          try {
            await fetchResult2(
              COMPLIANCE_REGION_CONFIG_PUBLIC,
              `/accounts/${accountId}/pages/projects/${projectName}`
            );
          } catch (err) {
            if (err.code !== 8000007) {
              maybeWarnAboutIgnoredConfigFile(configPath, config2);
              throw err;
            } else {
              isExistingProject = false;
            }
          }
        }
        const delegation = await maybeDelegatePagesToWorkers({
          command: "deploy",
          projectPath: process.cwd(),
          assetsDirectory: directory,
          accountHasPagesProjects: /* @__PURE__ */ __name(async () => (await listProjects({ ...

                  })
                }
              );
              saveToConfigCache(PAGES_CONFIG_CACHE_FILENAME, {
                account_id: accountId,
                project_name: projectName
              });
              logger2.log(`\u2728 Successfully created the '${projectName}' project.`);
              sendMetricsEvent("create pages project");
              break;
            }
          }
        }
        if (projectName && !isExistingProject && !isInteractive4) {
          let message = `The Pages project "${projectName}" does not exist.`;
          if (configPath && config2 === void 0) {
            message += `
A configuration file was found at ${configPath} that does not appear to be for a Pages project (missing "pages_build_output_dir"). Did you mean to run \`wrangler deploy\` (to deploy a Worker) instead?`;
          } else {
            message += `
Maybe you intended to deploy a Worker project instead? ...

            if (!commitHash) {
              commitHash = childProcess.execSync(`git rev-parse HEAD`).toString().trim();
              logger2.debug(`pages deploy: Detected commit hash: "${commitHash}"`);
            } else {
              logger2.debug(
                `pages deploy: Using provided commit hash: "${commitHash}"`
              );
            }
            if (!commitMessage) {
              commitMessage = childProcess.execFileSync("git", [
                "show",
                "-s",
                "--format=%B",
                commitHash
              ]).toString().trim();
              logger2.debug(
                `pages deploy: Detected commit message: "${commitMessage.substring(0, 50)}${commitMessage.length > 50 ? "..." : ""}"`
              );
            } else {
              logger2.debug(`pages deploy: Using provided commit message`);
            }
          } catch (err) {
            logger2.debug(
              `pages deploy: Failed to detect git ...

=== requireAuth / account discovery ===
=== 'More than one account' full ===
More than one account available but unable to select one in non-interactive mode.

112612:          `More than one account available but unable to select one in non-interactive mode.

In a non-interactive environment, it is mandatory to specify an account ID, either by assigning its value to CLOUDFLARE_ACCOUNT_ID, or as \`account_id\` in your ${descriptor.getConfigFileLabel()} file.
Alternatively, try running \`${descriptor.commands.login}\` to re-authenticate.`,
        { telemetryMessage: "user account fetch empty" }
      );
    }
    return usableAccounts;
  }
  __name(fetchAllAccounts2, "fetchAllAccounts");
  __name4(fetchAllAccounts2, "fetchAllAccounts");
  function getActiveAccountId(config2) {
    const temporaryAccount = oauthFlow.getActiveTemporaryAccount();
    if (temporaryAccount) {
      return temporaryAccount.account.id;
    }
    if (config2.account_id) {
      return config2.account_id;
    }
    const envAccountId = getCloudflareAccountIdFromEnv();
    if (envAccountId) {
      return envAccountId;
    }
    return getAccountFromCache2()?.id;
  }
  __name(getActiveAccountId, "getActiveAccountId");
  __name4(getActiveAccountId, ...

=== auth mechanisms: global API key + email ===
=== getAuthFromEnv-ish ===

=== pages project create handler default production branch ===
299764:        description: "Create a new Cloudflare Pages project",

=== global key search variants ===
     16 apiEmail
      3 ApiEmail
      6 authEmail
      3 AuthEmail
     10 authKey
     15 AuthKey
      1 CF_API_KEY
      6 CLOUDFLARE_API_KEY
      5 CLOUDFLARE_EMAIL
      3 globalApiKey
      2 Global API Key
      2 x-auth-email
      5 X-Auth-Email
      2 x-auth-key
      5 X-Auth-Key

      return results;
    }, "listProjects");
    pagesProjectCreateCommand = createCommand({
      metadata: {
        description: "Create a new Cloudflare Pages project",
        status: "stable",
        owner: "Workers: Authoring and Testing",
        hideGlobalFlags: ["config", "env"]
      },
      behaviour: {
        provideConfig: false
      },
      args: {
        "project-name": {
          type: "string",
          demandOption: true,
          description: "The name of your Pages project"
        },
        "production-branch": {
          type: "string",
          description: "The name of the production branch of your project"
        },
        "compatibility-flags": {
          description: "Flags to use for compatibility checks",
          alias: "compatibility-flag",
          type: "string",
          requiresArg: true,
          array: true
        },
        "compatibility-date": {
          description: "Date to use for compatibility checks",
          type: ...

        }
        if (!projectName) {
          throw new UserError(
            "Missing Pages project name. Provide the project name as a positional argument: wrangler pages project create <name>.",
            { telemetryMessage: "pages projects create missing project name" }
          );
        }
        if (!productionBranch && isInteractive4) {
          logger2.debug(
            "pages project create: Detecting git repository for production branch suggestion..."
          );
          let isGitDir = true;
          try {
            childProcess.execSync(`git rev-parse --is-inside-work-tree`, {
              stdio: "ignore"
            });
            logger2.debug("pages project create: Git repository detected");
          } catch (err) {
            isGitDir = false;
            logger2.debug(
              `pages project create: Not a git repository: ${err instanceof Error ? err.message : String(err)}`
            );
          }
          if (isGitDir) {
            try {
 ...

108093:       * @param {string | null | undefined} [opts.apiKey=process.env['CLOUDFLARE_API_KEY'] ?? null]
108105:      constructor({ baseURL = readEnv("CLOUDFLARE_BASE_URL"), apiVersion = null, apiToken = readEnv("CLOUDFLARE_API_TOKEN") ?? null, apiKey = readEnv("CLOUDFLARE_API_KEY") ?? null, apiEmail = readEnv("CLOUDFLARE_EMAIL") ?? null, userServiceKey = readEnv("CLOUDFLARE_API_USER_SERVICE_KEY") ?? null, ...opts } = {}) {
111004:      variableName: "CLOUDFLARE_API_KEY",

    fs6.rmSync(encryptedPath);
  }
  return { backendAvailable: false, encryptedFileExisted };
}
var import_undici2, hasWarnedAboutDeprecatedV1ApiToken, getCloudflareAPITokenFromEnv, getCloudflareGlobalAuthKeyFromEnv, getCloudflareGlobalAuthEmailFromEnv, getAuthDomainFromEnv, getAuthUrlFromEnv, getTokenUrlFromEnv, getRevokeUrlFromEnv, getCloudflareAccountIdFromEnv, getAccessClientIdFromEnv, getAccessClientSecretFromEnv, getCfAuthorizationTokenFromEnv, getCloudflareAuthUseKeyringFromEnv, headersCache, usesAccessCache, RECOMMENDED_CODE_VERIFIER_LENGTH, RECOMMENDED_STATE_LENGTH, PKCE_CHARSET, generateAuthUrl, POW_MAX_ITERATIONS, TEMPORARY_TERMS_URLS, TEMPORARY_TERMS_PROMPT, TEMPORARY_TERMS_NOTICE, TEMPORARY_TERMS_ERROR, esm_default3, ErrorOAuth2, ErrorUnknown, ErrorNoAuthCode, ErrorInvalidReturnedStateParam, ErrorInvalidJson, ErrorInvalidScope, ErrorInvalidRequest, ErrorInvalidToken, ErrorAuthenticationGrant, ErrorUnauthorizedClient, ErrorAccessDenied, ErrorUnsupportedResponseType, ...

---
title: System environment variables
description: Local environment variables that can change Wrangler's behavior.
image: https://developers.cloudflare.com/dev-products-preview.png
---

> Documentation Index  
> Fetch the complete documentation index at: https://developers.cloudflare.com/workers/llms.txt  
> Use this file to discover all available pages before exploring further. 

[Skip to content](#%5Ftop) 

# System environment variables

System environment variables are local environment variables that can change Wrangler's behavior. There are three ways to set system environment variables:

1. Create an `.env` file in your project directory. Set the values of your environment variables in your [.env](https://developers.cloudflare.com/workers/wrangler/system-environment-variables/#example-env-file) file. This is the recommended way to set these variables, as it persists the values between Wrangler sessions.
2. Inline the values in your Wrangler command. ...

---
title: Commands
description: Create, develop, and deploy your Cloudflare Workers with Wrangler commands.
image: https://developers.cloudflare.com/dev-products-preview.png
---

> Documentation Index  
> Fetch the complete documentation index at: https://developers.cloudflare.com/workers/llms.txt  
> Use this file to discover all available pages before exploring further. 

[Skip to content](#%5Ftop) 

# Commands

[Wrangler](https://developers.cloudflare.com/workers/wrangler/) offers a number of commands to manage your Cloudflare Workers.

## Workers commands

The core Wrangler commands for creating, developing, and deploying Workers are on the [Workers commands page](https://developers.cloudflare.com/workers/wrangler/commands/workers/). This includes `wrangler dev`, `wrangler deploy`, `wrangler versions`, and more.

## All commands

* [ Artifacts ](https://developers.cloudflare.com/workers/wrangler/commands/artifacts/)
* [ Browser ...

---
title: Pages
description: Wrangler commands for configuring Cloudflare Pages.
image: https://developers.cloudflare.com/dev-products-preview.png
---

> Documentation Index  
> Fetch the complete documentation index at: https://developers.cloudflare.com/workers/llms.txt  
> Use this file to discover all available pages before exploring further. 

[Skip to content](#%5Ftop) 

# Pages

Configure [Cloudflare Pages](https://developers.cloudflare.com/pages/) using Wrangler.

## `pages dev`

Develop your full-stack Pages application locally

* [  npm ](#tab-panel-13363)
* [  pnpm ](#tab-panel-13364)
* [  yarn ](#tab-panel-13365)

```sh
npx wrangler pages dev [DIRECTORY] [COMMAND]
```

```sh
pnpm wrangler pages dev [DIRECTORY] [COMMAND]
```

```sh
yarn wrangler pages dev [DIRECTORY] [COMMAND]
```

* `[DIRECTORY]` ` string `  
The directory of static assets to serve
* `[COMMAND]` ` string `  
The proxy command to run \[deprecated\]
* `--compatibility-date` ` string `  
Date to use for ...

---
title: Branch deployment controls
description: Control which branches trigger automatic deployments in your Cloudflare Pages project.
image: https://developers.cloudflare.com/dev-products-preview.png
---

> Documentation Index  
> Fetch the complete documentation index at: https://developers.cloudflare.com/pages/llms.txt  
> Use this file to discover all available pages before exploring further. 

[Skip to content](#%5Ftop) 

# Branch deployment controls

When connected to your git repository, Pages allows you to control which environments and branches you would like to automatically deploy to. By default, Pages will trigger a deployment any time you commit to either your production or preview environment. However, with branch deployment controls, you can configure automatic deployments to suit your preference on a per project basis.

## Production branch control

Direct Upload

If your project is a [Direct ...

Found 40 matches
/home/byk/Code/getsentry/craft/src/targets/cloudflare.ts:
  Line 29:   'CLOUDFLARE_API_TOKEN',

  Line 30:   'CLOUDFLARE_ACCOUNT_ID',

  Line 51: /** Default production branch passed to `wrangler pages deploy --branch` */

  Line 66:   productionBranch?: string;

  Line 78:    * The Cloudflare Pages project's production branch name. Passed to

  Line 79:    * `wrangler pages deploy --branch` so a release publish always targets the

  Line 80:    * production environment. This is the Cloudflare environment selector, NOT

  Line 83:   productionBranch: string;

  Line 149:     // environment -- which includes CLOUDFLARE_API_TOKEN/ACCOUNT_ID. Reject

  Line 153:       productionBranch: config.productionBranch,

  Line 171:       productionBranch: config.productionBranch || DEFAULT_PRODUCTION_BRANCH,

  Line 213:     // Pages deploy. `--branch <productionBranch>` forces a production

  Line 222:       '--branch',

  Line 223:       ...

<path>/home/byk/Code/getsentry/craft/src/targets/cloudflare.ts</path>
<type>file</type>
<content>
20: import { BaseArtifactProvider } from '../artifact_providers/base';
21: 
22: /**
23:  * Secrets required to authenticate with the Cloudflare API.
24:  *
25:  * Exported so tests (and documentation tooling) can reference the canonical
26:  * list of environment variables this target consumes.
27:  */
28: export const targetSecrets = [
29:   'CLOUDFLARE_API_TOKEN',
30:   'CLOUDFLARE_ACCOUNT_ID',
31: ] as const;
32: type SecretsType = (typeof targetSecrets)[number];
33: 
34: /** Wrangler executable configuration */
35: const WRANGLER_CONFIG = {
36:   name: 'wrangler',
37:   envVar: 'WRANGLER_BIN',
38:   errorHint:
39:     'Install wrangler (npm install -g wrangler) or set WRANGLER_BIN to its path',
40: } as const;
41: 
42: /** How the artifact should be deployed to Cloudflare */
43: type CloudflareDeployType = 'pages' | 'worker';
44: 
45: /** Valid deploy types */
46: const DEPLOY_TYPES: ...

<path>/home/byk/Code/getsentry/craft/src/targets/cloudflare.ts</path>
<type>file</type>
<content>
140: 
141:     if (deployType === 'pages' && !config.projectName) {
142:       throw new ConfigurationError(
143:         '[cloudflare] "projectName" is required when deployType is "pages"',
144:       );
145:     }
146: 
147:     // These config values are passed to wrangler as command-line arguments.
148:     // spawnProcess() expands args of the exact form "${VAR}" using the
149:     // environment -- which includes CLOUDFLARE_API_TOKEN/ACCOUNT_ID. Reject
150:     // such values so a config string can never be expanded into a secret.
151:     for (const [key, value] of Object.entries({
152:       projectName: config.projectName,
153:       productionBranch: config.productionBranch,
154:       workingDir: config.workingDir,
155:     })) {
156:       if (typeof value === 'string' && /^\$\{.*\}$/.test(value)) {
157:         throw new ConfigurationError(
158:           `[cloudflare] ...