@tolinax/ayoune-cli 2026.2.3 → 2026.2.4

package/lib/commands/createCompletionsCommand.js

@@ -3,7 +3,7 @@ _ay_completions() {
   local cur commands
   COMPREPLY=()
   cur="\${COMP_WORDS[COMP_CWORD]}"
-  commands="modules list get edit copy create describe audit stream events storage whoami login logout completions alias config actions exec ai services deploy monitor delete update batch search webhooks jobs"
+  commands="modules list get edit copy create describe audit stream events storage whoami login logout completions alias config actions exec ai services deploy monitor delete update batch search webhooks jobs export users sync permissions templates"
 
   if [[ \${COMP_CWORD} -eq 1 ]]; then
     COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
@@ -44,6 +44,11 @@ _ay() {
     'search:Search entries with advanced filtering'
     'webhooks:Manage webhooks and event subscriptions'
     'jobs:Manage background jobs and automations'
+    'export:Export data from collections'
+    'users:Manage users, teams, and roles'
+    'sync:Synchronize platform data across systems'
+    'permissions:Manage permissions and access requests'
+    'templates:Manage platform templates'
   )
   _describe 'command' commands
 }
@@ -79,6 +84,11 @@ complete -c ay -n '__fish_use_subcommand' -a batch -d 'Run bulk operations on mu
 complete -c ay -n '__fish_use_subcommand' -a search -d 'Search entries with advanced filtering'
 complete -c ay -n '__fish_use_subcommand' -a webhooks -d 'Manage webhooks and event subscriptions'
 complete -c ay -n '__fish_use_subcommand' -a jobs -d 'Manage background jobs and automations'
