@tolinax/ayoune-cli 2026.2.1 → 2026.2.2

package/lib/commands/createDescribeCommand.js

@@ -0,0 +1,42 @@
+import { Argument } from "commander";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { handleDescribeSingleOperation } from "../operations/handleDescribeSingleOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.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 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")})`))
+        .action(async (collection, id, options) => {
+        try {
+            if (!collection) {
+                spinner.error({ text: "Missing required argument: collection. Run a list or get command first, or provide it explicitly." });
+                process.exit(EXIT_MISUSE);
+            }
+            if (!id) {
+                spinner.error({ text: "Missing required argument: id. Provide an entry ID explicitly." });
+                process.exit(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,
+            });
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createEditCommand.js

@@ -0,0 +1,43 @@
+import { Argument } from "commander";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { handleGetSingleOperation } from "../operations/handleGetSingleOperation.js";
+import { handleEditOperation } from "../operations/handleEditOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.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) {
+                spinner.error({ text: "Missing required argument: collection. Run a list or get command first, or provide it explicitly." });
+                process.exit(EXIT_MISUSE);
+            }
+            if (!id) {
+                spinner.error({ text: "Missing required argument: id. Provide an entry ID explicitly." });
+                process.exit(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);
+            await handleEditOperation(module.module, collection, result.content);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createEventsCommand.js

@@ -0,0 +1,60 @@
+import { Option } from "commander";
+import { localStorage } from "../helpers/localStorage.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";
+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(localStorage.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) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createExecCommand.js

@@ -0,0 +1,182 @@
+import chalk from "chalk";
+import { api } from "../api/apiClient.js";
+import { apiCallHandler } from "../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../helpers/handleResponseFormatOptions.js";
+import { saveFile } from "../helpers/saveFile.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+async function resolveAction(searchTerm) {
+    // Try exact operationId match first
+    const res = await apiCallHandler("config", "ayouneapiactions", "get", null, {
+        q: searchTerm,
+        limit: 50,
+        responseFormat: "json",
+    });
+    if (!(res === null || res === void 0 ? void 0 : res.payload) || !Array.isArray(res.payload) || res.payload.length === 0) {
+        return null;
+    }
+    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]);
+    return null;
+}
+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) {
+                spinner.error({ text: `No API action found for: ${operationId}` });
+                process.exit(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) {
+                    spinner.error({ text: "Invalid JSON in --body" });
+                    process.exit(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) {
+                    spinner.error({ text: `Invalid JSON in file: ${opts.bodyFile}` });
+                    process.exit(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) {
+                        spinner.error({ text: "Invalid JSON from stdin" });
+                        process.exit(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 ${localStorage.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) {
+            spinner.error({ text: e.message || "Failed to execute API action" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createGetCommand.js

@@ -0,0 +1,47 @@
+import { parseInteger } from "../helpers/parseInt.js";
+import { promptCollectionWithModule } from "../prompts/promptCollectionWithModule.js";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { saveFile } from "../helpers/saveFile.js";
+import { handleGetOperation } from "../operations/handleGetOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+export function createGetCommand(program) {
+    program
+        .command("get [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 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 (collection, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (!collection) {
+                if (!process.stdin.isTTY) {
+                    spinner.error({ text: "Missing required argument: collection" });
+                    process.exit(EXIT_MISUSE);
+                }
+                collection = await promptCollectionWithModule();
+            }
+            const module = getModuleFromCollection(collection);
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+            let result = {};
+            result = await handleGetOperation(module.module, collection, opts);
+            if (opts.save) {
+                await saveFile("get", opts, result);
+            }
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createListCommand.js

@@ -0,0 +1,49 @@
+import { parseInteger } from "../helpers/parseInt.js";
+import { promptCollectionWithModule } from "../prompts/promptCollectionWithModule.js";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { handleListOperation } from "../operations/handleListOperation.js";
+import { saveFile } from "../helpers/saveFile.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+export function createListCommand(program) {
+    program
+        .command("list [collection]")
+        .alias("l")
+        .description("List entries in a collection with pagination support")
+        .addHelpText("after", `
+Examples:
+  ay list contacts                  List contacts (page 1, limit 20)
+  ay list products -p 2 -l 50      List products page 2, 50 per page
+  ay list orders -r yaml -s        List orders as YAML and save to file
+  ay list contacts --all            Fetch all pages
+  ay list contacts --jq '[].name'   Extract just names using JMESPath`)
+        .option("-p, --page <number>", "Page", parseInteger, 1)
+        .option("-l, --limit <number>", "Limit", parseInteger, 20)
+        .option("-f, --from <date>", "From date")
+        .option("-a, --all", "Fetch all pages automatically")
+        .action(async (collection, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (!collection) {
+                if (!process.stdin.isTTY) {
+                    spinner.error({ text: "Missing required argument: collection" });
+                    process.exit(EXIT_MISUSE);
+                }
+                collection = await promptCollectionWithModule();
+            }
+            const module = getModuleFromCollection(collection);
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+            let result = {};
+            result = await handleListOperation(module.module, collection, opts);
+            if (opts.save) {
+                await saveFile("list", opts, result);
+            }
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createLoginCommand.js

@@ -0,0 +1,18 @@
+import { login } from "../api/login.js";
+import { spinner } from "../../index.js";
+import { EXIT_AUTH_REQUIRED } from "../exitCodes.js";
+export function createLoginCommand(program) {
+    program
+        .command("login")
+        .alias("auth")
+        .description("Authenticate with your aYOUne account via browser")
+        .action(async () => {
+        try {
+            await login();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_AUTH_REQUIRED);
+        }
+    });
+}

package/lib/commands/createLogoutCommand.js

@@ -0,0 +1,21 @@
+import { localStorage } from "../helpers/localStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
+export function createLogoutCommand(program) {
+    program
+        .command("logout")
+        .alias("signout")
+        .description("Clear stored credentials and log out")
+        .action(async (options) => {
+        try {
+            spinner.start({ text: "Clearing credentials" });
+            localStorage.removeItem("token");
+            localStorage.removeItem("refreshToken");
+            spinner.success({ text: "Credentials cleared" });
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createModulesCommand.js

@@ -0,0 +1,89 @@
+import { promptModule } from "../prompts/promptModule.js";
+import { promptCollectionInModule } from "../prompts/promptCollectionInModule.js";
+import { promptOperation } from "../prompts/promptOperation.js";
+import { handleListOperation } from "../operations/handleListOperation.js";
+import { promptEntry } from "../prompts/promptEntry.js";
+import { handleCollectionOperation } from "../operations/handleCollectionOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { parseInteger } from "../helpers/parseInt.js";
+import { handleGetOperation } from "../operations/handleGetOperation.js";
+import { aYOUneModules } from "../../data/modules.js";
+import { getModelsInModules } from "../models/getModelsInModules.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+function resolveModule(input) {
+    const lower = input.toLowerCase();
+    const match = aYOUneModules.find((m) => m.module === lower || m.label.toLowerCase() === lower);
+    return match ? match.module : null;
+}
+function resolveCollection(module, input) {
+    const lower = input.toLowerCase();
+    const collections = getModelsInModules(module);
+    const match = collections.find((c) => c.value === lower || c.name.toLowerCase() === lower);
+    return match ? match.value : null;
+}
+export function createModulesCommand(program) {
+    program
+        .command("modules [module] [collection]")
+        .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`)
+        .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) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (!process.stdin.isTTY) {
+                spinner.error({ text: "The modules command requires an interactive terminal" });
+                process.exit(EXIT_MISUSE);
+            }
+            let module;
+            if (moduleArg) {
+                const resolved = resolveModule(moduleArg);
+                if (!resolved) {
+                    spinner.error({ text: `Unknown module: ${moduleArg}` });
+                    process.exit(EXIT_MISUSE);
+                }
+                module = resolved;
+            }
+            else {
+                module = await promptModule();
+            }
+            let collection;
+            if (collectionArg) {
+                const resolved = resolveCollection(module, collectionArg);
+                if (!resolved) {
+                    spinner.error({ text: `Unknown collection: ${collectionArg} in module ${module}` });
+                    process.exit(EXIT_MISUSE);
+                }
+                collection = resolved;
+            }
+            else {
+                collection = await promptCollectionInModule(module);
+            }
+            const operation = await promptOperation();
+            localStorage.setItem("lastModule", module);
+            localStorage.setItem("lastCollection", collection);
+            let entry = "";
+            if (operation === "list") {
+                const { result } = await handleListOperation(module, collection, opts);
+                entry = await promptEntry(result);
+            }
+            if (operation === "get") {
+                const { result } = await handleGetOperation(module, collection, opts);
+                entry = await promptEntry(result);
+            }
+            await handleCollectionOperation(module, collection, entry, opts);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}