@tolinax/ayoune-cli 2026.3.1 → 2026.4.0

package/lib/commands/createDescribeCommand.js

@@ -0,0 +1,44 @@
+import { Argument } from "commander";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { handleDescribeSingleOperation } from "../operations/handleDescribeSingleOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+export function createDescribeCommand(program) {
+    program
+        .command("describe")
+        .alias("d")
+        .description("Show detailed YAML description of an entry")
+        .addHelpText("after", `
+Examples:
+  ay describe contacts 64a1b2c3d4e5              Describe a contact entry
+  ay describe tasks 64a1b2c3d4e5 comments        Extract sub-resource array
+  ay describe tasks 64a1b2c3d4e5 comments -r json Sub-resource as JSON
+  ay describe tasks 64a1b2c3d4e5 --jq "subject"  JMESPath on describe
+  ay d                                            Describe last used entry`)
+        .addArgument(new Argument("[collection]", "The collection to use").default(localStorage.getItem("lastCollection"), `The last used collection (${localStorage.getItem("lastCollection")})`))
+        .addArgument(new Argument("[id]", "The ID of the entry to describe").default(localStorage.getItem("lastId"), `The last used id (${localStorage.getItem("lastId")})`))
+        .addArgument(new Argument("[subResource]", "Extract a sub-resource array (e.g., comments, attachments, worklogs)"))
+        .action(async (collection, id, subResource, options) => {
+        try {
+            if (!collection) {
+                cliError("Missing required argument: collection. Run a list or get command first, or provide it explicitly.", EXIT_MISUSE);
+            }
+            if (!id) {
+                cliError("Missing required argument: id. Provide an entry ID explicitly.", EXIT_MISUSE);
+            }
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+            localStorage.setItem("lastId", id);
+            await handleDescribeSingleOperation(module.module, collection, id, {
+                ...opts,
+                subResource,
+            });
+        }
+        catch (e) {
+            cliError(e.message || "An unexpected error occurred", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createEditCommand.js

@@ -0,0 +1,48 @@
+import { Argument } from "commander";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { handleGetSingleOperation } from "../operations/handleGetSingleOperation.js";
+import { handleEditOperation } from "../operations/handleEditOperation.js";
+import { handleEditRawOperation } from "../operations/handleEditRawOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+export function createEditCommand(program) {
+    program
+        .command("edit")
+        .alias("e")
+        .description("Edit an entry by ID in a collection")
+        .addHelpText("after", `
+Examples:
+  ay edit contacts 64a1b2c3d4e5     Edit contact by ID
+  ay edit                            Edit last used entry`)
+        .addArgument(new Argument("[collection]", "The collection to use").default(localStorage.getItem("lastCollection"), `The last used collection (${localStorage.getItem("lastCollection")})`))
+        .addArgument(new Argument("[id]", "The ID of the entry to edit").default(localStorage.getItem("lastId"), `The last used id (${localStorage.getItem("lastId")})`))
+        .action(async (collection, id, options) => {
+        try {
+            if (!collection) {
+                cliError("Missing required argument: collection. Run a list or get command first, or provide it explicitly.", EXIT_MISUSE);
+            }
+            if (!id) {
+                cliError("Missing required argument: id. Provide an entry ID explicitly.", EXIT_MISUSE);
+            }
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+            localStorage.setItem("lastId", id);
+            let result = {};
+            result = await handleGetSingleOperation(module.module, collection, id, opts);
+            // handleEditOperation expects {columns, rows} table structure;
+            // fall back to raw JSON editor if content doesn't have columns
+            if (result.content && result.content.columns) {
+                await handleEditOperation(module.module, collection, result.content);
+            }
+            else {
+                await handleEditRawOperation(module.module, collection, result.result || result.data);
+            }
+        }
+        catch (e) {
+            cliError(e.message || "An unexpected error occurred", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createEventsCommand.js

@@ -0,0 +1,60 @@
+import { Option } from "commander";
+import { secureStorage } from "../helpers/secureStorage.js";
+import { decodeToken } from "../api/decodeToken.js";
+import { customerSocket } from "../socket/customerSocketClient.js";
+import { spinner } from "../../index.js";
+import yaml from "js-yaml";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+export function createEventsCommand(program) {
+    program
+        .command("events")
+        .alias("sub")
+        .description("Subscribe to filtered events via WebSocket")
+        .addHelpText("after", `
+Examples:
+  ay events                                Listen to all events
+  ay events -c sales -a create             Filter by category and action
+  ay sub -f yaml -c crm                    Subscribe to CRM events as YAML`)
+        .addOption(new Option("-f, --format <format>", "Set the output format")
+        .choices(["json", "yaml", "table"])
+        .default("json"))
+        .addOption(new Option("-c, --category <category>", "Set the category to listen").default("*"))
+        .addOption(new Option("-a, --action <action>", "Set the action to listen").default("*"))
+        .addOption(new Option("-l, --label <label>", "Set the label to listen").default("*"))
+        .addOption(new Option("-V, --value <value>", "Set the value to listen").default("*"))
+        .action(async (options) => {
+        try {
+            const tokenPayload = decodeToken(secureStorage.getItem("token"));
+            const user = tokenPayload.payload;
+            spinner.start({ text: `Starting stream with [${user._customerID}]` });
+            const socket = customerSocket(user);
+            spinner.update({ text: "Stream active" });
+            socket.on("event", (data) => {
+                if (options.category !== "*" && options.category !== data.category)
+                    return;
+                if (options.action !== "*" && options.action !== data.action)
+                    return;
+                if (options.label !== "*" && options.label !== data.label)
+                    return;
+                if (options.value !== "*" && options.value !== data.value)
+                    return;
+                spinner.update({
+                    text: `Received [${data.category}.${data.action}.${data.label}.${data.value}]`,
+                });
+                if (options.format === "table") {
+                    console.table(data.evt_data);
+                }
+                if (options.format === "yaml") {
+                    console.log(yaml.dump(data.evt_data));
+                }
+                if (options.format === "json") {
+                    console.log(JSON.stringify(data.evt_data, null, 2));
+                }
+            });
+        }
+        catch (e) {
+            cliError(e.message || "An unexpected error occurred", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createExecCommand.js

@@ -0,0 +1,212 @@
+import chalk from "chalk";
+import { api, getModuleBaseUrl } from "../api/apiClient.js";
+import { handleResponseFormatOptions } from "../helpers/handleResponseFormatOptions.js";
+import { saveFile } from "../helpers/saveFile.js";
+import { secureStorage } from "../helpers/secureStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE, EXIT_PERMISSION_DENIED } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+async function resolveAction(searchTerm) {
+    var _a, _b;
+    // Try su module first (full access), fall back to config module (limited access)
+    const modules = ["su", "config"];
+    let permissionDenied = false;
+    for (const mod of modules) {
+        try {
+            const token = secureStorage.getItem("token") || "";
+            const response = await api({
+                baseURL: getModuleBaseUrl(mod),
+                method: "get",
+                url: "ayouneapiactions",
+                params: { q: searchTerm, limit: 50, responseFormat: "json" },
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            const res = response.data;
+            if (!(res === null || res === void 0 ? void 0 : res.payload) || !Array.isArray(res.payload) || res.payload.length === 0) {
+                continue;
+            }
+            const actions = res.payload.filter((a) => !a.deprecated);
+            // Exact operationId match
+            const exact = actions.find((a) => a.operationId === searchTerm);
+            if (exact)
+                return mapAction(exact);
+            // Partial operationId match
+            const partial = actions.find((a) => { var _a; return (_a = a.operationId) === null || _a === void 0 ? void 0 : _a.includes(searchTerm); });
+            if (partial)
+                return mapAction(partial);
+            // If multiple results, return first match
+            if (actions.length > 0)
+                return mapAction(actions[0]);
+        }
+        catch (e) {
+            // On 401/403 permission denied, try next module
+            if (((_a = e.response) === null || _a === void 0 ? void 0 : _a.status) === 403 || ((_b = e.response) === null || _b === void 0 ? void 0 : _b.status) === 401) {
+                permissionDenied = true;
+                continue;
+            }
+            // For other errors (network, 500, etc.), only throw on last module
+            if (mod === modules[modules.length - 1])
+                throw e;
+        }
+    }
+    // Distinguish between "not found" and "permission denied on all modules"
+    if (permissionDenied) {
+        throw new PermissionError("Permission denied: you do not have access to query API actions. Contact your administrator for the required rights.");
+    }
+    return null;
+}
+class PermissionError extends Error {
+    constructor(message) {
+        super(message);
+        this.isPermissionError = true;
+        this.name = "PermissionError";
+    }
+}
+function mapAction(a) {
+    return {
+        host: a.host || "",
+        endpoint: a.endpoint || "",
+        method: (a.method || "GET").toUpperCase(),
+        operationId: a.operationId || "",
+        nameSpace: a.nameSpace || "",
+        capability: a.capability || "",
+        params: a.params || [],
+        query: a.query || [],
+        description: a.shortDescription || a.description || "",
+    };
+}
+function buildUrl(endpoint, paramValues) {
+    let url = endpoint;
+    for (const [key, value] of Object.entries(paramValues)) {
+        url = url.replace(`:${key}`, encodeURIComponent(value));
+    }
+    return url;
+}
+export function createExecCommand(program) {
+    program
+        .command("exec <operationId>")
+        .alias("x")
+        .description("Execute any registered API action by operationId")
+        .addHelpText("after", `
+Examples:
+  ay exec ayoune.ai.conversations.create.one --body '{"prompt":"Hello"}'
+  ay exec ayoune.crm.contacts.list
+  ay exec ayoune.pm.projects.create.one --body '{"subject":"Migration"}'
+  ay exec ayoune.ai.prompts.list -r table
+  ay exec ayoune.sale.orders.get.one --param id=507f1f77bcf86cd799439011`)
+        .option("--body <json>", "Request body as JSON string")
+        .option("--body-file <path>", "Read request body from file")
+        .option("--body-stdin", "Read request body from stdin (for piping)")
+        .option("--param <kv...>", "Path parameters as key=value pairs")
+        .option("--query <kv...>", "Query parameters as key=value pairs")
+        .action(async (operationId, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Resolving action: ${operationId}`, color: "magenta" });
+            const action = await resolveAction(operationId);
+            if (!action) {
+                cliError(`No API action found for: ${operationId}`, EXIT_MISUSE);
+            }
+            spinner.update({ text: `Executing: ${action.method} https://${action.host}${action.endpoint}` });
+            // Parse path params
+            const paramValues = {};
+            if (opts.param) {
+                for (const p of opts.param) {
+                    const [key, ...rest] = p.split("=");
+                    paramValues[key] = rest.join("=");
+                }
+            }
+            // Parse query params
+            const queryParams = {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.hideMeta)
+                queryParams.hideMeta = "true";
+            if (opts.query) {
+                for (const q of opts.query) {
+                    const [key, ...rest] = q.split("=");
+                    queryParams[key] = rest.join("=");
+                }
+            }
+            // Parse body
+            let body = null;
+            if (opts.body) {
+                try {
+                    body = JSON.parse(opts.body);
+                }
+                catch (_a) {
+                    cliError("Invalid JSON in --body", EXIT_MISUSE);
+                }
+            }
+            if (opts.bodyFile) {
+                const fs = await import("fs");
+                const content = fs.readFileSync(opts.bodyFile, "utf-8");
+                try {
+                    body = JSON.parse(content);
+                }
+                catch (_b) {
+                    cliError(`Invalid JSON in file: ${opts.bodyFile}`, EXIT_MISUSE);
+                }
+            }
+            if (opts.bodyStdin && !process.stdin.isTTY) {
+                const chunks = [];
+                for await (const chunk of process.stdin) {
+                    chunks.push(chunk);
+                }
+                const stdinContent = Buffer.concat(chunks).toString("utf-8").trim();
+                if (stdinContent) {
+                    try {
+                        body = JSON.parse(stdinContent);
+                    }
+                    catch (_c) {
+                        cliError("Invalid JSON from stdin", EXIT_MISUSE);
+                    }
+                }
+            }
+            // Build final URL
+            const url = buildUrl(action.endpoint, paramValues);
+            const fullUrl = `https://${action.host}${url}`;
+            // Dry-run support
+            if (opts.dryRun && action.method !== "GET") {
+                spinner.stop();
+                console.error(chalk.yellow.bold("\n  [DRY RUN] Request not sent:\n"));
+                console.error(`  ${chalk.dim("Operation:")} ${chalk.cyan(action.operationId)}`);
+                console.error(`  ${chalk.dim("Method:")}    ${chalk.cyan(action.method)}`);
+                console.error(`  ${chalk.dim("URL:")}       ${chalk.cyan(fullUrl)}`);
+                if (body) {
+                    console.error(`  ${chalk.dim("Body:")}      ${JSON.stringify(body, null, 2).split("\n").join("\n            ")}`);
+                }
+                console.error();
+                return;
+            }
+            // Execute the request directly against the service host
+            const response = await api({
+                baseURL: `https://${action.host}`,
+                method: action.method.toLowerCase(),
+                url,
+                data: body,
+                params: queryParams,
+                headers: {
+                    Authorization: `Bearer ${secureStorage.getItem("token")}`,
+                },
+            });
+            const res = response.data;
+            const { plainResult, result, content } = handleResponseFormatOptions(opts, res);
+            const payloadCount = Array.isArray(res === null || res === void 0 ? void 0 : res.payload) ? res.payload.length : 1;
+            spinner.success({
+                text: `${action.method} ${action.operationId} — ${payloadCount} result(s)`,
+            });
+            spinner.stop();
+            if (opts.save) {
+                await saveFile("exec", opts, res);
+            }
+        }
+        catch (e) {
+            if (e instanceof PermissionError) {
+                cliError(e.message, EXIT_PERMISSION_DENIED);
+            }
+            cliError(e.message || "Failed to execute API action", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createExportCommand.js

@@ -0,0 +1,216 @@
+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";
+import { cliError } from "../helpers/cliError.js";
+import { sanitizeFields } from "../helpers/sanitizeFields.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;
+        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 = sanitizeFields(opts.fields).join(",");
+            // 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;
+                const { result: expResult, meta: expMeta } = handleResponseFormatOptions(opts, res);
+                const total = (_e = (_d = expMeta === null || expMeta === void 0 ? void 0 : expMeta.pageInfo) === null || _d === void 0 ? void 0 : _d.totalEntries) !== null && _e !== void 0 ? _e : (Array.isArray(expResult) ? expResult.length : 0);
+                spinner.success({ text: `Exported ${total} entries from ${collection}` });
+                spinner.stop();
+                if (opts.save)
+                    await saveFile(`export-${collection}`, opts, res);
+            }
+        }
+        catch (e) {
+            cliError(e.message || "Export failed", 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;
+        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,
+            });
+            const { result: listResult, meta: listMeta } = handleResponseFormatOptions(opts, res);
+            const total = (_b = (_a = listMeta === null || listMeta === void 0 ? void 0 : listMeta.pageInfo) === null || _a === void 0 ? void 0 : _a.totalEntries) !== null && _b !== void 0 ? _b : (Array.isArray(listResult) ? listResult.length : 0);
+            spinner.success({ text: `Found ${total} exports` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("exports-list", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list exports", 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) {
+            cliError(e.message || "Failed to get export", 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;
+        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,
+            });
+            const { result: cfgResult, meta: cfgMeta } = handleResponseFormatOptions(opts, res);
+            const total = (_b = (_a = cfgMeta === null || cfgMeta === void 0 ? void 0 : cfgMeta.pageInfo) === null || _a === void 0 ? void 0 : _a.totalEntries) !== null && _b !== void 0 ? _b : (Array.isArray(cfgResult) ? cfgResult.length : 0);
+            spinner.success({ text: `Found ${total} export configurations` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("export-configs", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list export configs", 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;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching export logs...", color: "magenta" });
+            const res = await apiCallHandler("export", "exportlogs", "get", null, {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            const { result: logResult, meta: logMeta } = handleResponseFormatOptions(opts, res);
+            const total = (_b = (_a = logMeta === null || logMeta === void 0 ? void 0 : logMeta.pageInfo) === null || _a === void 0 ? void 0 : _a.totalEntries) !== null && _b !== void 0 ? _b : (Array.isArray(logResult) ? logResult.length : 0);
+            spinner.success({ text: `Found ${total} export log entries` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("export-logs", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list export logs", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createGetCommand.js

@@ -0,0 +1,46 @@
+import { parseInteger } from "../helpers/parseInt.js";
+import { promptCollectionWithModule } from "../prompts/promptCollectionWithModule.js";
+import { resolveCollectionArgs } from "../helpers/resolveCollectionArgs.js";
+import { saveFile } from "../helpers/saveFile.js";
+import { handleGetOperation } from "../operations/handleGetOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+export function createGetCommand(program) {
+    program
+        .command("get [collectionOrModule] [collection]")
+        .alias("g")
+        .description("Retrieve entries from a collection with field selection")
+        .addHelpText("after", `
+Examples:
+  ay get contacts                       Get contacts with default fields
+  ay get crm consumers                  Get consumers (explicit module)
+  ay get products -i name price         Get only name and price fields
+  ay get orders -p 3 -l 10 -r csv      Get orders page 3, 10 per page, as CSV`)
+        .option("-p, --page <number>", "Page", parseInteger, 1)
+        .option("-l, --limit <number>", "Limit", parseInteger, 20)
+        .option("-f, --from <date>", "From date")
+        .option("-i, --fields <fields...>", "Fields to get")
+        .action(async (collectionOrModule, collection, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (!collectionOrModule) {
+                if (!process.stdin.isTTY) {
+                    cliError("Missing required argument: collection", EXIT_MISUSE);
+                }
+                collectionOrModule = await promptCollectionWithModule();
+            }
+            const resolved = resolveCollectionArgs(collectionOrModule, collection);
+            localStorage.setItem("lastModule", resolved.module);
+            localStorage.setItem("lastCollection", resolved.collection);
+            let result = {};
+            result = await handleGetOperation(resolved.module, resolved.collection, opts);
+            if (opts.save) {
+                await saveFile("get", opts, result);
+            }
+        }
+        catch (e) {
+            cliError(e.message || "An unexpected error occurred", EXIT_GENERAL_ERROR);
+        }
+    });
+}