@tolinax/ayoune-cli 2026.2.1 → 2026.2.2

package/lib/commands/createMonitorCommand.js

@@ -0,0 +1,283 @@
+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";
+export function createMonitorCommand(program) {
+    const monitor = program
+        .command("monitor")
+        .alias("mon")
+        .description("Monitor platform activity, logs, and alerts");
+    // ay monitor logs [type]
+    monitor
+        .command("logs [type]")
+        .description("List recent platform logs (api, error, mail, ai, trigger, ...)")
+        .addHelpText("after", `
+Log types: api, error, mail, ai, trigger, doi, export, sms, whatsapp, production, setup, state, shop, score, sensor, stock, soi, reward, merge, download, post, webreceiver, work, computingentitieslogs, consumerapi, accessterminal, googleads
+
+Examples:
+  ay monitor logs error                 List recent error logs
+  ay monitor logs api -l 10             List last 10 API logs
+  ay monitor logs ai -r table           List AI logs in table format`)
+        .option("-l, --limit <number>", "Limit results", parseInt, 25)
+        .option("-p, --page <number>", "Page number", parseInt, 1)
+        .option("--sort <field>", "Sort by field", "-createdAt")
+        .action(async (type, options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            const logType = type || "api";
+            const collectionMap = {
+                api: "apilogs",
+                error: "errorlogs",
+                mail: "maillogs",
+                ai: "ailogs",
+                trigger: "triggerlogs",
+                doi: "doilogs",
+                export: "exportlogs",
+                sms: "smslogs",
+                whatsapp: "whatsapplogs",
+                production: "productionlogs",
+                setup: "setuplogs",
+                state: "statelogs",
+                shop: "shoplogs",
+                score: "scorelogs",
+                sensor: "sensorlogs",
+                stock: "stocklogs",
+                soi: "soilogs",
+                reward: "rewardlogs",
+                merge: "mergelogs",
+                download: "downloadlogs",
+                post: "postlogs",
+                webreceiver: "webreceiverlogs",
+                work: "worklogs",
+                consumerapi: "consumerapilogs",
+                accessterminal: "accessterminallogs",
+                googleads: "adwordslogs",
+                computing: "computingentitieslogs",
+            };
+            const collection = collectionMap[logType] || `${logType}logs`;
+            spinner.start({ text: `Fetching ${logType} logs...`, color: "magenta" });
+            const res = await apiCallHandler("logs", collection, "get", null, {
+                page: opts.page,
+                limit: opts.limit,
+                sort: opts.sort,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            });
+            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} ${logType} log entries` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile(`monitor-logs-${logType}`, opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to fetch logs" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay monitor alerts — command group
+    const alerts = monitor
+        .command("alerts")
+        .description("Manage platform alerts (list, acknowledge, resolve)");
+    // ay monitor alerts list
+    alerts
+        .command("list")
+        .alias("ls")
+        .description("List active alerts")
+        .addHelpText("after", `
+Examples:
+  ay monitor alerts list                          List all active alerts
+  ay monitor alerts list --severity critical      Show critical alerts only
+  ay monitor alerts list --type pod_crash          Filter by alert type
+  ay monitor alerts list --status acknowledged    Show acknowledged alerts`)
+        .option("-l, --limit <number>", "Limit results", parseInt, 50)
+        .option("-p, --page <number>", "Page number", parseInt, 1)
+        .option("--severity <level>", "Filter: info, warning, critical")
+        .option("--type <type>", "Filter: pod_crash, oom_killed, image_pull_error, deployment_failed, pipeline_failed, cluster_unreachable, high_restart_count, custom")
+        .option("--status <status>", "Filter: active, acknowledged, resolved", "active")
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching alerts...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            };
+            if (opts.severity)
+                params.severity = opts.severity;
+            if (opts.type)
+                params.type = opts.type;
+            if (opts.status)
+                params.status = opts.status;
+            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("monitor-alerts", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to fetch alerts" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay monitor alerts ack <id>
+    alerts
+        .command("ack <id>")
+        .alias("acknowledge")
+        .description("Acknowledge an alert")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Acknowledging alert ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("devops", `alerts/${id}/acknowledge`, "put", null, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Alert ${id} acknowledged` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to acknowledge alert" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay monitor alerts resolve <id>
+    alerts
+        .command("resolve <id>")
+        .description("Resolve an alert")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Resolving alert ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("devops", `alerts/${id}/resolve`, "put", null, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Alert ${id} resolved` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to resolve alert" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay monitor sessions
+    monitor
+        .command("sessions")
+        .description("List active user sessions")
+        .option("-l, --limit <number>", "Limit results", parseInt, 50)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching active sessions...", color: "magenta" });
+            const res = await apiCallHandler("monitoring", "sessions", "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} active sessions` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("monitor-sessions", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to fetch sessions" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay monitor checks
+    monitor
+        .command("checks")
+        .description("List monitoring checks and their results")
+        .option("-l, --limit <number>", "Limit results", parseInt, 50)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching monitoring checks...", color: "magenta" });
+            const res = await apiCallHandler("monitoring", "checks", "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} monitoring checks` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("monitor-checks", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to fetch checks" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay monitor activeusers
+    monitor
+        .command("activeusers")
+        .alias("users")
+        .description("Show currently active users on the platform")
+        .option("-l, --limit <number>", "Limit results", parseInt, 50)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching active users...", color: "magenta" });
+            const res = await apiCallHandler("monitoring", "activeusers", "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: `${total} active users` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("monitor-activeusers", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to fetch active users" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay monitor pagestats
+    monitor
+        .command("pagestats")
+        .alias("pages")
+        .description("View page view statistics")
+        .option("-l, --limit <number>", "Limit results", parseInt, 50)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching page statistics...", color: "magenta" });
+            const res = await apiCallHandler("monitoring", "pagestats", "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} page stat entries` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("monitor-pagestats", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to fetch page stats" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createProgram.js

@@ -0,0 +1,163 @@
+//Defines the main program structure for command line interface
+import { Option } from "commander";
+import chalk from "chalk";
+import path from "path";
+import os from "os";
+import { spinner } from "../../index.js";
+import { createModulesCommand } from "./createModulesCommand.js";
+import { createListCommand } from "./createListCommand.js";
+import { createGetCommand } from "./createGetCommand.js";
+import { createEditCommand } from "./createEditCommand.js";
+import { createLoginCommand } from "./createLoginCommand.js";
+import { createDescribeCommand } from "./createDescribeCommand.js";
+import { createCopyCommand } from "./createCopyCommand.js";
+import { createCreateCommand } from "./createCreateCommand.js";
+import { createStorageCommand } from "./createStorageCommand.js";
+import { createAuditCommand } from "./createAuditCommand.js";
+import { createStreamCommand } from "./createStreamCommand.js";
+import { createEventsCommand } from "./createEventsCommand.js";
+import { createWhoAmICommand } from "./createWhoAmICommand.js";
+import { createLogoutCommand } from "./createLogoutCommand.js";
+import { createCompletionsCommand } from "./createCompletionsCommand.js";
+import { createAliasCommand, registerUserAliases } from "./createAliasCommand.js";
+import { createConfigCommand } from "./createConfigCommand.js";
+import { createActionsCommand } from "./createActionsCommand.js";
+import { createExecCommand } from "./createExecCommand.js";
+import { createAiCommand } from "./createAiCommand.js";
+import { enableDebug } from "../api/apiClient.js";
+import { enableDryRun } from "../api/apiCallHandler.js";
+import { enableJsonErrors } from "../api/handleAPIError.js";
+import { createServicesCommand } from "./createServicesCommand.js";
+import { createDeployCommand } from "./createDeployCommand.js";
+import { createMonitorCommand } from "./createMonitorCommand.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { login } from "../api/login.js";
+import { loadConfig } from "../helpers/configLoader.js";
+export function createProgram(program) {
+    program
+        .version("2024.8.0")
+        .addOption(new Option("-r, --responseFormat <format>", "Set the output format")
+        .choices(["json", "csv", "yaml", "table"])
+        .default("json"))
+        .addOption(new Option("-v, --verbosity <level>", "Set the verbosity level of the returned meta information")
+        .choices(["default", "extended", "minimal"])
+        .default("default")
+        .conflicts("hideMeta"))
+        .addOption(new Option("-m, --hideMeta", "Returns only the payload without meta information. ")
+        .default(false)
+        .conflicts("verbosity"))
+        .addOption(new Option("-s, --save", "Saves the response as file"))
+        .addOption(new Option("-d, --debug", "Show detailed request/response information"))
+        .addOption(new Option("-o, --outPath [filePath]", "Lets you set a path").default(path.join(os.homedir(), "aYOUne")))
+        .addOption(new Option("-n, --name [fileName]", "Lets you set a filename"))
+        .addOption(new Option("-q, --quiet", "Suppress all output except errors and results"))
+        .addOption(new Option("--force", "Skip confirmation prompts for destructive actions"))
+        .addOption(new Option("--dry-run", "Preview what a command would do without executing"))
+        .addOption(new Option("--jq <expression>", "Filter JSON output using JMESPath expression"))
+        .addOption(new Option("--columns <fields>", "Comma-separated list of columns to display"))
+        .addOption(new Option("--no-color", "Disable colored output"))
+        .addOption(new Option("--json-errors", "Output errors as JSON to stderr (for AI agents/scripts)"))
+        .description("aYOUne - Business as a Service Command Line Interface");
+    program.showHelpAfterError();
+    program.showSuggestionAfterError(true);
+    createModulesCommand(program);
+    createListCommand(program);
+    createGetCommand(program);
+    createEditCommand(program);
+    createCopyCommand(program);
+    createDescribeCommand(program);
+    createCreateCommand(program);
+    createStorageCommand(program);
+    createAuditCommand(program);
+    createStreamCommand(program);
+    createEventsCommand(program);
+    createWhoAmICommand(program);
+    createLogoutCommand(program);
+    createActionsCommand(program);
+    createExecCommand(program);
+    createAiCommand(program);
+    createServicesCommand(program);
+    createDeployCommand(program);
+    createMonitorCommand(program);
+    createCompletionsCommand(program);
+    createAliasCommand(program);
+    createConfigCommand(program);
+    registerUserAliases(program);
+    createLoginCommand(program);
+    program.addHelpText("beforeAll", `
+     __     ______  _    _            
+     \\ \\   / / __ \\| |  | |           
+   __ \\ \\_/ / |  | | |  | |_ __   ___ 
+  / _\` \\   /| |  | | |  | | '_ \\ / _ \\
+ | (_| || | | |__| | |__| | | | |  __/
+  \\__,_||_|  \\____/ \\____/|_| |_|\\___|
+`);
+    program.configureHelp({
+        sortOptions: true,
+        sortSubcommands: true,
+        showGlobalOptions: true,
+    });
+    // Respect NO_COLOR env var (no-color.org standard)
+    if (process.env.NO_COLOR !== undefined) {
+        chalk.level = 0;
+    }
+    program.hook("preAction", async (thisCommand) => {
+        var _a;
+        // Apply saved defaults — only when the user didn't pass the flag explicitly
+        const config = loadConfig();
+        const defaults = (_a = config.defaults) !== null && _a !== void 0 ? _a : {};
+        const rawArgs = process.argv.slice(2);
+        if (defaults.responseFormat && !rawArgs.some(a => ["-r", "--responseFormat"].includes(a)))
+            program.setOptionValue("responseFormat", defaults.responseFormat);
+        if (defaults.verbosity && !rawArgs.some(a => ["-v", "--verbosity"].includes(a)))
+            program.setOptionValue("verbosity", defaults.verbosity);
+        if (defaults.outPath && !rawArgs.some(a => ["-o", "--outPath"].includes(a)))
+            program.setOptionValue("outPath", defaults.outPath);
+        if (defaults.hideMeta && !rawArgs.some(a => ["-m", "--hideMeta"].includes(a)))
+            program.setOptionValue("hideMeta", defaults.hideMeta);
+        if (defaults.quiet && !rawArgs.some(a => ["-q", "--quiet"].includes(a)))
+            program.setOptionValue("quiet", defaults.quiet);
+        if (defaults.force && !rawArgs.some(a => ["--force"].includes(a)))
+            program.setOptionValue("force", defaults.force);
+        if (defaults.dryRun && !rawArgs.some(a => ["--dry-run"].includes(a)))
+            program.setOptionValue("dryRun", defaults.dryRun);
+        const opts = program.opts();
+        if (opts.color === false) {
+            chalk.level = 0;
+        }
+        if (opts.debug) {
+            enableDebug();
+        }
+        if (opts.dryRun) {
+            enableDryRun();
+        }
+        if (opts.jsonErrors) {
+            enableJsonErrors();
+        }
+        if (opts.quiet) {
+            spinner.start = () => spinner;
+            spinner.update = () => spinner;
+            spinner.success = () => spinner;
+            spinner.stop = () => spinner;
+            // spinner.error left intact
+        }
+        // Token from env var (headless/AI agent mode) — takes precedence over stored token
+        const envToken = process.env.AYOUNE_TOKEN;
+        if (envToken && !localStorage.getItem("token")) {
+            localStorage.setItem("token", envToken);
+        }
+        // First-run onboarding: auto-login if no token stored
+        const cmdName = thisCommand.name();
+        const skipAuth = ["login", "logout", "whoami", "completions", "alias", "config", "help"];
+        if (!skipAuth.includes(cmdName) && process.stdin.isTTY) {
+            const token = localStorage.getItem("token");
+            if (!token) {
+                console.error(chalk.cyan.bold("\n  Welcome to aYOUne CLI!\n"));
+                console.error(chalk.dim("  You need to authenticate before using this command.\n"));
+                await login();
+            }
+        }
+    });
+    //Parse command line arguments
+    program.parse(process.argv);
+}

package/lib/commands/createServicesCommand.js

@@ -0,0 +1,228 @@
+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 { aYOUneModules } from "../../data/modules.js";
+import { aYOUneServices } from "../../data/services.js";
+function buildServiceRegistry() {
+    const services = [];
+    // APIs from modules
+    for (const m of aYOUneModules) {
+        services.push({
+            name: m.label,
+            type: "api",
+            module: m.module,
+            host: m.host,
+        });
+    }
+    // Services
+    for (const s of aYOUneServices) {
+        services.push({
+            name: s.label,
+            type: "service",
+            module: s.module,
+            host: s.host,
+        });
+    }
+    return services;
+}
+export function createServicesCommand(program) {
+    const svc = program
+        .command("services")
+        .alias("svc")
+        .description("Discover and manage aYOUne platform services");
+    // ay services list
+    svc
+        .command("list")
+        .alias("ls")
+        .description("List all registered services, APIs, and gateways")
+        .option("--type <type>", "Filter by type: api, service, gateway, worker")
+        .option("--module <module>", "Filter by module name")
+        .action(async (options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Loading service registry...", color: "magenta" });
+            let services = buildServiceRegistry();
+            if (opts.type) {
+                services = services.filter((s) => s.type === opts.type);
+            }
+            if (opts.module) {
+                services = services.filter((s) => s.module === opts.module);
+            }
+            const res = {
+                payload: services,
+                meta: { responseTime: 0, pageInfo: { totalEntries: services.length, page: 1, totalPages: 1 } },
+            };
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Found ${services.length} services` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("services-list", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list services" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay services endpoints <host>
+    svc
+        .command("endpoints <host>")
+        .alias("ep")
+        .description("List API endpoints for a service host")
+        .addHelpText("after", `
+Examples:
+  ay services endpoints ai.ayoune.app
+  ay services endpoints crm-api.ayoune.app -r table`)
+        .action(async (host, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Fetching endpoints for ${host}...`, color: "magenta" });
+            const res = await apiCallHandler("config", "ayouneapiactions", "get", null, {
+                limit: 500,
+                responseFormat: "json",
+            });
+            if (!(res === null || res === void 0 ? void 0 : res.payload)) {
+                spinner.error({ text: "No API actions found" });
+                return;
+            }
+            const endpoints = (Array.isArray(res.payload) ? res.payload : [])
+                .filter((a) => {
+                const h = a.host || "";
+                return h.includes(host) && !a.deprecated;
+            })
+                .map((a) => ({
+                method: (a.method || "GET").toUpperCase(),
+                endpoint: a.endpoint || "",
+                operationId: a.operationId || "",
+                action: a.action || "",
+                description: a.shortDescription || a.description || "",
+            }))
+                .sort((a, b) => a.endpoint.localeCompare(b.endpoint));
+            const formattedRes = {
+                payload: endpoints,
+                meta: { responseTime: 0, pageInfo: { totalEntries: endpoints.length, page: 1, totalPages: 1 } },
+            };
+            handleResponseFormatOptions(opts, formattedRes);
+            spinner.success({ text: `Found ${endpoints.length} endpoints on ${host}` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("service-endpoints", opts, formattedRes);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to fetch endpoints" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay services health [host]
+    svc
+        .command("health [host]")
+        .description("Check health of a service or all services")
+        .option("--timeout <ms>", "Request timeout in ms", parseInt, 5000)
+        .action(async (host, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const targets = host
+                ? [{ name: host, host }]
+                : buildServiceRegistry().map((s) => ({ name: s.name, host: s.host }));
+            // Deduplicate by host
+            const uniqueTargets = [...new Map(targets.map((t) => [t.host, t])).values()];
+            spinner.start({ text: `Checking ${uniqueTargets.length} service(s)...`, color: "magenta" });
+            const { default: axios } = await import("axios");
+            const https = await import("https");
+            const agent = new https.Agent({ rejectUnauthorized: false });
+            const results = await Promise.allSettled(uniqueTargets.map(async (t) => {
+                const start = Date.now();
+                try {
+                    const resp = await axios.get(`https://${t.host}/`, {
+                        timeout: opts.timeout,
+                        httpsAgent: agent,
+                        validateStatus: () => true,
+                    });
+                    return {
+                        host: t.host,
+                        name: t.name,
+                        status: resp.status < 500 ? "healthy" : "unhealthy",
+                        statusCode: resp.status,
+                        responseTime: Date.now() - start,
+                    };
+                }
+                catch (e) {
+                    return {
+                        host: t.host,
+                        name: t.name,
+                        status: "unreachable",
+                        statusCode: 0,
+                        responseTime: Date.now() - start,
+                        error: e.code || e.message,
+                    };
+                }
+            }));
+            const payload = results.map((r) => (r.status === "fulfilled" ? r.value : { status: "error" }));
+            const healthy = payload.filter((p) => p.status === "healthy").length;
+            const res = {
+                payload,
+                meta: {
+                    responseTime: 0,
+                    pageInfo: { totalEntries: payload.length, page: 1, totalPages: 1 },
+                },
+            };
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `${healthy}/${uniqueTargets.length} services healthy` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("services-health", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Health check failed" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay services describe <module>
+    svc
+        .command("describe <module>")
+        .alias("desc")
+        .description("Show detailed info about a module/service")
+        .action(async (moduleName, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Describing ${moduleName}...`, color: "magenta" });
+            // Find matching entries
+            const apis = aYOUneModules.filter((m) => m.module === moduleName);
+            const svcs = aYOUneServices.filter((s) => s.module === moduleName);
+            // Fetch endpoint count from apiactions
+            const res = await apiCallHandler("config", "ayouneapiactions", "get", null, {
+                limit: 500,
+                responseFormat: "json",
+            });
+            const allActions = Array.isArray(res === null || res === void 0 ? void 0 : res.payload) ? res.payload : [];
+            const moduleActions = allActions.filter((a) => a.nameSpace === moduleName && !a.deprecated);
+            const methods = {};
+            for (const a of moduleActions) {
+                const m = (a.method || "GET").toUpperCase();
+                methods[m] = (methods[m] || 0) + 1;
+            }
+            const description = {
+                module: moduleName,
+                apis: apis.map((a) => ({ label: a.label, host: a.host })),
+                services: svcs.map((s) => ({ label: s.label, host: s.host })),
+                endpoints: {
+                    total: moduleActions.length,
+                    byMethod: methods,
+                },
+                capabilities: [...new Set(moduleActions.map((a) => a.capability).filter(Boolean))].sort(),
+            };
+            const formattedRes = {
+                payload: description,
+                meta: { responseTime: 0 },
+            };
+            handleResponseFormatOptions(opts, formattedRes);
+            spinner.success({ text: `Module: ${moduleName} — ${moduleActions.length} endpoints` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to describe service" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}