@tolinax/ayoune-cli 2026.2.1 → 2026.2.2

package/data/modules.js

@@ -0,0 +1,111 @@
+const aYOUneModules = [
+    {
+        label: "Artificial Intelligence",
+        module: "ai",
+        host: "ai.ayoune.app",
+    },
+    {
+        label: "Asset store",
+        module: "assetstore",
+        host: "assetstore.ayoune.app",
+    },
+    {
+        label: "Customer Relationship Management",
+        module: "crm",
+        host: "crm.ayoune.app",
+    },
+    {
+        label: "Project management",
+        module: "pm",
+        host: "pm.ayoune.app",
+    },
+    {
+        label: "Content management system",
+        module: "cms",
+        host: "cms.ayoune.app",
+    },
+    {
+        label: "Marketing",
+        module: "marketing",
+        host: "marketing.ayoune.app",
+    },
+    {
+        label: "Automation",
+        module: "automation",
+        host: "automation.ayoune.app",
+    },
+    { label: "Sale", module: "sale", host: "sale.ayoune.app" },
+    {
+        label: "Product information management",
+        module: "pim",
+        host: "pim.ayoune.app",
+    },
+    { label: "Hub", module: "hub", host: "hub.ayoune.app" },
+    {
+        label: "Human Resources",
+        module: "hr",
+        host: "hr.ayoune.app",
+    },
+    {
+        label: "Service Desk",
+        module: "service",
+        host: "service.ayoune.app",
+    },
+    {
+        label: "Purchase",
+        module: "purchase",
+        host: "purchase.ayoune.app",
+    },
+    {
+        label: "Accounting",
+        module: "accounting",
+        host: "accounting.ayoune.app",
+    },
+    {
+        label: "E Commerce",
+        module: "ecommerce",
+        host: "ecommerce.ayoune.app",
+    },
+    {
+        label: "Monitoring",
+        module: "monitoring",
+        host: "monitoring.ayoune.app",
+    },
+    {
+        label: "Research",
+        module: "research",
+        host: "research.ayoune.app",
+    },
+    {
+        label: "Production",
+        module: "production",
+        host: "production.ayoune.app",
+    },
+    {
+        label: "Affiliate",
+        module: "affiliate",
+        host: "affiliate.ayoune.app",
+    },
+    {
+        label: "Reporting",
+        module: "reporting",
+        host: "reporting.ayoune.app",
+    },
+    {
+        label: "Export",
+        module: "export",
+        host: "export.ayoune.app",
+    },
+    {
+        label: "Configuration",
+        module: "config",
+        host: "config.ayoune.app",
+    },
+    {
+        label: "Audit",
+        module: "audit",
+        host: "audit.ayoune.app",
+    },
+];
+export default aYOUneModules;
+export { aYOUneModules };

package/data/operations.js

@@ -0,0 +1,5 @@
+const operations = [
+    'list',
+    'get',
+];
+export { operations };

package/data/services.js

@@ -0,0 +1,139 @@
+const aYOUneServices = [
+    {
+        label: "Barcodes",
+        module: "global",
+        host: "bc.ayoune.app",
+    },
+    {
+        label: "Aggregation",
+        module: "global",
+        host: "aggregation.ayoune.app",
+    },
+    {
+        label: "Browser Automations",
+        module: "automation",
+        host: "browser-automations.ayoune.app",
+    },
+    {
+        label: "Datatables",
+        module: "global",
+        host: "datatables.ayoune.app",
+    },
+    {
+        label: "Exports",
+        module: "exports",
+        host: "exports.ayoune.app",
+    },
+    {
+        label: "Middleware",
+        module: "global",
+        host: "mw.ayoune.app",
+    },
+    {
+        label: "Replacer",
+        module: "global",
+        host: "replacer.ayoune.app",
+    },
+    {
+        label: "Services",
+        module: "services",
+        host: "services.ayoune.app",
+    },
+    {
+        label: "Endpoints",
+        module: "global",
+        host: "endpoints.ayoune.app",
+    },
+    {
+        label: "Gists",
+        module: "pm",
+        host: "gists.ayoune.app",
+    },
+    {
+        label: "Text to Speech",
+        module: "global",
+        host: "tts.ayoune.app",
+    },
+    {
+        label: "Statistics",
+        module: "metrics",
+        host: "stats.ayoune.app",
+    },
+    {
+        label: "Statistics",
+        module: "stats",
+        host: "stats.ayoune.app",
+    },
+    {
+        label: "Video Generation",
+        module: "cms",
+        host: "video-generation.ayoune.app",
+    },
+    {
+        label: "Image Generation",
+        module: "cms",
+        host: "image-generation.ayoune.app",
+    },
+    {
+        label: "Text Generation",
+        module: "text",
+        host: "text-generation.ayoune.app",
+    },
+    {
+        label: "Serp Html Archive",
+        module: "research",
+        host: "serp-html-archive.ayoune.app",
+    },
+    {
+        label: "Config files",
+        module: "global",
+        host: "configs.ayoune.app",
+    },
+    {
+        label: "GraphQl",
+        module: "global",
+        host: "graph.ayoune.app",
+    },
+    {
+        label: "Dynamic Content",
+        module: "cms",
+        host: "dc.ayoune.app",
+    },
+    {
+        label: "Media",
+        module: "cms",
+        host: "media.ayoune.app",
+    },
+    {
+        label: "Text Spinner",
+        module: "cms",
+        host: "spinner.ayoune.app",
+    },
+    {
+        label: "Content Snippets",
+        module: "cms",
+        host: "snippets.ayoune.app",
+    },
+    {
+        label: "Downloads",
+        module: "cms",
+        host: "downloads.ayoune.app",
+    },
+    {
+        label: "Scripts",
+        module: "global",
+        host: "scripts.ayoune.app",
+    },
+    {
+        label: "Downloads",
+        module: "cms",
+        host: "downloads.ayoune.app",
+    },
+    {
+        label: "Documents",
+        module: "crm",
+        host: "documents.ayoune.app",
+    },
+];
+export default aYOUneServices;
+export { aYOUneServices };

