@tolinax/ayoune-cli 2026.3.1 → 2026.4.0

package/lib/commands/createDeployCommand.js

@@ -0,0 +1,642 @@
+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 { secureStorage } from "../helpers/secureStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+function getToken() {
+    return secureStorage.getItem("token") || process.env.AYOUNE_TOKEN || "";
+}
+export function createDeployCommand(program) {
+    const deploy = program
+        .command("deploy")
+        .alias("dp")
+        .description("Manage deployments, pods, clusters, pipelines, and plans via DevOps API");
+    // ─── DEPLOYMENTS ───────────────────────────────────────
+    // 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 = { ...program.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 = { ...program.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 = { ...program.opts(), ...options };
+            if (opts.follow) {
+                // SSE streaming mode
+                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 ${getToken()}`,
+                        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 = { ...program.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 = { ...program.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);
+        }
+    });
+    // ─── PODS ──────────────────────────────────────────────
+    // ay deploy pods
+    deploy
+        .command("pods")
+        .description("List pods across clusters")
+        .option("--cluster <name>", "Filter by cluster")
+        .option("--namespace <ns>", "Filter by namespace")
+        .option("--status <status>", "Filter: Running, Pending, Failed, Succeeded, Unknown")
+        .option("--deployment <name>", "Filter by deployment")
+        .option("-l, --limit <number>", "Limit", parseInt, 100)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching pods...", color: "magenta" });
+            const params = {
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.cluster)
+                params.cluster = opts.cluster;
+            if (opts.namespace)
+                params.namespace = opts.namespace;
+            if (opts.status)
+                params.status = opts.status;
+            if (opts.deployment)
+                params.deployment = opts.deployment;
+            const res = await apiCallHandler("devops", "pods", "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} pods` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("deploy-pods", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list pods", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay deploy pod-delete <id>
+    deploy
+        .command("pod-delete <id>")
+        .description("Delete a pod (triggers recreation by controller)")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Deleting pod ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("devops", `pods/${id}`, "delete", null, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Pod ${id} deleted` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to delete pod", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ─── CLUSTERS ──────────────────────────────────────────
+    // 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 = { ...program.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 = { ...program.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);
+        }
+    });
+    // ─── ALERTS ────────────────────────────────────────────
+    // ay deploy alerts
+    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 = { ...program.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);
+        }
+    });
+    // ─── PIPELINES ─────────────────────────────────────────
+    // 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 = { ...program.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 = { ...program.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);
+        }
+    });
+    // ─── DEPLOYMENT PLANS ──────────────────────────────────
+    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 = { ...program.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 = { ...program.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 = { ...program.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 = { ...program.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 = { ...program.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);
+        }
+    });
+    // ─── REPOSITORIES ──────────────────────────────────────
+    const repos = deploy
+        .command("repos")
+        .description("Manage git repositories");
+    // ay deploy repos list
+    repos
+        .command("list")
+        .alias("ls")
+        .description("List registered repositories")
+        .option("--provider <provider>", "Filter: bitbucket, github")
+        .option("-l, --limit <number>", "Limit", parseInt, 50)
+        .option("-p, --page <number>", "Page", parseInt, 1)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching repositories...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.provider)
+                params.provider = opts.provider;
+            const res = await apiCallHandler("devops", "repositories", "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} repositories` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("deploy-repos", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list repositories", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay deploy repos sync <id>
+    repos
+        .command("sync <id>")
+        .description("Sync a repository with its remote provider")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Syncing repository ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("devops", `repositories/${id}/sync`, "post", null, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Repository ${id} sync initiated` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to sync repository", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ─── DASHBOARD ─────────────────────────────────────────
+    // ay deploy dashboard
+    deploy
+        .command("dashboard")
+        .alias("dash")
+        .description("Show deployment overview dashboard (clusters, deployments, alerts, pipelines)")
+        .action(async (options) => {
+        try {
+            const opts = { ...program.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);
+        }
+    });
+}