@tolinax/ayoune-cli 2026.2.3 → 2026.3.0

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/createModulesCommand.js

@@ -7,10 +7,15 @@ import { handleCollectionOperation } from "../operations/handleCollectionOperati
 import { localStorage } from "../helpers/localStorage.js";
 import { parseInteger } from "../helpers/parseInt.js";
 import { handleGetOperation } from "../operations/handleGetOperation.js";
+import { handleCreateSingleOperation } from "../operations/handleCreateSingleOperation.js";
+import { handleDeleteSingleOperation } from "../operations/handleDeleteSingleOperation.js";
 import { aYOUneModules } from "../../data/modules.js";
 import { getModelsInModules } from "../models/getModelsInModules.js";
+import { apiCallHandler } from "../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../helpers/handleResponseFormatOptions.js";
 import { spinner } from "../../index.js";
 import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+const DIRECT_OPERATIONS = ["list", "get", "create", "delete"];
 function resolveModule(input) {
     const lower = input.toLowerCase();
     const match = aYOUneModules.find((m) => m.module === lower || m.label.toLowerCase() === lower);
@@ -24,25 +29,28 @@ function resolveCollection(module, input) {
 }
 export function createModulesCommand(program) {
     program
-        .command("modules [module] [collection]")
+        .command("modules [module] [collection] [operation] [subject]")
         .alias("m")
         .description("Browse modules, collections, and entries interactively")
         .addHelpText("after", `
 Examples:
-  ay modules              Start interactive module browser
-  ay m                    Same using alias
-  ay m crm                Jump straight to the CRM module
-  ay m crm consumers      Jump to CRM consumers collection`)
+  ay modules                            Start interactive module browser
+  ay m                                  Same using alias
+  ay m crm                              Jump straight to the CRM module
+  ay m crm consumers                    Jump to CRM consumers collection
+  ay m pm projects list                 List all projects
+  ay m pm projects create "Migration"   Create a new project
+  ay m pm projects get <id>             Get a project by ID
+  ay m pm projects delete <id>          Delete a project by ID`)
         .option("-p, --page <number>", "Page", parseInteger, 1)
         .option("-l, --limit <number>", "Limit", parseInteger, 20)
         .option("-f, --from <date>", "From date")
-        .action(async (moduleArg, collectionArg, options) => {
+        .option("-a, --all", "Fetch all pages (list only)")
+        .option("-q, --search <term>", "Search term")
+        .action(async (moduleArg, collectionArg, operationArg, subjectArg, options) => {
         try {
             const opts = { ...program.opts(), ...options };
-            if (!process.stdin.isTTY) {
-                spinner.error({ text: "The modules command requires an interactive terminal" });
-                process.exit(EXIT_MISUSE);
-            }
+            // ─── Resolve module ──────────────────────────────────
             let module;
             if (moduleArg) {
                 const resolved = resolveModule(moduleArg);
@@ -53,8 +61,13 @@ Examples:
                 module = resolved;
             }
             else {
+                if (!process.stdin.isTTY) {
+                    spinner.error({ text: "The modules command requires an interactive terminal" });
+                    process.exit(EXIT_MISUSE);
+                }
                 module = await promptModule();
             }
+            // ─── Resolve collection ──────────────────────────────
             let collection;
             if (collectionArg) {
                 const resolved = resolveCollection(module, collectionArg);
@@ -65,11 +78,59 @@ Examples:
                 collection = resolved;
             }
             else {
+                if (!process.stdin.isTTY) {
+                    spinner.error({ text: "Missing required argument: collection" });
+                    process.exit(EXIT_MISUSE);
+                }
                 collection = await promptCollectionInModule(module);
             }
-            const operation = await promptOperation();
             localStorage.setItem("lastModule", module);
             localStorage.setItem("lastCollection", collection);
+            // ─── Direct operation mode ───────────────────────────
+            if (operationArg && DIRECT_OPERATIONS.includes(operationArg.toLowerCase())) {
+                const op = operationArg.toLowerCase();
+                if (op === "list") {
+                    const { result } = await handleListOperation(module, collection, opts);
+                    return;
+                }
+                if (op === "get") {
+                    if (!subjectArg) {
+                        spinner.error({ text: "Missing required argument: id" });
+                        process.exit(EXIT_MISUSE);
+                    }
+                    spinner.start({ text: `Getting ${collection} ${subjectArg}...`, color: "magenta" });
+                    const res = await apiCallHandler(module, `${collection.toLowerCase()}/${subjectArg}`, "get", null, {
+                        responseFormat: opts.responseFormat,
+                        verbosity: opts.verbosity,
+                    });
+                    handleResponseFormatOptions(opts, res);
+                    spinner.success({ text: `Got ${collection} [${subjectArg}]` });
+                    spinner.stop();
+                    return;
+                }
+                if (op === "create") {
+                    if (!subjectArg) {
+                        spinner.error({ text: "Missing required argument: name/subject" });
+                        process.exit(EXIT_MISUSE);
+                    }
+                    await handleCreateSingleOperation(module, collection, subjectArg, opts);
+                    return;
+                }
+                if (op === "delete") {
+                    if (!subjectArg) {
+                        spinner.error({ text: "Missing required argument: id" });
+                        process.exit(EXIT_MISUSE);
+                    }
+                    await handleDeleteSingleOperation(module, collection, subjectArg, opts);
+                    return;
+                }
+            }
+            // ─── Interactive mode (no operation provided) ────────
+            if (!process.stdin.isTTY) {
+                spinner.error({ text: "Interactive mode requires a terminal. Use: ay m <module> <collection> <operation> [subject]" });
+                process.exit(EXIT_MISUSE);
+            }
+            const operation = await promptOperation();
             let entry = "";
             if (operation === "list") {
                 const { result } = await handleListOperation(module, collection, opts);

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);