package/lib/api/apiCallHandler.js

@@ -0,0 +1,68 @@
+import { api, getModuleBaseUrl } from "./apiClient.js";
+import chalk from "chalk";
+import * as process from "process";
+import { localStorage } from "../helpers/localStorage.js";
+import { handleAPIError } from "./handleAPIError.js";
+import { login } from "./login.js";
+import { spinner } from "../../index.js";
+let dryRunEnabled = false;
+export function enableDryRun() {
+    dryRunEnabled = true;
+}
+function cleanParams(params) {
+    const cleaned = {};
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null || value === false || value === "")
+            continue;
+        cleaned[key] = value;
+    }
+    const version = process.env.AYOUNE_VERSION;
+    if (version) {
+        cleaned.ref = `ayoune-cli@${version}`;
+    }
+    return cleaned;
+}
+function getToken() {
+    return localStorage.getItem("token") || process.env.AYOUNE_TOKEN || "";
+}
+const makeRequest = (module, url, method, data, params) => api({
+    baseURL: getModuleBaseUrl(module),
+    method,
+    url,
+    data,
+    params: cleanParams(params),
+    headers: {
+        Authorization: `Bearer ${getToken()}`,
+    },
+});
+export const apiCallHandler = async (module, url, method = "get", data = null, params = {}) => {
+    var _a;
+    // Dry-run: show what would happen for mutating requests
+    if (dryRunEnabled && method !== "get") {
+        const baseUrl = getModuleBaseUrl(module);
+        const fullUrl = `${baseUrl}/${url}`.replace(/\/+/g, "/").replace(":/", "://");
+        spinner.stop();
+        console.error(chalk.yellow.bold("\n  [DRY RUN] Request not sent:\n"));
+        console.error(`  ${chalk.dim("Method:")}  ${chalk.cyan(method.toUpperCase())}`);
+        console.error(`  ${chalk.dim("URL:")}     ${chalk.cyan(fullUrl)}`);
+        if (data) {
+            console.error(`  ${chalk.dim("Body:")}    ${JSON.stringify(data, null, 2).split("\n").join("\n          ")}`);
+        }
+        console.error();
+        return { payload: null, meta: { responseTime: 0, message: "Dry run - no request sent" } };
+    }
+    try {
+        const response = await makeRequest(module, url, method, data, params);
+        return response.data;
+    }
+    catch (error) {
+        if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+            spinner.stop();
+            spinner.error({ text: "Session expired. Re-authenticating..." });
+            await login();
+            const response = await makeRequest(module, url, method, data, params);
+            return response.data;
+        }
+        handleAPIError(error);
+    }
+};

package/lib/api/apiClient.js

