wrangler 4.20.5 → 4.21.0

package/wrangler-dist/cli.js

@@ -20469,7 +20469,7 @@ var init_UpdateApplicationRolloutRequest = __esm({
 });
 
 // ../containers-shared/src/client/core/request.ts
-var import_undici, isDefined, isString, isStringWithValue, isBlob, base64, getQueryString, getUrl, getFormData, resolve5, getHeaders, getRequestBody, isResponseSchemaV4, sendRequest, getResponseHeader, getResponseBody, catchErrorCodes, request;
+var import_undici, isDefined, isString, isStringWithValue, isBlob, base64, getQueryString, getUrl, getFormData, resolve5, getHeaders, getRequestBody, isResponseSchemaV4, parseResponseSchemaV4, sendRequest, getResponseHeader, getResponseBody, catchErrorCodes, request;
 var init_request = __esm({
   "../containers-shared/src/client/core/request.ts"() {
     init_import_meta_url();
@@ -20615,6 +20615,27 @@ var init_request = __esm({
     isResponseSchemaV4 = /* @__PURE__ */ __name((config, _options) => {
       return config.BASE.endsWith("/containers");
     }, "isResponseSchemaV4");
+    parseResponseSchemaV4 = /* @__PURE__ */ __name((url4, response, responseHeader, responseBody) => {
+      const fetchResult2 = typeof responseBody === "object" ? responseBody : JSON.parse(responseBody);
+      const ok = response.ok && fetchResult2.success;
+      let result;
+      if (ok) {
+        if (fetchResult2.result !== void 0) {
+          result = fetchResult2.result;
+        } else {
+          result = {};
+        }
+      } else {
+        result = { error: fetchResult2.errors?.[0].message };
+      }
+      return {
+        url: url4,
+        ok,
+        status: response.status,
+        statusText: response.statusText,
+        body: responseHeader ?? result
+      };
+    }, "parseResponseSchemaV4");
     sendRequest = /* @__PURE__ */ __name(async (config, options, url4, body, formData, headers, onCancel) => {
       const controller = new AbortController();
       const request4 = {
@@ -20701,23 +20722,23 @@ var init_request = __esm({
               response,
               options.responseHeader
             );
-            const parseResponseSchemaV4 = /* @__PURE__ */ __name((body2) => {
-              const fetchResult2 = body2;
-              return {
+            let result;
+            if (isResponseSchemaV4(config, options)) {
+              result = parseResponseSchemaV4(
+                url4,
+                response,
+                responseHeader,
+                responseBody
+              );
+            } else {
+              result = {
                 url: url4,
-                ok: response.ok && fetchResult2.success,
+                ok: response.ok,
                 status: response.status,
                 statusText: response.statusText,
-                body: responseHeader ?? fetchResult2.result
+                body: responseHeader ?? responseBody
               };
-            }, "parseResponseSchemaV4");
-            const result = isResponseSchemaV4(config, options) ? parseResponseSchemaV4(responseBody) : {
-              url: url4,
-              ok: response.ok,
-              status: response.status,
-              statusText: response.statusText,
-              body: responseHeader ?? responseBody
-            };
+            }
             catchErrorCodes(options, result);
             resolve24(result.body);
           }
@@ -29487,7 +29508,7 @@ var name, version;
 var init_package = __esm({
   "package.json"() {
     name = "wrangler";
-    version = "4.20.5";
+    version = "4.21.0";
   }
 });
 
@@ -37670,6 +37691,11 @@ function applyPythonConfig(config, args) {
     if (!config.rules.some((rule) => rule.type === "PythonModule")) {
       config.rules.push({ type: "PythonModule", globs: ["**/*.py"] });
     }
+    if (!config.rules.some(
+      (rule) => rule.type === "Data" && rule.globs.includes("vendor/**/*.so")
+    )) {
+      config.rules.push({ type: "Data", globs: ["vendor/**/*.so"] });
+    }
     if (!config.compatibility_flags.includes("python_workers")) {
       throw new UserError(
         "The `python_workers` compatibility flag is required to use Python."
@@ -49290,9 +49316,6 @@ function getAuthFromEnv() {
     return { apiToken };
   }
 }
-function setLoginScopeKeys(scopes) {
-  DefaultScopeKeys = scopes;
-}
 function validateScopeKeys(scopes) {
   return scopes.every((scope) => scope in DefaultScopes);
 }
@@ -49760,7 +49783,7 @@ function listScopes(message = "\u{1F481} Available scopes:") {
   logger.log(message);
   const data = DefaultScopeKeys.map((scope) => ({
     Scope: scope,
-    Description: AllScopes[scope]
+    Description: DefaultScopes[scope]
   }));
   logger.table(data);
 }
@@ -49871,7 +49894,7 @@ async function getJSONFromResponse(response) {
     );
   }
 }
-var import_node_assert2, import_node_crypto2, import_node_fs6, import_node_http, import_node_path12, import_node_url4, import_node_util2, import_toml3, import_undici3, USER_AUTH_CONFIG_PATH, DefaultScopes, OptionalScopes, AllScopes, DefaultScopeKeys, LocalState, ErrorOAuth2, ErrorUnknown, ErrorNoAuthCode, ErrorInvalidReturnedStateParam, ErrorInvalidJson, ErrorInvalidScope, ErrorInvalidRequest, ErrorInvalidToken, ErrorAuthenticationGrant, ErrorUnauthorizedClient, ErrorAccessDenied, ErrorUnsupportedResponseType, ErrorServerError, ErrorTemporarilyUnavailable, ErrorAccessTokenResponse, ErrorInvalidClient, ErrorInvalidGrant, ErrorUnsupportedGrantType, RawErrorToErrorClassMap, RECOMMENDED_CODE_VERIFIER_LENGTH, RECOMMENDED_STATE_LENGTH, PKCE_CHARSET;
+var import_node_assert2, import_node_crypto2, import_node_fs6, import_node_http, import_node_path12, import_node_url4, import_node_util2, import_toml3, import_undici3, USER_AUTH_CONFIG_PATH, DefaultScopes, DefaultScopeKeys, LocalState, ErrorOAuth2, ErrorUnknown, ErrorNoAuthCode, ErrorInvalidReturnedStateParam, ErrorInvalidJson, ErrorInvalidScope, ErrorInvalidRequest, ErrorInvalidToken, ErrorAuthenticationGrant, ErrorUnauthorizedClient, ErrorAccessDenied, ErrorUnsupportedResponseType, ErrorServerError, ErrorTemporarilyUnavailable, ErrorAccessTokenResponse, ErrorInvalidClient, ErrorInvalidGrant, ErrorUnsupportedGrantType, RawErrorToErrorClassMap, RECOMMENDED_CODE_VERIFIER_LENGTH, RECOMMENDED_STATE_LENGTH, PKCE_CHARSET;
 var init_user = __esm({
   "src/user/user.ts"() {
     init_import_meta_url();
@@ -49917,17 +49940,11 @@ var init_user = __esm({
       "ai:write": "See and change Workers AI catalog and assets",
       "queues:write": "See and change Cloudflare Queues settings and data",
       "pipelines:write": "See and change Cloudflare Pipelines configurations and data",
-      "secrets_store:write": "See and change secrets + stores within the Secrets Store"
-    };
-    OptionalScopes = {
+      "secrets_store:write": "See and change secrets + stores within the Secrets Store",
+      "containers:write": "Manage Workers Containers",
       "cloudchamber:write": "Manage Cloudchamber"
     };
-    AllScopes = {
-      ...DefaultScopes,
-      ...OptionalScopes
-    };
     DefaultScopeKeys = Object.keys(DefaultScopes);
-    __name(setLoginScopeKeys, "setLoginScopeKeys");
     __name(validateScopeKeys, "validateScopeKeys");
     __name(getCallbackUrl, "getCallbackUrl");
     LocalState = {
@@ -52126,6 +52143,16 @@ function isValidPythonPackageName(name2) {
   const regex2 = /^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$/i;
   return regex2.test(name2);
 }
+function filterPythonVendorModules(isPythonEntrypoint, modules) {
+  if (!isPythonEntrypoint) {
+    return modules;
+  }
+  return modules.filter((m6) => !m6.name.startsWith("vendor/"));
+}
+function getPythonVendorModulesSize(modules) {
+  const vendorModules = modules.filter((m6) => m6.name.startsWith("vendor/"));
+  return vendorModules.reduce((total, m6) => total + m6.content.length, 0);
+}
 async function findAdditionalModules(entry, rules, attachSourcemaps = false) {
   const files = getFiles(
     entry.configPath,
@@ -52176,24 +52203,37 @@ async function findAdditionalModules(entry, rules, attachSourcemaps = false) {
   }
   if (modules.length > 0) {
     logger.info(`Attaching additional modules:`);
+    const filteredModules = filterPythonVendorModules(
+      isPythonEntrypoint,
+      modules
+    );
+    const vendorModulesSize = getPythonVendorModulesSize(modules);
     const totalSize = modules.reduce(
       (previous, { content }) => previous + content.length,
       0
     );
-    logger.table([
-      ...modules.map(({ name: name2, type, content }) => {
+    const tableEntries = [
+      ...filteredModules.map(({ name: name2, type, content }) => {
         return {
           Name: name2,
           Type: type ?? "",
           Size: type === "python-requirement" ? "" : `${(content.length / 1024).toFixed(2)} KiB`
         };
-      }),
-      {
-        Name: `Total (${modules.length} module${modules.length > 1 ? "s" : ""})`,
+      })
+    ];
+    if (isPythonEntrypoint && vendorModulesSize > 0) {
+      tableEntries.push({
+        Name: "Vendored Modules",
         Type: "",
-        Size: `${(totalSize / 1024).toFixed(2)} KiB`
-      }
-    ]);
+        Size: `${(vendorModulesSize / 1024).toFixed(2)} KiB`
+      });
+    }
+    tableEntries.push({
+      Name: `Total (${modules.length} module${modules.length > 1 ? "s" : ""})`,
+      Type: "",
+      Size: `${(totalSize / 1024).toFixed(2)} KiB`
+    });
+    logger.table(tableEntries);
   }
   return modules;
 }
@@ -52286,6 +52326,8 @@ var init_find_additional_modules = __esm({
     init_source_maps();
     __name(getFiles, "getFiles");
     __name(isValidPythonPackageName, "isValidPythonPackageName");
+    __name(filterPythonVendorModules, "filterPythonVendorModules");
+    __name(getPythonVendorModulesSize, "getPythonVendorModulesSize");
     __name(findAdditionalModules, "findAdditionalModules");
     __name(matchFiles, "matchFiles");
     __name(findAdditionalModuleWatchDirs, "findAdditionalModuleWatchDirs");
@@ -53725,7 +53767,7 @@ var require_update_check = __commonJS({
     var { tmpdir } = require("os");
     var registryUrl = require_registry_url();
     var writeFile11 = promisify3(fs24.writeFile);
-    var mkdir7 = promisify3(fs24.mkdir);
+    var mkdir6 = promisify3(fs24.mkdir);
     var readFile18 = promisify3(fs24.readFile);
     var compareVersions = /* @__PURE__ */ __name((a5, b6) => a5.localeCompare(b6, "en-US", { numeric: true }), "compareVersions");
     var encode = /* @__PURE__ */ __name((value) => encodeURIComponent(value).replace(/^%40/, "@"), "encode");
@@ -53733,7 +53775,7 @@ var require_update_check = __commonJS({
       const rootDir = tmpdir();
       const subDir = join24(rootDir, "update-check");
       if (!fs24.existsSync(subDir)) {
-        await mkdir7(subDir);
+        await mkdir6(subDir);
       }
       let name2 = `${details.name}-${distTag}.json`;
       if (details.scope) {
@@ -59660,139 +59702,6 @@ Ensure all assets in your assets directory "${dir}" conform with the Workers max
   }
 });
 
-// src/versions/api.ts
-async function fetchVersion(complianceConfig, accountId, workerName, versionId, versionCache) {
-  const cachedVersion = versionCache?.get(versionId);
-  if (cachedVersion) {
-    return cachedVersion;
-  }
-  const version5 = await fetchResult(
-    complianceConfig,
-    `/accounts/${accountId}/workers/scripts/${workerName}/versions/${versionId}`
-  );
-  versionCache?.set(version5.id, version5);
-  return version5;
-}
-async function fetchVersions(complianceConfig, accountId, workerName, versionCache, ...versionIds) {
-  return Promise.all(
-    versionIds.map(
-      (versionId) => fetchVersion(
-        complianceConfig,
-        accountId,
-        workerName,
-        versionId,
-        versionCache
-      )
-    )
-  );
-}
-async function fetchLatestDeployments(complianceConfig, accountId, workerName) {
-  const { deployments } = await fetchResult(
-    complianceConfig,
-    `/accounts/${accountId}/workers/scripts/${workerName}/deployments`
-  );
-  return deployments;
-}
-async function fetchLatestDeployment(complianceConfig, accountId, workerName) {
-  const deployments = await fetchLatestDeployments(
-    complianceConfig,
-    accountId,
-    workerName
-  );
-  return deployments.at(0);
-}
-async function fetchDeploymentVersions(complianceConfig, accountId, workerName, deployment, versionCache) {
-  if (!deployment) {
-    return [[], /* @__PURE__ */ new Map()];
-  }
-  const versionTraffic = new Map(
-    deployment.versions.map((v7) => [v7.version_id, v7.percentage])
-  );
-  const versions2 = await fetchVersions(
-    complianceConfig,
-    accountId,
-    workerName,
-    versionCache,
-    ...versionTraffic.keys()
-  );
-  return [versions2, versionTraffic];
-}
-async function fetchDeployableVersions(complianceConfig, accountId, workerName, versionCache) {
-  const { items: versions2 } = await fetchResult(
-    complianceConfig,
-    `/accounts/${accountId}/workers/scripts/${workerName}/versions?deployable=true`
-  );
-  for (const version5 of versions2) {
-    versionCache.set(version5.id, version5);
-  }
-  return versions2;
-}
-async function createDeployment(complianceConfig, accountId, workerName, versionTraffic, message, force) {
-  return await fetchResult(
-    complianceConfig,
-    `/accounts/${accountId}/workers/scripts/${workerName}/deployments${force ? "?force=true" : ""}`,
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        strategy: "percentage",
-        versions: Array.from(versionTraffic).map(
-          ([version_id, percentage]) => ({ version_id, percentage })
-        ),
-        annotations: {
-          "workers/message": message
-        }
-      })
-    }
-  );
-}
-async function patchNonVersionedScriptSettings(complianceConfig, accountId, workerName, settings) {
-  const res = await fetchResult(
-    complianceConfig,
-    `/accounts/${accountId}/workers/scripts/${workerName}/script-settings`,
-    {
-      method: "PATCH",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(settings)
-    }
-  );
-  return res;
-}
-var init_api = __esm({
-  "src/versions/api.ts"() {
-    init_import_meta_url();
-    init_cfetch();
-    __name(fetchVersion, "fetchVersion");
-    __name(fetchVersions, "fetchVersions");
-    __name(fetchLatestDeployments, "fetchLatestDeployments");
-    __name(fetchLatestDeployment, "fetchLatestDeployment");
-    __name(fetchDeploymentVersions, "fetchDeploymentVersions");
-    __name(fetchDeployableVersions, "fetchDeployableVersions");
-    __name(createDeployment, "createDeployment");
-    __name(patchNonVersionedScriptSettings, "patchNonVersionedScriptSettings");
-  }
-});
-
-// ../cli/args.ts
-var processArgument;
-var init_args = __esm({
-  "../cli/args.ts"() {
-    init_import_meta_url();
-    init_interactive();
-    processArgument = /* @__PURE__ */ __name(async (args, name2, promptConfig) => {
-      const value = args[name2];
-      const result = await inputPrompt({
-        ...promptConfig,
-        // Accept the default value if the arg is already set
-        acceptDefault: promptConfig.acceptDefault ?? value !== void 0,
-        defaultValue: value ?? promptConfig.defaultValue
-      });
-      args[name2] = result;
-      return result;
-    }, "processArgument");
-  }
-});
-
 // src/core/helpers.ts
 function demandOneOfOption(...options) {
   return function(argv) {
@@ -60518,15 +60427,16 @@ function parseImageName(value) {
   }
   return { name: name2, tag, digest };
 }
-function handleFailure(command2, cb2) {
+function handleFailure(command2, cb2, scope) {
   return async (args) => {
     try {
       if (!args.json) {
         await printWranglerBanner();
-        logger.warn(constructStatusMessage(command2, "alpha"));
+        const commandStatus = command2.includes("cloudchamber") ? "alpha" : "open-beta";
+        logger.warn(constructStatusMessage(command2, commandStatus));
       }
       const config = readConfig(args);
-      await fillOpenAPIConfiguration(config, args.json);
+      await fillOpenAPIConfiguration(config, args.json, scope);
       await cb2(args, config);
     } catch (err) {
       if (!args.json || !isNonInteractiveOrCI()) {
@@ -60547,10 +60457,10 @@ function handleFailure(command2, cb2) {
 async function loadAccountSpinner({ json }) {
   await promiseSpinner(loadAccount(), { message: "Loading account", json });
 }
-async function getAPIUrl(config) {
+async function getAPIUrl(config, accountId, scope) {
   const api = getCloudflareApiBaseUrl(config);
-  const accountId = config.account_id || await getAccountId(config);
-  return `${api}/accounts/${accountId}/cloudchamber`;
+  const endpoint = scope === cloudchamberScope ? "cloudchamber" : "containers";
+  return `${api}/accounts/${accountId}/${endpoint}`;
 }
 async function promiseSpinner(promise, {
   json = false,
@@ -60571,73 +60481,21 @@ async function promiseSpinner(promise, {
   stop();
   return t7;
 }
-async function fillOpenAPIConfiguration(config, json) {
+async function fillOpenAPIConfiguration(config, _json2, scope) {
   const headers = OpenAPI.HEADERS !== void 0 ? { ...OpenAPI.HEADERS } : {};
-  if (Object.keys(getConfigCache("wrangler-account.json")).length === 0) {
-    await wrap2((0, import_promises12.mkdir)("node_modules", {}));
-    purgeConfigCaches();
-  }
-  const scopes = getScopes();
-  const needsCloudchamberToken = !scopes?.find(
-    (scope) => scope === "cloudchamber:write"
-  );
-  const cloudchamberScope = ["cloudchamber:write"];
-  const scopesToSet = scopes == void 0 ? cloudchamberScope.concat(DefaultScopeKeys) : cloudchamberScope.concat(scopes);
-  if (getAuthFromEnv() && needsCloudchamberToken) {
-    setLoginScopeKeys(scopesToSet);
-    reinitialiseAuthTokens({
-      expiration_time: "2300-01-01:00:00:00+00:00",
-      oauth_token: "_"
-    });
-  } else {
-    if (needsCloudchamberToken && scopes) {
-      logRaw(
-        status.warning + " We need to re-authenticate to add a cloudchamber token..."
-      );
-      await getAccountId(config);
-      const account = getAccountFromCache();
-      config.account_id = account?.id ?? config.account_id;
-      await promiseSpinner(logout(), { json, message: "Revoking token" });
-      purgeConfigCaches();
-      reinitialiseAuthTokens({});
-    }
-    setLoginScopeKeys(scopesToSet);
-    const [, err2] = await wrap2(requireAuth(config));
-    if (err2) {
-      throw new UserError(
-        `authenticating with the Cloudflare API: ${err2.message}`
-      );
-    }
-  }
-  const token = getAPIToken();
-  if (!token) {
-    throw new UserError("unexpected apiToken not existing in credentials");
-  }
-  const val2 = "apiToken" in token ? token.apiToken : null;
-  if (!val2) {
-    throw new UserError(
-      "we don't allow for authKey/email credentials, use `wrangler login` or CLOUDFLARE_API_TOKEN env variable to authenticate"
-    );
-  }
-  headers["Authorization"] = `Bearer ${val2}`;
-  headers["User-Agent"] = `wrangler/${version}`;
+  const accountId = await requireAuth(config);
+  const auth = requireApiToken();
+  addAuthorizationHeaderIfUnspecified(headers, auth);
+  addUserAgent(headers);
   OpenAPI.CREDENTIALS = "omit";
   if (OpenAPI.BASE.length === 0) {
-    const [base, errApiURL] = await wrap2(getAPIUrl(config));
+    const [base, errApiURL] = await wrap2(getAPIUrl(config, accountId, scope));
     if (errApiURL) {
       throw new UserError("getting the API url: " + errApiURL.message);
     }
     OpenAPI.BASE = base;
   }
   OpenAPI.HEADERS = headers;
-  const [, err] = await wrap2(loadAccountSpinner({ json }));
-  if (err) {
-    let message = err.message;
-    if (json && err instanceof ApiError) {
-      message = JSON.stringify(err);
-    }
-    throw new UserError("Loading account failed: " + message);
-  }
 }
 function interactWithUser(config) {
   return !config.json && !isNonInteractiveOrCI();
@@ -60979,18 +60837,16 @@ function cleanForInstanceType(app) {
   delete app.configuration.vcpu;
   return app;
 }
-var import_promises12, imageRe;
+var cloudchamberScope, imageRe;
 var init_common = __esm({
   "src/cloudchamber/common.ts"() {
     init_import_meta_url();
-    import_promises12 = require("fs/promises");
     init_cli();
     init_colors();
     init_interactive();
     init_containers_shared();
-    init_package();
+    init_internal();
     init_config2();
-    init_config_cache();
     init_CommandRegistry();
     init_misc_variables();
     init_errors();
@@ -61001,6 +60857,7 @@ var init_common = __esm({
     init_parse();
     init_wrap();
     init_locations();
+    cloudchamberScope = "cloudchamber:write";
     imageRe = (() => {
       const alphaNumeric = "[a-z0-9]+";
       const separator = "(?:\\.|_|__|-+)";
@@ -61037,6 +60894,830 @@ var init_common = __esm({
   }
 });
 
+// src/cloudchamber/build.ts
+function buildYargs(yargs) {
+  return yargs.positional("PATH", {
+    type: "string",
+    describe: "Path for the directory containing the Dockerfile to build",
+    demandOption: true
+  }).option("tag", {
+    alias: "t",
+    type: "string",
+    demandOption: true,
+    describe: 'Name and optionally a tag (format: "name:tag")'
+  }).option("path-to-docker", {
+    type: "string",
+    default: "docker",
+    describe: "Path to your docker binary if it's not on $PATH",
+    demandOption: false
+  }).option("push", {
+    alias: "p",
+    type: "boolean",
+    describe: "Push the built image to Cloudflare's managed registry",
+    default: false
+  }).option("platform", {
+    type: "string",
+    default: "linux/amd64",
+    describe: "Platform to build for. Defaults to the architecture support by Workers (linux/amd64)",
+    demandOption: false
+  });
+}
+function pushYargs(yargs) {
+  return yargs.option("path-to-docker", {
+    type: "string",
+    default: "docker",
+    describe: "Path to your docker binary if it's not on $PATH",
+    demandOption: false
+  }).positional("TAG", { type: "string", demandOption: true });
+}
+async function buildAndMaybePush(args, pathToDocker, push, containerConfig) {
+  try {
+    const account = await loadAccount();
+    const cloudflareAccountID = account.external_account_id;
+    const imageTag = getCloudflareRegistryWithAccountNamespace(
+      cloudflareAccountID,
+      args.tag
+    );
+    const { buildCmd, dockerfile } = await constructBuildCommand(
+      {
+        tag: imageTag,
+        pathToDockerfile: args.pathToDockerfile,
+        buildContext: args.buildContext,
+        args: args.args,
+        platform: args.platform,
+        setNetworkToHost: Boolean(getCIOverrideNetworkModeHost())
+      },
+      logger
+    );
+    await dockerBuild(pathToDocker, {
+      buildCmd,
+      dockerfile
+    });
+    const inspectOutput = await dockerImageInspect(pathToDocker, {
+      imageTag,
+      formatString: "{{ .Size }} {{ len .RootFS.Layers }}"
+    });
+    const [sizeStr, layerStr] = inspectOutput.split(" ");
+    const size = parseInt(sizeStr, 10);
+    const layers = parseInt(layerStr, 10);
+    const MiB = 1024 * 1024;
+    const requiredSize = Math.ceil(size * 1.1 + layers * 16 * MiB);
+    await ensureDiskLimits({
+      requiredSize,
+      account,
+      containerApp: containerConfig
+    });
+    if (push) {
+      await dockerLoginManagedRegistry(pathToDocker);
+      try {
+        const repositoryOnly = imageTag.split(":")[0];
+        const localDigest = await getDockerImageDigest(pathToDocker, imageTag);
+        const digest = repositoryOnly + "@" + localDigest;
+        await runDockerCmd(
+          pathToDocker,
+          ["manifest", "inspect", digest],
+          "ignore"
+        );
+        logger.log("Image already exists remotely, skipping push");
+        logger.debug(
+          `Untagging built image: ${imageTag} since there was no change.`
+        );
+        await runDockerCmd(pathToDocker, ["image", "rm", imageTag]);
+        return "";
+      } catch (error2) {
+        logger.log(`Image does not exist remotely, pushing: ${imageTag}`);
+        await runDockerCmd(pathToDocker, ["push", imageTag]);
+      }
+    }
+    return imageTag;
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      throw new UserError(error2.message);
+    }
+    throw new UserError("An unknown error occurred");
+  }
+}
+async function buildCommand(args, config) {
+  if ((0, import_fs12.existsSync)(args.PATH) && !isDir(args.PATH)) {
+    throw new UserError(
+      `${args.PATH} is not a directory. Please specify a valid directory path.`
+    );
+  }
+  const containers2 = config.containers ?? [void 0];
+  const pathToDockerfile = (0, import_path8.join)(args.PATH, "Dockerfile");
+  for (const container of containers2) {
+    await buildAndMaybePush(
+      {
+        tag: args.tag,
+        pathToDockerfile,
+        buildContext: args.PATH,
+        platform: args.platform
+        // no option to add env vars at build time...?
+      },
+      getDockerPath() ?? args.pathToDocker,
+      args.push,
+      container
+    );
+  }
+}
+async function pushCommand(args, _4) {
+  try {
+    await dockerLoginManagedRegistry(args.pathToDocker);
+    const account = await loadAccount();
+    const newTag = getCloudflareRegistryWithAccountNamespace(
+      account.external_account_id,
+      args.TAG
+    );
+    const dockerPath = args.pathToDocker ?? getDockerPath();
+    await runDockerCmd(dockerPath, ["tag", args.TAG, newTag]);
+    await runDockerCmd(dockerPath, ["push", newTag]);
+    logger.log(`Pushed image: ${newTag}`);
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      throw new UserError(error2.message);
+    }
+    throw new UserError("An unknown error occurred");
+  }
+}
+async function ensureDiskLimits(options) {
+  const MB = 1e3 * 1e3;
+  const MiB = 1024 * 1024;
+  const appDiskSize = resolveAppDiskSize(options.account, options.containerApp);
+  const accountDiskSize = (options.account.limits.disk_mb_per_deployment ?? 2e3) * MB;
+  if (appDiskSize && appDiskSize > accountDiskSize) {
+    throw new UserError(
+      `Exceeded account limits: Your container is configured to use a disk size of ${appDiskSize / MB} MB. However, that exceeds the account limit of ${accountDiskSize / MB}`
+    );
+  }
+  const maxAllowedImageSizeBytes = appDiskSize ?? accountDiskSize;
+  logger.debug(
+    `Disk size limits when building the container: appDiskSize:${appDiskSize}, accountDiskSize:${accountDiskSize}, maxAllowedImageSizeBytes=${maxAllowedImageSizeBytes}(${maxAllowedImageSizeBytes / MB} MB), requiredSized=${options.requiredSize}(${Math.ceil(options.requiredSize / MiB)}MiB)`
+  );
+  if (maxAllowedImageSizeBytes < options.requiredSize) {
+    throw new UserError(
+      `Image too large: needs ${Math.ceil(options.requiredSize / MB)} MB, but your app is limited to images with size ${maxAllowedImageSizeBytes / MB} MB. Your account needs more disk size per instance to run this container. The default disk size is 2GB.`
+    );
+  }
+}
+var import_fs12, import_path8;
+var init_build2 = __esm({
+  "src/cloudchamber/build.ts"() {
+    init_import_meta_url();
+    import_fs12 = require("fs");
+    import_path8 = require("path");
+    init_containers_shared();
+    init_misc_variables();
+    init_errors();
+    init_logger();
+    init_common();
+    init_locations();
+    __name(buildYargs, "buildYargs");
+    __name(pushYargs, "pushYargs");
+    __name(buildAndMaybePush, "buildAndMaybePush");
+    __name(buildCommand, "buildCommand");
+    __name(pushCommand, "pushCommand");
+    __name(ensureDiskLimits, "ensureDiskLimits");
+  }
+});
+
+// src/cloudchamber/images/list.ts
+function deleteImageYargs(yargs) {
+  return yargs.positional("image", {
+    type: "string",
+    description: "image to delete",
+    demandOption: true
+  });
+}
+function listImagesYargs(yargs) {
+  return yargs.option("filter", {
+    type: "string",
+    description: "Regex to filter results"
+  });
+}
+async function handleDeleteImageCommand(args, _config) {
+  try {
+    if (!args.image.includes(":")) {
+      throw new Error(`Must provide a tag to delete`);
+    }
+    return await promiseSpinner(
+      getCreds().then(async (creds) => {
+        const url4 = new URL(`https://${getCloudflareContainerRegistry()}`);
+        const baseUrl = `${url4.protocol}//${url4.host}`;
+        const [image, tag] = args.image.split(":");
+        await deleteTag(baseUrl, image, tag, creds);
+        const gcUrl = `${baseUrl}/v2/gc/layers`;
+        const gcResponse = await fetch(gcUrl, {
+          method: "PUT",
+          headers: {
+            Authorization: `Basic ${creds}`,
+            "Content-Type": "application/json"
+          }
+        });
+        if (!gcResponse.ok) {
+          throw new Error(
+            `Failed to delete image ${args.image}: ${gcResponse.status} ${gcResponse.statusText}`
+          );
+        }
+        await logger.log(`Deleted tag: ${args.image}`);
+      }),
+      { message: "Deleting", json: args.json }
+    );
+  } catch (error2) {
+    logger.log(`Error when removing image: ${error2}`);
+  }
+}
+async function handleListImagesCommand(args, _config) {
+  try {
+    return await promiseSpinner(
+      getCreds().then(async (creds) => {
+        const repos = await listRepos(creds);
+        const tags = [];
+        for (const repo of repos) {
+          const stripped = repo.replace(/^\/+/, "");
+          const regex2 = new RegExp(args.filter ?? "");
+          if (regex2.test(stripped)) {
+            const repoTags = await listTags(stripped, creds);
+            tags.push({ name: stripped, tags: repoTags });
+          }
+        }
+        await ListTags(tags, false, args.json);
+      }),
+      { message: "Listing", json: args.json }
+    );
+  } catch (error2) {
+    logger.log(`Error listing images: ${error2}`);
+  }
+}
+async function ListTags(responses, digests = false, json = false) {
+  if (!digests) {
+    responses = responses.map((resp) => {
+      return {
+        name: resp.name,
+        tags: resp.tags.filter((t7) => !t7.startsWith("sha256"))
+      };
+    });
+  }
+  responses = responses.filter((resp) => {
+    return resp.tags !== void 0 && resp.tags.length != 0;
+  });
+  if (json) {
+    logger.log(JSON.stringify(responses, null, 2));
+  } else {
+    const rows = responses.map((resp) => {
+      return {
+        REPOSITORY: resp.name,
+        TAG: resp.tags.join(" ")
+      };
+    }).flat();
+    logger.table(rows);
+  }
+}
+async function listTags(repo, creds) {
+  const url4 = new URL(`https://${getCloudflareContainerRegistry()}`);
+  const baseUrl = `${url4.protocol}//${url4.host}`;
+  const tagsUrl = `${baseUrl}/v2/${repo}/tags/list`;
+  const tagsResponse = await fetch(tagsUrl, {
+    method: "GET",
+    headers: {
+      Authorization: `Basic ${creds}`
+    }
+  });
+  const tagsData = await tagsResponse.json();
+  return tagsData.tags || [];
+}
+async function listRepos(creds) {
+  const url4 = new URL(`https://${getCloudflareContainerRegistry()}`);
+  const catalogUrl = `${url4.protocol}//${url4.host}/v2/_catalog`;
+  const response = await fetch(catalogUrl, {
+    method: "GET",
+    headers: {
+      Authorization: `Basic ${creds}`
+    }
+  });
+  if (!response.ok) {
+    console.log(JSON.stringify(response));
+    throw new Error(
+      `Failed to fetch repository catalog: ${response.status} ${response.statusText}`
+    );
+  }
+  const data = await response.json();
+  return data.repositories || [];
+}
+async function deleteTag(baseUrl, image, tag, creds) {
+  const manifestAcceptHeader = "application/vnd.oci.image.manifest.v1+json, application/vnd.docker.distribution.manifest.v2+json";
+  const manifestUrl = `${baseUrl}/v2/${image}/manifests/${tag}`;
+  const headResponse = await fetch(manifestUrl, {
+    method: "HEAD",
+    headers: {
+      Authorization: `Basic ${creds}`,
+      Accept: manifestAcceptHeader
+    }
+  });
+  if (!headResponse.ok) {
+    throw new Error(
+      `failed to retrieve tag info for ${tag}: ${headResponse.status} ${headResponse.statusText}`
+    );
+  }
+  const digest = headResponse.headers.get("Docker-Content-Digest");
+  if (!digest) {
+    throw new Error(`Digest not found for tag "${tag}".`);
+  }
+  const deleteUrl = `${baseUrl}/v2/${image}/manifests/${tag}`;
+  const deleteResponse = await fetch(deleteUrl, {
+    method: "DELETE",
+    headers: {
+      Authorization: `Basic ${creds}`,
+      Accept: manifestAcceptHeader
+    }
+  });
+  if (!deleteResponse.ok) {
+    throw new Error(
+      `Failed to delete tag "${tag}" (digest: ${digest}): ${deleteResponse.status} ${deleteResponse.statusText}`
+    );
+  }
+}
+async function getCreds() {
+  return await ImageRegistriesService.generateImageRegistryCredentials(
+    getCloudflareContainerRegistry(),
+    {
+      expiration_minutes: 5,
+      permissions: ["pull", "push"]
+    }
+  ).then(async (credentials) => {
+    return Buffer.from(`v1:${credentials.password}`).toString("base64");
+  });
+}
+var imagesCommand;
+var init_list = __esm({
+  "src/cloudchamber/images/list.ts"() {
+    init_import_meta_url();
+    init_containers_shared();
+    init_logger();
+    init_common();
+    imagesCommand = /* @__PURE__ */ __name((yargs, scope) => {
+      return yargs.command(
+        "list",
+        "perform operations on images in your Cloudflare managed registry",
+        (args) => listImagesYargs(args),
+        (args) => handleFailure(
+          `wrangler containers images list`,
+          async (_args, config) => {
+            await handleListImagesCommand(args, config);
+          },
+          scope
+        )(args)
+      ).command(
+        "delete [image]",
+        "remove an image from your Cloudflare managed registry",
+        (args) => deleteImageYargs(args),
+        (args) => handleFailure(
+          `wrangler containers images delete`,
+          async (_args, config) => {
+            await handleDeleteImageCommand(args, config);
+          },
+          scope
+        )(args)
+      );
+    }, "imagesCommand");
+    __name(deleteImageYargs, "deleteImageYargs");
+    __name(listImagesYargs, "listImagesYargs");
+    __name(handleDeleteImageCommand, "handleDeleteImageCommand");
+    __name(handleListImagesCommand, "handleListImagesCommand");
+    __name(ListTags, "ListTags");
+    __name(listTags, "listTags");
+    __name(listRepos, "listRepos");
+    __name(deleteTag, "deleteTag");
+    __name(getCreds, "getCreds");
+  }
+});
+
+// ../cli/args.ts
+var processArgument;
+var init_args = __esm({
+  "../cli/args.ts"() {
+    init_import_meta_url();
+    init_interactive();
+    processArgument = /* @__PURE__ */ __name(async (args, name2, promptConfig) => {
+      const value = args[name2];
+      const result = await inputPrompt({
+        ...promptConfig,
+        // Accept the default value if the arg is already set
+        acceptDefault: promptConfig.acceptDefault ?? value !== void 0,
+        defaultValue: value ?? promptConfig.defaultValue
+      });
+      args[name2] = result;
+      return result;
+    }, "processArgument");
+  }
+});
+
+// src/containers/containers.ts
+function deleteYargs(args) {
+  return args.positional("ID", {
+    describe: "id of the containers to delete",
+    type: "string"
+  });
+}
+async function deleteCommand(deleteArgs, _config) {
+  if (!deleteArgs.ID) {
+    throw new Error(
+      "You must provide an ID. Use 'wrangler containers list` to view your containers."
+    );
+  }
+  if (deleteArgs.json) {
+    const container = await ApplicationsService.deleteApplication(
+      deleteArgs.ID
+    );
+    console.log(JSON.stringify(container, null, 4));
+    return;
+  }
+  startSection("Delete your container");
+  if (isInteractive2()) {
+    const yes = await inputPrompt({
+      question: "Are you sure that you want to delete these containers? The associated DO container will lose access to the containers.",
+      type: "confirm",
+      label: ""
+    });
+    if (!yes) {
+      cancel("The operation has been cancelled");
+      return;
+    }
+  }
+  const [, err] = await wrap2(
+    ApplicationsService.deleteApplication(deleteArgs.ID)
+  );
+  if (err) {
+    if (err instanceof ApiError) {
+      if (err.status === 400 || err.status === 404) {
+        throw new UserError(
+          `There has been an error deleting the container.
+${err.body.error}`
+        );
+      }
+      throw new Error(
+        `There has been an unknown error deleting the container.
+${JSON.stringify(err.body)}`
+      );
+    }
+    throw new Error(
+      `There has been an internal error deleting your containers.
+${err.message}`
+    );
+  }
+  endSection("Your container has been deleted");
+}
+function infoYargs(args) {
+  return args.positional("ID", {
+    describe: "id of the containers to view",
+    type: "string"
+  });
+}
+async function infoCommand(infoArgs, _config) {
+  if (!infoArgs.ID) {
+    throw new Error(
+      "You must provide an ID. Use 'wrangler containers list` to view your containers."
+    );
+  }
+  if (infoArgs.json || !isInteractive2()) {
+    const application2 = ApplicationsService.getApplication(infoArgs.ID);
+    console.log(JSON.stringify(application2, null, 4));
+    return;
+  }
+  await loadAccountSpinner(infoArgs);
+  const [application, err] = await wrap2(
+    ApplicationsService.getApplication(infoArgs.ID)
+  );
+  if (err) {
+    throw new UserError(
+      `There has been an internal error requesting your containers.
+ ${err.message}`
+    );
+  }
+  const details = flatDetails(application);
+  const applicationDetails = {
+    label: `${application.name} (${application.created_at})`,
+    details,
+    value: application.id
+  };
+  await inputPrompt({
+    type: "list",
+    question: "Container",
+    options: [applicationDetails],
+    label: "Exiting"
+  });
+}
+function listYargs(args) {
+  return args;
+}
+async function listCommand(listArgs, config) {
+  if (listArgs.json || !isInteractive2()) {
+    const applications = await ApplicationsService.listApplications();
+    console.log(JSON.stringify(applications, null, 4));
+    return;
+  }
+  await listCommandHandle(listArgs, config);
+}
+function flatDetails(obj, indentLevel = 0) {
+  const indent = "  ".repeat(indentLevel);
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    if (value !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value)) {
+      acc.push(`${indent}${key}:`);
+      acc.push(
+        ...flatDetails(value, indentLevel + 1)
+      );
+    } else if (value !== void 0) {
+      acc.push(`${indent}${key}: ${value}`);
+    }
+    return acc;
+  }, []);
+}
+async function listCommandHandle(_args, _config) {
+  const keepListIter = true;
+  while (keepListIter) {
+    logRaw(gray(shapes.bar));
+    const { start, stop } = spinner();
+    start("Loading Containers");
+    const [applications, err] = await wrap2(
+      ApplicationsService.listApplications()
+    );
+    stop();
+    if (err) {
+      throw new UserError(
+        `There has been an internal error listing your containers.
+ ${err.message}`
+      );
+    }
+    if (applications === void 0 || applications === null || applications.length === 0) {
+      logRaw(
+        "No containers found. See https://dash.cloudflare.com/?to=/:account/workers/containers to learn more."
+      );
+      return;
+    }
+    const applicationDetails = /* @__PURE__ */ __name((a5) => {
+      const details = flatDetails(a5);
+      return {
+        label: `${a5.name} (${a5.created_at})`,
+        details,
+        value: a5.id
+      };
+    }, "applicationDetails");
+    const application = await listContainersAndChoose(applications);
+    let refresh = false;
+    await inputPrompt({
+      type: "list",
+      question: "Containers",
+      helpText: "Hit enter to return to your containers or 'r' to refresh",
+      options: [applicationDetails(application)],
+      label: "going back",
+      onRefresh: /* @__PURE__ */ __name(async () => {
+        start("Refreshing application");
+        const app = await ApplicationsService.getApplication(application.id);
+        if (refresh) {
+          return [];
+        }
+        stop();
+        if (app) {
+          const details = applicationDetails(app);
+          details.label += ", last refresh: " + (/* @__PURE__ */ new Date()).toLocaleString();
+          return [details];
+        }
+        return app;
+      }, "onRefresh")
+    });
+    refresh = true;
+    stop();
+  }
+}
+async function listContainersAndChoose(applications) {
+  const getLabels = /* @__PURE__ */ __name((a5) => {
+    const labels = a5.configuration.labels ?? [];
+    if (!labels || labels.length == 0) {
+      return [];
+    }
+    const out = labels.map((l6) => `        ${dim(l6.name)}: ${dim(l6.value)}`);
+    return `Labels:
+` + out.join(",\n");
+  }, "getLabels");
+  const application = await processArgument({}, "applicationId", {
+    type: "list",
+    question: "Your Containers",
+    helpText: "Get more information by selecting a container with the enter/return key",
+    options: applications.map((i5) => ({
+      label: i5.name,
+      value: i5.id,
+      details: [
+        `Id: ${dim(`${i5.id}`)}`,
+        `Instances: ${dim(`${i5.instances}`)}`,
+        `Image: ${dim(i5.configuration.image)}`,
+        ...getLabels(i5) ?? []
+      ]
+    })),
+    label: "container"
+  });
+  return applications.find((a5) => a5.id === application);
+}
+var init_containers = __esm({
+  "src/containers/containers.ts"() {
+    init_import_meta_url();
+    init_cli();
+    init_args();
+    init_colors();
+    init_interactive();
+    init_containers_shared();
+    init_common();
+    init_wrap();
+    init_errors();
+    init_is_interactive();
+    __name(deleteYargs, "deleteYargs");
+    __name(deleteCommand, "deleteCommand");
+    __name(infoYargs, "infoYargs");
+    __name(infoCommand, "infoCommand");
+    __name(listYargs, "listYargs");
+    __name(listCommand, "listCommand");
+    __name(flatDetails, "flatDetails");
+    __name(listCommandHandle, "listCommandHandle");
+    __name(listContainersAndChoose, "listContainersAndChoose");
+  }
+});
+
+// src/containers/index.ts
+var containersScope, containers;
+var init_containers2 = __esm({
+  "src/containers/index.ts"() {
+    init_import_meta_url();
+    init_build2();
+    init_common();
+    init_list();
+    init_containers();
+    containersScope = "containers:write";
+    containers = /* @__PURE__ */ __name((yargs, subHelp) => {
+      return yargs.command(
+        "build [PATH]",
+        "build a dockerfile",
+        (args) => buildYargs(args),
+        (args) => handleFailure(
+          `wrangler containers build`,
+          buildCommand,
+          containersScope
+        )(args)
+      ).command(
+        "push [TAG]",
+        "push a tagged image to a Cloudflare managed registry, which is automatically integrated with your account",
+        (args) => pushYargs(args),
+        (args) => handleFailure(
+          `wrangler containers push`,
+          pushCommand,
+          containersScope
+        )(args)
+      ).command(
+        "images",
+        "perform operations on images in your Cloudflare managed registry",
+        (args) => imagesCommand(args, containersScope).command(subHelp)
+      ).command(
+        "info [ID]",
+        "get information about a specific container",
+        (args) => infoYargs(args),
+        (args) => handleFailure(
+          `wrangler containers info`,
+          infoCommand,
+          containersScope
+        )(args)
+      ).command(
+        "list",
+        "list containers",
+        (args) => listYargs(args),
+        (args) => handleFailure(
+          `wrangler containers list`,
+          listCommand,
+          containersScope
+        )(args)
+      ).command(
+        "delete [ID]",
+        "delete a container",
+        (args) => deleteYargs(args),
+        (args) => handleFailure(
+          `wrangler containers delete`,
+          deleteCommand,
+          containersScope
+        )(args)
+      );
+    }, "containers");
+  }
+});
+
+// src/versions/api.ts
+async function fetchVersion(complianceConfig, accountId, workerName, versionId, versionCache) {
+  const cachedVersion = versionCache?.get(versionId);
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+  const version5 = await fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/workers/scripts/${workerName}/versions/${versionId}`
+  );
+  versionCache?.set(version5.id, version5);
+  return version5;
+}
+async function fetchVersions(complianceConfig, accountId, workerName, versionCache, ...versionIds) {
+  return Promise.all(
+    versionIds.map(
+      (versionId) => fetchVersion(
+        complianceConfig,
+        accountId,
+        workerName,
+        versionId,
+        versionCache
+      )
+    )
+  );
+}
+async function fetchLatestDeployments(complianceConfig, accountId, workerName) {
+  const { deployments } = await fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/workers/scripts/${workerName}/deployments`
+  );
+  return deployments;
+}
+async function fetchLatestDeployment(complianceConfig, accountId, workerName) {
+  const deployments = await fetchLatestDeployments(
+    complianceConfig,
+    accountId,
+    workerName
+  );
+  return deployments.at(0);
+}
+async function fetchDeploymentVersions(complianceConfig, accountId, workerName, deployment, versionCache) {
+  if (!deployment) {
+    return [[], /* @__PURE__ */ new Map()];
+  }
+  const versionTraffic = new Map(
+    deployment.versions.map((v7) => [v7.version_id, v7.percentage])
+  );
+  const versions2 = await fetchVersions(
+    complianceConfig,
+    accountId,
+    workerName,
+    versionCache,
+    ...versionTraffic.keys()
+  );
+  return [versions2, versionTraffic];
+}
+async function fetchDeployableVersions(complianceConfig, accountId, workerName, versionCache) {
+  const { items: versions2 } = await fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/workers/scripts/${workerName}/versions?deployable=true`
+  );
+  for (const version5 of versions2) {
+    versionCache.set(version5.id, version5);
+  }
+  return versions2;
+}
+async function createDeployment(complianceConfig, accountId, workerName, versionTraffic, message, force) {
+  return await fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/workers/scripts/${workerName}/deployments${force ? "?force=true" : ""}`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        strategy: "percentage",
+        versions: Array.from(versionTraffic).map(
+          ([version_id, percentage]) => ({ version_id, percentage })
+        ),
+        annotations: {
+          "workers/message": message
+        }
+      })
+    }
+  );
+}
+async function patchNonVersionedScriptSettings(complianceConfig, accountId, workerName, settings) {
+  const res = await fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/workers/scripts/${workerName}/script-settings`,
+    {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(settings)
+    }
+  );
+  return res;
+}
+var init_api = __esm({
+  "src/versions/api.ts"() {
+    init_import_meta_url();
+    init_cfetch();
+    __name(fetchVersion, "fetchVersion");
+    __name(fetchVersions, "fetchVersions");
+    __name(fetchLatestDeployments, "fetchLatestDeployments");
+    __name(fetchLatestDeployment, "fetchLatestDeployment");
+    __name(fetchDeploymentVersions, "fetchDeploymentVersions");
+    __name(fetchDeployableVersions, "fetchDeployableVersions");
+    __name(createDeployment, "createDeployment");
+    __name(patchNonVersionedScriptSettings, "patchNonVersionedScriptSettings");
+  }
+});
+
 // src/cloudchamber/helpers/diff.ts
 function buildValues(diff, lastComponent, newString, oldString, useLongestToken) {
   const components = [];
@@ -61844,192 +62525,6 @@ var init_apply = __esm({
   }
 });
 
-// src/cloudchamber/build.ts
-function buildYargs(yargs) {
-  return yargs.positional("PATH", {
-    type: "string",
-    describe: "Path for the directory containing the Dockerfile to build",
-    demandOption: true
-  }).option("tag", {
-    alias: "t",
-    type: "string",
-    demandOption: true,
-    describe: 'Name and optionally a tag (format: "name:tag")'
-  }).option("path-to-docker", {
-    type: "string",
-    default: "docker",
-    describe: "Path to your docker binary if it's not on $PATH",
-    demandOption: false
-  }).option("push", {
-    alias: "p",
-    type: "boolean",
-    describe: "Push the built image to Cloudflare's managed registry",
-    default: false
-  }).option("platform", {
-    type: "string",
-    default: "linux/amd64",
-    describe: "Platform to build for. Defaults to the architecture support by Workers (linux/amd64)",
-    demandOption: false
-  });
-}
-function pushYargs(yargs) {
-  return yargs.option("path-to-docker", {
-    type: "string",
-    default: "docker",
-    describe: "Path to your docker binary if it's not on $PATH",
-    demandOption: false
-  }).positional("TAG", { type: "string", demandOption: true });
-}
-async function buildAndMaybePush(args, pathToDocker, push, containerConfig) {
-  try {
-    const account = await loadAccount();
-    const cloudflareAccountID = account.external_account_id;
-    const imageTag = getCloudflareRegistryWithAccountNamespace(
-      cloudflareAccountID,
-      args.tag
-    );
-    const { buildCmd, dockerfile } = await constructBuildCommand(
-      {
-        tag: imageTag,
-        pathToDockerfile: args.pathToDockerfile,
-        buildContext: args.buildContext,
-        args: args.args,
-        platform: args.platform,
-        setNetworkToHost: Boolean(getCIOverrideNetworkModeHost())
-      },
-      logger
-    );
-    await dockerBuild(pathToDocker, {
-      buildCmd,
-      dockerfile
-    });
-    const inspectOutput = await dockerImageInspect(pathToDocker, {
-      imageTag,
-      formatString: "{{ .Size }} {{ len .RootFS.Layers }}"
-    });
-    const [sizeStr, layerStr] = inspectOutput.split(" ");
-    const size = parseInt(sizeStr, 10);
-    const layers = parseInt(layerStr, 10);
-    const MiB = 1024 * 1024;
-    const requiredSize = Math.ceil(size * 1.1 + layers * 16 * MiB);
-    await ensureDiskLimits({
-      requiredSize,
-      account,
-      containerApp: containerConfig
-    });
-    if (push) {
-      await dockerLoginManagedRegistry(pathToDocker);
-      try {
-        const repositoryOnly = imageTag.split(":")[0];
-        const localDigest = await getDockerImageDigest(pathToDocker, imageTag);
-        const digest = repositoryOnly + "@" + localDigest;
-        await runDockerCmd(
-          pathToDocker,
-          ["manifest", "inspect", digest],
-          "ignore"
-        );
-        logger.log("Image already exists remotely, skipping push");
-        logger.debug(
-          `Untagging built image: ${imageTag} since there was no change.`
-        );
-        await runDockerCmd(pathToDocker, ["image", "rm", imageTag]);
-        return "";
-      } catch (error2) {
-        logger.log(`Image does not exist remotely, pushing: ${imageTag}`);
-        await runDockerCmd(pathToDocker, ["push", imageTag]);
-      }
-    }
-    return imageTag;
-  } catch (error2) {
-    if (error2 instanceof Error) {
-      throw new UserError(error2.message);
-    }
-    throw new UserError("An unknown error occurred");
-  }
-}
-async function buildCommand(args, config) {
-  if ((0, import_fs12.existsSync)(args.PATH) && !isDir(args.PATH)) {
-    throw new UserError(
-      `${args.PATH} is not a directory. Please specify a valid directory path.`
-    );
-  }
-  const containers2 = config.containers ?? [void 0];
-  const pathToDockerfile = (0, import_path8.join)(args.PATH, "Dockerfile");
-  for (const container of containers2) {
-    await buildAndMaybePush(
-      {
-        tag: args.tag,
-        pathToDockerfile,
-        buildContext: args.PATH,
-        platform: args.platform
-        // no option to add env vars at build time...?
-      },
-      getDockerPath() ?? args.pathToDocker,
-      args.push,
-      container
-    );
-  }
-}
-async function pushCommand(args, _4) {
-  try {
-    await dockerLoginManagedRegistry(args.pathToDocker);
-    const account = await loadAccount();
-    const newTag = getCloudflareRegistryWithAccountNamespace(
-      account.external_account_id,
-      args.TAG
-    );
-    const dockerPath = args.pathToDocker ?? getDockerPath();
-    await runDockerCmd(dockerPath, ["tag", args.TAG, newTag]);
-    await runDockerCmd(dockerPath, ["push", newTag]);
-    logger.log(`Pushed image: ${newTag}`);
-  } catch (error2) {
-    if (error2 instanceof Error) {
-      throw new UserError(error2.message);
-    }
-    throw new UserError("An unknown error occurred");
-  }
-}
-async function ensureDiskLimits(options) {
-  const MB = 1e3 * 1e3;
-  const MiB = 1024 * 1024;
-  const appDiskSize = resolveAppDiskSize(options.account, options.containerApp);
-  const accountDiskSize = (options.account.limits.disk_mb_per_deployment ?? 2e3) * MB;
-  if (appDiskSize && appDiskSize > accountDiskSize) {
-    throw new UserError(
-      `Exceeded account limits: Your container is configured to use a disk size of ${appDiskSize / MB} MB. However, that exceeds the account limit of ${accountDiskSize / MB}`
-    );
-  }
-  const maxAllowedImageSizeBytes = appDiskSize ?? accountDiskSize;
-  logger.debug(
-    `Disk size limits when building the container: appDiskSize:${appDiskSize}, accountDiskSize:${accountDiskSize}, maxAllowedImageSizeBytes=${maxAllowedImageSizeBytes}(${maxAllowedImageSizeBytes / MB} MB), requiredSized=${options.requiredSize}(${Math.ceil(options.requiredSize / MiB)}MiB)`
-  );
-  if (maxAllowedImageSizeBytes < options.requiredSize) {
-    throw new UserError(
-      `Image too large: needs ${Math.ceil(options.requiredSize / MB)} MB, but your app is limited to images with size ${maxAllowedImageSizeBytes / MB} MB. Your account needs more disk size per instance to run this container. The default disk size is 2GB.`
-    );
-  }
-}
-var import_fs12, import_path8;
-var init_build2 = __esm({
-  "src/cloudchamber/build.ts"() {
-    init_import_meta_url();
-    import_fs12 = require("fs");
-    import_path8 = require("path");
-    init_containers_shared();
-    init_misc_variables();
-    init_errors();
-    init_logger();
-    init_common();
-    init_locations();
-    __name(buildYargs, "buildYargs");
-    __name(pushYargs, "pushYargs");
-    __name(buildAndMaybePush, "buildAndMaybePush");
-    __name(buildCommand, "buildCommand");
-    __name(pushCommand, "pushCommand");
-    __name(ensureDiskLimits, "ensureDiskLimits");
-  }
-});
-
 // src/cloudchamber/deploy.ts
 async function maybeBuildContainer(containerConfig, imageTag, dryRun, pathToDocker) {
   try {
@@ -62059,7 +62554,11 @@ async function deployContainers(config, { versionId, accountId, scriptName, dryR
     return;
   }
   if (!dryRun) {
-    await fillOpenAPIConfiguration(config, isNonInteractiveOrCI());
+    await fillOpenAPIConfiguration(
+      config,
+      isNonInteractiveOrCI(),
+      containersScope
+    );
   }
   const pathToDocker = getDockerPath();
   for (const container of config.containers) {
@@ -62116,6 +62615,7 @@ var init_deploy = __esm({
   "src/cloudchamber/deploy.ts"() {
     init_import_meta_url();
     init_containers_shared();
+    init_containers2();
     init_misc_variables();
     init_errors();
     init_is_interactive();
@@ -62230,7 +62730,7 @@ var init_create = __esm({
 
 // src/d1/list.ts
 var d1ListCommand, listDatabases;
-var init_list = __esm({
+var init_list2 = __esm({
   "src/d1/list.ts"() {
     init_import_meta_url();
     init_cfetch();
@@ -62325,7 +62825,7 @@ var init_utils3 = __esm({
     init_cfetch();
     init_errors();
     init_constants4();
-    init_list();
+    init_list2();
     __name(getDatabaseInfoFromConfig, "getDatabaseInfoFromConfig");
     getDatabaseByNameOrBinding = /* @__PURE__ */ __name(async (config, accountId, name2) => {
       const dbFromConfig = getDatabaseInfoFromConfig(config, name2);
@@ -65179,7 +65679,7 @@ var init_bindings = __esm({
     import_node_assert10 = __toESM(require("assert"));
     init_cfetch();
     init_create();
-    init_list();
+    init_list2();
     init_utils3();
     init_dialogs();
     init_errors();
@@ -67343,7 +67843,7 @@ var init_xxhash_wasm = __esm({
 
 // src/sites.ts
 async function* getFilesInFolder(dirPath) {
-  const files = await (0, import_promises13.readdir)(dirPath, { withFileTypes: true });
+  const files = await (0, import_promises12.readdir)(dirPath, { withFileTypes: true });
   for (const file of files) {
     if (ALWAYS_IGNORE.has(file.name)) {
       continue;
@@ -67440,7 +67940,7 @@ async function syncWorkersSite(complianceConfig, accountId, scriptName, siteAsse
     if (!include(assetFile) || exclude2(assetFile)) {
       continue;
     }
-    const content = await (0, import_promises13.readFile)(absAssetFile, "base64");
+    const content = await (0, import_promises12.readFile)(absAssetFile, "base64");
     const assetSize = Buffer.byteLength(content);
     await validateAssetSize(absAssetFile, assetFile);
     const assetKey = hashAsset(hasher, assetFile, content);
@@ -67495,7 +67995,7 @@ async function syncWorkersSite(complianceConfig, accountId, scriptName, siteAsse
       for (const [absAssetFile, assetKey] of nextBucket) {
         bucket.push({
           key: assetKey,
-          value: await (0, import_promises13.readFile)(absAssetFile, "base64"),
+          value: await (0, import_promises12.readFile)(absAssetFile, "base64"),
           base64: true
         });
         if (controller.signal.aborted) {
@@ -67579,7 +68079,7 @@ async function syncWorkersSite(complianceConfig, accountId, scriptName, siteAsse
   return { manifest, namespace };
 }
 async function validateAssetSize(absFilePath, relativeFilePath) {
-  const { size } = await (0, import_promises13.stat)(absFilePath);
+  const { size } = await (0, import_promises12.stat)(absFilePath);
   if (size > 25 * 1024 * 1024) {
     throw new UserError(
       `File ${relativeFilePath} is too big, it should be under 25 MiB. See https://developers.cloudflare.com/workers/platform/limits#kv-limits`
@@ -67610,12 +68110,12 @@ function getSiteAssetPaths(config, assetDirectory, includePatterns = config.site
     return void 0;
   }
 }
-var import_node_assert15, import_promises13, path26, ALWAYS_IGNORE, HIDDEN_FILES_TO_INCLUDE, MAX_DIFF_LINES2, MAX_BUCKET_SIZE2, MAX_BUCKET_KEYS, MAX_BATCH_OPERATIONS;
+var import_node_assert15, import_promises12, path26, ALWAYS_IGNORE, HIDDEN_FILES_TO_INCLUDE, MAX_DIFF_LINES2, MAX_BUCKET_SIZE2, MAX_BUCKET_KEYS, MAX_BATCH_OPERATIONS;
 var init_sites = __esm({
   "src/sites.ts"() {
     init_import_meta_url();
     import_node_assert15 = __toESM(require("assert"));
-    import_promises13 = require("fs/promises");
+    import_promises12 = require("fs/promises");
     path26 = __toESM(require("path"));
     init_workers_shared();
     init_source();
@@ -67788,7 +68288,7 @@ async function retryOnAPIFailure(action, backoff = 0, attempts = MAX_ATTEMPTS) {
     if (attempts <= 1) {
       throw err;
     }
-    await (0, import_promises14.setTimeout)(backoff);
+    await (0, import_promises13.setTimeout)(backoff);
     return retryOnAPIFailure(
       action,
       backoff + (MAX_ATTEMPTS - attempts) * 1e3,
@@ -67796,11 +68296,11 @@ async function retryOnAPIFailure(action, backoff = 0, attempts = MAX_ATTEMPTS) {
     );
   }
 }
-var import_promises14, MAX_ATTEMPTS;
+var import_promises13, MAX_ATTEMPTS;
 var init_retry = __esm({
   "src/utils/retry.ts"() {
     init_import_meta_url();
-    import_promises14 = require("timers/promises");
+    import_promises13 = require("timers/promises");
     init_source();
     init_logger();
     init_parse();
@@ -76475,7 +76975,7 @@ function createSSHPublicKeyOptionalYargs(yargs) {
 }
 async function retrieveSSHKey(sshKeyPath, { json } = { json: false }) {
   try {
-    const file = (await (0, import_promises15.readFile)(sshKeyPath)).toString();
+    const file = (await (0, import_promises14.readFile)(sshKeyPath)).toString();
     validatePublicSSHKeyCLI(file, { json });
     return file;
   } catch (err) {
@@ -76516,10 +77016,10 @@ async function tryToRetrieveAllDefaultSSHKeyPaths() {
   const path71 = `${HOME}/.ssh`;
   const paths = [];
   try {
-    const dirList = await (0, import_promises15.readdir)(path71);
+    const dirList = await (0, import_promises14.readdir)(path71);
     for (const file of dirList) {
       if (file.endsWith(".pub")) {
-        const s5 = await (0, import_promises15.stat)(`${path71}/${file}`);
+        const s5 = await (0, import_promises14.stat)(`${path71}/${file}`);
         if (s5.isFile()) {
           paths.push(`${path71}/${file}`);
         }
@@ -76558,7 +77058,7 @@ async function shouldPromptForNewSSHKeyAppear(keys = void 0) {
     }
     let foundValidSSHKeyThatDontExist = false;
     for (const defaultSSHKeyPath of defaultSSHKeyPaths) {
-      const file = (await (0, import_promises15.readFile)(defaultSSHKeyPath)).toString().trim();
+      const file = (await (0, import_promises14.readFile)(defaultSSHKeyPath)).toString().trim();
       try {
         validateSSHKey(file);
       } catch {
@@ -76671,11 +77171,11 @@ async function promptForSSHKey(args) {
   }
   return res;
 }
-var import_promises15, import_os4, sshCommand;
+var import_promises14, import_os4, sshCommand;
 var init_ssh = __esm({
   "src/cloudchamber/ssh/ssh.ts"() {
     init_import_meta_url();
-    import_promises15 = require("fs/promises");
+    import_promises14 = require("fs/promises");
     import_os4 = require("os");
     init_cli();
     init_colors();
@@ -76690,7 +77190,7 @@ var init_ssh = __esm({
     __name(createSSHPublicKeyOptionalYargs, "createSSHPublicKeyOptionalYargs");
     __name(retrieveSSHKey, "retrieveSSHKey");
     __name(sshPrompts, "sshPrompts");
-    sshCommand = /* @__PURE__ */ __name((yargs) => {
+    sshCommand = /* @__PURE__ */ __name((yargs, scope) => {
       return yargs.command(
         "list",
         "list the ssh keys added to your account",
@@ -76704,7 +77204,8 @@ var init_ssh = __esm({
               return;
             }
             await handleListSSHKeysCommand(sshArgs, config);
-          }
+          },
+          scope
         )(args)
       ).command(
         "create",
@@ -76728,7 +77229,8 @@ var init_ssh = __esm({
               return;
             }
             await handleCreateSSHPublicKeyCommand(sshArgs);
-          }
+          },
+          scope
         )(args)
       );
     }, "sshCommand");
@@ -77364,7 +77866,7 @@ function deleteCommandOptionalYargs(yargs) {
     describe: "deployment you want to delete"
   });
 }
-async function deleteCommand(deleteArgs, config) {
+async function deleteCommand2(deleteArgs, config) {
   await loadAccountSpinner(deleteArgs);
   if (!interactWithUser(deleteArgs)) {
     if (!deleteArgs.deploymentId) {
@@ -77415,7 +77917,7 @@ var init_delete = __esm({
     init_common();
     init_wrap();
     __name(deleteCommandOptionalYargs, "deleteCommandOptionalYargs");
-    __name(deleteCommand, "deleteCommand");
+    __name(deleteCommand2, "deleteCommand");
     __name(handleDeleteCommand, "handleDeleteCommand");
   }
 });
@@ -77528,7 +78030,7 @@ var init_images2 = __esm({
     init_common();
     init_wrap();
     __name(configureImageRegistryOptionalYargs, "configureImageRegistryOptionalYargs");
-    registriesCommand = /* @__PURE__ */ __name((yargs) => {
+    registriesCommand = /* @__PURE__ */ __name((yargs, scope) => {
       return yargs.command(
         "configure",
         "Configure Cloudchamber to pull from specific registries",
@@ -77551,7 +78053,8 @@ var init_images2 = __esm({
               return;
             }
             await handleConfigureImageRegistryCommand(args, config);
-          }
+          },
+          scope
         )(args)
       ).command(
         "credentials [domain]",
@@ -77590,7 +78093,8 @@ var init_images2 = __esm({
                 }
               );
               console.log(credentials.password);
-            }
+            },
+            scope
           )(args);
         }
       ).command(
@@ -77606,7 +78110,8 @@ var init_images2 = __esm({
                 imageArgs.domain
               );
               console.log(JSON.stringify(registry, null, 4));
-            }
+            },
+            scope
           )(args);
         }
       ).command(
@@ -77622,7 +78127,8 @@ var init_images2 = __esm({
               return;
             }
             await handleListImageRegistriesCommand(args, config);
-          }
+          },
+          scope
         )(args)
       );
     }, "registriesCommand");
@@ -77632,215 +78138,6 @@ var init_images2 = __esm({
   }
 });
 
-// src/cloudchamber/images/list.ts
-function deleteImageYargs(yargs) {
-  return yargs.positional("image", {
-    type: "string",
-    description: "image to delete",
-    demandOption: true
-  });
-}
-function listImagesYargs(yargs) {
-  return yargs.option("filter", {
-    type: "string",
-    description: "Regex to filter results"
-  });
-}
-async function handleDeleteImageCommand(args, _config) {
-  try {
-    if (!args.image.includes(":")) {
-      throw new Error(`Must provide a tag to delete`);
-    }
-    return await promiseSpinner(
-      getCreds().then(async (creds) => {
-        const url4 = new URL(`https://${getCloudflareContainerRegistry()}`);
-        const baseUrl = `${url4.protocol}//${url4.host}`;
-        const [image, tag] = args.image.split(":");
-        await deleteTag(baseUrl, image, tag, creds);
-        const gcUrl = `${baseUrl}/v2/gc/layers`;
-        const gcResponse = await fetch(gcUrl, {
-          method: "PUT",
-          headers: {
-            Authorization: `Basic ${creds}`,
-            "Content-Type": "application/json"
-          }
-        });
-        if (!gcResponse.ok) {
-          throw new Error(
-            `Failed to delete image ${args.image}: ${gcResponse.status} ${gcResponse.statusText}`
-          );
-        }
-        await logger.log(`Deleted tag: ${args.image}`);
-      }),
-      { message: "Deleting", json: args.json }
-    );
-  } catch (error2) {
-    logger.log(`Error when removing image: ${error2}`);
-  }
-}
-async function handleListImagesCommand(args, _config) {
-  try {
-    return await promiseSpinner(
-      getCreds().then(async (creds) => {
-        const repos = await listRepos(creds);
-        const tags = [];
-        for (const repo of repos) {
-          const stripped = repo.replace(/^\/+/, "");
-          const regex2 = new RegExp(args.filter ?? "");
-          if (regex2.test(stripped)) {
-            const repoTags = await listTags(stripped, creds);
-            tags.push({ name: stripped, tags: repoTags });
-          }
-        }
-        await ListTags(tags, false, args.json);
-      }),
-      { message: "Listing", json: args.json }
-    );
-  } catch (error2) {
-    logger.log(`Error listing images: ${error2}`);
-  }
-}
-async function ListTags(responses, digests = false, json = false) {
-  if (!digests) {
-    responses = responses.map((resp) => {
-      return {
-        name: resp.name,
-        tags: resp.tags.filter((t7) => !t7.startsWith("sha256"))
-      };
-    });
-  }
-  responses = responses.filter((resp) => {
-    return resp.tags !== void 0 && resp.tags.length != 0;
-  });
-  if (json) {
-    logger.log(JSON.stringify(responses, null, 2));
-  } else {
-    const rows = responses.map((resp) => {
-      return {
-        REPOSITORY: resp.name,
-        TAG: resp.tags.join(" ")
-      };
-    }).flat();
-    logger.table(rows);
-  }
-}
-async function listTags(repo, creds) {
-  const url4 = new URL(`https://${getCloudflareContainerRegistry()}`);
-  const baseUrl = `${url4.protocol}//${url4.host}`;
-  const tagsUrl = `${baseUrl}/v2/${repo}/tags/list`;
-  const tagsResponse = await fetch(tagsUrl, {
-    method: "GET",
-    headers: {
-      Authorization: `Basic ${creds}`
-    }
-  });
-  const tagsData = await tagsResponse.json();
-  return tagsData.tags || [];
-}
-async function listRepos(creds) {
-  const url4 = new URL(`https://${getCloudflareContainerRegistry()}`);
-  const catalogUrl = `${url4.protocol}//${url4.host}/v2/_catalog`;
-  const response = await fetch(catalogUrl, {
-    method: "GET",
-    headers: {
-      Authorization: `Basic ${creds}`
-    }
-  });
-  if (!response.ok) {
-    console.log(JSON.stringify(response));
-    throw new Error(
-      `Failed to fetch repository catalog: ${response.status} ${response.statusText}`
-    );
-  }
-  const data = await response.json();
-  return data.repositories || [];
-}
-async function deleteTag(baseUrl, image, tag, creds) {
-  const manifestAcceptHeader = "application/vnd.oci.image.manifest.v1+json, application/vnd.docker.distribution.manifest.v2+json";
-  const manifestUrl = `${baseUrl}/v2/${image}/manifests/${tag}`;
-  const headResponse = await fetch(manifestUrl, {
-    method: "HEAD",
-    headers: {
-      Authorization: `Basic ${creds}`,
-      Accept: manifestAcceptHeader
-    }
-  });
-  if (!headResponse.ok) {
-    throw new Error(
-      `failed to retrieve tag info for ${tag}: ${headResponse.status} ${headResponse.statusText}`
-    );
-  }
-  const digest = headResponse.headers.get("Docker-Content-Digest");
-  if (!digest) {
-    throw new Error(`Digest not found for tag "${tag}".`);
-  }
-  const deleteUrl = `${baseUrl}/v2/${image}/manifests/${tag}`;
-  const deleteResponse = await fetch(deleteUrl, {
-    method: "DELETE",
-    headers: {
-      Authorization: `Basic ${creds}`,
-      Accept: manifestAcceptHeader
-    }
-  });
-  if (!deleteResponse.ok) {
-    throw new Error(
-      `Failed to delete tag "${tag}" (digest: ${digest}): ${deleteResponse.status} ${deleteResponse.statusText}`
-    );
-  }
-}
-async function getCreds() {
-  return await ImageRegistriesService.generateImageRegistryCredentials(
-    getCloudflareContainerRegistry(),
-    {
-      expiration_minutes: 5,
-      permissions: ["pull", "push"]
-    }
-  ).then(async (credentials) => {
-    return Buffer.from(`v1:${credentials.password}`).toString("base64");
-  });
-}
-var imagesCommand;
-var init_list2 = __esm({
-  "src/cloudchamber/images/list.ts"() {
-    init_import_meta_url();
-    init_containers_shared();
-    init_logger();
-    init_common();
-    imagesCommand = /* @__PURE__ */ __name((yargs) => {
-      return yargs.command(
-        "list",
-        "perform operations on images in your Cloudflare managed registry",
-        (args) => listImagesYargs(args),
-        (args) => handleFailure(
-          `wrangler containers images list`,
-          async (_args, config) => {
-            await handleListImagesCommand(args, config);
-          }
-        )(args)
-      ).command(
-        "delete [image]",
-        "remove an image from your Cloudflare managed registry",
-        (args) => deleteImageYargs(args),
-        (args) => handleFailure(
-          `wrangler containers images delete`,
-          async (_args, config) => {
-            await handleDeleteImageCommand(args, config);
-          }
-        )(args)
-      );
-    }, "imagesCommand");
-    __name(deleteImageYargs, "deleteImageYargs");
-    __name(listImagesYargs, "listImagesYargs");
-    __name(handleDeleteImageCommand, "handleDeleteImageCommand");
-    __name(handleListImagesCommand, "handleListImagesCommand");
-    __name(ListTags, "ListTags");
-    __name(listTags, "listTags");
-    __name(listRepos, "listRepos");
-    __name(deleteTag, "deleteTag");
-    __name(getCreds, "getCreds");
-  }
-});
-
 // src/cloudchamber/list.ts
 function listDeploymentsYargs(args) {
   return args.option("location", {
@@ -77874,7 +78171,7 @@ function listDeploymentsYargs(args) {
     type: "string"
   });
 }
-async function listCommand(deploymentArgs, config) {
+async function listCommand2(deploymentArgs, config) {
   await loadAccountSpinner(deploymentArgs);
   const prefix = deploymentArgs.deploymentIdPrefix ?? "";
   if (deploymentArgs.json || !isInteractive2()) {
@@ -77905,7 +78202,7 @@ async function listCommand(deploymentArgs, config) {
     console.log(JSON.stringify(deployments, null, 4));
     return;
   }
-  await listCommandHandle(prefix, deploymentArgs, config);
+  await listCommandHandle2(prefix, deploymentArgs, config);
 }
 function eventMessage(event, lastEvent) {
   let { message } = event;
@@ -77925,7 +78222,7 @@ function eventMessage(event, lastEvent) {
   }
   return `${message} (${event.time})`;
 }
-var listCommandHandle;
+var listCommandHandle2;
 var init_list3 = __esm({
   "src/cloudchamber/list.ts"() {
     init_import_meta_url();
@@ -77938,9 +78235,9 @@ var init_list3 = __esm({
     init_util();
     init_common();
     __name(listDeploymentsYargs, "listDeploymentsYargs");
-    __name(listCommand, "listCommand");
+    __name(listCommand2, "listCommand");
     __name(eventMessage, "eventMessage");
-    listCommandHandle = /* @__PURE__ */ __name(async (deploymentIdPrefix, args, _config) => {
+    listCommandHandle2 = /* @__PURE__ */ __name(async (deploymentIdPrefix, args, _config) => {
       const keepListIter = true;
       while (keepListIter) {
         logRaw(gray(shapes.bar));
@@ -78259,7 +78556,7 @@ var init_cloudchamber = __esm({
     init_curl();
     init_delete();
     init_images2();
-    init_list2();
+    init_list();
     init_list3();
     init_modify();
     init_ssh();
@@ -78270,334 +78567,91 @@ var init_cloudchamber = __esm({
         "delete [deploymentId]",
         "Delete an existing deployment that is running in the Cloudflare edge",
         (args) => deleteCommandOptionalYargs(args),
-        (args) => handleFailure(`wrangler cloudchamber delete`, deleteCommand)(args)
+        (args) => handleFailure(
+          `wrangler cloudchamber delete`,
+          deleteCommand2,
+          cloudchamberScope
+        )(args)
       ).command(
         "create",
         "Create a new deployment",
         (args) => createCommandOptionalYargs(args),
-        (args) => handleFailure(`wrangler cloudchamber create`, createCommand2)(args)
+        (args) => handleFailure(
+          `wrangler cloudchamber create`,
+          createCommand2,
+          cloudchamberScope
+        )(args)
       ).command(
         "list [deploymentIdPrefix]",
         "List and view status of deployments",
         (args) => listDeploymentsYargs(args),
-        (args) => handleFailure(`wrangler cloudchamber list`, listCommand)(args)
+        (args) => handleFailure(
+          `wrangler cloudchamber list`,
+          listCommand2,
+          cloudchamberScope
+        )(args)
       ).command(
         "modify [deploymentId]",
         "Modify an existing deployment",
         (args) => modifyCommandOptionalYargs(args),
-        (args) => handleFailure(`wrangler cloudchamber modify`, modifyCommand)(args)
+        (args) => handleFailure(
+          `wrangler cloudchamber modify`,
+          modifyCommand,
+          cloudchamberScope
+        )(args)
       ).command(
         "ssh",
         "Manage the ssh keys of your account",
-        (args) => sshCommand(args).command(subHelp)
+        (args) => sshCommand(args, cloudchamberScope).command(subHelp)
       ).command(
         "registries",
         "Configure registries via Cloudchamber",
-        (args) => registriesCommand(args).command(subHelp)
+        (args) => registriesCommand(args, cloudchamberScope).command(subHelp)
       ).command(
         "curl <path>",
-        "send a request to an arbitrary cloudchamber endpoint",
+        "send a request to an arbitrary Cloudchamber endpoint",
         (args) => yargsCurl(args),
-        (args) => handleFailure(`wrangler cloudchamber curl`, curlCommand)(args)
+        (args) => handleFailure(
+          `wrangler cloudchamber curl`,
+          curlCommand,
+          cloudchamberScope
+        )(args)
       ).command(
         "apply",
         "apply the changes in the container applications to deploy",
         (args) => applyCommandOptionalYargs(args),
-        (args) => handleFailure(`wrangler cloudchamber apply`, applyCommand)(args)
+        (args) => handleFailure(
+          `wrangler cloudchamber apply`,
+          applyCommand,
+          cloudchamberScope
+        )(args)
       ).command(
         "build [PATH]",
         "build a dockerfile",
         (args) => buildYargs(args),
-        (args) => handleFailure(`wrangler cloudchamber build`, buildCommand)(args)
+        (args) => handleFailure(
+          `wrangler cloudchamber build`,
+          buildCommand,
+          cloudchamberScope
+        )(args)
       ).command(
         "push [TAG]",
         "push a tagged image to a Cloudflare managed registry, which is automatically integrated with your account",
         (args) => pushYargs(args),
-        (args) => handleFailure(`wrangler cloudchamber push`, pushCommand)(args)
+        (args) => handleFailure(
+          `wrangler cloudchamber push`,
+          pushCommand,
+          cloudchamberScope
+        )(args)
       ).command(
         "images",
-        "perform operations on images in your clouchamber registry",
-        (args) => imagesCommand(args).command(subHelp)
+        "perform operations on images in your Cloudchamber registry",
+        (args) => imagesCommand(args, cloudchamberScope).command(subHelp)
       );
     }, "cloudchamber");
   }
 });
 
-// src/containers/containers.ts
-function deleteYargs(args) {
-  return args.positional("ID", {
-    describe: "id of the containers to delete",
-    type: "string"
-  });
-}
-async function deleteCommand2(deleteArgs, _config) {
-  await loadAccountSpinner(deleteArgs);
-  if (!deleteArgs.ID) {
-    throw new Error(
-      "You must provide an ID. Use 'wrangler containers list` to view your containers."
-    );
-  }
-  if (deleteArgs.json) {
-    const container = await ApplicationsService.deleteApplication(
-      deleteArgs.ID
-    );
-    console.log(JSON.stringify(container, null, 4));
-    return;
-  }
-  startSection("Delete your container");
-  if (isInteractive2()) {
-    const yes = await inputPrompt({
-      question: "Are you sure that you want to delete these containers? The associated DO container will lose access to the containers.",
-      type: "confirm",
-      label: ""
-    });
-    if (!yes) {
-      cancel("The operation has been cancelled");
-      return;
-    }
-  }
-  const [, err] = await wrap2(
-    ApplicationsService.deleteApplication(deleteArgs.ID)
-  );
-  if (err) {
-    if (err instanceof ApiError) {
-      if (err.status === 400 || err.status === 404) {
-        const body = JSON.parse(err.body);
-        throw new UserError(
-          `There has been an error deleting the container.
-${body.error}`
-        );
-      }
-      throw new Error(
-        `There has been an unknown error deleting the container.
-${JSON.stringify(err.body)}`
-      );
-    }
-    throw new Error(
-      `There has been an internal error deleting your containers.
-${err.message}`
-    );
-  }
-  endSection("Your container has been deleted");
-}
-function infoYargs(args) {
-  return args.positional("ID", {
-    describe: "id of the containers to view",
-    type: "string"
-  });
-}
-async function infoCommand(infoArgs, _config) {
-  if (!infoArgs.ID) {
-    throw new Error(
-      "You must provide an ID. Use 'wrangler containers list` to view your containers."
-    );
-  }
-  if (infoArgs.json || !isInteractive2()) {
-    const application2 = ApplicationsService.getApplication(infoArgs.ID);
-    console.log(JSON.stringify(application2, null, 4));
-    return;
-  }
-  await loadAccountSpinner(infoArgs);
-  const [application, err] = await wrap2(
-    ApplicationsService.getApplication(infoArgs.ID)
-  );
-  if (err) {
-    throw new UserError(
-      `There has been an internal error requesting your containers.
- ${err.message}`
-    );
-  }
-  const details = flatDetails(application);
-  const applicationDetails = {
-    label: `${application.name} (${application.created_at})`,
-    details,
-    value: application.id
-  };
-  await inputPrompt({
-    type: "list",
-    question: "Container",
-    options: [applicationDetails],
-    label: "Exiting"
-  });
-}
-function listYargs(args) {
-  return args;
-}
-async function listCommand2(listArgs, config) {
-  if (listArgs.json || !isInteractive2()) {
-    const applications = await ApplicationsService.listApplications();
-    console.log(JSON.stringify(applications, null, 4));
-    return;
-  }
-  await listCommandHandle2(listArgs, config);
-}
-function flatDetails(obj, indentLevel = 0) {
-  const indent = "  ".repeat(indentLevel);
-  return Object.entries(obj).reduce((acc, [key, value]) => {
-    if (value !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value)) {
-      acc.push(`${indent}${key}:`);
-      acc.push(
-        ...flatDetails(value, indentLevel + 1)
-      );
-    } else if (value !== void 0) {
-      acc.push(`${indent}${key}: ${value}`);
-    }
-    return acc;
-  }, []);
-}
-async function listCommandHandle2(_args, _config) {
-  const keepListIter = true;
-  while (keepListIter) {
-    logRaw(gray(shapes.bar));
-    const { start, stop } = spinner();
-    start("Loading Containers");
-    const [applications, err] = await wrap2(
-      ApplicationsService.listApplications()
-    );
-    stop();
-    if (err) {
-      throw new UserError(
-        `There has been an internal error listing your containers.
- ${err.message}`
-      );
-    }
-    if (applications === void 0 || applications === null || applications.length === 0) {
-      logRaw(
-        "No containers found. See https://dash.cloudflare.com/?to=/:account/workers/containers to learn more."
-      );
-      return;
-    }
-    const applicationDetails = /* @__PURE__ */ __name((a5) => {
-      const details = flatDetails(a5);
-      return {
-        label: `${a5.name} (${a5.created_at})`,
-        details,
-        value: a5.id
-      };
-    }, "applicationDetails");
-    const application = await listContainersAndChoose(applications);
-    let refresh = false;
-    await inputPrompt({
-      type: "list",
-      question: "Containers",
-      helpText: "Hit enter to return to your containers or 'r' to refresh",
-      options: [applicationDetails(application)],
-      label: "going back",
-      onRefresh: /* @__PURE__ */ __name(async () => {
-        start("Refreshing application");
-        const app = await ApplicationsService.getApplication(application.id);
-        if (refresh) {
-          return [];
-        }
-        stop();
-        if (app) {
-          const details = applicationDetails(app);
-          details.label += ", last refresh: " + (/* @__PURE__ */ new Date()).toLocaleString();
-          return [details];
-        }
-        return app;
-      }, "onRefresh")
-    });
-    refresh = true;
-    stop();
-  }
-}
-async function listContainersAndChoose(applications) {
-  const getLabels = /* @__PURE__ */ __name((a5) => {
-    const labels = a5.configuration.labels ?? [];
-    if (!labels || labels.length == 0) {
-      return [];
-    }
-    const out = labels.map((l6) => `        ${dim(l6.name)}: ${dim(l6.value)}`);
-    return `Labels:
-` + out.join(",\n");
-  }, "getLabels");
-  const application = await processArgument({}, "applicationId", {
-    type: "list",
-    question: "Your Containers",
-    helpText: "Get more information by selecting a container with the enter/return key",
-    options: applications.map((i5) => ({
-      label: i5.name,
-      value: i5.id,
-      details: [
-        `Id: ${dim(`${i5.id}`)}`,
-        `Instances: ${dim(`${i5.instances}`)}`,
-        `Image: ${dim(i5.configuration.image)}`,
-        ...getLabels(i5) ?? []
-      ]
-    })),
-    label: "container"
-  });
-  return applications.find((a5) => a5.id === application);
-}
-var init_containers = __esm({
-  "src/containers/containers.ts"() {
-    init_import_meta_url();
-    init_cli();
-    init_args();
-    init_colors();
-    init_interactive();
-    init_containers_shared();
-    init_common();
-    init_wrap();
-    init_errors();
-    init_is_interactive();
-    __name(deleteYargs, "deleteYargs");
-    __name(deleteCommand2, "deleteCommand");
-    __name(infoYargs, "infoYargs");
-    __name(infoCommand, "infoCommand");
-    __name(listYargs, "listYargs");
-    __name(listCommand2, "listCommand");
-    __name(flatDetails, "flatDetails");
-    __name(listCommandHandle2, "listCommandHandle");
-    __name(listContainersAndChoose, "listContainersAndChoose");
-  }
-});
-
-// src/containers/index.ts
-var containers;
-var init_containers2 = __esm({
-  "src/containers/index.ts"() {
-    init_import_meta_url();
-    init_build2();
-    init_common();
-    init_list2();
-    init_containers();
-    containers = /* @__PURE__ */ __name((yargs, subHelp) => {
-      return yargs.command(
-        "build [PATH]",
-        "build a dockerfile",
-        (args) => buildYargs(args),
-        (args) => handleFailure(`wrangler containers build`, buildCommand)(args)
-      ).command(
-        "push [TAG]",
-        "push a tagged image to a Cloudflare managed registry, which is automatically integrated with your account",
-        (args) => pushYargs(args),
-        (args) => handleFailure(`wrangler containers push`, pushCommand)(args)
-      ).command(
-        "images",
-        "perform operations on images in your Cloudflare managed registry",
-        (args) => imagesCommand(args).command(subHelp)
-      ).command(
-        "info [ID]",
-        "get information about a specific container",
-        (args) => infoYargs(args),
-        (args) => handleFailure(`wrangler containers info`, infoCommand)(args)
-      ).command(
-        "list",
-        "list containers",
-        (args) => listYargs(args),
-        (args) => handleFailure(`wrangler containers list`, listCommand2)(args)
-      ).command(
-        "delete [ID]",
-        "delete a container",
-        (args) => deleteYargs(args),
-        (args) => handleFailure(`wrangler containers delete`, deleteCommand2)(args)
-      );
-    }, "containers");
-  }
-});
-
 // src/core/index.ts
 var init_core2 = __esm({
   "src/core/index.ts"() {
@@ -79581,7 +79635,7 @@ async function exportLocal(config, name2, output, tables, noSchema, noData) {
   logger.log(`\u{1F300} Exporting SQL to ${output}...`);
   try {
     const dump = await db.prepare(`PRAGMA miniflare_d1_export(?,?,?);`).bind(noSchema, noData, ...tables).raw();
-    await import_promises16.default.writeFile(output, dump[0].join("\n"));
+    await import_promises15.default.writeFile(output, dump[0].join("\n"));
   } catch (e7) {
     throw new UserError(e7.message);
   } finally {
@@ -79625,7 +79679,7 @@ async function exportRemotely(config, name2, output, tables, noSchema, noData) {
           `There was an error while downloading from the presigned URL with status code: ${contents.status}`
         );
       }
-      await import_promises16.default.writeFile(output, contents.body || "");
+      await import_promises15.default.writeFile(output, contents.body || "");
     }
   });
   logger.log(`\u{1F300} Downloaded to ${output} successfully!`);
@@ -79676,11 +79730,11 @@ async function pollExport(s5, complianceConfig, accountId, db, dumpOptions, curr
     );
   }
 }
-var import_promises16, import_node_path28, import_miniflare13, import_undici11, d1ExportCommand;
+var import_promises15, import_node_path28, import_miniflare13, import_undici11, d1ExportCommand;
 var init_export = __esm({
   "src/d1/export.ts"() {
     init_import_meta_url();
-    import_promises16 = __toESM(require("fs/promises"));
+    import_promises15 = __toESM(require("fs/promises"));
     import_node_path28 = __toESM(require("path"));
     init_interactive();
     init_source();
@@ -83649,11 +83703,11 @@ async function downloadWorker(accountId, workerName) {
     config
   };
 }
-var import_promises17, import_node_path34, import_toml4, init;
+var import_promises16, import_node_path34, import_toml4, init;
 var init_init = __esm({
   "src/init.ts"() {
     init_import_meta_url();
-    import_promises17 = require("fs/promises");
+    import_promises16 = require("fs/promises");
     import_node_path34 = __toESM(require("path"));
     import_toml4 = __toESM(require_toml());
     init_execa();
@@ -83736,12 +83790,12 @@ var init_init = __esm({
             throw err;
           }
           const creationDir = import_node_path34.default.join(process.cwd(), args.fromDash);
-          await (0, import_promises17.mkdir)(creationDir, { recursive: true });
+          await (0, import_promises16.mkdir)(creationDir, { recursive: true });
           const { modules, config } = await downloadWorker(
             accountId,
             args.fromDash
           );
-          await (0, import_promises17.mkdir)(import_node_path34.default.join(creationDir, "./src"), {
+          await (0, import_promises16.mkdir)(import_node_path34.default.join(creationDir, "./src"), {
             recursive: true
           });
           config.main = `src/${config.main}`;
@@ -83751,12 +83805,12 @@ var init_init = __esm({
               files.map(async (file) => {
                 const filepath = import_node_path34.default.join(creationDir, `./src/${file.name}`);
                 const directory = (0, import_node_path34.dirname)(filepath);
-                await (0, import_promises17.mkdir)(directory, { recursive: true });
-                await (0, import_promises17.writeFile)(filepath, file.stream());
+                await (0, import_promises16.mkdir)(directory, { recursive: true });
+                await (0, import_promises16.writeFile)(filepath, file.stream());
               })
             );
           }
-          await (0, import_promises17.writeFile)(
+          await (0, import_promises16.writeFile)(
             import_node_path34.default.join(creationDir, "wrangler.toml"),
             import_toml4.default.stringify(config)
           );
@@ -85367,8 +85421,8 @@ function assetsPlugin(buildOutputDirectory) {
           args.resolveDir,
           args.path.slice("assets:".length)
         );
-        const exists = await (0, import_promises18.access)(directory).then(() => true).catch(() => false);
-        const isDirectory2 = exists && (await (0, import_promises18.lstat)(directory)).isDirectory();
+        const exists = await (0, import_promises17.access)(directory).then(() => true).catch(() => false);
+        const isDirectory2 = exists && (await (0, import_promises17.lstat)(directory)).isDirectory();
         if (!isDirectory2) {
           return {
             errors: [
@@ -85397,11 +85451,11 @@ function assetsPlugin(buildOutputDirectory) {
               "pages-plugins",
               identifier
             );
-            await (0, import_promises18.rm)(staticAssetsOutputDirectory, {
+            await (0, import_promises17.rm)(staticAssetsOutputDirectory, {
               force: true,
               recursive: true
             });
-            await (0, import_promises18.cp)(args.path, staticAssetsOutputDirectory, {
+            await (0, import_promises17.cp)(args.path, staticAssetsOutputDirectory, {
               force: true,
               recursive: true
             });
@@ -85421,12 +85475,12 @@ function assetsPlugin(buildOutputDirectory) {
     }
   };
 }
-var import_node_crypto7, import_promises18, import_node_path37, import_esbuild3;
+var import_node_crypto7, import_promises17, import_node_path37, import_esbuild3;
 var init_buildWorker = __esm({
   "src/pages/functions/buildWorker.ts"() {
     init_import_meta_url();
     import_node_crypto7 = __toESM(require("crypto"));
-    import_promises18 = require("fs/promises");
+    import_promises17 = require("fs/promises");
     import_node_path37 = require("path");
     import_esbuild3 = require("esbuild");
     init_bundle();
@@ -85506,8 +85560,8 @@ function buildPluginFromFunctions({
               args.resolveDir,
               args.path.slice("assets:".length)
             );
-            const exists = await (0, import_promises19.access)(directory).then(() => true).catch(() => false);
-            const isDirectory2 = exists && (await (0, import_promises19.lstat)(directory)).isDirectory();
+            const exists = await (0, import_promises18.access)(directory).then(() => true).catch(() => false);
+            const isDirectory2 = exists && (await (0, import_promises18.lstat)(directory)).isDirectory();
             if (!isDirectory2) {
               return {
                 errors: [
@@ -85552,11 +85606,11 @@ function buildPluginFromFunctions({
     metafile: void 0
   });
 }
-var import_promises19, import_node_path38;
+var import_promises18, import_node_path38;
 var init_buildPlugin = __esm({
   "src/pages/functions/buildPlugin.ts"() {
     init_import_meta_url();
-    import_promises19 = require("fs/promises");
+    import_promises18 = require("fs/promises");
     import_node_path38 = require("path");
     init_bundle();
     init_module_collection();
@@ -85695,7 +85749,7 @@ async function forEachFile(baseDir, fn2) {
   const returnValues = [];
   while (isNotEmpty(searchPaths)) {
     const cwd2 = searchPaths.shift();
-    const dir = await import_promises20.default.readdir(cwd2, { withFileTypes: true });
+    const dir = await import_promises19.default.readdir(cwd2, { withFileTypes: true });
     for (const entry of dir) {
       const pathname = import_node_path39.default.join(cwd2, entry.name);
       if (entry.isDirectory()) {
@@ -85732,11 +85786,11 @@ function convertSimpleParams(routePath) {
     }
   });
 }
-var import_promises20, import_node_path39, import_esbuild4, validParamNameRegExp;
+var import_promises19, import_node_path39, import_esbuild4, validParamNameRegExp;
 var init_filepath_routing = __esm({
   "src/pages/functions/filepath-routing.ts"() {
     init_import_meta_url();
-    import_promises20 = __toESM(require("fs/promises"));
+    import_promises19 = __toESM(require("fs/promises"));
     import_node_path39 = __toESM(require("path"));
     import_esbuild4 = require("esbuild");
     init_errors();
@@ -85832,7 +85886,7 @@ async function writeRoutesModule({
 }) {
   const { importMap, routes } = parseConfig(config, srcDir);
   const routesModule = generateRoutesModule(importMap, routes);
-  await import_promises21.default.writeFile(outfile, routesModule);
+  await import_promises20.default.writeFile(outfile, routesModule);
   return outfile;
 }
 function parseConfig(config, baseDir) {
@@ -85897,11 +85951,11 @@ export const routes = [
   ).join("\n")}
   ]`;
 }
-var import_promises21, import_node_path40;
+var import_promises20, import_node_path40;
 var init_routes2 = __esm({
   "src/pages/functions/routes.ts"() {
     init_import_meta_url();
-    import_promises21 = __toESM(require("fs/promises"));
+    import_promises20 = __toESM(require("fs/promises"));
     import_node_path40 = __toESM(require("path"));
     init_errors();
     init_identifiers();
@@ -86169,7 +86223,7 @@ async function maybeReadPagesConfig(args) {
     });
     return {
       ...config,
-      hash: (0, import_node_crypto8.createHash)("sha256").update(await (0, import_promises22.readFile)(configPath)).digest("hex")
+      hash: (0, import_node_crypto8.createHash)("sha256").update(await (0, import_promises21.readFile)(configPath)).digest("hex")
     };
   } catch (e7) {
     if (e7 instanceof FatalError && e7.code === EXIT_CODE_INVALID_PAGES_CONFIG) {
@@ -86178,13 +86232,13 @@ async function maybeReadPagesConfig(args) {
     throw e7;
   }
 }
-var import_node_crypto8, import_node_fs22, import_promises22, import_node_path43, pagesFunctionsBuildCommand, validateArgs;
+var import_node_crypto8, import_node_fs22, import_promises21, import_node_path43, pagesFunctionsBuildCommand, validateArgs;
 var init_build4 = __esm({
   "src/pages/build.ts"() {
     init_import_meta_url();
     import_node_crypto8 = require("crypto");
     import_node_fs22 = require("fs");
-    import_promises22 = require("fs/promises");
+    import_promises21 = require("fs/promises");
     import_node_path43 = __toESM(require("path"));
     init_create_worker_bundle_contents();
     init_config2();
@@ -86836,7 +86890,7 @@ async function deploy2({
     );
   }
   if (config !== void 0 && config.configPath !== void 0 && config.pages_build_output_dir) {
-    const configHash = (0, import_node_crypto9.createHash)("sha256").update(await (0, import_promises23.readFile)(config.configPath)).digest("hex");
+    const configHash = (0, import_node_crypto9.createHash)("sha256").update(await (0, import_promises22.readFile)(config.configPath)).digest("hex");
     const outputDir = import_node_path45.default.relative(
       process.cwd(),
       config.pages_build_output_dir
@@ -86976,13 +87030,13 @@ async function deploy2({
   }
   throw lastErr;
 }
-var import_node_crypto9, import_node_fs24, import_promises23, import_node_path45, import_node_process11, import_undici14;
+var import_node_crypto9, import_node_fs24, import_promises22, import_node_path45, import_node_process11, import_undici14;
 var init_deploy4 = __esm({
   "src/api/pages/deploy.ts"() {
     init_import_meta_url();
     import_node_crypto9 = require("crypto");
     import_node_fs24 = require("fs");
-    import_promises23 = require("fs/promises");
+    import_promises22 = require("fs/promises");
     import_node_path45 = __toESM(require("path"));
     import_node_process11 = require("process");
     import_undici14 = __toESM(require_undici());
@@ -87401,12 +87455,12 @@ function promptSelectExistingOrNewProject(message, items) {
     choices: items.map((i5) => ({ title: i5.label, value: i5.value }))
   });
 }
-var import_node_child_process5, import_promises24, import_node_path46, pagesDeploymentCreateCommand, pagesPublishCommand, pagesDeployCommand;
+var import_node_child_process5, import_promises23, import_node_path46, pagesDeploymentCreateCommand, pagesPublishCommand, pagesDeployCommand;
 var init_deploy5 = __esm({
   "src/pages/deploy.ts"() {
     init_import_meta_url();
     import_node_child_process5 = require("child_process");
-    import_promises24 = require("fs/promises");
+    import_promises23 = require("fs/promises");
     import_node_path46 = __toESM(require("path"));
     init_deploy4();
     init_cfetch();
@@ -87750,7 +87804,7 @@ To silence this warning, pass in --commit-dirty=true`
           if (failureMessage.includes("Script startup exceeded CPU time limit")) {
             const workerBundle = formData.get("_worker.bundle");
             const filePath = import_node_path46.default.join(getPagesTmpDir(), "_worker.bundle");
-            await (0, import_promises24.writeFile)(filePath, workerBundle.stream());
+            await (0, import_promises23.writeFile)(filePath, workerBundle.stream());
             await handleStartupError(filePath, getPagesProjectRoot());
           }
           throw new FatalError(
@@ -89315,11 +89369,11 @@ var init_createTail = __esm({
 });
 
 // src/pages/deployment-tails.ts
-var import_promises25, import_signal_exit5, statusChoices, isStatusChoiceList, pagesDeploymentTailCommand;
+var import_promises24, import_signal_exit5, statusChoices, isStatusChoiceList, pagesDeploymentTailCommand;
 var init_deployment_tails = __esm({
   "src/pages/deployment-tails.ts"() {
     init_import_meta_url();
-    import_promises25 = require("timers/promises");
+    import_promises24 = require("timers/promises");
     import_signal_exit5 = __toESM(require_signal_exit());
     init_cfetch();
     init_config2();
@@ -89541,10 +89595,10 @@ var init_deployment_tails = __esm({
         while (tail.readyState !== tail.OPEN) {
           switch (tail.readyState) {
             case tail.CONNECTING:
-              await (0, import_promises25.setTimeout)(100);
+              await (0, import_promises24.setTimeout)(100);
               break;
             case tail.CLOSING:
-              await (0, import_promises25.setTimeout)(100);
+              await (0, import_promises24.setTimeout)(100);
               break;
             case tail.CLOSED:
               sendMetricsEvent("end log stream", {
@@ -90722,7 +90776,7 @@ async function toEnvironment(deploymentConfig, accountId) {
 async function writeWranglerToml(toml) {
   let tomlString = import_toml5.default.stringify(toml);
   tomlString = tomlString.split("\n").map((line) => line.trimStart()).join("\n");
-  await (0, import_promises26.writeFile)(
+  await (0, import_promises25.writeFile)(
     "wrangler.toml",
     `# Generated by Wrangler on ${/* @__PURE__ */ new Date()}
 ${tomlString}`
@@ -90779,12 +90833,12 @@ async function downloadProject(accountId, projectName) {
     }
   };
 }
-var import_fs15, import_promises26, import_toml5, import_miniflare16, pagesDownloadConfigCommand;
+var import_fs15, import_promises25, import_toml5, import_miniflare16, pagesDownloadConfigCommand;
 var init_download_config = __esm({
   "src/pages/download-config.ts"() {
     init_import_meta_url();
     import_fs15 = require("fs");
-    import_promises26 = require("fs/promises");
+    import_promises25 = require("fs/promises");
     import_toml5 = __toESM(require_toml());
     init_source();
     import_miniflare16 = require("miniflare");
@@ -113962,14 +114016,14 @@ var init_retry_wrapper = __esm({
 });
 
 // ../../node_modules/.pnpm/@aws-sdk+credential-provider-http@3.716.0/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/fromHttp.js
-var import_promises27, AWS_CONTAINER_CREDENTIALS_RELATIVE_URI, DEFAULT_LINK_LOCAL_HOST, AWS_CONTAINER_CREDENTIALS_FULL_URI, AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE, AWS_CONTAINER_AUTHORIZATION_TOKEN, fromHttp;
+var import_promises26, AWS_CONTAINER_CREDENTIALS_RELATIVE_URI, DEFAULT_LINK_LOCAL_HOST, AWS_CONTAINER_CREDENTIALS_FULL_URI, AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE, AWS_CONTAINER_AUTHORIZATION_TOKEN, fromHttp;
 var init_fromHttp = __esm({
   "../../node_modules/.pnpm/@aws-sdk+credential-provider-http@3.716.0/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/fromHttp.js"() {
     init_import_meta_url();
     init_client5();
     init_dist_es12();
     init_dist_es17();
-    import_promises27 = __toESM(require("fs/promises"));
+    import_promises26 = __toESM(require("fs/promises"));
     init_checkUrl();
     init_requestHelpers();
     init_retry_wrapper();
@@ -114013,7 +114067,7 @@ Set AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI
         if (token) {
           request4.headers.Authorization = token;
         } else if (tokenFile) {
-          request4.headers.Authorization = (await import_promises27.default.readFile(tokenFile)).toString();
+          request4.headers.Authorization = (await import_promises26.default.readFile(tokenFile)).toString();
         }
         try {
           const result = await requestHandler.handle(request4);
@@ -124521,7 +124575,7 @@ var init_dist_es73 = __esm({
 async function generateR2ServiceToken(accountId, bucketName, pipelineName) {
   const controller = new AbortController();
   const signal = controller.signal;
-  const timeoutPromise = (0, import_promises28.setTimeout)(12e4, "timeout", { signal });
+  const timeoutPromise = (0, import_promises27.setTimeout)(12e4, "timeout", { signal });
   const serverPromise = new Promise((resolve24, reject) => {
     const server = import_node_http2.default.createServer(async (request4, response) => {
       (0, import_node_assert19.default)(request4.url, "This request doesn't have a URL");
@@ -124626,14 +124680,14 @@ async function deletePipeline(complianceConfig, accountId, name2) {
     }
   );
 }
-var import_node_assert19, import_node_crypto10, import_node_http2, import_promises28, API_HEADERS;
+var import_node_assert19, import_node_crypto10, import_node_http2, import_promises27, API_HEADERS;
 var init_client7 = __esm({
   "src/pipelines/client.ts"() {
     init_import_meta_url();
     import_node_assert19 = __toESM(require("assert"));
     import_node_crypto10 = require("crypto");
     import_node_http2 = __toESM(require("http"));
-    import_promises28 = require("timers/promises");
+    import_promises27 = require("timers/promises");
     init_cfetch();
     init_misc_variables();
     init_errors();
@@ -124670,7 +124724,7 @@ async function verifyBucketAccess(r22, bucketName) {
       if (attempt === MAX_ATTEMPTS2) {
         throw error2;
       }
-      await (0, import_promises29.setTimeout)(DELAY_MS);
+      await (0, import_promises28.setTimeout)(DELAY_MS);
     }
   }
 }
@@ -124794,11 +124848,11 @@ function formatPipelinePretty(pipeline) {
   }
   return buffer;
 }
-var import_promises29, BYTES_PER_MB, __testSkipDelaysFlag, pipelinesNamespace;
+var import_promises28, BYTES_PER_MB, __testSkipDelaysFlag, pipelinesNamespace;
 var init_pipelines = __esm({
   "src/pipelines/index.ts"() {
     init_import_meta_url();
-    import_promises29 = require("timers/promises");
+    import_promises28 = require("timers/promises");
     init_dist_es73();
     init_pretty_bytes();
     init_create_command();
@@ -141393,11 +141447,11 @@ var init_sentry = __esm({
 });
 
 // src/tail/index.ts
-var import_promises30, import_signal_exit6, tailCommand;
+var import_promises29, import_signal_exit6, tailCommand;
 var init_tail = __esm({
   "src/tail/index.ts"() {
     init_import_meta_url();
-    import_promises30 = require("timers/promises");
+    import_promises29 = require("timers/promises");
     import_signal_exit6 = __toESM(require_signal_exit());
     init_config2();
     init_create_command();
@@ -141543,10 +141597,10 @@ var init_tail = __esm({
         while (tail.readyState !== tail.OPEN) {
           switch (tail.readyState) {
             case tail.CONNECTING:
-              await (0, import_promises30.setTimeout)(100);
+              await (0, import_promises29.setTimeout)(100);
               break;
             case tail.CLOSING:
-              await (0, import_promises30.setTimeout)(100);
+              await (0, import_promises29.setTimeout)(100);
               break;
             case tail.CLOSED:
               sendMetricsEvent("end log stream", {
@@ -141748,7 +141802,7 @@ async function generateRuntimeTypes({
   }
   const header = `// Runtime types generated with workerd@${import_workerd.version} ${compatibility_date} ${compatibility_flags.sort().join(",")}`;
   try {
-    const lines = (await (0, import_promises31.readFile)(outFile, "utf8")).split("\n");
+    const lines = (await (0, import_promises30.readFile)(outFile, "utf8")).split("\n");
     const existingHeader = lines.find(
       (line) => line.startsWith("// Runtime types generated with workerd@")
     );
@@ -141800,12 +141854,12 @@ async function generate({
     await mf.dispose();
   }
 }
-var import_fs24, import_promises31, import_miniflare19, import_workerd, DEFAULT_OUTFILE_RELATIVE_PATH;
+var import_fs24, import_promises30, import_miniflare19, import_workerd, DEFAULT_OUTFILE_RELATIVE_PATH;
 var init_runtime = __esm({
   "src/type-generation/runtime/index.ts"() {
     init_import_meta_url();
     import_fs24 = require("fs");
-    import_promises31 = require("fs/promises");
+    import_promises30 = require("fs/promises");
     import_miniflare19 = require("miniflare");
     import_workerd = require("workerd");
     init_logger();
@@ -143088,8 +143142,8 @@ var init_client10 = __esm({
 // src/vectorize/common.ts
 async function isValidFile(path71) {
   try {
-    await (0, import_promises32.access)(path71, import_promises32.constants.R_OK);
-    const fileStat = await (0, import_promises32.stat)(path71);
+    await (0, import_promises31.access)(path71, import_promises31.constants.R_OK);
+    const fileStat = await (0, import_promises31.stat)(path71);
     return fileStat.isFile() && fileStat.size > 0;
   } catch (err) {
     return false;
@@ -143114,11 +143168,11 @@ async function* getBatchFromFile(rl, batchSize = VECTORIZE_MAX_BATCH_SIZE) {
     return;
   }
 }
-var import_promises32, deprecatedV1DefaultFlag, VECTORIZE_V1_MAX_BATCH_SIZE, VECTORIZE_MAX_BATCH_SIZE, VECTORIZE_UPSERT_BATCH_SIZE, VECTORIZE_MAX_UPSERT_VECTOR_RECORDS;
+var import_promises31, deprecatedV1DefaultFlag, VECTORIZE_V1_MAX_BATCH_SIZE, VECTORIZE_MAX_BATCH_SIZE, VECTORIZE_UPSERT_BATCH_SIZE, VECTORIZE_MAX_UPSERT_VECTOR_RECORDS;
 var init_common3 = __esm({
   "src/vectorize/common.ts"() {
     init_import_meta_url();
-    import_promises32 = require("fs/promises");
+    import_promises31 = require("fs/promises");
     init_logger();
     deprecatedV1DefaultFlag = false;
     VECTORIZE_V1_MAX_BATCH_SIZE = 1e3;
@@ -151609,7 +151663,7 @@ ${tryRunningItIn}${oneOfThese}`
       const controller = new AbortController();
       await Promise.race([
         Promise.allSettled(dispatcher?.requests ?? []),
-        (0, import_promises33.setTimeout)(1e3, void 0, controller)
+        (0, import_promises32.setTimeout)(1e3, void 0, controller)
         // Ensure we don't hang indefinitely
       ]).then(() => controller.abort());
     } catch (e7) {
@@ -151620,12 +151674,12 @@ ${tryRunningItIn}${oneOfThese}`
     }
   }
 }
-var import_node_os7, import_promises33, import_undici21;
+var import_node_os7, import_promises32, import_undici21;
 var init_src = __esm({
   "src/index.ts"() {
     init_import_meta_url();
     import_node_os7 = __toESM(require("os"));
-    import_promises33 = require("timers/promises");
+    import_promises32 = require("timers/promises");
     init_source();
     import_undici21 = __toESM(require_undici());
     init_yargs();
@@ -151650,7 +151704,7 @@ var init_src = __esm({
     init_export();
     init_info();
     init_insights();
-    init_list();
+    init_list2();
     init_migrations();
     init_apply2();
     init_create3();
@@ -151836,7 +151890,7 @@ async function checkStartupHandler({
     startMessage: "Analysing",
     endMessage: source_default.green("Startup phase analysed")
   });
-  await (0, import_promises35.writeFile)(outfile, JSON.stringify(await cpuProfileResult));
+  await (0, import_promises34.writeFile)(outfile, JSON.stringify(await cpuProfileResult));
   log(
     `CPU Profile written to ${outfile}. Load it into the Chrome DevTools profiler (or directly in VSCode) to view a flamegraph.`
   );
@@ -151871,7 +151925,7 @@ async function convertWorkerBundleToModules(workerBundle) {
   );
 }
 async function parseFormDataFromFile(file) {
-  const bundle = await (0, import_promises34.readFile)(file);
+  const bundle = await (0, import_promises33.readFile)(file);
   const firstLine = bundle.findIndex((v7) => v7 === 10);
   const boundary = Uint8Array.prototype.slice.call(bundle, 2, firstLine).toString();
   return await new Response(bundle, {
@@ -151937,14 +151991,14 @@ async function analyseBundle(workerBundle) {
   ws.send(JSON.stringify({ id: 3, method: "Profiler.stop", params: {} }));
   return cpuProfileResult;
 }
-var import_crypto6, import_promises34, import_node_events3, import_promises35, import_path24, import_miniflare21, mimeTypeModuleType, checkNamespace, checkStartupCommand;
+var import_crypto6, import_promises33, import_node_events3, import_promises34, import_path24, import_miniflare21, mimeTypeModuleType, checkNamespace, checkStartupCommand;
 var init_commands9 = __esm({
   "src/check/commands.ts"() {
     init_import_meta_url();
     import_crypto6 = require("crypto");
-    import_promises34 = require("fs/promises");
+    import_promises33 = require("fs/promises");
     import_node_events3 = __toESM(require("events"));
-    import_promises35 = require("fs/promises");
+    import_promises34 = require("fs/promises");
     import_path24 = __toESM(require("path"));
     init_cli();
     init_interactive();
@@ -152042,7 +152096,7 @@ async function handleStartupError(workerBundle, projectRoot) {
     projectRoot ?? process.cwd(),
     import_node_path54.default.join(tmpDir.path, `worker.cpuprofile`)
   );
-  await (0, import_promises36.writeFile)(profile, JSON.stringify(cpuProfile));
+  await (0, import_promises35.writeFile)(profile, JSON.stringify(cpuProfile));
   throw new UserError(esm_default2`
 		Your Worker failed validation because it exceeded startup limits.
 		To ensure fast responses, there are constraints on Worker startup, such as how much CPU it can use, or how long it can take. Your Worker has hit one of these startup limits. Try reducing the amount of work done during startup (outside the event handler), either by removing code or relocating it inside the event handler.
@@ -152058,11 +152112,11 @@ async function helpIfErrorIsSizeOrScriptStartup(err, dependencies, workerBundle,
     await handleStartupError(workerBundle, projectRoot);
   }
 }
-var import_promises36, import_node_path54, scriptStartupErrorRegex;
+var import_promises35, import_node_path54, scriptStartupErrorRegex;
 var init_friendly_validator_errors = __esm({
   "src/utils/friendly-validator-errors.ts"() {
     init_import_meta_url();
-    import_promises36 = require("fs/promises");
+    import_promises35 = require("fs/promises");
     import_node_path54 = __toESM(require("path"));
     init_esm2();
     init_commands9();
@@ -153870,7 +153924,11 @@ If you are trying to develop Pages and Workers together, please use \`wrangler p
     (c6) => !isDockerfile(c6.image ?? c6.configuration.image)
   );
   if (needsPulling && !resolved.dev.remote) {
-    await fillOpenAPIConfiguration(config, isNonInteractiveOrCI());
+    await fillOpenAPIConfiguration(
+      config,
+      isNonInteractiveOrCI(),
+      containersScope
+    );
   }
   const queues = extractBindingsOfType("queue", resolved.bindings);
   if (resolved.dev.remote && (queues?.length || resolved.triggers?.some((t7) => t7.type === "queue-consumer"))) {
@@ -153901,6 +153959,7 @@ var init_ConfigController = __esm({
     init_assets();
     init_common();
     init_config2();
+    init_containers2();
     init_entry();
     init_dev2();
     init_class_names_sqlite();
@@ -174121,7 +174180,7 @@ async function getBinaryFileContents2(file) {
     }
     return Buffer.from(file.contents);
   }
-  return (0, import_promises37.readFile)(file.path);
+  return (0, import_promises36.readFile)(file.path);
 }
 async function getTextFileContents(file) {
   if ("contents" in file) {
@@ -174133,7 +174192,7 @@ async function getTextFileContents(file) {
     }
     return Buffer.from(file.contents).toString();
   }
-  return (0, import_promises37.readFile)(file.path, "utf8");
+  return (0, import_promises36.readFile)(file.path, "utf8");
 }
 function getName2(config) {
   return config.name;
@@ -174243,13 +174302,13 @@ async function getContainerOptions(config) {
   }
   return containers2;
 }
-var import_node_assert29, import_node_crypto14, import_promises37, import_miniflare26, LocalRuntimeController;
+var import_node_assert29, import_node_crypto14, import_promises36, import_miniflare26, LocalRuntimeController;
 var init_LocalRuntimeController = __esm({
   "src/api/startDevWorker/LocalRuntimeController.ts"() {
     init_import_meta_url();
     import_node_assert29 = __toESM(require("assert"));
     import_node_crypto14 = require("crypto");
-    import_promises37 = require("fs/promises");
+    import_promises36 = require("fs/promises");
     init_containers_shared();
     init_source();
     import_miniflare26 = require("miniflare");
@@ -174739,8 +174798,8 @@ async function registerWorker(name2, definition) {
   if (existingHeartbeat) {
     clearInterval(existingHeartbeat);
   }
-  await (0, import_promises38.mkdir)(DEV_REGISTRY_PATH, { recursive: true });
-  await (0, import_promises38.writeFile)(
+  await (0, import_promises37.mkdir)(DEV_REGISTRY_PATH, { recursive: true });
+  await (0, import_promises37.writeFile)(
     import_node_path64.default.join(DEV_REGISTRY_PATH, name2),
     // We don't currently do anything with the stored Wrangler version,
     // but if we need to make breaking changes to this format in the future
@@ -174761,7 +174820,7 @@ async function getRegisteredWorkers() {
 }
 async function unregisterWorker(name2) {
   try {
-    await (0, import_promises38.unlink)(import_node_path64.default.join(DEV_REGISTRY_PATH, name2));
+    await (0, import_promises37.unlink)(import_node_path64.default.join(DEV_REGISTRY_PATH, name2));
     const existingHeartbeat = heartbeats.get(name2);
     if (existingHeartbeat) {
       clearInterval(existingHeartbeat);
@@ -174772,17 +174831,17 @@ async function unregisterWorker(name2) {
   return;
 }
 async function loadWorkerDefinitions() {
-  await (0, import_promises38.mkdir)(DEV_REGISTRY_PATH, { recursive: true });
+  await (0, import_promises37.mkdir)(DEV_REGISTRY_PATH, { recursive: true });
   globalWorkers ??= {};
   const newWorkers = /* @__PURE__ */ new Set();
-  const workerDefinitions = await (0, import_promises38.readdir)(DEV_REGISTRY_PATH);
+  const workerDefinitions = await (0, import_promises37.readdir)(DEV_REGISTRY_PATH);
   for (const workerName of workerDefinitions) {
     try {
-      const file = await (0, import_promises38.readFile)(
+      const file = await (0, import_promises37.readFile)(
         import_node_path64.default.join(DEV_REGISTRY_PATH, workerName),
         "utf8"
       );
-      const stats = await (0, import_promises38.stat)(import_node_path64.default.join(DEV_REGISTRY_PATH, workerName));
+      const stats = await (0, import_promises37.stat)(import_node_path64.default.join(DEV_REGISTRY_PATH, workerName));
       if (stats.mtime.getTime() < Date.now() - 6e5) {
         await unregisterWorker(workerName);
       } else {
@@ -174803,12 +174862,12 @@ async function loadWorkerDefinitions() {
   }
   return globalWorkers;
 }
-var import_node_fs34, import_promises38, import_node_path64, util3, DEV_REGISTRY_PATH, heartbeats, globalWorkers, globalWatcher, FileRegistry;
+var import_node_fs34, import_promises37, import_node_path64, util3, DEV_REGISTRY_PATH, heartbeats, globalWorkers, globalWatcher, FileRegistry;
 var init_file_registry = __esm({
   "src/dev-registry/file-registry.ts"() {
     init_import_meta_url();
     import_node_fs34 = require("fs");
-    import_promises38 = require("fs/promises");
+    import_promises37 = require("fs/promises");
     import_node_path64 = __toESM(require("path"));
     util3 = __toESM(require("util"));
     init_esm4();
@@ -175010,6 +175069,24 @@ function registerDevHotKeys(devEnv, args) {
         );
       }, "handler")
     },
+    {
+      keys: ["r"],
+      label: "rebuild container(s)",
+      disabled: /* @__PURE__ */ __name(() => {
+        return !devEnv.config.latestConfig?.dev?.enableContainers || !devEnv.config.latestConfig?.containers?.length;
+      }, "disabled"),
+      handler: /* @__PURE__ */ __name(async () => {
+        const newContainerBuildId = (0, import_crypto7.randomUUID)().slice(0, 8);
+        devEnv.runtimes.map(async (runtime) => {
+          if (runtime instanceof LocalRuntimeController) {
+            await runtime.cleanupContainers();
+          }
+        });
+        await devEnv.config.patch({
+          dev: { containerBuildId: newContainerBuildId }
+        });
+      }, "handler")
+    },
     {
       keys: ["l"],
       disabled: /* @__PURE__ */ __name(() => args.forceLocal ?? false, "disabled"),
@@ -175035,25 +175112,6 @@ function registerDevHotKeys(devEnv, args) {
       handler: /* @__PURE__ */ __name(async () => {
         await devEnv.teardown();
       }, "handler")
-    },
-    {
-      keys: ["r"],
-      // omitting the label means it won't be printed but is still enabled
-      // label: "rebuild container",
-      handler: /* @__PURE__ */ __name(async () => {
-        if (!devEnv.config.latestConfig?.dev?.enableContainers || !devEnv.config.latestConfig?.containers?.length) {
-          return;
-        }
-        const newContainerBuildId = (0, import_crypto7.randomUUID)().slice(0, 8);
-        devEnv.runtimes.map(async (runtime) => {
-          if (runtime instanceof LocalRuntimeController) {
-            await runtime.cleanupContainers();
-          }
-        });
-        await devEnv.config.patch({
-          dev: { containerBuildId: newContainerBuildId }
-        });
-      }, "handler")
     }
   ]);
   return unregisterHotKeys;
@@ -177585,9 +177643,6 @@ async function startDev(args) {
     if (Array.isArray(args.config)) {
       const runtime = new MultiworkerRuntimeController(args.config.length);
       const primaryDevEnv = new DevEnv({ runtimes: [runtime] });
-      if (isInteractive2() && args.showInteractiveDevSession !== false) {
-        unregisterHotKeys = registerDevHotKeys(primaryDevEnv, args);
-      }
       devEnv = [
         await setupDevEnv(primaryDevEnv, args.config[0], authHook, {
           ...args,
@@ -177613,6 +177668,9 @@ async function startDev(args) {
           })
         )
       );
+      if (isInteractive2() && args.showInteractiveDevSession !== false) {
+        unregisterHotKeys = registerDevHotKeys(primaryDevEnv, args);
+      }
     } else {
       devEnv = new DevEnv();
       void devEnv.proxy.ready.promise.then(({ url: url4 }) => {
@@ -177652,10 +177710,10 @@ async function startDev(args) {
           );
         });
       }
+      await setupDevEnv(devEnv, args.config, authHook, args);
       if (isInteractive2() && args.showInteractiveDevSession !== false) {
         unregisterHotKeys = registerDevHotKeys(devEnv, args);
       }
-      await setupDevEnv(devEnv, args.config, authHook, args);
     }
     return {
       devEnv: Array.isArray(devEnv) ? devEnv[0] : devEnv,