@tolinax/ayoune-cli 2026.2.2 → 2026.2.3

package/lib/commands/createBatchCommand.js

@@ -0,0 +1,304 @@
+import chalk from "chalk";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { apiCallHandler } from "../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../helpers/handleResponseFormatOptions.js";
+import { handleDeleteSingleOperation } from "../operations/handleDeleteSingleOperation.js";
+import { saveFile } from "../helpers/saveFile.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString("utf-8").trim();
+}
+function parseIds(input) {
+    return input
+        .split(/[,\n]/)
+        .map((id) => id.trim())
+        .filter(Boolean);
+}
+export function createBatchCommand(program) {
+    const batch = program
+        .command("batch")
+        .description("Run bulk operations on multiple entries (for scripts and AI agents)");
+    // ay batch get <collection> <ids>
+    batch
+        .command("get <collection> <ids>")
+        .description("Get multiple entries by comma-separated IDs")
+        .addHelpText("after", `
+Examples:
+  ay batch get contacts id1,id2,id3
+  echo "id1,id2,id3" | ay batch get contacts --stdin`)
+        .option("--stdin", "Read IDs from stdin")
+        .action(async (collection, ids, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            let idList = parseIds(ids);
+            if (opts.stdin && !process.stdin.isTTY) {
+                const stdinIds = parseIds(await readStdin());
+                idList.push(...stdinIds);
+            }
+            if (idList.length === 0) {
+                spinner.error({ text: "No IDs provided" });
+                process.exit(EXIT_MISUSE);
+            }
+            spinner.start({ text: `Fetching ${idList.length} entries from ${collection}...`, color: "magenta" });
+            const results = [];
+            let errorCount = 0;
+            for (const id of idList) {
+                try {
+                    const res = await apiCallHandler(module.module, `${collection.toLowerCase()}/${id}`, "get", null, { responseFormat: "json" });
+                    if (res === null || res === void 0 ? void 0 : res.payload)
+                        results.push(res.payload);
+                }
+                catch (_a) {
+                    errorCount++;
+                }
+            }
+            const res = {
+                payload: results,
+                meta: { pageInfo: { totalEntries: results.length, page: 1, totalPages: 1 } },
+            };
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Fetched ${results.length}/${idList.length} entries` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("batch-get", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Batch get failed" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay batch delete <collection> <ids>
+    batch
+        .command("delete <collection> <ids>")
+        .alias("rm")
+        .description("Delete multiple entries by comma-separated IDs")
+        .addHelpText("after", `
+Examples:
+  ay batch delete contacts id1,id2,id3 --force
+  echo "id1,id2" | ay batch delete contacts --stdin --force`)
+        .option("--stdin", "Read IDs from stdin")
+        .action(async (collection, ids, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            let idList = parseIds(ids);
+            if (opts.stdin && !process.stdin.isTTY) {
+                const stdinIds = parseIds(await readStdin());
+                idList.push(...stdinIds);
+            }
+            if (idList.length === 0) {
+                spinner.error({ text: "No IDs provided" });
+                process.exit(EXIT_MISUSE);
+            }
+            // Confirmation
+            if (!opts.force && process.stdin.isTTY) {
+                const inquirer = (await import("inquirer")).default;
+                const { confirmed } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "confirmed",
+                        message: `Delete ${idList.length} entries from ${collection}?`,
+                        default: false,
+                    },
+                ]);
+                if (!confirmed) {
+                    console.error(chalk.yellow("  Aborted."));
+                    return;
+                }
+            }
+            spinner.start({ text: `Deleting ${idList.length} entries from ${collection}...`, color: "magenta" });
+            let successCount = 0;
+            let errorCount = 0;
+            for (const id of idList) {
+                try {
+                    await handleDeleteSingleOperation(module.module, collection, id, opts);
+                    successCount++;
+                }
+                catch (_a) {
+                    errorCount++;
+                }
+            }
+            spinner.success({ text: `Deleted ${successCount}/${idList.length} entries from ${collection}` });
+            spinner.stop();
+            if (errorCount > 0)
+                process.exit(EXIT_GENERAL_ERROR);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Batch delete failed" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay batch update <collection> --body-file <file>
+    batch
+        .command("update <collection>")
+        .description("Update multiple entries from a JSON array")
+        .addHelpText("after", `
+Expects a JSON array where each object has an _id field.
+
+Examples:
+  ay batch update contacts --body '[{"_id":"id1","status":"active"},{"_id":"id2","status":"inactive"}]'
+  ay batch update contacts --body-file updates.json
+  cat updates.json | ay batch update contacts --body-stdin`)
+        .option("--body <json>", "JSON array of entries to update")
+        .option("--body-file <path>", "Read entries from file")
+        .option("--body-stdin", "Read entries from stdin")
+        .action(async (collection, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            let entries = [];
+            if (opts.body) {
+                try {
+                    entries = 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 {
+                    entries = 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 stdinContent = await readStdin();
+                if (stdinContent) {
+                    try {
+                        entries = JSON.parse(stdinContent);
+                    }
+                    catch (_c) {
+                        spinner.error({ text: "Invalid JSON from stdin" });
+                        process.exit(EXIT_MISUSE);
+                    }
+                }
+            }
+            if (!Array.isArray(entries) || entries.length === 0) {
+                spinner.error({ text: "Provide a JSON array of entries with _id fields" });
+                process.exit(EXIT_MISUSE);
+            }
+            spinner.start({ text: `Updating ${entries.length} entries in ${collection}...`, color: "magenta" });
+            let successCount = 0;
+            let errorCount = 0;
+            for (const entry of entries) {
+                if (!entry._id) {
+                    errorCount++;
+                    continue;
+                }
+                try {
+                    await apiCallHandler(module.module, collection.toLowerCase(), "put", entry, { responseFormat: "json" });
+                    successCount++;
+                }
+                catch (_d) {
+                    errorCount++;
+                }
+            }
+            spinner.success({ text: `Updated ${successCount}/${entries.length} entries in ${collection}` });
+            spinner.stop();
+            if (errorCount > 0)
+                process.exit(EXIT_GENERAL_ERROR);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Batch update failed" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay batch create <collection> --body-file <file>
+    batch
+        .command("create <collection>")
+        .description("Create multiple entries from a JSON array")
+        .addHelpText("after", `
+Expects a JSON array of objects to create.
+
+Examples:
+  ay batch create contacts --body '[{"firstName":"A"},{"firstName":"B"}]'
+  ay batch create contacts --body-file entries.json`)
+        .option("--body <json>", "JSON array of entries to create")
+        .option("--body-file <path>", "Read entries from file")
+        .option("--body-stdin", "Read entries from stdin")
+        .action(async (collection, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            let entries = [];
+            if (opts.body) {
+                try {
+                    entries = 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 {
+                    entries = 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 stdinContent = await readStdin();
+                if (stdinContent) {
+                    try {
+                        entries = JSON.parse(stdinContent);
+                    }
+                    catch (_c) {
+                        spinner.error({ text: "Invalid JSON from stdin" });
+                        process.exit(EXIT_MISUSE);
+                    }
+                }
+            }
+            if (!Array.isArray(entries) || entries.length === 0) {
+                spinner.error({ text: "Provide a JSON array of entries to create" });
+                process.exit(EXIT_MISUSE);
+            }
+            spinner.start({ text: `Creating ${entries.length} entries in ${collection}...`, color: "magenta" });
+            let successCount = 0;
+            let errorCount = 0;
+            const created = [];
+            for (const entry of entries) {
+                try {
+                    const res = await apiCallHandler(module.module, collection.toLowerCase(), "post", entry, { responseFormat: "json" });
+                    if (res === null || res === void 0 ? void 0 : res.payload)
+                        created.push(res.payload);
+                    successCount++;
+                }
+                catch (_d) {
+                    errorCount++;
+                }
+            }
+            const res = {
+                payload: created,
+                meta: { pageInfo: { totalEntries: created.length, page: 1, totalPages: 1 } },
+            };
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Created ${successCount}/${entries.length} entries in ${collection}` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("batch-create", opts, res);
+            if (errorCount > 0)
+                process.exit(EXIT_GENERAL_ERROR);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Batch create failed" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createCompletionsCommand.js

@@ -3,7 +3,7 @@ _ay_completions() {
   local cur commands
   COMPREPLY=()
   cur="\${COMP_WORDS[COMP_CWORD]}"
-  commands="modules list get edit copy create describe audit stream events storage whoami login logout completions alias config actions exec ai services deploy monitor"
+  commands="modules list get edit copy create describe audit stream events storage whoami login logout completions alias config actions exec ai services deploy monitor delete update batch search webhooks jobs"
 
   if [[ \${COMP_CWORD} -eq 1 ]]; then
     COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
@@ -38,6 +38,12 @@ _ay() {
     'services:Discover and manage platform services'
     'deploy:Manage deployments and pipelines'
     'monitor:Monitor platform activity, logs, and alerts'
+    'delete:Delete entries from a collection'
+    'update:Update an entry non-interactively'
+    'batch:Run bulk operations on multiple entries'
+    'search:Search entries with advanced filtering'
+    'webhooks:Manage webhooks and event subscriptions'
+    'jobs:Manage background jobs and automations'
   )
   _describe 'command' commands
 }
@@ -67,6 +73,12 @@ complete -c ay -n '__fish_use_subcommand' -a ai -d 'AI assistant commands'
 complete -c ay -n '__fish_use_subcommand' -a services -d 'Discover and manage platform services'
 complete -c ay -n '__fish_use_subcommand' -a deploy -d 'Manage deployments and pipelines'
 complete -c ay -n '__fish_use_subcommand' -a monitor -d 'Monitor platform activity, logs, and alerts'
+complete -c ay -n '__fish_use_subcommand' -a delete -d 'Delete entries from a collection'
+complete -c ay -n '__fish_use_subcommand' -a update -d 'Update an entry non-interactively'
+complete -c ay -n '__fish_use_subcommand' -a batch -d 'Run bulk operations on multiple entries'
+complete -c ay -n '__fish_use_subcommand' -a search -d 'Search entries with advanced filtering'
+complete -c ay -n '__fish_use_subcommand' -a webhooks -d 'Manage webhooks and event subscriptions'
+complete -c ay -n '__fish_use_subcommand' -a jobs -d 'Manage background jobs and automations'
 ###-end-ay-completions-###`;
 const POWERSHELL_COMPLETION = `###-begin-ay-completions-###
 Register-ArgumentCompleter -CommandName ay -ScriptBlock {
@@ -95,6 +107,12 @@ Register-ArgumentCompleter -CommandName ay -ScriptBlock {
     @{ Name = 'services'; Description = 'Discover and manage platform services' }
     @{ Name = 'deploy'; Description = 'Manage deployments and pipelines' }
     @{ Name = 'monitor'; Description = 'Monitor platform activity, logs, and alerts' }
+    @{ Name = 'delete'; Description = 'Delete entries from a collection' }
+    @{ Name = 'update'; Description = 'Update an entry non-interactively' }
+    @{ Name = 'batch'; Description = 'Run bulk operations on multiple entries' }
+    @{ Name = 'search'; Description = 'Search entries with advanced filtering' }
+    @{ Name = 'webhooks'; Description = 'Manage webhooks and event subscriptions' }
+    @{ Name = 'jobs'; Description = 'Manage background jobs and automations' }
   )
   $commands | Where-Object { $_.Name -like "$wordToComplete*" } | ForEach-Object {
     [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ParameterValue', $_.Description)

package/lib/commands/createDeleteCommand.js

@@ -0,0 +1,98 @@
+import { Argument } from "commander";
+import chalk from "chalk";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { handleDeleteSingleOperation } from "../operations/handleDeleteSingleOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+export function createDeleteCommand(program) {
+    program
+        .command("delete")
+        .alias("rm")
+        .description("Delete one or more entries from a collection")
+        .addHelpText("after", `
+Examples:
+  ay delete contacts 64a1b2c3d4e5                    Delete a single contact
+  ay rm contacts 64a1b2c3d4e5 --force                Skip confirmation
+  ay delete contacts id1,id2,id3                      Delete multiple entries
+  echo "id1,id2" | ay delete contacts --ids-stdin     Read IDs from stdin`)
+        .addArgument(new Argument("[collection]", "The collection to use").default(localStorage.getItem("lastCollection"), `The last used collection (${localStorage.getItem("lastCollection")})`))
+        .addArgument(new Argument("[ids]", "Comma-separated ID(s) to delete").default(localStorage.getItem("lastId"), `The last used id (${localStorage.getItem("lastId")})`))
+        .option("--ids-stdin", "Read IDs from stdin (one per line or comma-separated)")
+        .action(async (collection, ids, 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);
+            }
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            // Collect IDs from argument and/or stdin
+            let idList = [];
+            if (ids) {
+                idList = ids.split(",").map((id) => id.trim()).filter(Boolean);
+            }
+            if (opts.idsStdin && !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) {
+                    const stdinIds = stdinContent
+                        .split(/[,\n]/)
+                        .map((id) => id.trim())
+                        .filter(Boolean);
+                    idList.push(...stdinIds);
+                }
+            }
+            if (idList.length === 0) {
+                spinner.error({ text: "No IDs provided. Pass IDs as argument or via --ids-stdin." });
+                process.exit(EXIT_MISUSE);
+            }
+            // Confirmation prompt (unless --force)
+            if (!opts.force && process.stdin.isTTY) {
+                const inquirer = (await import("inquirer")).default;
+                const { confirmed } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "confirmed",
+                        message: `Delete ${idList.length} entry/entries from ${collection}?`,
+                        default: false,
+                    },
+                ]);
+                if (!confirmed) {
+                    spinner.stop();
+                    console.error(chalk.yellow("  Aborted."));
+                    return;
+                }
+            }
+            // Execute deletions
+            let successCount = 0;
+            let errorCount = 0;
+            for (const id of idList) {
+                try {
+                    await handleDeleteSingleOperation(module.module, collection, id, opts);
+                    successCount++;
+                }
+                catch (e) {
+                    errorCount++;
+                    spinner.error({ text: `Failed to delete ${id}: ${e.message}` });
+                }
+            }
+            if (idList.length > 1) {
+                spinner.success({ text: `Deleted ${successCount}/${idList.length} entries from ${collection}` });
+                spinner.stop();
+            }
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+            if (errorCount > 0) {
+                process.exit(EXIT_GENERAL_ERROR);
+            }
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createJobsCommand.js

@@ -0,0 +1,168 @@
+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 createJobsCommand(program) {
+    const jobs = program
+        .command("jobs")
+        .alias("j")
+        .description("Manage background jobs, automations, and triggers");
+    // ay jobs list
+    jobs
+        .command("list")
+        .alias("ls")
+        .description("List scheduled/queued jobs")
+        .option("--status <status>", "Filter: active, waiting, completed, failed, delayed")
+        .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 jobs...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.status)
+                params.status = opts.status;
+            const res = await apiCallHandler("general", "agendajobs", "get", null, params);
+            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} jobs` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("jobs-list", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list jobs" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay jobs triggers
+    jobs
+        .command("triggers")
+        .description("List automation triggers")
+        .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 triggers...", color: "magenta" });
+            const res = await apiCallHandler("automation", "triggers", "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} triggers` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("jobs-triggers", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list triggers" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay jobs automations
+    jobs
+        .command("automations")
+        .alias("auto")
+        .description("List automations")
+        .option("--active", "Show only active automations")
+        .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 automations...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.active)
+                params.active = "true";
+            const res = await apiCallHandler("automation", "automations", "get", null, params);
+            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} automations` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("jobs-automations", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list automations" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay jobs execute <automationId>
+    jobs
+        .command("execute <automationId>")
+        .alias("run")
+        .description("Execute an automation immediately")
+        .option("--body <json>", "Optional payload as JSON")
+        .action(async (automationId, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: `Executing automation ${automationId}...`, color: "magenta" });
+            let body = null;
+            if (opts.body) {
+                try {
+                    body = JSON.parse(opts.body);
+                }
+                catch (_a) {
+                    spinner.error({ text: "Invalid JSON in --body" });
+                    process.exit(EXIT_GENERAL_ERROR);
+                }
+            }
+            const res = await apiCallHandler("automation", `automations/${automationId}/execute`, "post", body, { responseFormat: opts.responseFormat });
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `Automation ${automationId} executed` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to execute automation" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay jobs notifications
+    jobs
+        .command("notifications")
+        .alias("notify")
+        .description("List recent notifications")
+        .option("-l, --limit <number>", "Limit results", parseInt, 25)
+        .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 notifications...", color: "magenta" });
+            const res = await apiCallHandler("general", "notifications", "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} notifications` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("jobs-notifications", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list notifications" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createProgram.js

@@ -30,6 +30,12 @@ import { enableJsonErrors } from "../api/handleAPIError.js";
 import { createServicesCommand } from "./createServicesCommand.js";
 import { createDeployCommand } from "./createDeployCommand.js";
 import { createMonitorCommand } from "./createMonitorCommand.js";
+import { createDeleteCommand } from "./createDeleteCommand.js";
+import { createUpdateCommand } from "./createUpdateCommand.js";
+import { createBatchCommand } from "./createBatchCommand.js";
+import { createSearchCommand } from "./createSearchCommand.js";
+import { createWebhooksCommand } from "./createWebhooksCommand.js";
+import { createJobsCommand } from "./createJobsCommand.js";
 import { localStorage } from "../helpers/localStorage.js";
 import { login } from "../api/login.js";
 import { loadConfig } from "../helpers/configLoader.js";
@@ -79,6 +85,12 @@ export function createProgram(program) {
     createServicesCommand(program);
     createDeployCommand(program);
     createMonitorCommand(program);
+    createDeleteCommand(program);
+    createUpdateCommand(program);
+    createBatchCommand(program);
+    createSearchCommand(program);
+    createWebhooksCommand(program);
+    createJobsCommand(program);
     createCompletionsCommand(program);
     createAliasCommand(program);
     createConfigCommand(program);

package/lib/commands/createSearchCommand.js

@@ -0,0 +1,101 @@
+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 } from "../exitCodes.js";
+export function createSearchCommand(program) {
+    program
+        .command("search <collection> [query]")
+        .alias("find")
+        .description("Search entries in a collection with advanced filtering")
+        .addHelpText("after", `
+Examples:
+  ay search contacts "John"                       Full-text search
+  ay search contacts --filter "status=active"      Filter by field
+  ay search products --filter "price>100"          Comparison filter
+  ay search orders --filter "status=paid" --sort "-createdAt"
+  ay search leads --filter "source=website,stage=qualified" --fields "name,email,stage"
+  ay find invoices --filter "total>500" --count    Just count matches`)
+        .option("--filter <filters>", "Comma-separated key=value filters (supports =, !=, >, <, >=, <=)")
+        .option("--fields <fields>", "Comma-separated fields to return (projection)")
+        .option("--sort <field>", "Sort by field (prefix with - for descending)", "-createdAt")
+        .option("--count", "Only return count of matching entries", false)
+        .option("-l, --limit <number>", "Limit results", parseInt, 25)
+        .option("-p, --page <number>", "Page number", parseInt, 1)
+        .action(async (collection, query, options) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        try {
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            spinner.start({ text: `Searching ${collection}...`, color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                sort: opts.sort,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            };
+            if (query) {
+                params.q = query;
+            }
+            if (opts.fields) {
+                params.fields = opts.fields;
+            }
+            // Parse filters into query params
+            if (opts.filter) {
+                const filters = opts.filter.split(",");
+                for (const f of filters) {
+                    const match = f.match(/^(\w+)(!=|>=|<=|>|<|=)(.+)$/);
+                    if (match) {
+                        const [, key, op, value] = match;
+                        if (op === "=") {
+                            params[key] = value;
+                        }
+                        else if (op === "!=") {
+                            params[`${key}[ne]`] = value;
+                        }
+                        else if (op === ">") {
+                            params[`${key}[gt]`] = value;
+                        }
+                        else if (op === "<") {
+                            params[`${key}[lt]`] = value;
+                        }
+                        else if (op === ">=") {
+                            params[`${key}[gte]`] = value;
+                        }
+                        else if (op === "<=") {
+                            params[`${key}[lte]`] = value;
+                        }
+                    }
+                }
+            }
+            const res = await apiCallHandler(module.module, collection.toLowerCase(), "get", null, params);
+            if (opts.count) {
+                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: `${total} matching entries in ${collection}` });
+                spinner.stop();
+                console.log(total);
+                return;
+            }
+            handleResponseFormatOptions(opts, res);
+            const total = (_f = (_e = (_d = res.meta) === null || _d === void 0 ? void 0 : _d.pageInfo) === null || _e === void 0 ? void 0 : _e.totalEntries) !== null && _f !== void 0 ? _f : 0;
+            const page = (_j = (_h = (_g = res.meta) === null || _g === void 0 ? void 0 : _g.pageInfo) === null || _h === void 0 ? void 0 : _h.page) !== null && _j !== void 0 ? _j : 1;
+            const totalPages = (_m = (_l = (_k = res.meta) === null || _k === void 0 ? void 0 : _k.pageInfo) === null || _l === void 0 ? void 0 : _l.totalPages) !== null && _m !== void 0 ? _m : 1;
+            spinner.success({
+                text: `Found ${total} entries in ${collection} (page ${page}/${totalPages})`,
+            });
+            spinner.stop();
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+            if (opts.save)
+                await saveFile("search", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Search failed" });
+            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);
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tolinax/ayoune-cli",
-  "version": "2026.2.2",
+  "version": "2026.2.3",
   "description": "",
   "type": "module",
   "main": "./index.js",