@tolinax/ayoune-cli 2026.2.1 → 2026.2.3

package/lib/commands/createServicesCommand.js

@@ -0,0 +1,228 @@
+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 { aYOUneModules } from "../../data/modules.js";
+import { aYOUneServices } from "../../data/services.js";
+function buildServiceRegistry() {
+    const services = [];
+    // APIs from modules
+    for (const m of aYOUneModules) {
+        services.push({
+            name: m.label,
+            type: "api",
+            module: m.module,
+            host: m.host,
+        });
+    }
+    // Services
+    for (const s of aYOUneServices) {
+        services.push({
+            name: s.label,
+            type: "service",
+            module: s.module,
+            host: s.host,
+        });
+    }
+    return services;
+}
+export function createServicesCommand(program) {
+    const svc = program
+        .command("services")
+        .alias("svc")
+        .description("Discover and manage aYOUne platform services");
+    // ay services list
+    svc
+        .command("list")
+        .alias("ls")
+        .description("List all registered services, APIs, and gateways")
+        .option("--type <type>", "Filter by type: api, service, gateway, worker")
+        .option("--module <module>", "Filter by module name")
+        .action(async (options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Loading service registry...", color: "magenta" });
+            let services = buildServiceRegistry();
+            if (opts.type) {
+                services = services.filter((s) => s.type === opts.type);
+            }
+            if (opts.module) {
+                services = services.filter((s) => s.module === opts.module);
+            }
+            const res = {
+                payload: services,
+                meta: { responseTime: 0, pageInfo: { totalEntries: services.length, page: 1, totalPages: 1 } },
+            };
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Found ${services.length} services` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("services-list", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list services" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay services endpoints <host>
+    svc
+        .command("endpoints <host>")
+        .alias("ep")
+        .description("List API endpoints for a service host")
+        .addHelpText("after", `
+Examples:
+  ay services endpoints ai.ayoune.app
+  ay services endpoints crm-api.ayoune.app -r table`)
+        .action(async (host, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Fetching endpoints for ${host}...`, color: "magenta" });
+            const res = await apiCallHandler("config", "ayouneapiactions", "get", null, {
+                limit: 500,
+                responseFormat: "json",
+            });
+            if (!(res === null || res === void 0 ? void 0 : res.payload)) {
+                spinner.error({ text: "No API actions found" });
+                return;
+            }
+            const endpoints = (Array.isArray(res.payload) ? res.payload : [])
+                .filter((a) => {
+                const h = a.host || "";
+                return h.includes(host) && !a.deprecated;
+            })
+                .map((a) => ({
+                method: (a.method || "GET").toUpperCase(),
+                endpoint: a.endpoint || "",
+                operationId: a.operationId || "",
+                action: a.action || "",
+                description: a.shortDescription || a.description || "",
+            }))
+                .sort((a, b) => a.endpoint.localeCompare(b.endpoint));
+            const formattedRes = {
+                payload: endpoints,
+                meta: { responseTime: 0, pageInfo: { totalEntries: endpoints.length, page: 1, totalPages: 1 } },
+            };
+            handleResponseFormatOptions(opts, formattedRes);
+            spinner.success({ text: `Found ${endpoints.length} endpoints on ${host}` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("service-endpoints", opts, formattedRes);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to fetch endpoints" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay services health [host]
+    svc
+        .command("health [host]")
+        .description("Check health of a service or all services")
+        .option("--timeout <ms>", "Request timeout in ms", parseInt, 5000)
+        .action(async (host, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const targets = host
+                ? [{ name: host, host }]
+                : buildServiceRegistry().map((s) => ({ name: s.name, host: s.host }));
+            // Deduplicate by host
+            const uniqueTargets = [...new Map(targets.map((t) => [t.host, t])).values()];
+            spinner.start({ text: `Checking ${uniqueTargets.length} service(s)...`, color: "magenta" });
+            const { default: axios } = await import("axios");
+            const https = await import("https");
+            const agent = new https.Agent({ rejectUnauthorized: false });
+            const results = await Promise.allSettled(uniqueTargets.map(async (t) => {
+                const start = Date.now();
+                try {
+                    const resp = await axios.get(`https://${t.host}/`, {
+                        timeout: opts.timeout,
+                        httpsAgent: agent,
+                        validateStatus: () => true,
+                    });
+                    return {
+                        host: t.host,
+                        name: t.name,
+                        status: resp.status < 500 ? "healthy" : "unhealthy",
+                        statusCode: resp.status,
+                        responseTime: Date.now() - start,
+                    };
+                }
+                catch (e) {
+                    return {
+                        host: t.host,
+                        name: t.name,
+                        status: "unreachable",
+                        statusCode: 0,
+                        responseTime: Date.now() - start,
+                        error: e.code || e.message,
+                    };
+                }
+            }));
+            const payload = results.map((r) => (r.status === "fulfilled" ? r.value : { status: "error" }));
+            const healthy = payload.filter((p) => p.status === "healthy").length;
+            const res = {
+                payload,
+                meta: {
+                    responseTime: 0,
+                    pageInfo: { totalEntries: payload.length, page: 1, totalPages: 1 },
+                },
+            };
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `${healthy}/${uniqueTargets.length} services healthy` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("services-health", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Health check failed" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay services describe <module>
+    svc
+        .command("describe <module>")
+        .alias("desc")
+        .description("Show detailed info about a module/service")
+        .action(async (moduleName, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Describing ${moduleName}...`, color: "magenta" });
+            // Find matching entries
+            const apis = aYOUneModules.filter((m) => m.module === moduleName);
+            const svcs = aYOUneServices.filter((s) => s.module === moduleName);
+            // Fetch endpoint count from apiactions
+            const res = await apiCallHandler("config", "ayouneapiactions", "get", null, {
+                limit: 500,
+                responseFormat: "json",
+            });
+            const allActions = Array.isArray(res === null || res === void 0 ? void 0 : res.payload) ? res.payload : [];
+            const moduleActions = allActions.filter((a) => a.nameSpace === moduleName && !a.deprecated);
+            const methods = {};
+            for (const a of moduleActions) {
+                const m = (a.method || "GET").toUpperCase();
+                methods[m] = (methods[m] || 0) + 1;
+            }
+            const description = {
+                module: moduleName,
+                apis: apis.map((a) => ({ label: a.label, host: a.host })),
+                services: svcs.map((s) => ({ label: s.label, host: s.host })),
+                endpoints: {
+                    total: moduleActions.length,
+                    byMethod: methods,
+                },
+                capabilities: [...new Set(moduleActions.map((a) => a.capability).filter(Boolean))].sort(),
+            };
+            const formattedRes = {
+                payload: description,
+                meta: { responseTime: 0 },
+            };
+            handleResponseFormatOptions(opts, formattedRes);
+            spinner.success({ text: `Module: ${moduleName} — ${moduleActions.length} endpoints` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to describe service" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createStorageCommand.js

@@ -0,0 +1,54 @@
+import chalk from "chalk";
+import { localStorage } from "../helpers/localStorage.js";
+import { loadConfig } from "../helpers/configLoader.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
+const REDACT_KEYS = new Set(["token", "refreshToken"]);
+function redact(value) {
+    if (value.length <= 8)
+        return "••••";
+    return value.slice(0, 4) + "••••" + value.slice(-4);
+}
+export function createStorageCommand(program) {
+    program
+        .command("storage")
+        .alias("s")
+        .description("Display stored session data and preferences")
+        .action(async () => {
+        var _a, _b;
+        try {
+            const storage = {};
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key) {
+                    const value = (_a = localStorage.getItem(key)) !== null && _a !== void 0 ? _a : "";
+                    storage[key] = REDACT_KEYS.has(key) ? redact(value) : value;
+                }
+            }
+            console.log();
+            console.log(chalk.bold("  Session Storage"));
+            console.log(chalk.dim(`  ${"─".repeat(44)}`));
+            const maxKey = Math.max(...Object.keys(storage).map((k) => k.length), 0);
+            for (const [key, value] of Object.entries(storage)) {
+                console.log(`  ${chalk.dim(key.padEnd(maxKey + 2))} ${chalk.white(value)}`);
+            }
+            const config = loadConfig();
+            const defaults = (_b = config.defaults) !== null && _b !== void 0 ? _b : {};
+            const defaultEntries = Object.entries(defaults).filter(([, v]) => v !== undefined && v !== null);
+            if (defaultEntries.length > 0) {
+                console.log();
+                console.log(chalk.bold("  Config Defaults"));
+                console.log(chalk.dim(`  ${"─".repeat(44)}`));
+                const maxDefault = Math.max(...defaultEntries.map(([k]) => k.length));
+                for (const [key, value] of defaultEntries) {
+                    console.log(`  ${chalk.dim(key.padEnd(maxDefault + 2))} ${chalk.white(String(value))}`);
+                }
+            }
+            console.log();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createStreamCommand.js

@@ -0,0 +1,50 @@
+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 createStreamCommand(program) {
+    program
+        .command("stream")
+        .alias("listen")
+        .description("Subscribe to real-time data changes via WebSocket")
+        .addHelpText("after", `
+Examples:
+  ay stream                     Stream all data changes as JSON
+  ay stream -f yaml             Stream changes in YAML format
+  ay listen -l minimal          Stream with minimal detail`)
+        .addOption(new Option("-f, --format <format>", "Set the output format")
+        .choices(["json", "yaml", "table"])
+        .default("json"))
+        .addOption(new Option("-l, --level <level>", "Set the detail level")
+        .choices(["default", "minimal", "extended"])
+        .default("default"))
+        .action(async (options) => {
+        try {
+            const tokenPayload = decodeToken(localStorage.getItem("token"));
+            const user = tokenPayload.payload;
+            console.log(`Starting stream with [${user._customerID}]`);
+            spinner.start({ text: `Starting stream with [${user._customerID}]` });
+            const socket = customerSocket(user);
+            spinner.update({ text: "Stream active" });
+            socket.onAny((channel, data) => {
+                spinner.update({ text: `Received [${channel}]` });
+                if (options.format === "table") {
+                    console.table(data);
+                }
+                if (options.format === "yaml") {
+                    console.log(yaml.dump(data));
+                }
+                if (options.format === "json") {
+                    console.log(JSON.stringify(data, null, 2));
+                }
+            });
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createUpdateCommand.js

@@ -0,0 +1,115 @@
+import { Argument } from "commander";
+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 { localStorage } from "../helpers/localStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+export function createUpdateCommand(program) {
+    program
+        .command("update")
+        .alias("u")
+        .description("Update an entry non-interactively (for scripts and AI agents)")
+        .addHelpText("after", `
+Unlike 'edit' (which opens an interactive editor), 'update' accepts changes
+as JSON via --body, --body-file, or --body-stdin. Perfect for automation.
+
+Examples:
+  ay update contacts 64a1b2c3 --body '{"firstName":"Jane"}'
+  ay update products 64a1b2c3 --body-file changes.json
+  echo '{"status":"active"}' | ay update contacts 64a1b2c3 --body-stdin
+  ay u tasks 64a1b2c3 --body '{"done":true}' --force`)
+        .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 update").default(localStorage.getItem("lastId"), `The last used id (${localStorage.getItem("lastId")})`))
+        .option("--body <json>", "Update data as JSON string")
+        .option("--body-file <path>", "Read update data from JSON file")
+        .option("--body-stdin", "Read update data from stdin")
+        .option("--merge", "Merge with existing entry (GET + merge + PUT)", false)
+        .action(async (collection, id, options) => {
+        try {
+            if (!collection) {
+                spinner.error({ text: "Missing required argument: collection" });
+                process.exit(EXIT_MISUSE);
+            }
+            if (!id) {
+                spinner.error({ text: "Missing required argument: id" });
+                process.exit(EXIT_MISUSE);
+            }
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            // Parse body from various sources
+            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);
+                    }
+                }
+            }
+            if (!body) {
+                spinner.error({ text: "No update data provided. Use --body, --body-file, or --body-stdin." });
+                process.exit(EXIT_MISUSE);
+            }
+            // Merge mode: GET existing → merge → PUT
+            if (opts.merge) {
+                spinner.start({ text: `Fetching ${id} from ${collection}...`, color: "magenta" });
+                const existing = await apiCallHandler(module.module, `${collection.toLowerCase()}/${id}`, "get", null, { responseFormat: "json" });
+                const existingData = (existing === null || existing === void 0 ? void 0 : existing.payload) || {};
+                body = { ...existingData, ...body };
+                spinner.update({ text: `Updating ${id} in ${collection} (merged)...` });
+            }
+            else {
+                spinner.start({ text: `Updating ${id} in ${collection}...`, color: "magenta" });
+            }
+            // Ensure _id is set
+            body._id = id;
+            const res = await apiCallHandler(module.module, collection.toLowerCase(), "put", body, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Updated entry ${id} in ${collection}` });
+            spinner.stop();
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+            localStorage.setItem("lastId", id);
+            if (opts.save)
+                await saveFile("update", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createWebhooksCommand.js

@@ -0,0 +1,156 @@
+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 createWebhooksCommand(program) {
+    const hooks = program
+        .command("webhooks")
+        .alias("hooks")
+        .description("Manage webhooks and event subscriptions");
+    // ay webhooks list
+    hooks
+        .command("list")
+        .alias("ls")
+        .description("List registered webhooks")
+        .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 webhooks...", color: "magenta" });
+            const res = await apiCallHandler("config", "hooks", "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} webhooks` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("webhooks-list", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list webhooks" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay webhooks get <id>
+    hooks
+        .command("get <id>")
+        .description("Get webhook details")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Fetching webhook ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("config", `hooks/${id}`, "get", null, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Webhook ${id} loaded` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to get webhook" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay webhooks create --body '{...}'
+    hooks
+        .command("create")
+        .description("Create a new webhook")
+        .option("--body <json>", "Webhook definition as JSON")
+        .option("--body-file <path>", "Read webhook definition from file")
+        .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.bodyFile) {
+                const fs = await import("fs");
+                try {
+                    body = JSON.parse(fs.readFileSync(opts.bodyFile, "utf-8"));
+                }
+                catch (_b) {
+                    spinner.error({ text: `Invalid JSON in file: ${opts.bodyFile}` });
+                    process.exit(EXIT_MISUSE);
+                }
+            }
+            if (!body) {
+                spinner.error({ text: "Provide webhook definition via --body or --body-file" });
+                process.exit(EXIT_MISUSE);
+            }
+            spinner.start({ text: "Creating webhook...", color: "magenta" });
+            const res = await apiCallHandler("config", "hooks", "post", body, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Webhook created` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to create webhook" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay webhooks delete <id>
+    hooks
+        .command("delete <id>")
+        .alias("rm")
+        .description("Delete a webhook")
+        .action(async (id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Deleting webhook ${id}...`, color: "magenta" });
+            const res = await apiCallHandler("config", `hooks/${id}`, "delete", null, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Webhook ${id} deleted` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to delete webhook" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay webhooks templates
+    hooks
+        .command("templates")
+        .description("List available webhook templates")
+        .option("-l, --limit <number>", "Limit results", parseInt, 50)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching webhook templates...", color: "magenta" });
+            const res = await apiCallHandler("config", "hooktemplates", "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} webhook templates` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("webhook-templates", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list templates" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}