@tolinax/ayoune-cli 2026.8.2 → 2026.10.0

package/lib/commands/deploy/alerts.js

@@ -0,0 +1,43 @@
+// `ay deploy alerts` — surface active deployment alerts (pod crashes,
+// OOM kills, image pull errors, etc.). Read-only filter view; ack/resolve
+// lives under `ay monitor` so we don't duplicate state mutation here.
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { saveFile } from "../../helpers/saveFile.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+export function addAlertsSubcommands(deploy, rootProgram) {
+    deploy
+        .command("alerts")
+        .description("List active deployment alerts")
+        .option("--severity <level>", "Filter: critical, warning, info")
+        .option("--type <type>", "Filter: pod_crash, oom_killed, image_pull_error, deployment_failed, pipeline_failed, cluster_unreachable, high_restart_count, custom")
+        .option("-l, --limit <number>", "Limit", parseInt, 50)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: "Fetching alerts...", color: "magenta" });
+            const params = {
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.severity)
+                params.severity = opts.severity;
+            if (opts.type)
+                params.type = opts.type;
+            const res = await apiCallHandler("devops", "alerts", "get", null, params);
+            handleResponseFormatOptions(opts, res);
+            const total = (_c = (_b = (_a = res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo) === null || _b === void 0 ? void 0 : _b.totalEntries) !== null && _c !== void 0 ? _c : 0;
+            spinner.success({ text: `Found ${total} alerts` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("deploy-alerts", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to fetch alerts", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/deploy/clusters.js

@@ -0,0 +1,62 @@
+// `ay deploy {clusters, cluster-sync}` — Kubernetes cluster discovery and
+// manual reconcile trigger. The DevOps API maintains a registry of clusters
+// the customer has connected; `clusters` lists them and `cluster-sync` kicks
+// off a re-scan of resources for one cluster.
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { saveFile } from "../../helpers/saveFile.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+export function addClustersSubcommands(deploy, rootProgram) {
+    // ay deploy clusters
+    deploy
+        .command("clusters")
+        .alias("cl")
+        .description("List Kubernetes clusters and their health status")
+        .addHelpText("after", `
+Examples:
+  ay deploy clusters                   List all clusters
+  ay deploy clusters -r table          Show clusters in table format`)
+        .option("-l, --limit <number>", "Limit", parseInt, 50)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: "Fetching clusters...", color: "magenta" });
+            const res = await apiCallHandler("devops", "clusters", "get", null, {
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            const total = (_c = (_b = (_a = res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo) === null || _b === void 0 ? void 0 : _b.totalEntries) !== null && _c !== void 0 ? _c : 0;
+            spinner.success({ text: `Found ${total} clusters` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("deploy-clusters", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list clusters", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay deploy cluster-sync <id>
+    deploy
+        .command("cluster-sync <id>")
+        .description("Trigger sync for a Kubernetes cluster")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: `Syncing cluster ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("devops", `clusters/${id}/sync`, "post", null, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Cluster ${id} sync initiated` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to sync cluster", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/deploy/dashboard.js

@@ -0,0 +1,31 @@
+// `ay deploy dashboard` — single-call overview that returns the same
+// summary the web devops dashboard renders (cluster health, deployment
+// counts, active alerts, recent pipelines). Useful as a one-shot health
+// check during incident response.
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+export function addDashboardSubcommands(deploy, rootProgram) {
+    deploy
+        .command("dashboard")
+        .alias("dash")
+        .description("Show deployment overview dashboard (clusters, deployments, alerts, pipelines)")
+        .action(async (options) => {
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: "Fetching dashboard...", color: "magenta" });
+            const res = await apiCallHandler("devops", "dashboard", "get", null, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: "Dashboard loaded" });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to load dashboard", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/deploy/deployments.js

@@ -0,0 +1,216 @@
+// `ay deploy {list,get,logs,scale,restart}` — the core deployment-management
+// subcommands. All hit the DevOps API except `logs --follow`, which streams
+// Server-Sent Events directly from `${devops}/deployments/{id}/logs` so we
+// can render live log lines without buffering through axios.
+import chalk from "chalk";
+import { getModuleBaseUrl } from "../../api/apiClient.js";
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { saveFile } from "../../helpers/saveFile.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+import { getDeployToken } from "./_token.js";
+export function addDeploymentsSubcommands(deploy, rootProgram) {
+    // ay deploy list
+    deploy
+        .command("list")
+        .alias("ls")
+        .description("List deployments across clusters")
+        .option("--cluster <name>", "Filter by cluster name")
+        .option("--namespace <ns>", "Filter by namespace")
+        .option("--health <status>", "Filter: healthy, degraded, crashed, pending")
+        .option("-q, --search <term>", "Search by name")
+        .option("-l, --limit <number>", "Limit", parseInt, 50)
+        .option("-p, --page <number>", "Page", parseInt, 1)
+        .action(async (options) => {
+        var _a, _b;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: "Fetching deployments...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            };
+            if (opts.cluster)
+                params.cluster = opts.cluster;
+            if (opts.namespace)
+                params.namespace = opts.namespace;
+            if (opts.health)
+                params.health = opts.health;
+            if (opts.search)
+                params.q = opts.search;
+            const res = await apiCallHandler("devops", "deployments", "get", null, params);
+            const { result: fmtResult, meta: fmtMeta } = handleResponseFormatOptions(opts, res);
+            const total = (_b = (_a = fmtMeta === null || fmtMeta === void 0 ? void 0 : fmtMeta.pageInfo) === null || _a === void 0 ? void 0 : _a.totalEntries) !== null && _b !== void 0 ? _b : (Array.isArray(fmtResult) ? fmtResult.length : 0);
+            spinner.success({ text: `Found ${total} deployments` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("deploy-list", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list deployments", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay deploy get <id>
+    deploy
+        .command("get <id>")
+        .description("Get deployment details by ID")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: `Fetching deployment ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("devops", `deployments/${id}`, "get", null, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Deployment ${id} loaded` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to get deployment", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay deploy logs <id>
+    deploy
+        .command("logs <id>")
+        .description("Get deployment logs (supports live streaming)")
+        .addHelpText("after", `
+Examples:
+  ay deploy logs 64a1b2c3d4e5                Get recent logs
+  ay deploy logs 64a1b2c3d4e5 --follow       Stream logs in real-time (SSE)
+  ay deploy logs 64a1b2c3d4e5 --tail 100     Last 100 log lines`)
+        .option("-f, --follow", "Stream logs in real-time (Server-Sent Events)")
+        .option("--tail <lines>", "Number of recent log lines", parseInt, 50)
+        .action(async (id, options) => {
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            if (opts.follow) {
+                // SSE streaming mode — bypass apiCallHandler so we can read the
+                // stream chunk-by-chunk and emit each event as it arrives.
+                spinner.start({
+                    text: `Streaming logs for deployment ${id}...`,
+                    color: "magenta",
+                });
+                spinner.stop();
+                console.error(chalk.dim(`  Streaming logs for ${id} (Ctrl+C to stop)\n`));
+                const baseUrl = getModuleBaseUrl("devops");
+                const url = `${baseUrl}/deployments/${id}/logs?follow=true&tail=${opts.tail}`;
+                const https = await import("https");
+                const { URL } = await import("url");
+                const parsed = new URL(url);
+                const req = https.get({
+                    hostname: parsed.hostname,
+                    path: `${parsed.pathname}${parsed.search}`,
+                    headers: {
+                        Authorization: `Bearer ${getDeployToken()}`,
+                        Accept: "text/event-stream",
+                    },
+                }, (res) => {
+                    if (res.statusCode !== 200) {
+                        cliError(`Error: HTTP ${res.statusCode}`, EXIT_GENERAL_ERROR);
+                    }
+                    res.setEncoding("utf-8");
+                    res.on("data", (chunk) => {
+                        // Parse SSE: lines starting with "data: "
+                        const lines = chunk.split("\n");
+                        for (const line of lines) {
+                            if (line.startsWith("data: ")) {
+                                const data = line.slice(6);
+                                try {
+                                    const parsed = JSON.parse(data);
+                                    if (opts.responseFormat === "json") {
+                                        console.log(JSON.stringify(parsed));
+                                    }
+                                    else {
+                                        const ts = parsed.timestamp || "";
+                                        const level = parsed.level || "info";
+                                        const msg = parsed.message || data;
+                                        console.log(`${chalk.dim(ts)} ${chalk.cyan(level)} ${msg}`);
+                                    }
+                                }
+                                catch (_a) {
+                                    console.log(data);
+                                }
+                            }
+                        }
+                    });
+                    res.on("end", () => {
+                        console.error(chalk.dim("\n  Stream ended."));
+                    });
+                });
+                req.on("error", (e) => {
+                    cliError(`Stream error: ${e.message}`, EXIT_GENERAL_ERROR);
+                });
+                // Keep alive until Ctrl+C
+                process.on("SIGINT", () => {
+                    req.destroy();
+                    process.exit(0);
+                });
+                // Prevent Node from exiting
+                await new Promise(() => { });
+            }
+            else {
+                // One-shot log fetch
+                spinner.start({ text: `Fetching logs for deployment ${id}...`, color: "magenta" });
+                const res = await apiCallHandler("devops", `deployments/${id}/logs`, "get", null, {
+                    tail: opts.tail,
+                    responseFormat: opts.responseFormat,
+                    verbosity: opts.verbosity,
+                });
+                handleResponseFormatOptions(opts, res);
+                spinner.success({ text: `Logs loaded for deployment ${id}` });
+                spinner.stop();
+                if (opts.save)
+                    await saveFile("deploy-logs", opts, res);
+            }
+        }
+        catch (e) {
+            cliError(e.message || "Failed to fetch logs", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay deploy scale <deployment> <replicas>
+    deploy
+        .command("scale <deployment> <replicas>")
+        .description("Scale a deployment to N replicas")
+        .action(async (deployment, replicas, options) => {
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({
+                text: `Scaling ${deployment} to ${replicas} replicas...`,
+                color: "magenta",
+            });
+            const res = await apiCallHandler("devops", "deployments/scale", "post", {
+                deployment,
+                replicas: parseInt(replicas, 10),
+            }, { responseFormat: opts.responseFormat });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Scaled ${deployment} to ${replicas} replicas` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to scale deployment", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay deploy restart <deployment>
+    deploy
+        .command("restart <deployment>")
+        .description("Restart a deployment (rolling restart)")
+        .action(async (deployment, options) => {
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: `Restarting ${deployment}...`, color: "magenta" });
+            const res = await apiCallHandler("devops", "deployments/restart", "post", { deployment }, { responseFormat: opts.responseFormat });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Restart initiated for ${deployment}` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to restart deployment", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/deploy/index.js

@@ -0,0 +1,31 @@
+// `ay deploy` parent command — DevOps API surface (deployments, pods,
+// clusters, alerts, pipelines, plans, repos, dashboard).
+//
+// The original `createDeployCommand.ts` was 695 lines with 22 subcommands
+// inline; the split groups subcommands by topic into 8 files. This file just
+// instantiates the parent and wires the children. The exported function name
+// (`createDeployCommand`) is preserved so `_registry.ts` and the existing
+// test (`createDeployCommand.test.ts`) keep working through the back-compat
+// shim at `../createDeployCommand.ts`.
+import { addDeploymentsSubcommands } from "./deployments.js";
+import { addPodsSubcommands } from "./pods.js";
+import { addClustersSubcommands } from "./clusters.js";
+import { addAlertsSubcommands } from "./alerts.js";
+import { addPipelinesSubcommands } from "./pipelines.js";
+import { addPlansSubcommands } from "./plans.js";
+import { addReposSubcommands } from "./repos.js";
+import { addDashboardSubcommands } from "./dashboard.js";
+export function createDeployCommand(program) {
+    const deploy = program
+        .command("deploy")
+        .alias("dp")
+        .description("Manage deployments, pods, clusters, pipelines, and plans via DevOps API");
+    addDeploymentsSubcommands(deploy, program);
+    addPodsSubcommands(deploy, program);
+    addClustersSubcommands(deploy, program);
+    addAlertsSubcommands(deploy, program);
+    addPipelinesSubcommands(deploy, program);
+    addPlansSubcommands(deploy, program);
+    addReposSubcommands(deploy, program);
+    addDashboardSubcommands(deploy, program);
+}

package/lib/commands/deploy/pipelines.js

@@ -0,0 +1,82 @@
+// `ay deploy {pipelines, trigger}` — CI/CD pipeline visibility + manual
+// trigger. `pipelines` is read-only listing; `trigger` POSTs to
+// `pipelines/trigger` with a repo slug + branch + optional target name to
+// kick off a build. Default branch is "master" because that's what the
+// platform deploys from (see CLAUDE.md: master deploys to develop namespace
+// which IS prod).
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { saveFile } from "../../helpers/saveFile.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+export function addPipelinesSubcommands(deploy, rootProgram) {
+    // ay deploy pipelines
+    deploy
+        .command("pipelines")
+        .alias("pipe")
+        .description("List recent CI/CD pipelines")
+        .option("--repo <slug>", "Filter by repository slug")
+        .option("--result <result>", "Filter: SUCCESSFUL, FAILED, STOPPED, EXPIRED")
+        .option("-l, --limit <number>", "Limit", parseInt, 20)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: "Fetching pipelines...", color: "magenta" });
+            const params = {
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.repo)
+                params.repository = opts.repo;
+            if (opts.result)
+                params.result = opts.result;
+            const res = await apiCallHandler("devops", "pipelines", "get", null, params);
+            handleResponseFormatOptions(opts, res);
+            const total = (_c = (_b = (_a = res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo) === null || _b === void 0 ? void 0 : _b.totalEntries) !== null && _c !== void 0 ? _c : 0;
+            spinner.success({ text: `Found ${total} pipelines` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("deploy-pipelines", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to fetch pipelines", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay deploy trigger <repo>
+    deploy
+        .command("trigger <repo>")
+        .description("Trigger a CI/CD pipeline for a repository")
+        .addHelpText("after", `
+Examples:
+  ay deploy trigger ayoune-cli                         Trigger pipeline for ayoune-cli
+  ay deploy trigger ayoune-cli --branch feature/new    Use specific branch
+  ay deploy trigger ayoune-cli --target staging         Custom pipeline target`)
+        .option("--branch <branch>", "Branch to trigger pipeline on", "master")
+        .option("--target <target>", "Pipeline target name")
+        .action(async (repo, options) => {
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: `Triggering pipeline for ${repo}...`, color: "magenta" });
+            const body = {
+                repositorySlug: repo,
+                branch: opts.branch,
+            };
+            if (opts.target)
+                body.target = opts.target;
+            const res = await apiCallHandler("devops", "pipelines/trigger", "post", body, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({
+                text: `Pipeline triggered for ${repo} (branch: ${opts.branch})`,
+            });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to trigger pipeline", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/deploy/plans.js

@@ -0,0 +1,147 @@
+// `ay deploy plans {list,get,create,execute,delete}` — multi-step deployment
+// plans (e.g. "rolling deploy of 5 services with health-check gates between
+// each step"). The plans tree forms its own intermediate command so the
+// `ay deploy plans <action>` invocation surface stays grouped.
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { saveFile } from "../../helpers/saveFile.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+export function addPlansSubcommands(deploy, rootProgram) {
+    const plans = deploy.command("plans").description("Manage multi-step deployment plans");
+    // ay deploy plans list
+    plans
+        .command("list")
+        .alias("ls")
+        .description("List deployment plans")
+        .option("-l, --limit <number>", "Limit", parseInt, 50)
+        .option("-p, --page <number>", "Page", parseInt, 1)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: "Fetching deployment plans...", color: "magenta" });
+            const res = await apiCallHandler("devops", "deployment-plans", "get", null, {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            const total = (_c = (_b = (_a = res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo) === null || _b === void 0 ? void 0 : _b.totalEntries) !== null && _c !== void 0 ? _c : 0;
+            spinner.success({ text: `Found ${total} deployment plans` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("deploy-plans", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list deployment plans", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay deploy plans get <id>
+    plans
+        .command("get <id>")
+        .description("Get deployment plan details")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: `Fetching plan ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("devops", `deployment-plans/${id}`, "get", null, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Plan ${id} loaded` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to get plan", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay deploy plans create --body '{...}'
+    plans
+        .command("create")
+        .description("Create a new deployment plan")
+        .option("--body <json>", "Plan definition as JSON")
+        .option("--body-file <path>", "Read plan definition from file")
+        .action(async (options) => {
+        var _a;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            let body = null;
+            if (opts.body) {
+                try {
+                    body = JSON.parse(opts.body);
+                }
+                catch (_b) {
+                    cliError("Invalid JSON in --body", EXIT_GENERAL_ERROR);
+                }
+            }
+            else if (opts.bodyFile) {
+                const fs = await import("fs");
+                const content = fs.readFileSync(opts.bodyFile, "utf-8");
+                try {
+                    body = JSON.parse(content);
+                }
+                catch (_c) {
+                    cliError(`Invalid JSON in file: ${opts.bodyFile}`, EXIT_GENERAL_ERROR);
+                }
+            }
+            if (!body) {
+                cliError("Provide plan definition via --body or --body-file", EXIT_GENERAL_ERROR);
+            }
+            spinner.start({ text: "Creating deployment plan...", color: "magenta" });
+            const res = await apiCallHandler("devops", "deployment-plans", "post", body, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            const planId = ((_a = res.payload) === null || _a === void 0 ? void 0 : _a._id) || "unknown";
+            spinner.success({ text: `Deployment plan ${planId} created` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to create plan", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay deploy plans execute <id>
+    plans
+        .command("execute <id>")
+        .alias("exec")
+        .description("Execute a deployment plan")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: `Executing deployment plan ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("devops", `deployment-plans/${id}/execute`, "post", null, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Plan ${id} execution started` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to execute plan", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay deploy plans delete <id>
+    plans
+        .command("delete <id>")
+        .alias("rm")
+        .description("Delete a deployment plan")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: `Deleting plan ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("devops", `deployment-plans/${id}`, "delete", null, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Plan ${id} deleted` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to delete plan", EXIT_GENERAL_ERROR);
+        }
+    });
+}