wrangler 4.3.0 → 4.4.0

package/wrangler-dist/cli.js

@@ -81177,7 +81177,7 @@ var import_undici3 = __toESM(require_undici());
 
 // package.json
 var name = "wrangler";
-var version = "4.3.0";
+var version = "4.4.0";
 
 // src/environment-variables/misc-variables.ts
 init_import_meta_url();
@@ -90160,7 +90160,8 @@ var DefaultScopes = {
   "ssl_certs:write": "See and manage mTLS certificates for your account",
   "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"
+  "pipelines:write": "See and change Cloudflare Pipelines configurations and data",
+  "secrets_store:write": "See and change secrets + stores within the Secrets Store"
 };
 var OptionalScopes = {
   "cloudchamber:write": "Manage Cloudchamber"
@@ -93050,7 +93051,6 @@ async function buildMiniflareOptions(log2, config, proxyToUserWorkerAuthenticati
     liveReload: config.liveReload,
     upstream,
     unsafeProxySharedSecret: proxyToUserWorkerAuthenticationSecret,
-    unsafeEnableAssetsRpc: getFlag("ASSETS_RPC"),
     log: log2,
     verbose: logger.loggerLevel === "debug",
     handleRuntimeStdio,
@@ -114338,8 +114338,7 @@ function createHandler(def) {
       await def.validateArgs?.(args);
       const experimentalFlags = def.behaviour?.overrideExperimentalFlags ? def.behaviour?.overrideExperimentalFlags(args) : {
         MULTIWORKER: false,
-        RESOURCES_PROVISION: args.experimentalProvision ?? false,
-        ASSETS_RPC: false
+        RESOURCES_PROVISION: args.experimentalProvision ?? false
       };
       await run(
         experimentalFlags,
@@ -116984,8 +116983,7 @@ var deployCommand = createCommand({
     useConfigRedirectIfAvailable: true,
     overrideExperimentalFlags: /* @__PURE__ */ __name((args) => ({
       MULTIWORKER: false,
-      RESOURCES_PROVISION: args.experimentalProvision ?? false,
-      ASSETS_RPC: false
+      RESOURCES_PROVISION: args.experimentalProvision ?? false
     }), "overrideExperimentalFlags")
   },
   validateArgs(args) {
@@ -123360,8 +123358,7 @@ ${JSON.stringify(defaultRoutesJSONSpec, null, 2)}`
   const devServer = await run(
     {
       MULTIWORKER: Array.isArray(args.config),
-      RESOURCES_PROVISION: false,
-      ASSETS_RPC: false
+      RESOURCES_PROVISION: false
     },
     () => startDev({
       script: scriptEntrypoint,
@@ -123430,8 +123427,7 @@ ${JSON.stringify(defaultRoutesJSONSpec, null, 2)}`
       config: Array.isArray(args.config) ? args.config : void 0,
       site: void 0,
       siteInclude: void 0,
-      siteExclude: void 0,
-      experimentalAssetsRpc: false
+      siteExclude: void 0
     })
   );
   sendMetricsEvent("run pages dev");
@@ -132963,6 +132959,662 @@ var r2BucketSippyGetCommand = createCommand({
   }
 });
 
+// src/secrets-store/index.ts
+init_import_meta_url();
+var secretsStoreNamespace = createNamespace({
+  metadata: {
+    description: `\u{1F510} Manage the Secrets Store`,
+    status: "alpha",
+    owner: "Product: SSL"
+  }
+});
+var secretsStoreStoreNamespace = createNamespace({
+  metadata: {
+    description: "\u{1F510} Manage Stores within the Secrets Store",
+    status: "alpha",
+    owner: "Product: SSL"
+  }
+});
+var secretsStoreSecretNamespace = createNamespace({
+  metadata: {
+    description: "\u{1F510} Manage Secrets within the Secrets Store",
+    status: "alpha",
+    owner: "Product: SSL"
+  }
+});
+
+// src/secrets-store/commands.ts
+init_import_meta_url();
+
+// src/secrets-store/client.ts
+init_import_meta_url();
+async function createStore(accountId, body) {
+  return await fetchResult(`/accounts/${accountId}/secrets_store/stores`, {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+}
+__name(createStore, "createStore");
+async function deleteStore(accountId, storeId) {
+  return await fetchResult(
+    `/accounts/${accountId}/secrets_store/stores/${storeId}`,
+    {
+      method: "DELETE"
+    }
+  );
+}
+__name(deleteStore, "deleteStore");
+async function listStores(accountId, urlParams) {
+  return await fetchResult(
+    `/accounts/${accountId}/secrets_store/stores`,
+    {
+      method: "GET"
+    },
+    urlParams
+  );
+}
+__name(listStores, "listStores");
+async function listSecrets(accountId, storeId, urlParams) {
+  return await fetchResult(
+    `/accounts/${accountId}/secrets_store/stores/${storeId}/secrets`,
+    {
+      method: "GET"
+    },
+    urlParams
+  );
+}
+__name(listSecrets, "listSecrets");
+async function getSecret(accountId, storeId, secretId) {
+  return await fetchResult(
+    `/accounts/${accountId}/secrets_store/stores/${storeId}/secrets/${secretId}`,
+    {
+      method: "GET"
+    }
+  );
+}
+__name(getSecret, "getSecret");
+async function createSecret(accountId, storeId, body) {
+  return await fetchResult(
+    `/accounts/${accountId}/secrets_store/stores/${storeId}/secrets`,
+    {
+      method: "POST",
+      body: JSON.stringify([body])
+    }
+  );
+}
+__name(createSecret, "createSecret");
+async function updateSecret(accountId, storeId, secretId, body) {
+  return await fetchResult(
+    `/accounts/${accountId}/secrets_store/stores/${storeId}/secrets/${secretId}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify(body)
+    }
+  );
+}
+__name(updateSecret, "updateSecret");
+async function deleteSecret(accountId, storeId, secretId) {
+  return await fetchResult(
+    `/accounts/${accountId}/secrets_store/stores/${storeId}/secrets/${secretId}`,
+    {
+      method: "DELETE"
+    }
+  );
+}
+__name(deleteSecret, "deleteSecret");
+async function duplicateSecret(accountId, storeId, secretId, body) {
+  return await fetchResult(
+    `/accounts/${accountId}/secrets_store/stores/${storeId}/secrets/${secretId}/duplicate`,
+    {
+      method: "POST",
+      body: JSON.stringify(body)
+    }
+  );
+}
+__name(duplicateSecret, "duplicateSecret");
+
+// src/secrets-store/commands.ts
+var secretsStoreStoreCreateCommand = createCommand({
+  metadata: {
+    description: "Create a store within an account",
+    status: "alpha",
+    owner: "Product: SSL"
+  },
+  positionalArgs: ["name"],
+  args: {
+    name: {
+      type: "string",
+      description: "Name of the store",
+      demandOption: true,
+      requiresArg: true
+    },
+    remote: {
+      type: "boolean",
+      description: "Execute command against remote Secrets Store",
+      default: false
+    }
+  },
+  async handler(args, { config }) {
+    let store;
+    logger.log(`\u{1F510} Creating store... (Name: ${args.name})`);
+    if (args.remote) {
+      const accountId = config.account_id || await getAccountId();
+      store = await createStore(accountId, { name: args.name });
+    } else {
+      logger.log(`Local mode enabled, this command is a no-op.`);
+      return;
+    }
+    logger.log(`\u2705 Created store! (Name: ${args.name}, ID: ${store.id})`);
+  }
+});
+var secretsStoreStoreDeleteCommand = createCommand({
+  metadata: {
+    description: "Delete a store within an account",
+    status: "alpha",
+    owner: "Product: SSL"
+  },
+  positionalArgs: ["store-id"],
+  args: {
+    "store-id": {
+      type: "string",
+      description: "ID of the store",
+      demandOption: true,
+      requiresArg: true
+    },
+    remote: {
+      type: "boolean",
+      description: "Execute command against remote Secrets Store",
+      default: false
+    }
+  },
+  async handler(args, { config }) {
+    logger.log(`\u{1F510} Deleting store... (Name: ${args.storeId})`);
+    if (args.remote) {
+      const accountId = config.account_id || await getAccountId();
+      await deleteStore(accountId, args.storeId);
+    } else {
+      logger.log(`Local mode enabled, this command is a no-op.`);
+      return;
+    }
+    logger.log(`\u2705 Deleted store! (ID: ${args.storeId})`);
+  }
+});
+var secretsStoreStoreListCommand = createCommand({
+  metadata: {
+    description: "List stores within an account",
+    status: "alpha",
+    owner: "Product: SSL"
+  },
+  args: {
+    page: {
+      describe: 'Page number of stores listing results, can configure page size using "per-page"',
+      type: "number",
+      default: 1
+    },
+    "per-page": {
+      describe: "Number of stores to show per page",
+      type: "number",
+      default: 10
+    },
+    remote: {
+      type: "boolean",
+      description: "Execute command against remote Secrets Store",
+      default: false
+    }
+  },
+  async handler(args, { config }) {
+    const urlParams = new URLSearchParams();
+    urlParams.set("per_page", args.perPage.toString());
+    urlParams.set("page", args.page.toString());
+    logger.log(`\u{1F510} Listing stores...`);
+    let stores;
+    if (args.remote) {
+      const accountId = config.account_id || await getAccountId();
+      stores = await listStores(accountId, urlParams);
+    } else {
+      throw new UserError(
+        "No local dev version of this command available, need to include --remote in command",
+        { telemetryMessage: true }
+      );
+    }
+    if (stores.length === 0) {
+      throw new UserError("List request returned no stores.", {
+        telemetryMessage: true
+      });
+    } else {
+      const prettierStores = stores.sort((a5, b6) => a5.name.localeCompare(b6.name)).map((store) => ({
+        Name: store.name,
+        ID: store.id,
+        AccountID: store.account_id,
+        Created: new Date(store.created).toLocaleString(),
+        Modified: new Date(store.modified).toLocaleString()
+      }));
+      logger.table(prettierStores);
+    }
+  }
+});
+var secretsStoreSecretListCommand = createCommand({
+  metadata: {
+    description: "List secrets within a store",
+    status: "alpha",
+    owner: "Product: SSL"
+  },
+  positionalArgs: ["store-id"],
+  args: {
+    "store-id": {
+      describe: "ID of the store in which to list secrets",
+      type: "string",
+      demandOption: true,
+      requiresArg: true
+    },
+    page: {
+      describe: 'Page number of secrets listing results, can configure page size using "per-page"',
+      type: "number",
+      default: 1
+    },
+    "per-page": {
+      describe: "Number of secrets to show per page",
+      type: "number",
+      default: 10
+    },
+    remote: {
+      type: "boolean",
+      description: "Execute command against remote Secrets Store",
+      default: false
+    }
+  },
+  async handler(args, { config }) {
+    const urlParams = new URLSearchParams();
+    urlParams.set("per_page", args.perPage.toString());
+    urlParams.set("page", args.page.toString());
+    logger.log(
+      `\u{1F510} Listing secrets... (store-id: ${args.storeId}, page: ${args.page}, per-page: ${args.perPage})`
+    );
+    let secrets;
+    if (args.remote) {
+      const accountId = config.account_id || await getAccountId();
+      secrets = await listSecrets(accountId, args.storeId, urlParams);
+    } else {
+      throw new UserError(
+        "No local dev version of this command available, need to include --remote in command",
+        { telemetryMessage: true }
+      );
+    }
+    if (secrets.length === 0) {
+      throw new FatalError("List request returned no secrets.", 1, {
+        telemetryMessage: true
+      });
+    } else {
+      const prettierSecrets = secrets.map((secret2) => ({
+        Name: secret2.name,
+        ID: secret2.id,
+        Comment: secret2.comment,
+        Scopes: secret2.scopes.join(", "),
+        Status: secret2.status === "active" ? "active " : "pending",
+        Created: new Date(secret2.created).toLocaleString(),
+        Modified: new Date(secret2.modified).toLocaleString()
+      }));
+      logger.table(prettierSecrets);
+    }
+  }
+});
+var secretsStoreSecretGetCommand = createCommand({
+  metadata: {
+    description: "Get a secret within a store",
+    status: "alpha",
+    owner: "Product: SSL"
+  },
+  positionalArgs: ["store-id"],
+  args: {
+    "store-id": {
+      describe: "ID of the store in which the secret resides",
+      type: "string",
+      demandOption: true,
+      requiresArg: true
+    },
+    "secret-id": {
+      describe: "ID of the secret to retrieve",
+      type: "string",
+      demandOption: true,
+      requiresArg: true
+    },
+    remote: {
+      type: "boolean",
+      description: "Execute command against remote Secrets Store",
+      default: false
+    }
+  },
+  async handler(args, { config }) {
+    logger.log(`\u{1F510} Getting secret... (ID: ${args.secretId})`);
+    let secret2;
+    if (args.remote) {
+      const accountId = config.account_id || await getAccountId();
+      secret2 = await getSecret(accountId, args.storeId, args.secretId);
+    } else {
+      throw new UserError(
+        "No local dev version of this command available, need to include --remote in command",
+        { telemetryMessage: true }
+      );
+    }
+    const prettierSecret = [
+      {
+        Name: secret2.name,
+        ID: secret2.id,
+        StoreID: secret2.store_id,
+        Comment: secret2.comment,
+        Scopes: secret2.scopes.join(", "),
+        Status: secret2.status === "active" ? "active " : "pending",
+        Created: new Date(secret2.created).toLocaleString(),
+        Modified: new Date(secret2.modified).toLocaleString()
+      }
+    ];
+    logger.table(prettierSecret);
+  }
+});
+var secretsStoreSecretCreateCommand = createCommand({
+  metadata: {
+    description: "Create a secret within a store",
+    status: "alpha",
+    owner: "Product: SSL"
+  },
+  positionalArgs: ["store-id"],
+  args: {
+    "store-id": {
+      describe: "ID of the store in which the secret resides",
+      type: "string",
+      requiresArg: true,
+      demandOption: true
+    },
+    name: {
+      describe: "Name of the secret",
+      type: "string",
+      requiresArg: true,
+      demandOption: true
+    },
+    value: {
+      describe: "Value of the secret (Note: Only for testing. Not secure as this will leave secret value in plain-text in terminal history, exclude this flag and use automatic prompt instead)",
+      type: "string"
+    },
+    scopes: {
+      describe: 'Scopes for the secret (comma-separated list of scopes eg:"workers")',
+      type: "string",
+      requiresArg: true,
+      demandOption: true
+    },
+    comment: {
+      describe: "Comment for the secret",
+      type: "string"
+    },
+    remote: {
+      type: "boolean",
+      description: "Execute command against remote Secrets Store",
+      default: false
+    }
+  },
+  async handler(args, { config }) {
+    let secretValue = "";
+    if (!args.value) {
+      const isInteractive3 = process.stdin.isTTY;
+      secretValue = trimTrailingWhitespace(
+        isInteractive3 ? await prompt("Enter a secret value:", { isSecret: true }) : await readFromStdin()
+      );
+    } else {
+      secretValue = args.value;
+    }
+    if (!secretValue) {
+      throw new UserError("Need to pass in a value when creating a secret.");
+    }
+    logger.log(
+      `
+\u{1F510} Creating secret... (Name: ${args.name}, Value: REDACTED, Scopes: ${args.scopes}, Comment: ${args.comment})`
+    );
+    let secrets;
+    if (args.remote) {
+      const accountId = config.account_id || await getAccountId();
+      secrets = await createSecret(accountId, args.storeId, {
+        name: args.name,
+        value: secretValue,
+        scopes: args.scopes.split(","),
+        comment: args.comment
+      });
+    } else {
+      throw new UserError(
+        "No local dev version of this command available, need to include --remote in command",
+        { telemetryMessage: true }
+      );
+    }
+    if (secrets.length === 0) {
+      throw new FatalError("Failed to create a secret.", 1, {
+        telemetryMessage: true
+      });
+    }
+    const secret2 = secrets[0];
+    logger.log(`\u2705 Created secret! (ID: ${secret2.id})`);
+    const prettierSecret = [
+      {
+        Name: secret2.name,
+        ID: secret2.id,
+        StoreID: secret2.store_id,
+        Comment: secret2.comment,
+        Scopes: secret2.scopes.join(", "),
+        Status: secret2.status,
+        Created: new Date(secret2.created).toLocaleString(),
+        Modified: new Date(secret2.modified).toLocaleString()
+      }
+    ];
+    logger.table(prettierSecret);
+  }
+});
+var secretsStoreSecretUpdateCommand = createCommand({
+  metadata: {
+    description: "Update a secret within a store",
+    status: "alpha",
+    owner: "Product: SSL"
+  },
+  positionalArgs: ["store-id"],
+  args: {
+    "store-id": {
+      describe: "ID of the store in which the secret resides",
+      type: "string",
+      requiresArg: true,
+      demandOption: true
+    },
+    "secret-id": {
+      describe: "ID of the secret to update",
+      type: "string",
+      requiresArg: true,
+      demandOption: true
+    },
+    value: {
+      describe: "Updated value of the secret (Note: Only for testing. Not secure as this will leave secret value in plain-text in terminal history, exclude this flag and use automatic prompt instead)",
+      type: "string"
+    },
+    scopes: {
+      describe: 'Updated scopes for the secret (comma-separated list of scopes eg:"workers")',
+      type: "string"
+    },
+    comment: {
+      describe: "Updated comment for the secret",
+      type: "string"
+    },
+    remote: {
+      type: "boolean",
+      description: "Execute command against remote Secrets Store",
+      default: false
+    }
+  },
+  async handler(args, { config }) {
+    let secretValue = "";
+    if (!args.value) {
+      const confirmValueUpdate = await confirm(
+        "Do you want to update the secret value?",
+        { defaultValue: false }
+      );
+      if (confirmValueUpdate) {
+        const isInteractive3 = process.stdin.isTTY;
+        secretValue = trimTrailingWhitespace(
+          isInteractive3 ? await prompt("Enter a secret value:", { isSecret: true }) : await readFromStdin()
+        );
+      }
+    } else {
+      secretValue = args.value;
+    }
+    if (!secretValue && !args.scopes && !args.comment) {
+      throw new UserError(
+        "Need to pass in a new field using `--value`, `--scopes`, or `--comment` to update a secret."
+      );
+    }
+    logger.log(`\u{1F510} Updating secret... (ID: ${args.secretId})`);
+    let secret2;
+    if (args.remote) {
+      const accountId = config.account_id || await getAccountId();
+      secret2 = await updateSecret(accountId, args.storeId, args.secretId, {
+        ...secretValue && { value: secretValue },
+        ...args.scopes && { scopes: args.scopes.split(",") },
+        ...args.comment && { comment: args.comment }
+      });
+    } else {
+      throw new UserError(
+        "No local dev version of this command available, need to include --remote in command",
+        { telemetryMessage: true }
+      );
+    }
+    logger.log(`\u2705 Updated secret! (ID: ${secret2.id})`);
+    const prettierSecret = [
+      {
+        Name: secret2.name,
+        ID: secret2.id,
+        StoreID: secret2.store_id,
+        Comment: secret2.comment,
+        Scopes: secret2.scopes.join(", "),
+        Status: secret2.status,
+        Created: new Date(secret2.created).toLocaleString(),
+        Modified: new Date(secret2.modified).toLocaleString()
+      }
+    ];
+    logger.table(prettierSecret);
+  }
+});
+var secretsStoreSecretDeleteCommand = createCommand({
+  metadata: {
+    description: "Delete a secret within a store",
+    status: "alpha",
+    owner: "Product: SSL"
+  },
+  positionalArgs: ["store-id"],
+  args: {
+    "store-id": {
+      describe: "ID of the store in which the secret resides",
+      type: "string",
+      requiresArg: true,
+      demandOption: true
+    },
+    "secret-id": {
+      describe: "ID of the secret to delete",
+      type: "string",
+      requiresArg: true,
+      demandOption: true
+    },
+    remote: {
+      type: "boolean",
+      description: "Execute command against remote Secrets Store",
+      default: false
+    }
+  },
+  async handler(args, { config }) {
+    logger.log(`\u{1F510} Deleting secret... (ID: ${args.secretId})`);
+    if (args.remote) {
+      const accountId = config.account_id || await getAccountId();
+      await deleteSecret(accountId, args.storeId, args.secretId);
+    } else {
+      throw new UserError(
+        "No local dev version of this command available, need to include --remote in command",
+        { telemetryMessage: true }
+      );
+    }
+    logger.log(`\u2705 Deleted secret! (ID: ${args.secretId})`);
+  }
+});
+var secretsStoreSecretDuplicateCommand = createCommand({
+  metadata: {
+    description: "Duplicate a secret within a store",
+    status: "alpha",
+    owner: "Product: SSL"
+  },
+  positionalArgs: ["store-id"],
+  args: {
+    "store-id": {
+      describe: "ID of the store in which the secret resides",
+      type: "string",
+      requiresArg: true,
+      demandOption: true
+    },
+    "secret-id": {
+      describe: "ID of the secret to duplicate the secret value of",
+      type: "string",
+      requiresArg: true,
+      demandOption: true
+    },
+    name: {
+      describe: "Name of the new secret",
+      type: "string",
+      requiresArg: true,
+      demandOption: true
+    },
+    scopes: {
+      describe: "Scopes for the new secret",
+      type: "string",
+      requiresArg: true,
+      demandOption: true
+    },
+    comment: {
+      describe: "Comment for the new secret",
+      type: "string"
+    },
+    remote: {
+      type: "boolean",
+      description: "Execute command against remote Secrets Store",
+      default: false
+    }
+  },
+  async handler(args, { config }) {
+    logger.log(`\u{1F510} Duplicating secret... (ID: ${args.secretId})`);
+    let duplicatedSecret;
+    if (args.remote) {
+      const accountId = config.account_id || await getAccountId();
+      duplicatedSecret = await duplicateSecret(
+        accountId,
+        args.storeId,
+        args.secretId,
+        {
+          name: args.name,
+          scopes: args.scopes.split(","),
+          comment: args.comment || ""
+        }
+      );
+    } else {
+      throw new UserError(
+        "No local dev version of this command available, need to include --remote in command",
+        { telemetryMessage: true }
+      );
+    }
+    logger.log(`\u2705 Duplicated secret! (ID: ${duplicatedSecret.id})`);
+    const prettierSecret = [
+      {
+        Name: duplicatedSecret.name,
+        ID: duplicatedSecret.id,
+        StoreID: duplicatedSecret.store_id,
+        Comment: duplicatedSecret.comment,
+        Scopes: duplicatedSecret.scopes.join(", "),
+        Status: duplicatedSecret.status,
+        Created: new Date(duplicatedSecret.created).toLocaleString(),
+        Modified: new Date(duplicatedSecret.modified).toLocaleString()
+      }
+    ];
+    logger.table(prettierSecret);
+  }
+});
+
 // src/sentry/index.ts
 init_import_meta_url();
 
@@ -146234,8 +146886,7 @@ var versionsUploadCommand = createCommand({
     useConfigRedirectIfAvailable: true,
     overrideExperimentalFlags: /* @__PURE__ */ __name((args) => ({
       MULTIWORKER: false,
-      RESOURCES_PROVISION: args.experimentalProvision ?? false,
-      ASSETS_RPC: false
+      RESOURCES_PROVISION: args.experimentalProvision ?? false
     }), "overrideExperimentalFlags")
   },
   handler: /* @__PURE__ */ __name(async function versionsUploadHandler(args, { config }) {
@@ -146930,9 +147581,15 @@ var workflowsDeleteCommand = createCommand({
     }
   },
   positionalArgs: ["name"],
-  async handler(args) {
-    logger.info("\u{1F6AB} delete command not yet implement");
-    logger.log(`\u{1F6AB} Workflow "${args.name}" NOT removed`);
+  async handler(args, { config }) {
+    const accountId = await requireAuth(config);
+    await fetchResult(`/accounts/${accountId}/workflows/${args.name}`, {
+      method: "DELETE"
+    });
+    logger.log(
+      `\u2705 Workflow "${args.name}" removed successfully. 
+ Note that running instances might take a few minutes to be properly terminated.`
+    );
   }
 });
 
@@ -148205,6 +148862,65 @@ var workflowsInstancesTerminateCommand = createCommand({
   }
 });
 
+// src/workflows/commands/instances/terminate-all.ts
+init_import_meta_url();
+var workflowsInstancesTerminateAllCommand = createCommand({
+  metadata: {
+    description: "Terminate all workflow instances",
+    owner: "Product: Workflows",
+    status: "open-beta",
+    hidden: true
+  },
+  positionalArgs: ["name"],
+  args: {
+    name: {
+      describe: "Name of the workflow",
+      type: "string",
+      demandOption: true
+    },
+    status: {
+      describe: "Filter instances to be terminated by status",
+      type: "string"
+    }
+  },
+  validateArgs: /* @__PURE__ */ __name((args) => {
+    const validStatusToTerminate = [
+      "queued",
+      "running",
+      "paused",
+      "waitingForPause",
+      "waiting"
+    ];
+    if (args.status !== void 0 && !validStatusToTerminate.includes(args.status)) {
+      throw new CommandLineArgsError(
+        `Provided status "${args.status}" is not valid, it must be one of the following: ${validStatusToTerminate.join(", ")}.`
+      );
+    }
+  }, "validateArgs"),
+  async handler(args, { config }) {
+    const accountId = await requireAuth(config);
+    const maybeURLQueryString = args.status !== void 0 ? new URLSearchParams({
+      status: args.status
+    }) : void 0;
+    const result = await fetchResult(
+      `/accounts/${accountId}/workflows/${args.name}/instances/terminate`,
+      {
+        method: "PUT"
+      },
+      maybeURLQueryString
+    );
+    if (result.status === "ok") {
+      logger.info(
+        `\u{1F977} A job to terminate instances from Workflow "${args.name}" ${args.status !== void 0 ? `with status "${args.status}"` : ""} has been started. It might take a few minutes to complete.`
+      );
+      return;
+    }
+    logger.info(
+      `\u{1F977} A job to terminate instances from Workflow "${args.name}" ${args.status !== void 0 ? `with status "${args.status}"` : ""} is already running. It might take a few minutes to complete.`
+    );
+  }
+});
+
 // src/workflows/commands/list.ts
 init_import_meta_url();
 var workflowsListCommand = createCommand({
@@ -148822,6 +149538,54 @@ function createCLIParser(argv) {
   wrangler.command("ai", "\u{1F916} Manage AI models", (aiYargs) => {
     return ai(aiYargs.command(subHelp));
   });
+  registry.define([
+    { command: "wrangler secrets-store", definition: secretsStoreNamespace },
+    {
+      command: "wrangler secrets-store store",
+      definition: secretsStoreStoreNamespace
+    },
+    {
+      command: "wrangler secrets-store store create",
+      definition: secretsStoreStoreCreateCommand
+    },
+    {
+      command: "wrangler secrets-store store delete",
+      definition: secretsStoreStoreDeleteCommand
+    },
+    {
+      command: "wrangler secrets-store store list",
+      definition: secretsStoreStoreListCommand
+    },
+    {
+      command: "wrangler secrets-store secret",
+      definition: secretsStoreSecretNamespace
+    },
+    {
+      command: "wrangler secrets-store secret create",
+      definition: secretsStoreSecretCreateCommand
+    },
+    {
+      command: "wrangler secrets-store secret list",
+      definition: secretsStoreSecretListCommand
+    },
+    {
+      command: "wrangler secrets-store secret get",
+      definition: secretsStoreSecretGetCommand
+    },
+    {
+      command: "wrangler secrets-store secret update",
+      definition: secretsStoreSecretUpdateCommand
+    },
+    {
+      command: "wrangler secrets-store secret delete",
+      definition: secretsStoreSecretDeleteCommand
+    },
+    {
+      command: "wrangler secrets-store secret duplicate",
+      definition: secretsStoreSecretDuplicateCommand
+    }
+  ]);
+  registry.registerNamespace("cert");
   registry.define([
     {
       command: "wrangler workflows",
@@ -148859,6 +149623,10 @@ function createCLIParser(argv) {
       command: "wrangler workflows instances terminate",
       definition: workflowsInstancesTerminateCommand
     },
+    {
+      command: "wrangler workflows instances terminate-all",
+      definition: workflowsInstancesTerminateAllCommand
+    },
     {
       command: "wrangler workflows instances pause",
       definition: workflowsInstancesPauseCommand
@@ -150484,9 +151252,10 @@ ${resolvedAssetsPath}`,
   const headers = maybeGetFile(path62.join(resolvedAssetsPath, HEADERS_FILENAME));
   const assetConfig = {
     html_handling: config.assets?.html_handling,
-    not_found_handling: config.assets?.not_found_handling
+    not_found_handling: config.assets?.not_found_handling,
     // The _redirects and _headers files are parsed in Miniflare in dev and parsing is not required for deploy
-    // Similarly, `compatibility_date` and `compatibility_flags` are populated by Miniflare from the Worker definition and also are not required for deploy
+    compatibility_date: config.compatibility_date,
+    compatibility_flags: config.compatibility_flags
   };
   return {
     directory: resolvedAssetsPath,
@@ -150935,8 +151704,7 @@ var dev = createCommand({
     provideConfig: false,
     overrideExperimentalFlags: /* @__PURE__ */ __name((args) => ({
       MULTIWORKER: Array.isArray(args.config),
-      RESOURCES_PROVISION: args.experimentalProvision ?? false,
-      ASSETS_RPC: args.experimentalAssetsRpc
+      RESOURCES_PROVISION: args.experimentalProvision ?? false
     }), "overrideExperimentalFlags")
   },
   metadata: {
@@ -151152,13 +151920,6 @@ var dev = createCommand({
       type: "boolean",
       describe: "Use a local lower-fidelity implementation of the Images binding",
       default: false
-    },
-    "experimental-assets-rpc": {
-      alias: "x-assets-rpc",
-      type: "boolean",
-      describe: "Support JSRPC bindings to Workers + Assets projects",
-      default: false,
-      hidden: true
     }
   },
   async validateArgs(args) {
@@ -151814,15 +152575,13 @@ unstable_dev()'s behaviour will likely change in future releases`
     experimentalVectorizeBindToProd: vectorizeBindToProd ?? false,
     experimentalImagesLocalMode: imagesLocalMode ?? false,
     enableIpc: options33?.experimental?.enableIpc,
-    nodeCompat: void 0,
-    experimentalAssetsRpc: false
+    nodeCompat: void 0
   };
   const devServer = await run(
     {
       // TODO: can we make this work?
       MULTIWORKER: false,
-      RESOURCES_PROVISION: false,
-      ASSETS_RPC: false
+      RESOURCES_PROVISION: false
     },
     () => startDev(devOptions)
   );
@@ -153776,8 +154535,7 @@ async function getPlatformProxy(options33 = {}) {
   const miniflareOptions = await run(
     {
       MULTIWORKER: false,
-      RESOURCES_PROVISION: false,
-      ASSETS_RPC: false
+      RESOURCES_PROVISION: false
     },
     () => getMiniflareOptionsFromConfig(rawConfig, env6, options33)
   );