@tolinax/ayoune-cli 2026.8.1 → 2026.9.0

package/lib/api/apiCallHandler.js

@@ -31,7 +31,7 @@ function getToken() {
 }
 const makeRequest = (module, url, method, data, params) => api({
     baseURL: getModuleBaseUrl(module),
-    method,
+    method: method,
     url,
     data,
     params: cleanParams(params),

package/lib/api/apiClient.js

@@ -1,9 +1,6 @@
-import axios from "axios";
-import https from "https";
+import { http } from "@tolinax/ayoune-core/lib/http/index.js";
 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;
@@ -13,14 +10,6 @@ function debugLog(prefix, ...args) {
         return;
     console.error(chalk.dim(`  [debug] ${prefix}`), ...args);
 }
-const api = axios.create({
-    timeout: 30000,
-    httpsAgent,
-});
-const audit = axios.create({
-    baseURL: config.auditUrl,
-    httpsAgent,
-});
 // Modules that don't follow the standard {module}-api.ayoune.app pattern
 const MODULE_HOST_OVERRIDES = {
     su: "https://api-v1.ayoune.app/api/su",
@@ -33,52 +22,6 @@ const MODULE_HOST_OVERRIDES = {
 export function getModuleBaseUrl(module) {
     return MODULE_HOST_OVERRIDES[module] || `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) => {
@@ -100,10 +43,79 @@ const retryConfig = {
     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;
+        const status = (_a = error.response) === null || _a === void 0 ? void 0 : _a.status;
+        if (!status)
+            return true; // network error
+        return status >= 500 || status === 429;
     },
 };
-axiosRetry(api, retryConfig);
-axiosRetry(audit, retryConfig);
+/**
+ * Debug-aware HTTP request wrapper.
+ * Logs request/response details to stderr when debug mode is enabled.
+ */
+async function debugRequest(client, requestConfig) {
+    var _a, _b, _c, _d;
+    const url = `${requestConfig.baseURL || ""}/${requestConfig.url || ""}`.replace(/\/+/g, "/").replace(":/", "://");
+    const method = (requestConfig.method || "GET").toUpperCase();
+    if (debugEnabled) {
+        debugLog(`${chalk.yellow(method)} ${chalk.cyan(url)}`);
+        if (requestConfig.params && Object.keys(requestConfig.params).length) {
+            debugLog("params:", JSON.stringify(requestConfig.params));
+        }
+        if (requestConfig.data) {
+            debugLog("body:", JSON.stringify(requestConfig.data).substring(0, 200));
+        }
+        const auth = ((_a = requestConfig.headers) === null || _a === void 0 ? void 0 : _a.Authorization) || ((_b = requestConfig.headers) === null || _b === void 0 ? void 0 : _b.authorization);
+        if (auth) {
+            const token = String(auth);
+            debugLog("auth:", token.substring(0, 15) + "..." + token.substring(token.length - 10));
+        }
+    }
+    try {
+        const res = await client.request(requestConfig);
+        if (debugEnabled) {
+            const meta = (_c = res.data) === null || _c === void 0 ? void 0 : _c.meta;
+            const total = (_d = meta === null || meta === void 0 ? void 0 : meta.pageInfo) === null || _d === void 0 ? void 0 : _d.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;
+    }
+    catch (err) {
+        if (debugEnabled) {
+            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}`));
+            }
+        }
+        throw err;
+    }
+}
+const apiClient = http.create({
+    timeout: 30000,
+    retry: retryConfig,
+    logging: false,
+    metrics: false,
+});
+const auditClient = http.create({
+    baseURL: config.auditUrl,
+    retry: retryConfig,
+    logging: false,
+    metrics: false,
+});
+/** Callable API client that supports debug logging */
+const api = (requestConfig) => debugRequest(apiClient, requestConfig);
+/** Callable audit client that supports debug logging */
+const audit = (requestConfig) => debugRequest(auditClient, requestConfig);
 export { api, audit };

package/lib/commands/_registry.js