@@ -0,0 +1,100 @@
+import axios from "axios";
+import https from "https";
+import chalk from "chalk";
+import axiosRetry from "axios-retry";
+import { config } from "../helpers/config.js";
+const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+let debugEnabled = false;
+export function enableDebug() {
+    debugEnabled = true;
+}
+function debugLog(prefix, ...args) {
+    if (!debugEnabled)
+        return;
+    console.error(chalk.dim(`  [debug] ${prefix}`), ...args);
+}
+const api = axios.create({
+    timeout: 30000,
+    httpsAgent,
+});
+const audit = axios.create({
+    baseURL: config.auditUrl,
+    httpsAgent,
+});
+export function getModuleBaseUrl(module) {
+    return `https://${module}-api.ayoune.app`;
+}
+function addDebugInterceptors(instance) {
+    instance.interceptors.request.use((req) => {
+        var _a, _b, _c;
+        const url = `${req.baseURL || ""}/${req.url || ""}`.replace(/\/+/g, "/").replace(":/", "://");
+        debugLog(`${chalk.yellow((_a = req.method) === null || _a === void 0 ? void 0 : _a.toUpperCase())} ${chalk.cyan(url)}`);
+        if (req.params && Object.keys(req.params).length) {
+            debugLog("params:", JSON.stringify(req.params));
+        }
+        if (req.data) {
+            debugLog("body:", JSON.stringify(req.data).substring(0, 200));
+        }
+        const auth = ((_b = req.headers) === null || _b === void 0 ? void 0 : _b.Authorization) || ((_c = req.headers) === null || _c === void 0 ? void 0 : _c.authorization);
+        if (auth) {
+            const token = String(auth);
+            debugLog("auth:", token.substring(0, 15) + "..." + token.substring(token.length - 10));
+        }
+        return req;
+    });
+    instance.interceptors.response.use((res) => {
+        var _a, _b;
+        const meta = (_a = res.data) === null || _a === void 0 ? void 0 : _a.meta;
+        const total = (_b = meta === null || meta === void 0 ? void 0 : meta.pageInfo) === null || _b === void 0 ? void 0 : _b.totalEntries;
+        const time = meta === null || meta === void 0 ? void 0 : meta.responseTime;
+        debugLog(`${chalk.green(res.status)} ${res.statusText}` +
+            (time ? ` ${chalk.dim(`(${time}ms)`)}` : "") +
+            (total !== undefined ? ` ${chalk.dim(`[${total} entries]`)}` : ""));
+        if (res.data) {
+            const body = JSON.stringify(res.data);
+            debugLog("response:", body.length > 500 ? body.substring(0, 500) + "..." : body);
+        }
+        return res;
+    }, (err) => {
+        if (err.response) {
+            debugLog(`${chalk.red(err.response.status)} ${err.response.statusText}`);
+            if (err.response.data) {
+                debugLog("response:", JSON.stringify(err.response.data).substring(0, 500));
+            }
+        }
+        else {
+            debugLog(chalk.red(`network error: ${err.message}`));
+        }
+        return Promise.reject(err);
+    });
+}
+addDebugInterceptors(api);
+addDebugInterceptors(audit);
+const retryConfig = {
+    retries: 3,
+    retryDelay: (retryCount, error) => {
+        var _a, _b;
+        // Respect Retry-After header for 429 responses
+        const retryAfter = (_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.headers) === null || _b === void 0 ? void 0 : _b["retry-after"];
+        if (retryAfter) {
+            const seconds = parseInt(retryAfter, 10);
+            if (!isNaN(seconds)) {
+                debugLog(chalk.yellow(`Rate limited. Retrying in ${seconds}s...`));
+                return seconds * 1000;
+            }
+        }
+        // Exponential backoff: 1s, 2s, 4s
+        const delay = Math.pow(2, retryCount - 1) * 1000;
+        debugLog(chalk.yellow(`Retrying in ${delay / 1000}s (attempt ${retryCount}/3)...`));
+        return delay;
+    },
+    retryCondition: (error) => {
+        var _a;
+        // Retry on network errors, 5xx, and 429 (rate limit)
+        return axiosRetry.isNetworkOrIdempotentRequestError(error)
+            || ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 429;
+    },
+};
+axiosRetry(api, retryConfig);
+axiosRetry(audit, retryConfig);
+export { api, audit };

package/lib/api/auditCallHandler.js

@@ -0,0 +1,21 @@
+import { audit } from "./apiClient.js";
+import * as process from "process";
+import { localStorage } from "../helpers/localStorage.js";
+import { handleAPIError } from "./handleAPIError.js";
+export const auditCallHandler = async (url, method = "get", data = null, params = {}) => {
+    try {
+        const response = await audit({
+            method,
+            url,
+            data,
+            params: { ...params, ref: `ayoune-cli@${process.env.AYOUNE_VERSION}` },
+            headers: {
+                Authorization: `Bearer ${localStorage.getItem("token")}`,
+            },
+        });
+        return response.data;
+    }
+    catch (error) {
+        handleAPIError(error);
+    }
+};

package/lib/api/decodeToken.js