+complete -c ay -n '__fish_use_subcommand' -a export -d 'Export data from collections'
+complete -c ay -n '__fish_use_subcommand' -a users -d 'Manage users, teams, and roles'
+complete -c ay -n '__fish_use_subcommand' -a sync -d 'Synchronize platform data across systems'
+complete -c ay -n '__fish_use_subcommand' -a permissions -d 'Manage permissions and access requests'
+complete -c ay -n '__fish_use_subcommand' -a templates -d 'Manage platform templates'
 ###-end-ay-completions-###`;
 const POWERSHELL_COMPLETION = `###-begin-ay-completions-###
 Register-ArgumentCompleter -CommandName ay -ScriptBlock {
@@ -113,6 +123,11 @@ Register-ArgumentCompleter -CommandName ay -ScriptBlock {
     @{ Name = 'search'; Description = 'Search entries with advanced filtering' }
     @{ Name = 'webhooks'; Description = 'Manage webhooks and event subscriptions' }
     @{ Name = 'jobs'; Description = 'Manage background jobs and automations' }
+    @{ Name = 'export'; Description = 'Export data from collections' }
+    @{ Name = 'users'; Description = 'Manage users, teams, and roles' }
+    @{ Name = 'sync'; Description = 'Synchronize platform data across systems' }
+    @{ Name = 'permissions'; Description = 'Manage permissions and access requests' }
+    @{ Name = 'templates'; Description = 'Manage platform templates' }
   )
   $commands | Where-Object { $_.Name -like "$wordToComplete*" } | ForEach-Object {
     [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ParameterValue', $_.Description)

package/lib/commands/createExportCommand.js

@@ -0,0 +1,219 @@
+import { getModuleFromCollection } from "../models/getModuleFromCollection.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";
+export function createExportCommand(program) {
+    const exp = program
+        .command("export")
+        .alias("exp")
+        .description("Export data from collections in various formats");
+    // ay export run <collection>
+    exp
+        .command("run <collection>")
+        .description("Export entries from a collection")
+        .addHelpText("after", `
+Examples:
+  ay export run contacts --format csv --fields "firstName,lastName,email"
+  ay export run products --format json --filter "status=active"
+  ay export run invoices --format csv --filter "createdAt>2025-01-01" --save`)
+        .option("--format <format>", "Export format (json, csv, yaml)", "csv")
+        .option("--fields <fields>", "Comma-separated fields to include in export")
+        .option("--filter <filters>", "Comma-separated key=value filters")
+        .option("--sort <field>", "Sort by field (prefix with - for descending)", "-createdAt")
+        .option("-l, --limit <number>", "Limit results (0 = all)", parseInt, 0)
+        .option("-p, --page <number>", "Page number", parseInt, 1)
+        .action(async (collection, options) => {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            spinner.start({ text: `Exporting ${collection}...`, color: "magenta" });
+            const params = {
+                page: opts.page,
+                sort: opts.sort,
+                responseFormat: opts.format,
+                verbosity: opts.verbosity,
+            };
+            if (opts.limit > 0)
+                params.limit = opts.limit;
+            if (opts.fields)
+                params.fields = opts.fields;
+            // Parse filters
+            if (opts.filter) {
+                const filters = opts.filter.split(",");
+                for (const f of filters) {
+                    const match = f.match(/^(\w+)(!=|>=|<=|>|<|=)(.+)$/);
+                    if (match) {
+                        const [, key, op, value] = match;
+                        if (op === "=")
+                            params[key] = value;
+                        else if (op === "!=")
+                            params[`${key}[ne]`] = value;
+                        else if (op === ">")
+                            params[`${key}[gt]`] = value;
+                        else if (op === "<")
+                            params[`${key}[lt]`] = value;
+                        else if (op === ">=")
+                            params[`${key}[gte]`] = value;
+                        else if (op === "<=")
+                            params[`${key}[lte]`] = value;
+                    }
+                }
+            }
+            // If limit=0, fetch all pages
+            if (opts.limit === 0) {
+                params.limit = 500;
+                const allPayload = [];
+                let currentPage = 1;
+                let totalPages = 1;
+                do {
+                    params.page = currentPage;
+                    const res = await apiCallHandler(module.module, collection.toLowerCase(), "get", null, params);
+                    if (res === null || res === void 0 ? void 0 : res.payload) {
+                        if (Array.isArray(res.payload))
+                            allPayload.push(...res.payload);
+                        else
+                            allPayload.push(res.payload);
+                    }
+                    totalPages = (_c = (_b = (_a = res === null || res === void 0 ? void 0 : res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo) === null || _b === void 0 ? void 0 : _b.totalPages) !== null && _c !== void 0 ? _c : 1;
+                    spinner.update({ text: `Exporting ${collection}... page ${currentPage}/${totalPages}` });
+                    currentPage++;
+                } while (currentPage <= totalPages);
+                const fullRes = {
+                    payload: allPayload,
+                    meta: { pageInfo: { totalEntries: allPayload.length, page: 1, totalPages: 1 } },
+                };
+                // Force response format to match export format
+                opts.responseFormat = opts.format;
+                handleResponseFormatOptions(opts, fullRes);
+                spinner.success({ text: `Exported ${allPayload.length} entries from ${collection}` });
+                spinner.stop();
+                if (opts.save)
+                    await saveFile(`export-${collection}`, opts, fullRes);
+            }
+            else {
+                const res = await apiCallHandler(module.module, collection.toLowerCase(), "get", null, params);
+                opts.responseFormat = opts.format;
+                handleResponseFormatOptions(opts, res);
+                const total = (_f = (_e = (_d = res.meta) === null || _d === void 0 ? void 0 : _d.pageInfo) === null || _e === void 0 ? void 0 : _e.totalEntries) !== null && _f !== void 0 ? _f : 0;
+                spinner.success({ text: `Exported ${total} entries from ${collection}` });
+                spinner.stop();
+                if (opts.save)
+                    await saveFile(`export-${collection}`, opts, res);
+            }
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Export failed" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay export list
+    exp
+        .command("list")
+        .alias("ls")
+        .description("List previous exports")
+        .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 exports...", color: "magenta" });
+            const res = await apiCallHandler("export", "exports", "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} exports` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("exports-list", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list exports" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay export get <id>
+    exp
+        .command("get <id>")
+        .description("Get export details and download URL")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Fetching export ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("export", `exports/${id}`, "get", null, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Export ${id} loaded` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to get export" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay export configs
+    exp
+        .command("configs")
+        .description("List export configurations")
+        .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 export configs...", color: "magenta" });
+            const res = await apiCallHandler("export", "exportconfigs", "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} export configurations` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("export-configs", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list export configs" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay export logs
+    exp
+        .command("logs")
+        .description("List export logs")
+        .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 export logs...", color: "magenta" });
+            const res = await apiCallHandler("logs", "export", "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} export log entries` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("export-logs", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list export logs" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createPermissionsCommand.js

@@ -0,0 +1,241 @@
+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";
+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) {
+            spinner.error({ text: e.message || "Failed to list permission requests" });
+            process.exit(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) {
+            spinner.error({ text: e.message || "Failed to approve request" });
+            process.exit(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) {
+            spinner.error({ text: e.message || "Failed to reject request" });
+            process.exit(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) {
+                    spinner.error({ text: "Invalid JSON in --body" });
+                    process.exit(EXIT_MISUSE);
+                }
+            }
+            else if (opts.right) {
+                body = { right: opts.right };
+                if (opts.reason)
+                    body.reason = opts.reason;
+            }
+            if (!body) {
+                spinner.error({ text: "Provide request via --body or --right" });
+                process.exit(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) {
+            spinner.error({ text: e.message || "Failed to create permission request" });
+            process.exit(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) {
+            spinner.error({ text: e.message || "Failed to list user rights" });
+            process.exit(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) {
+            spinner.error({ text: e.message || "Failed to get user right" });
+            process.exit(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) {
+            spinner.error({ text: e.message || "Failed to fetch audit logs" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createProgram.js

@@ -36,6 +36,11 @@ import { createBatchCommand } from "./createBatchCommand.js";
 import { createSearchCommand } from "./createSearchCommand.js";
 import { createWebhooksCommand } from "./createWebhooksCommand.js";
 import { createJobsCommand } from "./createJobsCommand.js";
+import { createExportCommand } from "./createExportCommand.js";
+import { createUsersCommand } from "./createUsersCommand.js";
+import { createSyncCommand } from "./createSyncCommand.js";
+import { createPermissionsCommand } from "./createPermissionsCommand.js";
+import { createTemplateCommand } from "./createTemplateCommand.js";
 import { localStorage } from "../helpers/localStorage.js";
 import { login } from "../api/login.js";
 import { loadConfig } from "../helpers/configLoader.js";
@@ -91,6 +96,11 @@ export function createProgram(program) {
     createSearchCommand(program);
     createWebhooksCommand(program);
     createJobsCommand(program);
+    createExportCommand(program);
+    createUsersCommand(program);
+    createSyncCommand(program);
+    createPermissionsCommand(program);
+    createTemplateCommand(program);
     createCompletionsCommand(program);
     createAliasCommand(program);
     createConfigCommand(program);

package/lib/commands/createSyncCommand.js

@@ -0,0 +1,177 @@
+import { apiCallHandler } from "../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../helpers/handleResponseFormatOptions.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
+export function createSyncCommand(program) {
+    const sync = program
+        .command("sync")
+        .description("Synchronize platform data across systems");
+    // ay sync repos
+    sync
+        .command("repos")
+        .description("Sync repositories from connected providers")
+        .addHelpText("after", `
+Examples:
+  ay sync repos                      Sync all repositories
+  ay sync repos --provider bitbucket  Sync only Bitbucket repos
+  ay sync repos --id <repoId>        Sync a specific repository`)
+        .option("--provider <provider>", "Filter by provider (bitbucket, github)")
+        .option("--id <repoId>", "Sync a specific repository by ID")
+        .action(async (options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (opts.id) {
+                spinner.start({ text: `Syncing repository ${opts.id}...`, color: "magenta" });
+                const res = await apiCallHandler("devops", `repositories/${opts.id}/sync`, "post", null, { responseFormat: opts.responseFormat });
+                handleResponseFormatOptions(opts, res);
+                spinner.success({ text: `Repository ${opts.id} sync initiated` });
+                spinner.stop();
+            }
+            else {
+                spinner.start({ text: "Syncing repositories...", color: "magenta" });
+                const params = {
+                    responseFormat: opts.responseFormat,
+                    verbosity: opts.verbosity,
+                };
+                if (opts.provider)
+                    params.provider = opts.provider;
+                // List repos first, then trigger sync
+                const listRes = await apiCallHandler("devops", "repositories", "get", null, {
+                    ...params,
+                    limit: 200,
+                });
+                const repos = Array.isArray(listRes === null || listRes === void 0 ? void 0 : listRes.payload) ? listRes.payload : [];
+                let syncCount = 0;
+                let errorCount = 0;
+                for (const repo of repos) {
+                    if (opts.provider && repo.provider !== opts.provider)
+                        continue;
+                    try {
+                        await apiCallHandler("devops", `repositories/${repo._id}/sync`, "post", null, { responseFormat: "json" });
+                        syncCount++;
+                        spinner.update({ text: `Syncing repositories... ${syncCount}/${repos.length}` });
+                    }
+                    catch (_a) {
+                        errorCount++;
+                    }
+                }
+                spinner.success({ text: `Synced ${syncCount}/${repos.length} repositories` });
+                spinner.stop();
+                if (errorCount > 0) {
+                    console.error(`  ${errorCount} repositories failed to sync`);
+                }
+            }
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Repository sync failed" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay sync clusters
+    sync
+        .command("clusters")
+        .description("Sync Kubernetes cluster state")
+        .option("--id <clusterId>", "Sync a specific cluster by ID")
+        .action(async (options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (opts.id) {
+                spinner.start({ text: `Syncing cluster ${opts.id}...`, color: "magenta" });
+                const res = await apiCallHandler("devops", `clusters/${opts.id}/sync`, "post", null, { responseFormat: opts.responseFormat });
+                handleResponseFormatOptions(opts, res);
+                spinner.success({ text: `Cluster ${opts.id} sync initiated` });
+                spinner.stop();
+            }
+            else {
+                spinner.start({ text: "Syncing all clusters...", color: "magenta" });
+                const listRes = await apiCallHandler("devops", "clusters", "get", null, {
+                    limit: 100,
+                    responseFormat: "json",
+                });
+                const clusters = Array.isArray(listRes === null || listRes === void 0 ? void 0 : listRes.payload) ? listRes.payload : [];
+                let syncCount = 0;
+                for (const cluster of clusters) {
+                    try {
+                        await apiCallHandler("devops", `clusters/${cluster._id}/sync`, "post", null, { responseFormat: "json" });
+                        syncCount++;
+                    }
+                    catch (_a) {
+                        // ignore individual failures
+                    }
+                }
+                spinner.success({ text: `Synced ${syncCount}/${clusters.length} clusters` });
+                spinner.stop();
+            }
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Cluster sync failed" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay sync pipelines
+    sync
+        .command("pipelines")
+        .description("Sync pipeline status from CI/CD providers")
+        .option("--provider <provider>", "Filter by provider (bitbucket, github)")
+        .option("-l, --limit <number>", "Limit results", parseInt, 50)
+        .action(async (options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Syncing pipeline status...", color: "magenta" });
+            const params = {
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.provider)
+                params.provider = opts.provider;
+            const res = await apiCallHandler("devops", "pipelines/sync", "post", null, params);
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: "Pipeline sync initiated" });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Pipeline sync failed" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay sync status
+    sync
+        .command("status")
+        .description("Show sync status across all systems")
+        .action(async (options) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching sync status...", color: "magenta" });
+            // Gather status from multiple endpoints
+            const [reposRes, clustersRes, pipelinesRes] = await Promise.allSettled([
+                apiCallHandler("devops", "repositories", "get", null, { limit: 1, responseFormat: "json" }),
+                apiCallHandler("devops", "clusters", "get", null, { limit: 1, responseFormat: "json" }),
+                apiCallHandler("devops", "pipelines", "get", null, { limit: 1, responseFormat: "json" }),
+            ]);
+            const status = {
+                repositories: {
+                    total: reposRes.status === "fulfilled" ? (_d = (_c = (_b = (_a = reposRes.value) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.pageInfo) === null || _c === void 0 ? void 0 : _c.totalEntries) !== null && _d !== void 0 ? _d : 0 : "error",
+                },
+                clusters: {
+                    total: clustersRes.status === "fulfilled" ? (_h = (_g = (_f = (_e = clustersRes.value) === null || _e === void 0 ? void 0 : _e.meta) === null || _f === void 0 ? void 0 : _f.pageInfo) === null || _g === void 0 ? void 0 : _g.totalEntries) !== null && _h !== void 0 ? _h : 0 : "error",
+                },
+                pipelines: {
+                    total: pipelinesRes.status === "fulfilled" ? (_m = (_l = (_k = (_j = pipelinesRes.value) === null || _j === void 0 ? void 0 : _j.meta) === null || _k === void 0 ? void 0 : _k.pageInfo) === null || _l === void 0 ? void 0 : _l.totalEntries) !== null && _m !== void 0 ? _m : 0 : "error",
+                },
+            };
+            const res = {
+                payload: status,
+                meta: { pageInfo: { totalEntries: 1, page: 1, totalPages: 1 } },
+            };
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: "Sync status retrieved" });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to get sync status" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createTemplateCommand.js

@@ -0,0 +1,238 @@
+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 createTemplateCommand(program) {
+    const tmpl = program
+        .command("templates")
+        .alias("tmpl")
+        .description("Manage platform templates (email, notification, report, store)");
+    // ── EMAIL TEMPLATES ────────────────────────────────────
+    const email = tmpl
+        .command("email")
+        .description("Manage email templates");
+    // ay templates email list
+    email
+        .command("list")
+        .alias("ls")
+        .description("List email templates")
+        .option("--search <query>", "Search by name")
+        .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 email templates...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.search)
+                params.q = opts.search;
+            const res = await apiCallHandler("marketing", "emailtemplates", "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} email templates` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("email-templates", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list email templates" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay templates email get <id>
+    email
+        .command("get <id>")
+        .description("Get email template details")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Fetching email template ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("marketing", `emailtemplates/${id}`, "get", null, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Email template ${id} loaded` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to get email template" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ── NOTIFICATION TEMPLATES ─────────────────────────────
+    const notify = tmpl
+        .command("notification")
+        .alias("notify")
+        .description("Manage notification templates");
+    // ay templates notification list
+    notify
+        .command("list")
+        .alias("ls")
+        .description("List notification templates")
+        .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 notification templates...", color: "magenta" });
+            const res = await apiCallHandler("config", "notificationtemplates", "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} notification templates` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("notification-templates", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list notification templates" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay templates notification get <id>
+    notify
+        .command("get <id>")
+        .description("Get notification template details")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Fetching notification template ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("config", `notificationtemplates/${id}`, "get", null, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Notification template ${id} loaded` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to get notification template" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ── REPORT TEMPLATES ───────────────────────────────────
+    const report = tmpl
+        .command("report")
+        .description("Manage report templates");
+    // ay templates report list
+    report
+        .command("list")
+        .alias("ls")
+        .description("List report templates")
+        .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 report templates...", color: "magenta" });
+            const res = await apiCallHandler("reporting", "reporttemplates", "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} report templates` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("report-templates", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list report templates" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ── STORE TEMPLATES ────────────────────────────────────
+    const store = tmpl
+        .command("store")
+        .description("Browse template store / marketplace");
+    // ay templates store list
+    store
+        .command("list")
+        .alias("ls")
+        .description("List available store templates")
+        .option("--category <category>", "Filter by category")
+        .option("--search <query>", "Search templates")
+        .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 store templates...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.category)
+                params.category = opts.category;
+            if (opts.search)
+                params.q = opts.search;
+            const res = await apiCallHandler("config", "templategroups", "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} store templates` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("store-templates", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list store templates" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay templates store get <id>
+    store
+        .command("get <id>")
+        .description("Get store template details")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Fetching store template ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("config", `templategroups/${id}`, "get", null, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Store template ${id} loaded` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to get store template" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay templates store install <id>
+    store
+        .command("install <id>")
+        .description("Install a template from the store")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Installing template ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("config", `templategroups/${id}/install`, "post", null, { responseFormat: opts.responseFormat });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Template ${id} installed` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to install template" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createUsersCommand.js

@@ -0,0 +1,285 @@
+import chalk from "chalk";
+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";
+export function createUsersCommand(program) {
+    const users = program
+        .command("users")
+        .description("Manage users, teams, and roles");
+    // ── USERS ──────────────────────────────────────────────
+    // ay users list
+    users
+        .command("list")
+        .alias("ls")
+        .description("List users")
+        .option("--search <query>", "Search by name or email")
+        .option("--role <roleId>", "Filter by role ID")
+        .option("--active", "Show only active users")
+        .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 users...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.search)
+                params.q = opts.search;
+            if (opts.role)
+                params.role = opts.role;
+            if (opts.active)
+                params.active = "true";
+            const res = await apiCallHandler("config", "users", "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} users` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("users-list", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list users" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay users get <id>
+    users
+        .command("get <id>")
+        .description("Get user details")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Fetching user ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("config", `users/${id}`, "get", null, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `User ${id} loaded` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to get user" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay users invite --email <email> --role <roleId>
+    users
+        .command("invite")
+        .description("Invite a new user")
+        .requiredOption("--email <email>", "Email address of the user to invite")
+        .option("--role <roleId>", "Role ID to assign")
+        .option("--firstName <name>", "First name")
+        .option("--lastName <name>", "Last name")
+        .action(async (options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Inviting ${opts.email}...`, color: "magenta" });
+            const body = { email: opts.email };
+            if (opts.role)
+                body.role = opts.role;
+            if (opts.firstName)
+                body.firstName = opts.firstName;
+            if (opts.lastName)
+                body.lastName = opts.lastName;
+            const res = await apiCallHandler("config", "users", "post", body, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Invitation sent to ${opts.email}` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to invite user" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay users deactivate <id>
+    users
+        .command("deactivate <id>")
+        .description("Deactivate a user account")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (!opts.force && process.stdin.isTTY) {
+                const inquirer = (await import("inquirer")).default;
+                const { confirmed } = await inquirer.prompt([
+                    { type: "confirm", name: "confirmed", message: `Deactivate user ${id}?`, default: false },
+                ]);
+                if (!confirmed) {
+                    console.error(chalk.yellow("  Aborted."));
+                    return;
+                }
+            }
+            spinner.start({ text: `Deactivating user ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("config", "users", "put", { _id: id, active: false }, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `User ${id} deactivated` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to deactivate user" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ── TEAMS ──────────────────────────────────────────────
+    const teams = users
+        .command("teams")
+        .description("Manage teams");
+    // ay users teams list
+    teams
+        .command("list")
+        .alias("ls")
+        .description("List teams")
+        .option("--search <query>", "Search teams by name")
+        .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 teams...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.search)
+                params.q = opts.search;
+            const res = await apiCallHandler("config", "teams", "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} teams` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("teams-list", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list teams" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay users teams get <id>
+    teams
+        .command("get <id>")
+        .description("Get team details with members")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Fetching team ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("config", `teams/${id}`, "get", null, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Team ${id} loaded` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to get team" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay users teams create --body '{...}'
+    teams
+        .command("create")
+        .description("Create a new team")
+        .option("--name <name>", "Team name")
+        .option("--body <json>", "Full team definition as JSON")
+        .action(async (options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            let body = null;
+            if (opts.body) {
+                try {
+                    body = JSON.parse(opts.body);
+                }
+                catch (_a) {
+                    spinner.error({ text: "Invalid JSON in --body" });
+                    process.exit(EXIT_MISUSE);
+                }
+            }
+            else if (opts.name) {
+                body = { name: opts.name };
+            }
+            if (!body) {
+                spinner.error({ text: "Provide team definition via --name or --body" });
+                process.exit(EXIT_MISUSE);
+            }
+            spinner.start({ text: "Creating team...", color: "magenta" });
+            const res = await apiCallHandler("config", "teams", "post", body, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: "Team created" });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to create team" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ── ROLES ──────────────────────────────────────────────
+    const roles = users
+        .command("roles")
+        .description("Manage roles");
+    // ay users roles list
+    roles
+        .command("list")
+        .alias("ls")
+        .description("List available roles")
+        .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 roles...", color: "magenta" });
+            const res = await apiCallHandler("config", "roles", "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} roles` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("roles-list", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list roles" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay users roles get <id>
+    roles
+        .command("get <id>")
+        .description("Get role details with permissions")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Fetching role ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("config", `roles/${id}`, "get", null, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Role ${id} loaded` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to get role" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tolinax/ayoune-cli",
-  "version": "2026.2.3",
+  "version": "2026.2.4",
   "description": "",
   "type": "module",
   "main": "./index.js",