@@ -0,0 +1,279 @@
+// Lazy command registry for the `ay` CLI.
+//
+// Each command is described by a stub (name + aliases + one-line description)
+// plus a `loader` that dynamically imports its registration function. This lets
+// `createProgram` register the FULL command for only the one the user actually
+// invoked, instead of importing all 41 command modules eagerly on every cold
+// start. Help mode falls back to registering lightweight stubs for every entry
+// so `ay` / `ay --help` still produce a complete listing.
+//
+// To add a new command:
+//   1. Create `src/lib/commands/createXxxCommand.ts` exporting `createXxxCommand`
+//   2. Append a CommandSpec entry below
+//   3. (optional) add a corresponding test
+//
+// Adding/removing entries here is the ONLY thing `createProgram` needs to know
+// about — there are no static imports of command modules anywhere.
+export const COMMAND_REGISTRY = [
+    {
+        name: "modules",
+        aliases: ["m"],
+        description: "Browse modules, collections, and operations interactively",
+        loader: async () => (await import("./createModulesCommand.js")).createModulesCommand,
+    },
+    {
+        name: "list",
+        aliases: ["l"],
+        description: "List entries in a collection with pagination support",
+        loader: async () => (await import("./createListCommand.js")).createListCommand,
+    },
+    {
+        name: "get",
+        aliases: ["g"],
+        description: "Get a single entry by ID",
+        loader: async () => (await import("./createGetCommand.js")).createGetCommand,
+    },
+    {
+        name: "edit",
+        aliases: ["e"],
+        description: "Edit an existing entry",
+        loader: async () => (await import("./createEditCommand.js")).createEditCommand,
+    },
+    {
+        name: "copy",
+        aliases: ["cp"],
+        description: "Copy an existing entry",
+        loader: async () => (await import("./createCopyCommand.js")).createCopyCommand,
+    },
+    {
+        name: "describe",
+        aliases: ["d"],
+        description: "Show the schema of a collection",
+        loader: async () => (await import("./createDescribeCommand.js")).createDescribeCommand,
+    },
+    {
+        name: "create",
+        aliases: ["c"],
+        description: "Create a new entry",
+        loader: async () => (await import("./createCreateCommand.js")).createCreateCommand,
+    },
+    {
+        name: "storage",
+        aliases: ["s"],
+        description: "Manage local CLI storage (tokens, preferences)",
+        loader: async () => (await import("./createStorageCommand.js")).createStorageCommand,
+    },
+    {
+        name: "audit",
+        aliases: ["history"],
+        description: "Inspect the audit trail for an entry or collection",
+        loader: async () => (await import("./createAuditCommand.js")).createAuditCommand,
+    },
+    {
+        name: "stream",
+        aliases: ["listen"],
+        description: "Stream live updates from a collection",
+        loader: async () => (await import("./createStreamCommand.js")).createStreamCommand,
+    },
+    {
+        name: "events",
+        aliases: ["sub"],
+        description: "Subscribe to platform events",
+        loader: async () => (await import("./createEventsCommand.js")).createEventsCommand,
+    },
+    {
+        name: "whoami",
+        aliases: ["who"],
+        description: "Show the currently authenticated user",
+        loader: async () => (await import("./createWhoAmICommand.js")).createWhoAmICommand,
+    },
+    {
+        name: "logout",
+        aliases: ["signout"],
+        description: "Clear stored credentials and sign out",
+        loader: async () => (await import("./createLogoutCommand.js")).createLogoutCommand,
+    },
+    {
+        name: "actions",
+        aliases: ["act"],
+        description: "List available custom actions for a collection",
+        loader: async () => (await import("./createActionsCommand.js")).createActionsCommand,
+    },
+    {
+        name: "exec",
+        aliases: ["x"],
+        description: "Execute a custom action by name",
+        loader: async () => (await import("./createExecCommand.js")).createExecCommand,
+    },
+    {
+        name: "ai",
+        description: "Interact with aYOUne AI services",
+        loader: async () => (await import("./createAiCommand.js")).createAiCommand,
+    },
+    {
+        name: "services",
+        aliases: ["svc"],
+        description: "Discover and inspect platform services and endpoints",
+        loader: async () => (await import("./createServicesCommand.js")).createServicesCommand,
+    },
+    {
+        name: "deploy",
+        aliases: ["dp"],
+        description: "Deployments, pipelines, clusters, repos, and dashboards",
+        loader: async () => (await import("./createDeployCommand.js")).createDeployCommand,
+    },
+    {
+        name: "monitor",
+        aliases: ["mon"],
+        description: "Monitor logs, alerts, sessions, and uptime checks",
+        loader: async () => (await import("./createMonitorCommand.js")).createMonitorCommand,
+    },
+    {
+        name: "delete",
+        aliases: ["rm"],
+        description: "Delete an entry by ID",
+        loader: async () => (await import("./createDeleteCommand.js")).createDeleteCommand,
+    },
+    {
+        name: "update",
+        aliases: ["u"],
+        description: "Update fields on an existing entry",
+        loader: async () => (await import("./createUpdateCommand.js")).createUpdateCommand,
+    },
+    {
+        name: "batch",
+        description: "Run bulk operations on multiple entries (for scripts and AI agents)",
+        loader: async () => (await import("./createBatchCommand.js")).createBatchCommand,
+    },
+    {
+        name: "search",
+        aliases: ["find"],
+        description: "Full-text and model search across collections",
+        loader: async () => (await import("./createSearchCommand.js")).createSearchCommand,
+    },
+    {
+        name: "webhooks",
+        aliases: ["hooks"],
+        description: "Manage outbound webhooks",
+        loader: async () => (await import("./createWebhooksCommand.js")).createWebhooksCommand,
+    },
+    {
+        name: "jobs",
+        aliases: ["j"],
+        description: "Inspect job queues, triggers, automations, and notifications",
+        loader: async () => (await import("./createJobsCommand.js")).createJobsCommand,
+    },
+    {
+        name: "export",
+        aliases: ["exp"],
+        description: "Export collection data with pagination and format selection",
+        loader: async () => (await import("./createExportCommand.js")).createExportCommand,
+    },
+    {
+        name: "users",
+        description: "Manage users, teams, and roles",
+        loader: async () => (await import("./createUsersCommand.js")).createUsersCommand,
+    },
+    {
+        name: "sync",
+        description: "Synchronize platform data across systems",
+        loader: async () => (await import("./createSyncCommand.js")).createSyncCommand,
+    },
+    {
+        name: "permissions",
+        aliases: ["perms"],
+        description: "Manage permissions, requests, and rights",
+        loader: async () => (await import("./createPermissionsCommand.js")).createPermissionsCommand,
+    },
+    {
+        name: "templates",
+        aliases: ["tmpl"],
+        description: "Manage platform templates (email, notification, report, store)",
+        loader: async () => (await import("./createTemplateCommand.js")).createTemplateCommand,
+    },
+    {
+        name: "access",
+        description: "Show accessible modules and collections for the current user",
+        loader: async () => (await import("./createAccessCommand.js")).createAccessCommand,
+    },
+    {
+        name: "aggregate",
+        aliases: ["agg"],
+        description: "Run, save, and manage MongoDB aggregation pipelines",
+        loader: async () => (await import("./createAggregateCommand.js")).createAggregateCommand,
+    },
+    {
+        name: "db",
+        description: "Copy query results to external databases and manage targets",
+        loader: async () => (await import("./createDbCommand.js")).createDbCommand,
+    },
+    {
+        name: "setup",
+        description: "Interactive setup wizard for self-hosted aYOUne deployments",
+        loader: async () => (await import("./createSetupCommand.js")).createSetupCommand,
+    },
+    {
+        name: "status",
+        description: "Check health status of aYOUne platform services",
+        loader: async () => (await import("./createStatusCommand.js")).createStatusCommand,
+    },
+    {
+        name: "self-host-update",
+        aliases: ["shu"],
+        description: "Check for and apply updates to a self-hosted aYOUne deployment",
+        loader: async () => (await import("./createSelfHostUpdateCommand.js")).createSelfHostUpdateCommand,
+    },
+    {
+        name: "context",
+        aliases: ["ctx"],
+        description: "Manage the active entity context (auto-injects collection/ID)",
+        loader: async () => (await import("./createContextCommand.js")).createContextCommand,
+    },
+    {
+        name: "completions",
+        aliases: ["completion"],
+        description: "Generate shell completion script (bash/zsh/fish)",
+        loader: async () => (await import("./createCompletionsCommand.js")).createCompletionsCommand,
+    },
+    {
+        name: "alias",
+        description: "Manage custom command aliases",
+        loader: async () => (await import("./createAliasCommand.js")).createAliasCommand,
+    },
+    {
+        name: "config",
+        description: "Manage default CLI options stored in ~/.config/ayoune/config.json",
+        loader: async () => (await import("./createConfigCommand.js")).createConfigCommand,
+    },
+    {
+        name: "login",
+        aliases: ["auth"],
+        description: "Authenticate with the aYOUne platform",
+        loader: async () => (await import("./createLoginCommand.js")).createLoginCommand,
+    },
+];
+/**
+ * Look up a command spec by name OR alias. Used for resolving the user's
+ * argv[2] before deciding which loader to fire.
+ */
+export function findCommandSpec(nameOrAlias) {
+    return COMMAND_REGISTRY.find((spec) => { var _a, _b; return spec.name === nameOrAlias || ((_b = (_a = spec.aliases) === null || _a === void 0 ? void 0 : _a.includes(nameOrAlias)) !== null && _b !== void 0 ? _b : false); });
+}
+/**
+ * Register a lightweight stub (name + aliases + description, no options, no
+ * action) for every command. Used to populate `ay --help` output without
+ * loading any command modules.
+ *
+ * The stub's action is intentionally empty: in help mode commander never
+ * invokes it, and on the lazy path we replace the stub with the real command
+ * before parsing.
+ */
+export function registerStubsForHelp(program) {
+    for (const spec of COMMAND_REGISTRY) {
+        const cmd = program.command(spec.name).description(spec.description);
+        if (spec.aliases) {
+            for (const alias of spec.aliases)
+                cmd.alias(alias);
+        }
+    }
+}

package/lib/commands/aggregate/_shared.js

@@ -0,0 +1,21 @@
+// Helpers shared across all `ay aggregate` subcommands. Kept in their own
+// module so each subcommand file can import only what it needs and the wizard
+// stage builders don't pollute the cold-start path of `ay agg run`.
+/**
+ * Aggregation API responses come in two shapes depending on the route:
+ *
+ *   - `/aggregation/{model}` returns a raw array of documents
+ *   - `/aggregation/queries/execute/{id}` returns `{ payload, meta }`
+ *
+ * Normalize both into the `{ payload, meta }` shape that
+ * `handleResponseFormatOptions` expects, so each subcommand can pipe straight
+ * to it without per-call branching.
+ */
+export function wrapAggResult(res) {
+    if (Array.isArray(res)) {
+        return { payload: res, meta: { resultCount: res.length } };
+    }
+    if ((res === null || res === void 0 ? void 0 : res.payload) !== undefined)
+        return res;
+    return { payload: res, meta: {} };
+}