@@ -0,0 +1,4 @@
+import { decode } from "jsonwebtoken";
+export const decodeToken = (token) => {
+    return decode(token, { json: true, complete: true });
+};

package/lib/api/handleAPIError.js

@@ -0,0 +1,59 @@
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_AUTH_REQUIRED, EXIT_PERMISSION_DENIED, } from "../exitCodes.js";
+let jsonErrorsEnabled = false;
+export function enableJsonErrors() {
+    jsonErrorsEnabled = true;
+}
+function emitJsonError(code, type, message, details) {
+    if (jsonErrorsEnabled) {
+        const err = { error: type, code, message, ...(details ? { details } : {}) };
+        console.error(JSON.stringify(err));
+    }
+    process.exit(code);
+}
+export function handleAPIError(error) {
+    var _a, _b, _c, _d;
+    const apiError = error.response;
+    const requestConfig = error.config;
+    const method = ((requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.method) || "GET").toUpperCase();
+    const fullUrl = requestConfig
+        ? `${requestConfig.baseURL || ""}/${requestConfig.url || ""}`.replace(/\/+/g, "/").replace(":/", "://")
+        : "unknown";
+    if (!apiError) {
+        spinner.error({ text: `Network error: ${error.message}` });
+        if (!jsonErrorsEnabled)
+            console.error(`  Request: ${method} ${fullUrl}`);
+        emitJsonError(EXIT_GENERAL_ERROR, "network_error", error.message, { method, url: fullUrl });
+    }
+    const serverMessage = ((_b = (_a = apiError.data) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.message) || apiError.statusText;
+    if (apiError.status === 400) {
+        spinner.error({ text: `Bad Request: ${serverMessage}` });
+        if (!jsonErrorsEnabled)
+            console.error(`  Request: ${method} ${fullUrl}`);
+        emitJsonError(EXIT_GENERAL_ERROR, "bad_request", serverMessage, { method, url: fullUrl, status: 400 });
+    }
+    if (apiError.status === 401) {
+        spinner.error({ text: "Session expired. Please run: ay login" });
+        emitJsonError(EXIT_AUTH_REQUIRED, "auth_required", "Session expired", { status: 401 });
+    }
+    if (apiError.status === 403) {
+        const rights = ((_d = (_c = apiError.data) === null || _c === void 0 ? void 0 : _c.meta) === null || _d === void 0 ? void 0 : _d.requiredRights) || [];
+        spinner.error({
+            text: `Forbidden. Required rights: [${rights.join(", ")}]`,
+        });
+        if (!jsonErrorsEnabled)
+            console.error(`  Request: ${method} ${fullUrl}`);
+        emitJsonError(EXIT_PERMISSION_DENIED, "permission_denied", "Forbidden", { method, url: fullUrl, status: 403, requiredRights: rights });
+    }
+    spinner.error({
+        text: `Error ${apiError.status}: ${serverMessage}`,
+    });
+    if (!jsonErrorsEnabled) {
+        console.error(`  Request: ${method} ${fullUrl}`);
+        if (apiError.data && typeof apiError.data === "object") {
+            const debugInfo = apiError.data.meta || apiError.data;
+            console.error(`  Response: ${JSON.stringify(debugInfo)}`);
+        }
+    }
+    emitJsonError(EXIT_GENERAL_ERROR, "api_error", serverMessage, { method, url: fullUrl, status: apiError.status });
+}

package/lib/api/login.js

@@ -0,0 +1,45 @@
+import { socket } from "../socket/socketClient.js";
+import { randomAsciiString } from "../helpers/makeRandomToken.js";
+import { spinner } from "../../index.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { config } from "../helpers/config.js";
+import chalk from "chalk";
+function terminalLink(text, url) {
+    // OSC 8 hyperlink escape sequence - supported by most modern terminals
+    return `\u001B]8;;${url}\u0007${text}\u001B]8;;\u0007`;
+}
+export const login = async () => {
+    spinner.start({ text: "Waiting for login\n" });
+    const token = randomAsciiString();
+    const url = `${config.loginUrl}/ayoune?cli=${token}`;
+    const clickable = terminalLink(chalk.cyan.underline(url), url);
+    console.log();
+    console.log(`  ${chalk.dim("Open this URL to authenticate:")}`);
+    console.log(`  ${clickable}`);
+    console.log();
+    const credentials = await waitForCredentials(token);
+    return credentials;
+};
+const waitForCredentials = async (token) => {
+    return new Promise(function (resolve, reject) {
+        const _socket = socket(token);
+        _socket.on("join:cli:confirmed", async (data) => {
+            spinner.update({ text: `Session active` });
+        });
+        _socket.on("cli-token", async (data) => {
+            spinner.success({ text: `Received auth credentials` });
+            localStorage.setItem("token", data.token);
+            localStorage.setItem("refreshToken", data.refreshToken);
+            _socket.disconnect();
+            resolve(data);
+        });
+        _socket.on("connect_error", async (err) => {
+            spinner.error({ text: err.message });
+            _socket.disconnect();
+            reject(err);
+        });
+        _socket.on("connect", async () => {
+            spinner.update({ text: "Tunnel established. Waiting for credentials" });
+        });
+    });
+};

package/lib/commands/createActionsCommand.js

@@ -0,0 +1,109 @@
+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 createActionsCommand(program) {
+    program
+        .command("actions [search]")
+        .alias("act")
+        .description("Discover registered API actions from all services")
+        .addHelpText("after", `
+Examples:
+  ay actions                         List all API actions (interactive)
+  ay actions generate                Search actions matching "generate"
+  ay actions --namespace ai          List all AI actions
+  ay actions --host ai.ayoune.app    List actions for a specific host
+  ay actions --method POST           List only POST actions
+  ay actions --list-namespaces       List all available namespaces
+  ay actions -r table --columns "operationId,method,endpoint,host"`)
+        .option("--namespace <ns>", "Filter by namespace (e.g. ai, crm, pm)")
+        .option("--host <host>", "Filter by host")
+        .option("--method <method>", "Filter by HTTP method (GET, POST, PUT, DELETE)")
+        .option("--capability <cap>", "Filter by capability")
+        .option("--list-namespaces", "List all unique namespaces")
+        .option("--list-hosts", "List all unique hosts")
+        .option("-p, --page <number>", "Page", parseInt, 1)
+        .option("-l, --limit <number>", "Limit", parseInt, 100)
+        .action(async (search, options) => {
+        var _a;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching API actions...", color: "magenta" });
+            // Build query params
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: "json",
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            };
+            if (search)
+                params.q = search;
+            // Fetch actions from the SU config API (where apiactions are stored)
+            const res = await apiCallHandler("config", "ayouneapiactions", "get", null, params);
+            if (!(res === null || res === void 0 ? void 0 : res.payload)) {
+                spinner.error({ text: "No API actions found or insufficient permissions" });
+                return;
+            }
+            let actions = Array.isArray(res.payload) ? res.payload : [res.payload];
+            // Apply client-side filters
+            if (opts.namespace) {
+                actions = actions.filter((a) => a.nameSpace === opts.namespace);
+            }
+            if (opts.host) {
+                actions = actions.filter((a) => { var _a; return (_a = a.host) === null || _a === void 0 ? void 0 : _a.includes(opts.host); });
+            }
+            if (opts.method) {
+                actions = actions.filter((a) => { var _a; return ((_a = a.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) === opts.method.toUpperCase(); });
+            }
+            if (opts.capability) {
+                actions = actions.filter((a) => a.capability === opts.capability);
+            }
+            // Special modes: list namespaces or hosts
+            if (opts.listNamespaces) {
+                const namespaces = [...new Set(actions.map((a) => a.nameSpace).filter(Boolean))].sort();
+                spinner.success({ text: `Found ${namespaces.length} namespaces` });
+                spinner.stop();
+                console.log(namespaces.join("\n"));
+                return;
+            }
+            if (opts.listHosts) {
+                const hosts = [...new Set(actions.map((a) => a.host).filter(Boolean))].sort();
+                spinner.success({ text: `Found ${hosts.length} hosts` });
+                spinner.stop();
+                console.log(hosts.join("\n"));
+                return;
+            }
+            // Filter out deprecated
+            actions = actions.filter((a) => !a.deprecated);
+            // Build display-friendly response
+            const formattedRes = {
+                payload: actions.map((a) => ({
+                    operationId: a.operationId || "",
+                    method: (a.method || "GET").toUpperCase(),
+                    endpoint: a.endpoint || "",
+                    host: a.host || "",
+                    nameSpace: a.nameSpace || "",
+                    capability: a.capability || "",
+                    action: a.action || "",
+                    description: a.shortDescription || a.description || "",
+                })),
+                meta: {
+                    ...res.meta,
+                    pageInfo: { ...(_a = res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo, totalEntries: actions.length },
+                },
+            };
+            const { plainResult, result, content } = handleResponseFormatOptions(opts, formattedRes);
+            spinner.success({ text: `Found ${actions.length} API actions` });
+            spinner.stop();
+            if (opts.save) {
+                await saveFile("actions", opts, formattedRes);
+            }
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to fetch API actions" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}