@adobe-commerce/aio-toolkit 1.2.5 → 1.2.7

package/dist/aio-toolkit-cli-workflow/bin/cli.js

@@ -0,0 +1,2048 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/framework/command/registry/index.ts
+var _CommandRegistry, CommandRegistry;
+var init_registry = __esm({
+  "src/commands/framework/command/registry/index.ts"() {
+    "use strict";
+    _CommandRegistry = class _CommandRegistry {
+      /**
+       * Static method to get the commands - must be implemented by subclasses
+       *
+       * @returns {CommandDescriptor[]} The commands
+       */
+      static getCommands() {
+        throw new Error("getCommands() must be implemented by subclass");
+      }
+      /**
+       * Static execute method to execute a command
+       *
+       * @param {string} type - The name of the command to execute
+       * @param {...any} args - The arguments to pass to the command
+       * @returns {Promise<CommandResult>} The execution result
+       */
+      static async execute(type = "help", ...args2) {
+        const command2 = this.getCommands().find((cmd) => cmd.name === type);
+        if (!command2) {
+          return {
+            success: false,
+            message: `Unknown command: ${type}`
+          };
+        }
+        return await command2.execute(...args2);
+      }
+    };
+    __name(_CommandRegistry, "CommandRegistry");
+    CommandRegistry = _CommandRegistry;
+  }
+});
+
+// src/commands/framework/command/abstract/index.ts
+var _CommandAbstract, CommandAbstract;
+var init_abstract = __esm({
+  "src/commands/framework/command/abstract/index.ts"() {
+    "use strict";
+    _CommandAbstract = class _CommandAbstract {
+      /**
+       * Method to get the name of the command
+       * @returns {string} The name of the command
+       */
+      static getName() {
+        throw new Error("getName() must be implemented by subclass");
+      }
+      /**
+       * Method to get the description of the command
+       * @returns {string} The description of the command
+       */
+      static getDescription() {
+        throw new Error("getDescription() must be implemented by subclass");
+      }
+      /**
+       * Method to execute the command
+       * @param {...any} args - Command arguments
+       * @returns {Promise<CommandResult>} The execution result
+       */
+      static execute(...args2) {
+        throw new Error(`execute() must be implemented by subclass: ${args2.join(", ")}`);
+      }
+    };
+    __name(_CommandAbstract, "CommandAbstract");
+    CommandAbstract = _CommandAbstract;
+  }
+});
+
+// src/commands/framework/command/base-help/index.ts
+var _BaseHelpCommand, BaseHelpCommand;
+var init_base_help = __esm({
+  "src/commands/framework/command/base-help/index.ts"() {
+    "use strict";
+    init_abstract();
+    _BaseHelpCommand = class _BaseHelpCommand extends CommandAbstract {
+      /**
+       * Method to get the description of the command
+       * @returns {string} The description of the command
+       */
+      static getName() {
+        return this.NAME;
+      }
+      /**
+       * Static method to get the commands - must be implemented by subclasses
+       *
+       * @returns {CommandDescriptor[]} The commands
+       */
+      static getCliName() {
+        throw new Error("getCliName() must be implemented by subclass");
+      }
+      /**
+       * Get the commands dynamically
+       *
+       * @returns {CommandDescriptor[]} The commands array
+       */
+      static getCommands() {
+        throw new Error("getCommands() must be implemented by subclass");
+      }
+      /**
+       * Method to execute the command
+       * @param {...any} _args - Command arguments (unused)
+       * @returns {Promise<CommandResult>} The execution result
+       */
+      static execute(..._args) {
+        const helpText = [
+          this.getUsageSection(),
+          this.getCommandsSection(),
+          this.getExamplesSection(),
+          this.getFooterSection()
+        ].join("\n");
+        return {
+          success: true,
+          message: helpText
+        };
+      }
+      /**
+       * Get the usage section
+       *
+       * @returns {string} The usage section
+       */
+      static getUsageSection() {
+        return `Usage: npx ${this.getCliName()} <command>`;
+      }
+      /**
+       * Get the commands section
+       *
+       * @returns {string} The commands section
+       */
+      static getCommandsSection() {
+        const commands = this.getCommands();
+        const maxNameLength = Math.max(...commands.map((cmd) => cmd.name.length));
+        const commandsList = commands.map((cmd) => `  ${cmd.name.padEnd(maxNameLength + 2)}${cmd.description}`).join("\n");
+        return `
+Commands:
+${commandsList}`;
+      }
+      /**
+       * Get the examples section
+       *
+       * @returns {string} The examples section
+       */
+      static getExamplesSection() {
+        const commands = this.getCommands();
+        const examples = commands.map((cmd) => `  npx ${this.getCliName()} ${cmd.name}`).join("\n");
+        return `
+Examples:
+${examples}`;
+      }
+      /**
+       * Get the footer section with additional information
+       *
+       * @returns {string} The footer section
+       */
+      static getFooterSection() {
+        return `
+For more information, visit:
+  ${this.repositoryUrl}
+`;
+      }
+    };
+    __name(_BaseHelpCommand, "BaseHelpCommand");
+    /**
+     * Static command name
+     */
+    _BaseHelpCommand.NAME = "help";
+    /**
+     * Static repository URL
+     */
+    _BaseHelpCommand.repositoryUrl = "https://github.com/adobe-commerce/aio-toolkit";
+    BaseHelpCommand = _BaseHelpCommand;
+  }
+});
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "@adobe-commerce/aio-toolkit",
+      version: "1.2.7",
+      description: "A comprehensive TypeScript toolkit for Adobe App Builder applications providing standardized Adobe Commerce integrations, I/O Events orchestration, file storage utilities, authentication helpers, and robust backend development tools with 100% test coverage.",
+      main: "./dist/index.js",
+      module: "./dist/index.mjs",
+      types: "./dist/index.d.ts",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          import: "./dist/index.mjs",
+          require: "./dist/index.js"
+        }
+      },
+      files: [
+        "dist/**/*",
+        "files/**/*",
+        "onboard.config.default.yaml",
+        "README.md",
+        "CHANGELOG.md",
+        "LICENSE"
+      ],
+      bin: {
+        "aio-toolkit-cursor-context": "dist/aio-toolkit-cursor-context/bin/cli.js",
+        "aio-toolkit-onboard-events": "dist/aio-toolkit-onboard-events/bin/cli.js",
+        "aio-toolkit-cli-workflow": "dist/aio-toolkit-cli-workflow/bin/cli.js"
+      },
+      scripts: {
+        build: "tsup",
+        "build:watch": "tsup --watch",
+        clean: "rm -rf dist",
+        dev: "tsc --watch",
+        "type-check": "tsc --noEmit",
+        lint: "eslint src test --ext .ts",
+        "lint:fix": "eslint src test --ext .ts --fix",
+        format: 'prettier --write "src/**/*.ts" "test/**/*.ts"',
+        "format:check": 'prettier --check "src/**/*.ts" "test/**/*.ts"',
+        test: "jest --passWithNoTests",
+        "test:watch": "jest --watch",
+        "test:coverage": "jest --coverage",
+        "test:ci": "jest --ci --coverage --watchAll=false",
+        "test:fast": "jest --passWithNoTests --silent",
+        "pre-add": "echo '\u{1F528} Pre-add validation...' && npm run build && echo '\u2705 Ready to add files!'",
+        "safe-add": "npm run pre-add && git add",
+        "validate:commit": "npm run type-check && npm run lint:fix && npm run format && npm run test:fast",
+        "validate:push": "npm run format:check && npm run lint && npm run type-check && npm run test:ci && npm run build",
+        "security:audit": "npm audit --audit-level=moderate",
+        prepublishOnly: "npm run build",
+        prepare: "husky"
+      },
+      keywords: [
+        "adobe",
+        "app-builder",
+        "toolkit",
+        "backend",
+        "utilities",
+        "typescript",
+        "aio"
+      ],
+      author: "Hitarth Pattani <hitarth@example.com>",
+      license: "SEE LICENSE IN LICENSE",
+      dependencies: {
+        "@adobe-commerce/aio-services-kit": "^1.0.0",
+        "@aws-sdk/client-sqs": "^3.1045.0",
+        amqplib: "^1.0.3",
+        cloudevents: "^8.0.2",
+        dotenv: "^17.3.1",
+        got: "^11.8.6",
+        "node-fetch": "^2.7.0",
+        "oauth-1.0a": "^2.2.6",
+        openwhisk: "^3.21.8",
+        uuid: "^10.0.0",
+        yaml: "^2.0.0"
+      },
+      "lint-staged": {
+        "*.ts": [
+          "eslint --fix",
+          "prettier --write"
+        ]
+      },
+      devDependencies: {
+        "@adobe/aio-lib-db": "^1.0.1",
+        "@adobe/aio-lib-ims": "^7.0.2",
+        "@adobe/aio-lib-telemetry": "^1.1.3",
+        "@adobe/aio-sdk": "^6.0.0",
+        "@commitlint/cli": "^19.8.1",
+        "@commitlint/config-conventional": "^19.8.1",
+        "@opentelemetry/resources": "^2.0.0",
+        "@types/amqplib": "^0.10.8",
+        "@types/graphql": "^14.2.3",
+        "@types/jest": "^30.0.0",
+        "@types/node": "^20.10.0",
+        "@types/node-fetch": "^2.6.13",
+        "@types/uuid": "^10.0.0",
+        "@typescript-eslint/eslint-plugin": "^6.13.0",
+        "@typescript-eslint/parser": "^6.13.0",
+        eslint: "^8.55.0",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-plugin-prettier": "^5.0.1",
+        graphql: "^16.11.0",
+        husky: "^9.1.7",
+        jest: "^30.1.3",
+        "lint-staged": "^16.1.6",
+        prettier: "^3.1.0",
+        "ts-jest": "^29.4.1",
+        tsup: "^8.5.0",
+        typescript: "^5.9.2"
+      },
+      peerDependencies: {
+        "@adobe/aio-lib-db": ">=1.0.0",
+        "@adobe/aio-lib-ims": ">=7.0.0",
+        "@adobe/aio-lib-telemetry": ">=1.0.0",
+        "@adobe/aio-sdk": ">=6.0.0",
+        "@opentelemetry/resources": ">=2.0.0",
+        graphql: ">=14.0.0",
+        typescript: ">=4.9.0"
+      },
+      engines: {
+        node: ">=18.0.0"
+      },
+      publishConfig: {
+        access: "public"
+      }
+    };
+  }
+});
+
+// src/commands/cli-workflow/lib/help/index.ts
+var version, _CliWorkflowHelp, CliWorkflowHelp;
+var init_help = __esm({
+  "src/commands/cli-workflow/lib/help/index.ts"() {
+    "use strict";
+    init_base_help();
+    ({ version } = require_package());
+    _CliWorkflowHelp = class _CliWorkflowHelp extends BaseHelpCommand {
+      /**
+       * Returns the CLI executable name.
+       * @returns CLI name string
+       */
+      static getCliName() {
+        return "aio-toolkit-cli-workflow";
+      }
+      /**
+       * Returns the help command description.
+       * @returns Command description string
+       */
+      static getDescription() {
+        return this.DESCRIPTION;
+      }
+      /**
+       * Returns registered commands (uses dynamic require to avoid circular dependencies).
+       * @returns Array of command descriptors
+       */
+      static getCommands() {
+        const { CliWorkflowManager: CliWorkflowManager2 } = (init_lib(), __toCommonJS(lib_exports));
+        return CliWorkflowManager2.getCommands();
+      }
+      /**
+       * Renders the full help text with version and commands (including inline options).
+       */
+      static execute(..._args) {
+        const cli = this.getCliName();
+        const commands = this.getCommands();
+        const maxNameLength = Math.max(...commands.map((cmd) => cmd.name.length));
+        const commandsList = commands.map((cmd) => {
+          const namePadded = cmd.name.padEnd(maxNameLength + 2);
+          let entry = `  ${namePadded}${cmd.description}`;
+          if (cmd.options && cmd.options.length > 0) {
+            const optionLines = cmd.options.map((opt) => `    ${opt.flag.padEnd(24)}${opt.description}`).join("\n");
+            entry += `
+${optionLines}`;
+          }
+          return entry;
+        }).join("\n");
+        const helpText = [
+          `${cli} v${version}`,
+          `
+Usage: npx ${cli} <command> [options]`,
+          `
+Commands:
+${commandsList}`,
+          `
+For more information, visit:
+  https://github.com/adobe-commerce/aio-toolkit
+`
+        ].join("\n");
+        return { success: true, message: helpText };
+      }
+    };
+    __name(_CliWorkflowHelp, "CliWorkflowHelp");
+    /** Help command description */
+    _CliWorkflowHelp.DESCRIPTION = "Show help for the cli-workflow commands";
+    CliWorkflowHelp = _CliWorkflowHelp;
+  }
+});
+
+// src/commands/framework/helpers/aio-cli-detector/index.ts
+var import_child_process, INSTALL_DOCS_URL, AIO_CLI_PACKAGE, _AioCliDetector, AioCliDetector;
+var init_aio_cli_detector = __esm({
+  "src/commands/framework/helpers/aio-cli-detector/index.ts"() {
+    "use strict";
+    import_child_process = require("child_process");
+    INSTALL_DOCS_URL = "https://developer.adobe.com/app-builder/docs/guides/runtime_guides/tools/cli-install";
+    AIO_CLI_PACKAGE = "@adobe/aio-cli";
+    _AioCliDetector = class _AioCliDetector {
+      /**
+       * Returns the full status of the aio CLI installation.
+       *
+       * @param commandsToCheck - Optional list of aio sub-commands to probe (e.g. ['app', 'rt'])
+       */
+      static getStatus(commandsToCheck = []) {
+        const installed = this.isInstalled();
+        const version2 = installed ? this.getVersion() : null;
+        const commands = {};
+        if (installed) {
+          for (const cmd of commandsToCheck) {
+            commands[cmd] = this.isCommandAvailable(cmd);
+          }
+        }
+        return { installed, version: version2, commands };
+      }
+      /**
+       * Returns true if the `aio` binary is resolvable on the current PATH.
+       */
+      static isInstalled() {
+        try {
+          const result = (0, import_child_process.spawnSync)("aio", ["--version"], {
+            encoding: "utf8",
+            shell: false,
+            timeout: 5e3
+          });
+          return result.error?.message?.includes("ENOENT") !== true && result.pid !== 0;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Returns the installed `aio` version string, or null if unavailable.
+       */
+      static getVersion() {
+        try {
+          const result = (0, import_child_process.spawnSync)("aio", ["--version"], {
+            encoding: "utf8",
+            shell: false,
+            timeout: 5e3
+          });
+          const output = (result.stdout ?? "").trim();
+          return output.length > 0 ? output : null;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Returns true if the given aio sub-command is available (exit code 0 on --help).
+       *
+       * @param command - Sub-command name, e.g. 'app', 'rt', 'event'
+       */
+      static isCommandAvailable(command2) {
+        try {
+          const result = (0, import_child_process.spawnSync)("aio", [command2, "--help"], {
+            encoding: "utf8",
+            shell: false,
+            timeout: 5e3
+          });
+          return result.status === 0;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Returns a formatted, human-readable installation guide for the aio CLI.
+       */
+      static getInstallMessage() {
+        return `\u274C Adobe I/O CLI (aio) is not installed or not found on your PATH.
+
+To install it, run:
+
+  npm install -g ${AIO_CLI_PACKAGE}
+
+After installation, verify it is working:
+
+  aio help
+
+For full setup instructions, see:
+  ${INSTALL_DOCS_URL}`;
+      }
+      /**
+       * Returns a formatted message for one or more missing aio sub-commands.
+       *
+       * @param missingCommands - Sub-commands that were not found
+       */
+      static getMissingCommandsMessage(missingCommands) {
+        const list = missingCommands.map((cmd) => `  - aio ${cmd}`).join("\n");
+        return `\u26A0\uFE0F  The following aio command(s) are required but not available:
+
+${list}
+
+Make sure the relevant aio plugin(s) are installed. To see all plugins:
+
+  aio plugins
+
+To install a missing plugin:
+
+  aio plugins:install <plugin-name>
+
+For more information, see:
+  ${INSTALL_DOCS_URL}`;
+      }
+    };
+    __name(_AioCliDetector, "AioCliDetector");
+    AioCliDetector = _AioCliDetector;
+  }
+});
+
+// src/commands/framework/helpers/parse-cli-flag/index.ts
+var _ParseCliFlag, ParseCliFlag;
+var init_parse_cli_flag = __esm({
+  "src/commands/framework/helpers/parse-cli-flag/index.ts"() {
+    "use strict";
+    _ParseCliFlag = class _ParseCliFlag {
+      /**
+       * Returns the value of a named flag from a CLI args array, or `null` if absent.
+       *
+       * Supports both `--flag=<value>` and `--flag <value>` syntaxes.
+       * Returns `null` when the flag is absent or has an empty value.
+       *
+       * @param args  - Raw CLI arguments after the command name
+       * @param flag  - Flag name without leading dashes (e.g. `"env"`, `"config-file"`)
+       * @returns The flag value, or `null` if the flag was not provided
+       */
+      static parse(args2, flag) {
+        const prefix = `--${flag}=`;
+        for (let i = 0; i < args2.length; i++) {
+          const arg = args2[i];
+          if (arg.startsWith(prefix)) {
+            return arg.slice(prefix.length) || null;
+          }
+          if (arg === `--${flag}` && i + 1 < args2.length) {
+            return args2[i + 1];
+          }
+        }
+        return null;
+      }
+    };
+    __name(_ParseCliFlag, "ParseCliFlag");
+    ParseCliFlag = _ParseCliFlag;
+  }
+});
+
+// src/commands/cli-workflow/lib/env-setup/index.ts
+var fs, path, readline, import_child_process2, _CliWorkflowEnvSetup, CliWorkflowEnvSetup;
+var init_env_setup = __esm({
+  "src/commands/cli-workflow/lib/env-setup/index.ts"() {
+    "use strict";
+    fs = __toESM(require("fs"));
+    path = __toESM(require("path"));
+    readline = __toESM(require("readline"));
+    import_child_process2 = require("child_process");
+    init_abstract();
+    init_aio_cli_detector();
+    init_parse_cli_flag();
+    _CliWorkflowEnvSetup = class _CliWorkflowEnvSetup extends CommandAbstract {
+      /**
+       * Returns the command name.
+       * @returns Command name string
+       */
+      static getName() {
+        return this.NAME;
+      }
+      /**
+       * Returns the command description.
+       * @returns Command description string
+       */
+      static getDescription() {
+        return this.DESCRIPTION;
+      }
+      /**
+       * Returns the options/flags accepted by this command.
+       * @returns Array of CommandOption descriptors
+       */
+      static getOptions() {
+        return [
+          {
+            flag: "--config-file <path>",
+            description: "[optional] Path to workspace config file; skips the interactive prompt"
+          }
+        ];
+      }
+      /**
+       * Creates a readline interface bound to the current process stdio.
+       */
+      static createRl() {
+        return readline.createInterface({ input: process.stdin, output: process.stdout });
+      }
+      /**
+       * Asks a yes/no question and returns true for "yes", false for "no".
+       * Keeps re-prompting until a valid answer is given.
+       *
+       * @param question - The question text to display
+       */
+      static askYesNo(question) {
+        return new Promise((resolve2) => {
+          const rl = this.createRl();
+          const prompt = /* @__PURE__ */ __name(() => {
+            rl.question(`${question} (yes/no): `, (answer) => {
+              const normalised = answer.trim().toLowerCase();
+              if (normalised === "yes" || normalised === "y") {
+                rl.close();
+                resolve2(true);
+              } else if (normalised === "no" || normalised === "n") {
+                rl.close();
+                resolve2(false);
+              } else {
+                console.log('  Please enter "yes" or "no".');
+                prompt();
+              }
+            });
+          }, "prompt");
+          prompt();
+        });
+      }
+      /**
+       * Asks for a file path, resolves it against the current working directory,
+       * and validates that it points to an existing file.
+       * Keeps re-prompting on invalid input.
+       *
+       * @param question - The question text to display
+       * @returns Absolute resolved path to the file
+       */
+      static askFilePath(question) {
+        return new Promise((resolve2) => {
+          const rl = this.createRl();
+          const prompt = /* @__PURE__ */ __name(() => {
+            rl.question(`${question}: `, (input) => {
+              const trimmed = input.trim();
+              if (!trimmed) {
+                console.log("  Path cannot be empty. Please try again.");
+                prompt();
+                return;
+              }
+              const resolved = path.resolve(process.cwd(), trimmed);
+              if (!fs.existsSync(resolved)) {
+                console.log(`  File not found: ${resolved}`);
+                console.log("  Please provide a valid path and try again.");
+                prompt();
+                return;
+              }
+              if (!fs.statSync(resolved).isFile()) {
+                console.log(`  Path is not a file: ${resolved}`);
+                console.log("  Please provide a path to a file, not a directory.");
+                prompt();
+                return;
+              }
+              rl.close();
+              resolve2(resolved);
+            });
+          }, "prompt");
+          prompt();
+        });
+      }
+      /**
+       * Runs a single `aio` sub-command interactively, inheriting stdio so the
+       * user can respond to selection prompts directly in the terminal.
+       *
+       * @param args - Arguments to pass to the `aio` binary (no user-controlled input)
+       * @returns Resolved exit code (0 = success)
+       */
+      static runAioInteractive(args2) {
+        return new Promise((resolve2, reject) => {
+          const child = (0, import_child_process2.spawn)("aio", args2, {
+            stdio: "inherit",
+            shell: false
+          });
+          child.on("close", (code) => resolve2(code ?? 1));
+          child.on("error", (err) => reject(err));
+        });
+      }
+      /**
+       * Executes the env:setup workflow.
+       *
+       * When `--config-file=<path>` (or `--config-file <path>`) is passed the
+       * interactive prompt is skipped and `aio app use <file>` is run directly.
+       * Without the flag the user is asked whether they have a config file.
+       *
+       * @param args - Raw CLI arguments forwarded from bin/cli.ts
+       * @returns Promise resolving to a CommandResult with success status and message
+       */
+      static async execute(...args2) {
+        try {
+          console.log("\u{1F680} Setting up AIO Console environment...\n");
+          const flagValue = ParseCliFlag.parse(args2, "config-file");
+          if (flagValue !== null) {
+            const resolved = path.resolve(process.cwd(), flagValue);
+            if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
+              return {
+                success: false,
+                message: `\u274C Config file not found: ${resolved}
+
+Please provide a valid path to a workspace config file.
+Usage: --config-file=<path>  or  --config-file <path>`
+              };
+            }
+            return await this.executeWithConfigFile(resolved);
+          }
+          const hasConfigFile = await this.askYesNo("Do you have a workspace config file?");
+          if (hasConfigFile) {
+            return await this.executeWithConfigFile();
+          }
+          return await this.executeWithInteractiveSelection();
+        } catch (error) {
+          return {
+            success: false,
+            message: `\u274C Unexpected error during environment setup.
+Details: ${error.message}
+
+Please check the error above and try again.`
+          };
+        }
+      }
+      /**
+       * Runs `aio app use <file>` with the workspace config file.
+       *
+       * @param preResolvedPath - Absolute path from `--config-file` flag; when
+       *   omitted the user is prompted interactively.
+       */
+      static async executeWithConfigFile(preResolvedPath) {
+        const workspaceConfigPath = preResolvedPath ?? await this.askFilePath("Enter the path to your workspace config file");
+        if (!preResolvedPath) {
+          console.log(`
+\u2705 Workspace config file found: ${workspaceConfigPath}
+`);
+        }
+        console.log("\u25B6  Applying workspace config");
+        console.log(`   Running: aio app use ${workspaceConfigPath}
+`);
+        const exitCode = await this.runAioInteractive(["app", "use", workspaceConfigPath]);
+        if (exitCode !== 0) {
+          return {
+            success: false,
+            message: `\u274C Setup failed: could not apply workspace config file.
+   Command: aio app use ${workspaceConfigPath}
+   Exit code: ${exitCode}
+
+Please check the file is a valid workspace config and try again.`
+          };
+        }
+        return {
+          success: true,
+          message: `\u2705 Environment setup complete!
+
+Your AIO Console context has been configured via workspace config file:
+  - Config file: ${workspaceConfigPath}
+
+You can verify the active context by running:
+  aio console where`
+        };
+      }
+      /**
+       * Runs `aio console org select`, `aio console project select`, and
+       * `aio console workspace select` interactively in sequence.
+       */
+      static async executeWithInteractiveSelection() {
+        if (!AioCliDetector.isCommandAvailable("console")) {
+          return {
+            success: false,
+            message: AioCliDetector.getMissingCommandsMessage(["console"])
+          };
+        }
+        console.log("  No config file provided \u2014 continuing with interactive selection.\n");
+        for (const step of this.SETUP_STEPS) {
+          console.log(`\u25B6  ${step.label}`);
+          console.log(`   Running: aio ${step.args.join(" ")}
+`);
+          const exitCode = await this.runAioInteractive(step.args);
+          if (exitCode !== 0) {
+            return {
+              success: false,
+              message: `\u274C Setup failed at step: ${step.label}
+   Command: aio ${step.args.join(" ")}
+   Exit code: ${exitCode}
+
+Please resolve the issue above and run the command again.`
+            };
+          }
+          console.log(`
+\u2705 ${step.label} complete
+`);
+        }
+        return {
+          success: true,
+          message: "\u2705 Environment setup complete!\n\nYour AIO Console context has been configured:\n  - Organization selected\n  - Project selected\n  - Workspace selected\n\nYou can verify the active context by running:\n  aio console where"
+        };
+      }
+    };
+    __name(_CliWorkflowEnvSetup, "CliWorkflowEnvSetup");
+    /** Command name identifier */
+    _CliWorkflowEnvSetup.NAME = "env:setup";
+    /** Command description shown in help text */
+    _CliWorkflowEnvSetup.DESCRIPTION = "Select AIO Console org, project, and workspace [--config-file=<path>]";
+    /** Ordered list of aio console selection steps */
+    _CliWorkflowEnvSetup.SETUP_STEPS = [
+      { label: "Select Organization", args: ["console", "org", "select"] },
+      { label: "Select Project", args: ["console", "project", "select"] },
+      { label: "Select Workspace", args: ["console", "workspace", "select"] }
+    ];
+    CliWorkflowEnvSetup = _CliWorkflowEnvSetup;
+  }
+});
+
+// src/commands/cli-workflow/lib/env-reset/types.ts
+var VALID_ENVS;
+var init_types = __esm({
+  "src/commands/cli-workflow/lib/env-reset/types.ts"() {
+    "use strict";
+    VALID_ENVS = ["prod", "stage"];
+  }
+});
+
+// src/commands/cli-workflow/lib/env-reset/index.ts
+var import_child_process3, _CliWorkflowEnvReset, CliWorkflowEnvReset;
+var init_env_reset = __esm({
+  "src/commands/cli-workflow/lib/env-reset/index.ts"() {
+    "use strict";
+    import_child_process3 = require("child_process");
+    init_abstract();
+    init_aio_cli_detector();
+    init_parse_cli_flag();
+    init_types();
+    _CliWorkflowEnvReset = class _CliWorkflowEnvReset extends CommandAbstract {
+      /**
+       * Returns the command name.
+       * @returns Command name string
+       */
+      static getName() {
+        return this.NAME;
+      }
+      /**
+       * Returns the command description.
+       * @returns Command description string
+       */
+      static getDescription() {
+        return this.DESCRIPTION;
+      }
+      /**
+       * Returns the options/flags accepted by this command.
+       * @returns Array of CommandOption descriptors
+       */
+      static getOptions() {
+        return [
+          {
+            flag: "--env <prod|stage>",
+            description: `[optional] Target environment to reset (default: ${this.DEFAULT_ENV})`
+          }
+        ];
+      }
+      /**
+       * Runs a single `aio` sub-command with stdio inherited so the user sees
+       * all output and can respond to interactive prompts (e.g. `aio auth login`).
+       *
+       * @param args - Arguments passed to the `aio` binary (no user-controlled input)
+       * @returns Resolved exit code (0 = success)
+       */
+      static runAioInteractive(args2) {
+        return new Promise((resolve2, reject) => {
+          const child = (0, import_child_process3.spawn)("aio", args2, { stdio: "inherit", shell: false });
+          child.on("close", (code) => resolve2(code ?? 1));
+          child.on("error", (err) => reject(err));
+        });
+      }
+      /**
+       * Returns the ordered reset steps shared by both environments.
+       * The `env` parameter is forwarded to the `Set CLI environment` step.
+       */
+      static getResetSteps() {
+        return [
+          {
+            label: "Log out of current session",
+            run: /* @__PURE__ */ __name(() => this.runAioInteractive(["auth", "logout"]), "run")
+          },
+          {
+            label: "Clear local CLI config",
+            run: /* @__PURE__ */ __name(() => this.runAioInteractive(["config", "clear", "-f"]), "run")
+          },
+          {
+            label: "Clear global CLI config",
+            run: /* @__PURE__ */ __name(() => this.runAioInteractive(["config", "clear", "-g", "-f"]), "run")
+          },
+          {
+            label: "Disable telemetry",
+            run: /* @__PURE__ */ __name(() => this.runAioInteractive(["telemetry", "off", "--no-telemetry"]), "run")
+          },
+          {
+            label: "Set CLI environment",
+            run: /* @__PURE__ */ __name((env) => this.runAioInteractive(["config", "set", "cli.env", env]), "run")
+          },
+          {
+            label: "Export AIO_CLI_ENV for current process",
+            run: /* @__PURE__ */ __name((env) => {
+              process.env.AIO_CLI_ENV = env;
+              return Promise.resolve(0);
+            }, "run")
+          },
+          {
+            label: "Log in to new session",
+            run: /* @__PURE__ */ __name(() => this.runAioInteractive(["auth", "login"]), "run")
+          },
+          {
+            label: "Enable telemetry",
+            run: /* @__PURE__ */ __name(() => this.runAioInteractive(["telemetry", "on"]), "run")
+          }
+        ];
+      }
+      /**
+       * Executes the env:reset workflow.
+       *
+       * @param args - Raw CLI arguments forwarded from bin/cli.ts
+       * @returns Promise resolving to a CommandResult with success status and message
+       */
+      static async execute(...args2) {
+        try {
+          const rawEnv = ParseCliFlag.parse(args2, "env") ?? this.DEFAULT_ENV;
+          if (!VALID_ENVS.includes(rawEnv)) {
+            return {
+              success: false,
+              message: `\u274C Invalid value for --env: "${rawEnv}"
+
+Accepted values: ${VALID_ENVS.join(", ")}
+Usage: npx aio-toolkit-cli-workflow env:reset --env <prod|stage>`
+            };
+          }
+          const env = rawEnv;
+          if (!AioCliDetector.isInstalled()) {
+            return {
+              success: false,
+              message: AioCliDetector.getInstallMessage()
+            };
+          }
+          console.log(`\u{1F504} Resetting AIO CLI environment to: ${env}
+`);
+          for (const step of this.getResetSteps()) {
+            console.log(`\u25B6  ${step.label}`);
+            const exitCode = await step.run(env);
+            if (exitCode !== 0) {
+              return {
+                success: false,
+                message: `\u274C Reset failed at step: ${step.label}
+   Exit code: ${exitCode}
+
+Please resolve the issue above and run the command again.`
+              };
+            }
+            console.log(`\u2705 ${step.label} complete
+`);
+          }
+          return {
+            success: true,
+            message: `\u2705 Environment reset complete!
+
+AIO CLI has been reset to: ${env}
+
+Completed steps:
+  - Logged out of previous session
+  - Cleared local and global CLI config
+  - Telemetry disabled then re-enabled
+  - CLI environment set to: ${env}
+  - Logged in to new session
+
+You can verify the active environment by running:
+  aio config get cli.env
+  aio console where`
+          };
+        } catch (error) {
+          return {
+            success: false,
+            message: `\u274C Unexpected error during environment reset.
+Details: ${error.message}
+
+Please check the error above and try again.`
+          };
+        }
+      }
+    };
+    __name(_CliWorkflowEnvReset, "CliWorkflowEnvReset");
+    /** Command name identifier */
+    _CliWorkflowEnvReset.NAME = "env:reset";
+    /** Command description shown in help text */
+    _CliWorkflowEnvReset.DESCRIPTION = "Reset AIO CLI environment (logout, clear config, re-login)";
+    /** Default target environment when --env is not provided */
+    _CliWorkflowEnvReset.DEFAULT_ENV = "prod";
+    CliWorkflowEnvReset = _CliWorkflowEnvReset;
+  }
+});
+
+// src/commands/cli-workflow/lib/cron-delete/index.ts
+var readline2, import_child_process4, _CliWorkflowCronDelete, CliWorkflowCronDelete;
+var init_cron_delete = __esm({
+  "src/commands/cli-workflow/lib/cron-delete/index.ts"() {
+    "use strict";
+    readline2 = __toESM(require("readline"));
+    import_child_process4 = require("child_process");
+    init_abstract();
+    init_aio_cli_detector();
+    _CliWorkflowCronDelete = class _CliWorkflowCronDelete extends CommandAbstract {
+      static getName() {
+        return this.NAME;
+      }
+      static getDescription() {
+        return this.DESCRIPTION;
+      }
+      // ── Private helpers ──────────────────────────────────────────────────────
+      /**
+       * Creates a readline interface bound to the current process stdio.
+       */
+      static createRl() {
+        return readline2.createInterface({ input: process.stdin, output: process.stdout });
+      }
+      /**
+       * Asks a yes/no question and returns true for "yes", false for "no".
+       * Keeps re-prompting until a valid answer is given.
+       *
+       * @param question - The question text to display
+       */
+      static askYesNo(question) {
+        return new Promise((resolve2) => {
+          const rl = this.createRl();
+          const prompt = /* @__PURE__ */ __name(() => {
+            rl.question(`${question} (yes/no): `, (answer) => {
+              const normalised = answer.trim().toLowerCase();
+              if (normalised === "yes" || normalised === "y") {
+                rl.close();
+                resolve2(true);
+              } else if (normalised === "no" || normalised === "n") {
+                rl.close();
+                resolve2(false);
+              } else {
+                console.log('  Please enter "yes" or "no".');
+                prompt();
+              }
+            });
+          }, "prompt");
+          prompt();
+        });
+      }
+      /**
+       * Shows a numbered list of rules (with their associated trigger names) and
+       * prompts the user to enter a comma-separated list of rule numbers.
+       * Re-prompts on invalid input.
+       *
+       * @param rules - Rule references to display
+       * @returns Selected rule references
+       */
+      static askRuleSelection(rules) {
+        return new Promise((resolve2) => {
+          const rl = this.createRl();
+          console.log("\nAvailable rules:");
+          rules.forEach((rule, i) => {
+            const trigger = rule.triggerName ? ` (trigger: ${rule.triggerName})` : "";
+            console.log(`  ${i + 1}. ${rule.name}${trigger}`);
+          });
+          const prompt = /* @__PURE__ */ __name(() => {
+            rl.question("\nEnter rule numbers to delete (comma-separated, e.g. 1,3): ", (input) => {
+              const trimmed = input.trim();
+              if (!trimmed) {
+                console.log("  Please enter at least one rule number.");
+                prompt();
+                return;
+              }
+              const indices = trimmed.split(",").map((s) => Number(s.trim()) - 1);
+              const invalid = indices.filter((i) => !Number.isInteger(i) || i < 0 || i >= rules.length);
+              if (invalid.length > 0) {
+                console.log(`  Invalid selection. Choose numbers between 1 and ${rules.length}.`);
+                prompt();
+                return;
+              }
+              rl.close();
+              resolve2(indices.map((i) => rules[i]));
+            });
+          }, "prompt");
+          prompt();
+        });
+      }
+      /**
+       * Returns the current AIO workspace name (lowercased), or null if it cannot
+       * be determined. Rejects placeholder values such as "<no workspace selected>".
+       */
+      static getWorkspace() {
+        const result = (0, import_child_process4.spawnSync)("aio", ["where"], {
+          encoding: "utf8",
+          shell: false,
+          timeout: 5e3
+        });
+        const lines = (result.stdout ?? "").split("\n");
+        const wsLine = lines.find((l) => /workspace/i.test(l));
+        if (!wsLine) return null;
+        const name = wsLine.replace(/.*:\s*/, "").trim();
+        if (!name || /^<.*>$/.test(name)) return null;
+        return name.toLowerCase();
+      }
+      /**
+       * Returns all rules with their associated trigger names from
+       * `aio rt rule list --json`. The list response includes trigger details, so
+       * no additional per-rule fetch is required.
+       * Returns an empty array on empty output or JSON parse errors.
+       */
+      static getRules() {
+        const result = (0, import_child_process4.spawnSync)("aio", ["rt", "rule", "list", "--json"], {
+          encoding: "utf8",
+          shell: false,
+          timeout: 1e4
+        });
+        const stdout = (result.stdout ?? "").trim();
+        if (!stdout) return [];
+        try {
+          const data = JSON.parse(stdout);
+          return data.map((entry) => ({
+            name: String(entry.name ?? ""),
+            triggerName: entry.trigger?.name ? String(entry.trigger.name) : null
+          })).filter((r) => r.name);
+        } catch {
+          return [];
+        }
+      }
+      /**
+       * Runs `aio rt trigger delete <triggerName>` interactively, inheriting stdio
+       * so the user sees any prompts from the AIO CLI.
+       *
+       * @param triggerName - Trigger to delete (not from direct user input)
+       * @returns Resolved exit code (0 = success)
+       */
+      static runDeleteTrigger(triggerName) {
+        return new Promise((resolve2, reject) => {
+          const child = (0, import_child_process4.spawn)("aio", ["rt", "trigger", "delete", triggerName], {
+            stdio: "inherit",
+            shell: false
+          });
+          child.on("close", (code) => resolve2(code ?? 1));
+          child.on("error", (err) => reject(err));
+        });
+      }
+      /**
+       * Runs `aio rt rule delete <ruleName>` interactively, inheriting stdio so
+       * the user sees any prompts from the AIO CLI.
+       *
+       * @param ruleName - Rule to delete (not from direct user input)
+       * @returns Resolved exit code (0 = success)
+       */
+      static runDeleteRule(ruleName) {
+        return new Promise((resolve2, reject) => {
+          const child = (0, import_child_process4.spawn)("aio", ["rt", "rule", "delete", ruleName], {
+            stdio: "inherit",
+            shell: false
+          });
+          child.on("close", (code) => resolve2(code ?? 1));
+          child.on("error", (err) => reject(err));
+        });
+      }
+      // ── execute ──────────────────────────────────────────────────────────────
+      /**
+       * Executes the cron:delete workflow.
+       *
+       * @returns Promise resolving to a CommandResult with success status and message
+       */
+      static async execute() {
+        try {
+          if (!AioCliDetector.isInstalled()) {
+            return { success: false, message: AioCliDetector.getInstallMessage() };
+          }
+          const workspace = this.getWorkspace();
+          if (!workspace) {
+            return {
+              success: false,
+              message: "\u274C Could not determine the current AIO workspace.\n\nRun `aio where` to check your current context, or set one up with:\n  npx aio-toolkit-cli-workflow env:setup"
+            };
+          }
+          const proceed = await this.askYesNo(`Proceed with workspace "${workspace}"?`);
+          if (!proceed) {
+            return { success: false, message: "\u26A0\uFE0F  Aborted \u2014 no rules were deleted." };
+          }
+          const rules = this.getRules();
+          if (rules.length === 0) {
+            return {
+              success: true,
+              message: `\u2139\uFE0F  No rules found in workspace "${workspace}".`
+            };
+          }
+          const toDelete = await this.askRuleSelection(rules);
+          console.log(`
+Deleting ${toDelete.length} rule(s) from workspace "${workspace}"...
+`);
+          const deleted = [];
+          for (const rule of toDelete) {
+            if (rule.triggerName) {
+              console.log(`  \u{1F5D1}\uFE0F  Deleting trigger "${rule.triggerName}"...`);
+              const triggerCode = await this.runDeleteTrigger(rule.triggerName);
+              if (triggerCode !== 0) {
+                return {
+                  success: false,
+                  message: `\u274C Failed to delete trigger "${rule.triggerName}" (exit code ${triggerCode}).`
+                };
+              }
+            }
+            console.log(`  \u{1F5D1}\uFE0F  Deleting rule "${rule.name}"...`);
+            const ruleCode = await this.runDeleteRule(rule.name);
+            if (ruleCode !== 0) {
+              return {
+                success: false,
+                message: `\u274C Failed to delete rule "${rule.name}" (exit code ${ruleCode}).`
+              };
+            }
+            deleted.push(rule.name);
+          }
+          return {
+            success: true,
+            message: `
+\u2705 ${deleted.length} rule(s) deleted from workspace "${workspace}":
+${deleted.map((r) => `  \u2022 ${r}`).join("\n")}`
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return { success: false, message: `\u274C Unexpected error: ${message}` };
+        }
+      }
+    };
+    __name(_CliWorkflowCronDelete, "CliWorkflowCronDelete");
+    _CliWorkflowCronDelete.NAME = "cron:delete";
+    _CliWorkflowCronDelete.DESCRIPTION = "Delete AIO Runtime cron rules (and their triggers) in the current workspace";
+    CliWorkflowCronDelete = _CliWorkflowCronDelete;
+  }
+});
+
+// src/commands/cli-workflow/lib/cron-disable/index.ts
+var readline3, import_child_process5, _CliWorkflowCronDisable, CliWorkflowCronDisable;
+var init_cron_disable = __esm({
+  "src/commands/cli-workflow/lib/cron-disable/index.ts"() {
+    "use strict";
+    readline3 = __toESM(require("readline"));
+    import_child_process5 = require("child_process");
+    init_abstract();
+    init_aio_cli_detector();
+    _CliWorkflowCronDisable = class _CliWorkflowCronDisable extends CommandAbstract {
+      static getName() {
+        return this.NAME;
+      }
+      static getDescription() {
+        return this.DESCRIPTION;
+      }
+      static getOptions() {
+        return [
+          {
+            flag: "--all",
+            description: "[optional] Disable all cron rules without prompting for selection"
+          }
+        ];
+      }
+      /**
+       * Creates a readline interface bound to the current process stdio.
+       */
+      static createRl() {
+        return readline3.createInterface({ input: process.stdin, output: process.stdout });
+      }
+      /**
+       * Asks a yes/no question and returns true for "yes", false for "no".
+       * Keeps re-prompting until a valid answer is given.
+       *
+       * @param question - The question text to display
+       */
+      static askYesNo(question) {
+        return new Promise((resolve2) => {
+          const rl = this.createRl();
+          const prompt = /* @__PURE__ */ __name(() => {
+            rl.question(`${question} (yes/no): `, (answer) => {
+              const normalised = answer.trim().toLowerCase();
+              if (normalised === "yes" || normalised === "y") {
+                rl.close();
+                resolve2(true);
+              } else if (normalised === "no" || normalised === "n") {
+                rl.close();
+                resolve2(false);
+              } else {
+                console.log('  Please enter "yes" or "no".');
+                prompt();
+              }
+            });
+          }, "prompt");
+          prompt();
+        });
+      }
+      /**
+       * Shows a numbered list of rules and prompts the user to enter a
+       * comma-separated list of rule numbers. Re-prompts on invalid input.
+       *
+       * @param rules - Rule names to display
+       * @returns Selected rule names
+       */
+      static askRuleSelection(rules) {
+        return new Promise((resolve2) => {
+          const rl = this.createRl();
+          console.log("\nAvailable rules:");
+          rules.forEach((rule, i) => console.log(`  ${i + 1}. ${rule}`));
+          const prompt = /* @__PURE__ */ __name(() => {
+            rl.question("\nEnter rule numbers to disable (comma-separated, e.g. 1,3): ", (input) => {
+              const trimmed = input.trim();
+              if (!trimmed) {
+                console.log("  Please enter at least one rule number.");
+                prompt();
+                return;
+              }
+              const indices = trimmed.split(",").map((s) => Number(s.trim()) - 1);
+              const invalid = indices.filter((i) => !Number.isInteger(i) || i < 0 || i >= rules.length);
+              if (invalid.length > 0) {
+                console.log(`  Invalid selection. Choose numbers between 1 and ${rules.length}.`);
+                prompt();
+                return;
+              }
+              rl.close();
+              resolve2(indices.map((i) => rules[i]));
+            });
+          }, "prompt");
+          prompt();
+        });
+      }
+      /**
+       * Returns the current AIO workspace name (lowercased), or null if it cannot
+       * be determined. Uses `aio where` with captured stdout — no user input involved.
+       */
+      static getWorkspace() {
+        const result = (0, import_child_process5.spawnSync)("aio", ["where"], {
+          encoding: "utf8",
+          shell: false,
+          timeout: 5e3
+        });
+        const lines = (result.stdout ?? "").split("\n");
+        const wsLine = lines.find((l) => /workspace/i.test(l));
+        if (!wsLine) return null;
+        const name = wsLine.replace(/.*:\s*/, "").trim();
+        if (!name || /^<.*>$/.test(name)) return null;
+        return name.toLowerCase();
+      }
+      /**
+       * Returns all rule names from `aio rt rule list --json`.
+       * Uses the JSON flag for reliable structured output, avoiding fragile
+       * text-column parsing that varies across CLI versions and environments.
+       * Returns an empty array on empty output or JSON parse errors.
+       */
+      static getRules() {
+        const result = (0, import_child_process5.spawnSync)("aio", ["rt", "rule", "list", "--json"], {
+          encoding: "utf8",
+          shell: false,
+          timeout: 1e4
+        });
+        const stdout = (result.stdout ?? "").trim();
+        if (!stdout) return [];
+        try {
+          const data = JSON.parse(stdout);
+          return data.map((entry) => String(entry.name ?? "")).filter(Boolean);
+        } catch {
+          return [];
+        }
+      }
+      /**
+       * Runs `aio rt rule disable <ruleName>` interactively, inheriting stdio so
+       * the user sees the command output.
+       *
+       * @param ruleName - The rule to disable (not from direct user input)
+       * @returns Resolved exit code (0 = success)
+       */
+      static runDisableRule(ruleName) {
+        return new Promise((resolve2, reject) => {
+          const child = (0, import_child_process5.spawn)("aio", ["rt", "rule", "disable", ruleName], {
+            stdio: "inherit",
+            shell: false
+          });
+          child.on("close", (code) => resolve2(code ?? 1));
+          child.on("error", (err) => reject(err));
+        });
+      }
+      /**
+       * Executes the cron:disable workflow.
+       *
+       * @param args - Raw CLI arguments forwarded from bin/cli.ts
+       * @returns Promise resolving to a CommandResult with success status and message
+       */
+      static async execute(...args2) {
+        try {
+          if (!AioCliDetector.isInstalled()) {
+            return { success: false, message: AioCliDetector.getInstallMessage() };
+          }
+          const workspace = this.getWorkspace();
+          if (!workspace) {
+            return {
+              success: false,
+              message: "\u274C Could not determine the current AIO workspace.\n\nRun `aio where` to check your current context, or set one up with:\n  npx aio-toolkit-cli-workflow env:setup"
+            };
+          }
+          const proceed = await this.askYesNo(`Proceed with workspace "${workspace}"?`);
+          if (!proceed) {
+            return { success: false, message: "\u26A0\uFE0F  Aborted \u2014 no rules were disabled." };
+          }
+          const rules = this.getRules();
+          if (rules.length === 0) {
+            return {
+              success: true,
+              message: `\u2139\uFE0F  No rules found in workspace "${workspace}".`
+            };
+          }
+          const disableAll = args2.includes("--all");
+          const toDisable = disableAll ? rules : await this.askRuleSelection(rules);
+          console.log(`
+Disabling ${toDisable.length} rule(s) in workspace "${workspace}"...
+`);
+          for (const rule of toDisable) {
+            console.log(`  \u2192 ${rule}`);
+            const code = await this.runDisableRule(rule);
+            if (code !== 0) {
+              return {
+                success: false,
+                message: `\u274C Failed to disable rule "${rule}" (exit code ${code}).`
+              };
+            }
+          }
+          return {
+            success: true,
+            message: `
+\u2705 ${toDisable.length} rule(s) disabled in workspace "${workspace}":
+${toDisable.map((r) => `  \u2022 ${r}`).join("\n")}`
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return { success: false, message: `\u274C Unexpected error: ${message}` };
+        }
+      }
+    };
+    __name(_CliWorkflowCronDisable, "CliWorkflowCronDisable");
+    _CliWorkflowCronDisable.NAME = "cron:disable";
+    _CliWorkflowCronDisable.DESCRIPTION = "Disable AIO Runtime cron rules in the current workspace";
+    CliWorkflowCronDisable = _CliWorkflowCronDisable;
+  }
+});
+
+// src/commands/cli-workflow/lib/cron-enable/index.ts
+var readline4, import_child_process6, _CliWorkflowCronEnable, CliWorkflowCronEnable;
+var init_cron_enable = __esm({
+  "src/commands/cli-workflow/lib/cron-enable/index.ts"() {
+    "use strict";
+    readline4 = __toESM(require("readline"));
+    import_child_process6 = require("child_process");
+    init_abstract();
+    init_aio_cli_detector();
+    _CliWorkflowCronEnable = class _CliWorkflowCronEnable extends CommandAbstract {
+      static getName() {
+        return this.NAME;
+      }
+      static getDescription() {
+        return this.DESCRIPTION;
+      }
+      static getOptions() {
+        return [
+          {
+            flag: "--all",
+            description: "[optional] Enable all cron rules without prompting for selection"
+          }
+        ];
+      }
+      /**
+       * Creates a readline interface bound to the current process stdio.
+       */
+      static createRl() {
+        return readline4.createInterface({ input: process.stdin, output: process.stdout });
+      }
+      /**
+       * Asks a yes/no question and returns true for "yes", false for "no".
+       * Keeps re-prompting until a valid answer is given.
+       *
+       * @param question - The question text to display
+       */
+      static askYesNo(question) {
+        return new Promise((resolve2) => {
+          const rl = this.createRl();
+          const prompt = /* @__PURE__ */ __name(() => {
+            rl.question(`${question} (yes/no): `, (answer) => {
+              const normalised = answer.trim().toLowerCase();
+              if (normalised === "yes" || normalised === "y") {
+                rl.close();
+                resolve2(true);
+              } else if (normalised === "no" || normalised === "n") {
+                rl.close();
+                resolve2(false);
+              } else {
+                console.log('  Please enter "yes" or "no".');
+                prompt();
+              }
+            });
+          }, "prompt");
+          prompt();
+        });
+      }
+      /**
+       * Shows a numbered list of rules and prompts the user to enter a
+       * comma-separated list of rule numbers. Re-prompts on invalid input.
+       *
+       * @param rules - Rule names to display
+       * @returns Selected rule names
+       */
+      static askRuleSelection(rules) {
+        return new Promise((resolve2) => {
+          const rl = this.createRl();
+          console.log("\nAvailable rules:");
+          rules.forEach((rule, i) => console.log(`  ${i + 1}. ${rule}`));
+          const prompt = /* @__PURE__ */ __name(() => {
+            rl.question("\nEnter rule numbers to enable (comma-separated, e.g. 1,3): ", (input) => {
+              const trimmed = input.trim();
+              if (!trimmed) {
+                console.log("  Please enter at least one rule number.");
+                prompt();
+                return;
+              }
+              const indices = trimmed.split(",").map((s) => Number(s.trim()) - 1);
+              const invalid = indices.filter((i) => !Number.isInteger(i) || i < 0 || i >= rules.length);
+              if (invalid.length > 0) {
+                console.log(`  Invalid selection. Choose numbers between 1 and ${rules.length}.`);
+                prompt();
+                return;
+              }
+              rl.close();
+              resolve2(indices.map((i) => rules[i]));
+            });
+          }, "prompt");
+          prompt();
+        });
+      }
+      /**
+       * Returns the current AIO workspace name (lowercased), or null if it cannot
+       * be determined. Uses `aio where` with captured stdout — no user input involved.
+       */
+      static getWorkspace() {
+        const result = (0, import_child_process6.spawnSync)("aio", ["where"], {
+          encoding: "utf8",
+          shell: false,
+          timeout: 5e3
+        });
+        const lines = (result.stdout ?? "").split("\n");
+        const wsLine = lines.find((l) => /workspace/i.test(l));
+        if (!wsLine) return null;
+        const name = wsLine.replace(/.*:\s*/, "").trim();
+        if (!name || /^<.*>$/.test(name)) return null;
+        return name.toLowerCase();
+      }
+      /**
+       * Returns all rule names from `aio rt rule list --json`.
+       * Uses the JSON flag for reliable structured output, avoiding fragile
+       * text-column parsing that varies across CLI versions and environments.
+       * Returns an empty array on empty output or JSON parse errors.
+       */
+      static getRules() {
+        const result = (0, import_child_process6.spawnSync)("aio", ["rt", "rule", "list", "--json"], {
+          encoding: "utf8",
+          shell: false,
+          timeout: 1e4
+        });
+        const stdout = (result.stdout ?? "").trim();
+        if (!stdout) return [];
+        try {
+          const data = JSON.parse(stdout);
+          return data.map((entry) => String(entry.name ?? "")).filter(Boolean);
+        } catch {
+          return [];
+        }
+      }
+      /**
+       * Runs `aio rt rule enable <ruleName>` interactively, inheriting stdio so the
+       * user sees the command output.
+       *
+       * @param ruleName - The rule to enable (no user-controlled input)
+       * @returns Resolved exit code (0 = success)
+       */
+      static runEnableRule(ruleName) {
+        return new Promise((resolve2, reject) => {
+          const child = (0, import_child_process6.spawn)("aio", ["rt", "rule", "enable", ruleName], {
+            stdio: "inherit",
+            shell: false
+          });
+          child.on("close", (code) => resolve2(code ?? 1));
+          child.on("error", (err) => reject(err));
+        });
+      }
+      /**
+       * Executes the cron:enable workflow.
+       *
+       * @param args - Raw CLI arguments forwarded from bin/cli.ts
+       * @returns Promise resolving to a CommandResult with success status and message
+       */
+      static async execute(...args2) {
+        try {
+          if (!AioCliDetector.isInstalled()) {
+            return { success: false, message: AioCliDetector.getInstallMessage() };
+          }
+          const workspace = this.getWorkspace();
+          if (!workspace) {
+            return {
+              success: false,
+              message: "\u274C Could not determine the current AIO workspace.\n\nRun `aio where` to check your current context, or set one up with:\n  npx aio-toolkit-cli-workflow env:setup"
+            };
+          }
+          const proceed = await this.askYesNo(`Proceed with workspace "${workspace}"?`);
+          if (!proceed) {
+            return { success: false, message: "\u26A0\uFE0F  Aborted \u2014 no rules were enabled." };
+          }
+          const rules = this.getRules();
+          if (rules.length === 0) {
+            return {
+              success: true,
+              message: `\u2139\uFE0F  No rules found in workspace "${workspace}".`
+            };
+          }
+          const enableAll = args2.includes("--all");
+          const toEnable = enableAll ? rules : await this.askRuleSelection(rules);
+          console.log(`
+Enabling ${toEnable.length} rule(s) in workspace "${workspace}"...
+`);
+          for (const rule of toEnable) {
+            console.log(`  \u2192 ${rule}`);
+            const code = await this.runEnableRule(rule);
+            if (code !== 0) {
+              return {
+                success: false,
+                message: `\u274C Failed to enable rule "${rule}" (exit code ${code}).`
+              };
+            }
+          }
+          return {
+            success: true,
+            message: `
+\u2705 ${toEnable.length} rule(s) enabled in workspace "${workspace}":
+${toEnable.map((r) => `  \u2022 ${r}`).join("\n")}`
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return { success: false, message: `\u274C Unexpected error: ${message}` };
+        }
+      }
+    };
+    __name(_CliWorkflowCronEnable, "CliWorkflowCronEnable");
+    _CliWorkflowCronEnable.NAME = "cron:enable";
+    _CliWorkflowCronEnable.DESCRIPTION = "Enable AIO Runtime cron rules in the current workspace";
+    CliWorkflowCronEnable = _CliWorkflowCronEnable;
+  }
+});
+
+// src/commands/cli-workflow/lib/cron-status/index.ts
+var import_child_process7, _CliWorkflowCronStatus, CliWorkflowCronStatus;
+var init_cron_status = __esm({
+  "src/commands/cli-workflow/lib/cron-status/index.ts"() {
+    "use strict";
+    import_child_process7 = require("child_process");
+    init_abstract();
+    init_aio_cli_detector();
+    init_parse_cli_flag();
+    _CliWorkflowCronStatus = class _CliWorkflowCronStatus extends CommandAbstract {
+      static getName() {
+        return this.NAME;
+      }
+      static getDescription() {
+        return this.DESCRIPTION;
+      }
+      static getOptions() {
+        return [
+          {
+            flag: "--name [RULE_NAME]",
+            description: "Optional rule name. When provided, fetches only that specific rule instead of listing all rules."
+          }
+        ];
+      }
+      /**
+       * Extracts and parses JSON from a spawnSync result, handling:
+       *   - stdout-only output (normal case)
+       *   - stderr fallback (some AIO CLI versions route --json to stderr)
+       *   - ANSI escape codes that can corrupt JSON parsing
+       *   - oclif `--json` wrapper: `{ "result": <payload>, "warnings": [] }`
+       *   - prefix text before the JSON (e.g. progress lines in non-TTY mode)
+       *
+       * Each output stream is tried independently so that non-JSON content on
+       * stdout does not shadow JSON that arrives on stderr.
+       *
+       * Returns the unwrapped payload, or null on failure.
+       */
+      static parseJsonOutput(result) {
+        const sources = [(result.stdout ?? "").trim(), (result.stderr ?? "").trim()];
+        for (const source of sources) {
+          if (!source) continue;
+          const clean = source.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+          const full = this.tryParse(clean);
+          if (full !== void 0) return full;
+          const objAt = clean.indexOf("{");
+          const arrAt = clean.indexOf("[");
+          const start = objAt === -1 ? arrAt : arrAt === -1 ? objAt : Math.min(objAt, arrAt);
+          if (start !== -1) {
+            const sliced = this.tryParse(clean.slice(start));
+            if (sliced !== void 0) return sliced;
+          }
+        }
+        return null;
+      }
+      /**
+       * Tries to parse a JSON string and unwrap the oclif envelope if present.
+       * Returns `undefined` (not `null`) on failure so callers can distinguish
+       * "parse failed" from a valid JSON `null`.
+       */
+      static tryParse(text) {
+        try {
+          const parsed = JSON.parse(text);
+          if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const obj = parsed;
+            if ("result" in obj) return obj["result"];
+          }
+          return parsed;
+        } catch {
+          return void 0;
+        }
+      }
+      /**
+       * Returns the current AIO workspace name (lowercased), or null if it cannot
+       * be determined. Rejects placeholder values such as "<no workspace selected>".
+       */
+      static getWorkspace() {
+        const result = (0, import_child_process7.spawnSync)("aio", ["where"], {
+          encoding: "utf8",
+          shell: false,
+          timeout: 5e3
+        });
+        const lines = (result.stdout ?? "").split("\n");
+        const wsLine = lines.find((l) => /workspace/i.test(l));
+        if (!wsLine) return null;
+        const name = wsLine.replace(/.*:\s*/, "").trim();
+        if (!name || /^<.*>$/.test(name)) return null;
+        return name.toLowerCase();
+      }
+      /**
+       * Returns all rules with their full details from `aio rt rule list --json`.
+       * The list response includes the same fields as `aio rt rule get`, so no
+       * individual per-rule fetches are needed.
+       * Returns an empty array on empty output or JSON parse errors.
+       */
+      static getRuleList() {
+        const result = (0, import_child_process7.spawnSync)("aio", ["rt", "rule", "list", "--json"], {
+          encoding: "utf8",
+          shell: false,
+          timeout: 1e4
+        });
+        const data = this.parseJsonOutput(result);
+        if (!Array.isArray(data)) return [];
+        return data.filter(
+          (entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry)
+        );
+      }
+      /**
+       * Fetches the full rule object for a single rule via
+       * `aio rt rule get <name> --json`. Returns null on any error.
+       *
+       * @param name - Rule name (from the list output — not user input)
+       */
+      static getRuleDetail(name) {
+        const result = (0, import_child_process7.spawnSync)("aio", ["rt", "rule", "get", name, "--json"], {
+          encoding: "utf8",
+          shell: false,
+          timeout: 1e4
+        });
+        const data = this.parseJsonOutput(result);
+        if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+        return data;
+      }
+      /**
+       * Returns the cron schedule expression for the given trigger by calling
+       * `aio rt trigger get <name> --json` and extracting the `cron` parameter.
+       * Returns `'—'` when the value cannot be resolved.
+       *
+       * @param triggerName - Trigger name (from rule response — not user input)
+       */
+      static getCronSchedule(triggerName) {
+        const result = (0, import_child_process7.spawnSync)("aio", ["rt", "trigger", "get", triggerName], {
+          encoding: "utf8",
+          shell: false,
+          timeout: 1e4
+        });
+        const data = this.parseJsonOutput(result);
+        if (!data) return "\u2014";
+        const cronParam = data.parameters?.find((p) => p.key === "cron");
+        return cronParam ? String(cronParam.value) : "\u2014";
+      }
+      /**
+       * Formats a list of rule details into a human-readable display block.
+       *
+       * @param workspace - Current workspace name
+       * @param rules - Parsed rule details
+       */
+      static formatOutput(workspace, rules) {
+        const activeCount = rules.filter((r) => r.status === "active").length;
+        const inactiveCount = rules.length - activeCount;
+        const entries = rules.map((r) => {
+          const icon = r.status === "active" ? "\u2705" : "\u274C";
+          return [
+            `  \u2022 ${r.name}`,
+            `    Status:    ${icon} ${r.status}`,
+            `    Published: ${r.published}`,
+            `    Schedule:  ${r.cronSchedule}`,
+            `    Action:    ${r.actionName}`,
+            `    Trigger:   ${r.triggerName}`,
+            `    Version:   ${r.version}`
+          ].join("\n");
+        }).join("\n\n");
+        return `Cron rules in workspace "${workspace}":
+
+${entries}
+
+Summary: ${activeCount} active, ${inactiveCount} inactive (${rules.length} total)`;
+      }
+      /**
+       * Executes the cron:status workflow.
+       *
+       * @returns Promise resolving to a CommandResult with success status and message
+       */
+      static async execute() {
+        try {
+          if (!AioCliDetector.isInstalled()) {
+            return { success: false, message: AioCliDetector.getInstallMessage() };
+          }
+          const workspace = this.getWorkspace();
+          if (!workspace) {
+            return {
+              success: false,
+              message: "\u274C Could not determine the current AIO workspace.\n\nRun `aio where` to check your current context, or set one up with:\n  npx aio-toolkit-cli-workflow env:setup"
+            };
+          }
+          const ruleName = ParseCliFlag.parse(process.argv.slice(2), "name");
+          if (ruleName) {
+            return this.executeSingleRule(workspace, ruleName);
+          }
+          return this.executeAllRules(workspace);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return { success: false, message: `\u274C Unexpected error: ${message}` };
+        }
+      }
+      /**
+       * Fetches and displays the status of a single named rule.
+       */
+      static async executeSingleRule(workspace, ruleName) {
+        console.log(`
+\u{1F50D} Fetching rule "${ruleName}" in workspace "${workspace}"...
+`);
+        const rule = this.getRuleDetail(ruleName);
+        if (!rule) {
+          return {
+            success: false,
+            message: `\u274C Could not fetch details for rule "${ruleName}". Check the rule name and try again.`
+          };
+        }
+        const name = rule.name ? String(rule.name) : ruleName;
+        const triggerName = rule.trigger?.name ? String(rule.trigger.name) : "\u2014";
+        let cronSchedule = "\u2014";
+        if (triggerName !== "\u2014") {
+          console.log(`  \u23F0 Fetching schedule from trigger "${triggerName}"...`);
+          cronSchedule = this.getCronSchedule(triggerName);
+        }
+        const detail = {
+          name,
+          status: rule.status ? String(rule.status) : "unknown",
+          published: rule.publish === true,
+          actionName: rule.action?.name ? String(rule.action.name) : "\u2014",
+          triggerName,
+          cronSchedule,
+          version: rule.version ? String(rule.version) : "\u2014"
+        };
+        return { success: true, message: this.formatOutput(workspace, [detail]) };
+      }
+      /**
+       * Fetches and displays the status of all rules via `aio rt rule list --json`.
+       */
+      static async executeAllRules(workspace) {
+        console.log(`
+\u{1F50D} Fetching cron rules for workspace "${workspace}"...
+`);
+        const ruleList = this.getRuleList();
+        if (ruleList.length === 0) {
+          return {
+            success: true,
+            message: `\u2139\uFE0F  No rules found in workspace "${workspace}".`
+          };
+        }
+        console.log(`\u{1F4CB} Found ${ruleList.length} rule(s). Fetching trigger schedules...
+`);
+        const details = [];
+        for (const rule of ruleList) {
+          const name = rule.name ? String(rule.name) : "";
+          if (!name) continue;
+          const triggerName = rule.trigger?.name ? String(rule.trigger.name) : "\u2014";
+          let cronSchedule = "\u2014";
+          if (triggerName !== "\u2014") {
+            console.log(`  \u23F0 ${name} \u2192 fetching schedule from "${triggerName}"...`);
+            cronSchedule = this.getCronSchedule(triggerName);
+          }
+          details.push({
+            name,
+            status: rule.status ? String(rule.status) : "unknown",
+            published: rule.publish === true,
+            actionName: rule.action?.name ? String(rule.action.name) : "\u2014",
+            triggerName,
+            cronSchedule,
+            version: rule.version ? String(rule.version) : "\u2014"
+          });
+        }
+        if (details.length === 0) {
+          return {
+            success: true,
+            message: `\u2139\uFE0F  No rules found in workspace "${workspace}".`
+          };
+        }
+        return { success: true, message: this.formatOutput(workspace, details) };
+      }
+    };
+    __name(_CliWorkflowCronStatus, "CliWorkflowCronStatus");
+    _CliWorkflowCronStatus.NAME = "cron:status";
+    _CliWorkflowCronStatus.DESCRIPTION = "Display the detailed status of AIO Runtime cron rules in the current workspace";
+    CliWorkflowCronStatus = _CliWorkflowCronStatus;
+  }
+});
+
+// src/commands/cli-workflow/lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  CliWorkflowManager: () => CliWorkflowManager
+});
+var _CliWorkflowManager, CliWorkflowManager;
+var init_lib = __esm({
+  "src/commands/cli-workflow/lib/index.ts"() {
+    "use strict";
+    init_registry();
+    init_help();
+    init_env_setup();
+    init_env_reset();
+    init_cron_delete();
+    init_cron_disable();
+    init_cron_enable();
+    init_cron_status();
+    _CliWorkflowManager = class _CliWorkflowManager extends CommandRegistry {
+      /**
+       * Returns registered cli-workflow commands.
+       *
+       * @returns Array of command descriptors with name, description, and execute handler
+       */
+      static getCommands() {
+        return [
+          {
+            name: CliWorkflowHelp.getName(),
+            description: CliWorkflowHelp.getDescription(),
+            execute: CliWorkflowHelp.execute.bind(CliWorkflowHelp)
+          },
+          {
+            name: CliWorkflowEnvSetup.getName(),
+            description: CliWorkflowEnvSetup.getDescription(),
+            execute: CliWorkflowEnvSetup.execute.bind(CliWorkflowEnvSetup),
+            options: CliWorkflowEnvSetup.getOptions()
+          },
+          {
+            name: CliWorkflowEnvReset.getName(),
+            description: CliWorkflowEnvReset.getDescription(),
+            execute: CliWorkflowEnvReset.execute.bind(CliWorkflowEnvReset),
+            options: CliWorkflowEnvReset.getOptions()
+          },
+          {
+            name: CliWorkflowCronEnable.getName(),
+            description: CliWorkflowCronEnable.getDescription(),
+            execute: CliWorkflowCronEnable.execute.bind(CliWorkflowCronEnable),
+            options: CliWorkflowCronEnable.getOptions()
+          },
+          {
+            name: CliWorkflowCronDelete.getName(),
+            description: CliWorkflowCronDelete.getDescription(),
+            execute: CliWorkflowCronDelete.execute.bind(CliWorkflowCronDelete)
+          },
+          {
+            name: CliWorkflowCronDisable.getName(),
+            description: CliWorkflowCronDisable.getDescription(),
+            execute: CliWorkflowCronDisable.execute.bind(CliWorkflowCronDisable),
+            options: CliWorkflowCronDisable.getOptions()
+          },
+          {
+            name: CliWorkflowCronStatus.getName(),
+            description: CliWorkflowCronStatus.getDescription(),
+            execute: CliWorkflowCronStatus.execute.bind(CliWorkflowCronStatus),
+            options: CliWorkflowCronStatus.getOptions()
+          }
+        ];
+      }
+    };
+    __name(_CliWorkflowManager, "CliWorkflowManager");
+    CliWorkflowManager = _CliWorkflowManager;
+  }
+});
+
+// src/commands/cli-workflow/bin/cli.ts
+init_lib();
+init_aio_cli_detector();
+var AIO_EXEMPT_COMMANDS = ["help"];
+var command = process.argv[2] || "help";
+var args = process.argv.slice(3);
+function checkAioCli() {
+  if (AIO_EXEMPT_COMMANDS.includes(command)) {
+    return true;
+  }
+  if (!AioCliDetector.isInstalled()) {
+    console.error(AioCliDetector.getInstallMessage());
+    return false;
+  }
+  return true;
+}
+__name(checkAioCli, "checkAioCli");
+async function main() {
+  if (!checkAioCli()) {
+    process.exit(1);
+  }
+  const result = await CliWorkflowManager.execute(command, ...args);
+  console.log(result.message);
+  if (!result.success) {
+    process.exit(1);
+  }
+}
+__name(main, "main");
+main().catch((error) => {
+  console.error("Error:", error.message);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map