@tolinax/ayoune-cli 2026.3.1 → 2026.5.0

package/lib/commands/createMonitorCommand.js

@@ -0,0 +1,276 @@
+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 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) {
+            cliError(e.message || "Failed to fetch logs", 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) {
+            cliError(e.message || "Failed to fetch alerts", 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) {
+            cliError(e.message || "Failed to acknowledge alert", 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) {
+            cliError(e.message || "Failed to resolve alert", 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) {
+            cliError(e.message || "Failed to fetch sessions", 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) {
+            cliError(e.message || "Failed to fetch checks", 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) {
+            cliError(e.message || "Failed to fetch active users", 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) {
+            cliError(e.message || "Failed to fetch page stats", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createPermissionsCommand.js

@@ -0,0 +1,233 @@
+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, EXIT_MISUSE } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+export function createPermissionsCommand(program) {
+    const perms = program
+        .command("permissions")
+        .alias("perms")
+        .description("Manage permissions, access requests, and user rights");
+    // ── PERMISSION REQUESTS ────────────────────────────────
+    const requests = perms
+        .command("requests")
+        .alias("req")
+        .description("Manage permission requests");
+    // ay permissions requests list
+    requests
+        .command("list")
+        .alias("ls")
+        .description("List permission requests")
+        .option("--status <status>", "Filter by status (pending, approved, rejected)")
+        .option("-l, --limit <number>", "Limit results", parseInt, 25)
+        .option("-p, --page <number>", "Page number", parseInt, 1)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching permission requests...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.status)
+                params.status = opts.status;
+            const res = await apiCallHandler("config", "permissionrequests", "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} permission requests` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("permission-requests", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list permission requests", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay permissions requests approve <id>
+    requests
+        .command("approve <id>")
+        .description("Approve a permission request")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Approving request ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("config", "permissionrequests", "put", { _id: id, status: "approved" }, { responseFormat: opts.responseFormat });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Permission request ${id} approved` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to approve request", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay permissions requests reject <id>
+    requests
+        .command("reject <id>")
+        .description("Reject a permission request")
+        .option("--reason <reason>", "Reason for rejection")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Rejecting request ${id}...`, color: "magenta" });
+            const body = { _id: id, status: "rejected" };
+            if (opts.reason)
+                body.reason = opts.reason;
+            const res = await apiCallHandler("config", "permissionrequests", "put", body, { responseFormat: opts.responseFormat });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Permission request ${id} rejected` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to reject request", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay permissions requests create
+    requests
+        .command("create")
+        .description("Create a new permission request")
+        .option("--body <json>", "Request definition as JSON")
+        .option("--right <right>", "Right to request (e.g. crm.contacts.edit)")
+        .option("--reason <reason>", "Reason for the request")
+        .action(async (options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            let body = null;
+            if (opts.body) {
+                try {
+                    body = JSON.parse(opts.body);
+                }
+                catch (_a) {
+                    cliError("Invalid JSON in --body", EXIT_MISUSE);
+                }
+            }
+            else if (opts.right) {
+                body = { right: opts.right };
+                if (opts.reason)
+                    body.reason = opts.reason;
+            }
+            if (!body) {
+                cliError("Provide request via --body or --right", EXIT_MISUSE);
+            }
+            spinner.start({ text: "Creating permission request...", color: "magenta" });
+            const res = await apiCallHandler("config", "permissionrequests", "post", body, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: "Permission request created" });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to create permission request", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ── USER RIGHTS ────────────────────────────────────────
+    const rights = perms
+        .command("rights")
+        .description("View and manage user rights");
+    // ay permissions rights list
+    rights
+        .command("list")
+        .alias("ls")
+        .description("List user rights / permission assignments")
+        .option("--userId <id>", "Filter by user ID")
+        .option("-l, --limit <number>", "Limit results", parseInt, 50)
+        .option("-p, --page <number>", "Page number", parseInt, 1)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching user rights...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.userId)
+                params.userId = opts.userId;
+            const res = await apiCallHandler("config", "userrights", "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} user right assignments` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("user-rights", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list user rights", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay permissions rights get <id>
+    rights
+        .command("get <id>")
+        .description("Get user right details")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Fetching right ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("config", `userrights/${id}`, "get", null, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Right ${id} loaded` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to get user right", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ── AUDIT (ENHANCED) ──────────────────────────────────
+    perms
+        .command("audit")
+        .description("Audit permission changes and access logs")
+        .addHelpText("after", `
+Examples:
+  ay permissions audit --action delete --days 30
+  ay permissions audit --userId abc123 --collection contacts
+  ay permissions audit --action create --days 7 --save`)
+        .option("--userId <id>", "Filter by user ID")
+        .option("--action <action>", "Filter by action (create, update, delete, login)")
+        .option("--collection <name>", "Filter by collection")
+        .option("--days <number>", "Show entries from last N days", parseInt, 7)
+        .option("-l, --limit <number>", "Limit results", parseInt, 50)
+        .option("-p, --page <number>", "Page number", parseInt, 1)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching audit logs...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.userId)
+                params.userId = opts.userId;
+            if (opts.action)
+                params.action = opts.action;
+            if (opts.collection)
+                params.collection = opts.collection;
+            if (opts.days) {
+                const fromDate = new Date();
+                fromDate.setDate(fromDate.getDate() - opts.days);
+                params.from = fromDate.toISOString();
+            }
+            const res = await apiCallHandler("general", "auditlogs", "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} audit entries (last ${opts.days} days)` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("permissions-audit", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to fetch audit logs", EXIT_GENERAL_ERROR);
+        }
+    });
+}