@tolinax/ayoune-cli 2026.2.1 → 2026.2.3

package/lib/commands/createAiCommand.js

@@ -0,0 +1,188 @@
+import { apiCallHandler } from "../api/apiCallHandler.js";
+import { api } from "../api/apiClient.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";
+const AI_HOST = "ai.ayoune.app";
+export function createAiCommand(program) {
+    const ai = program
+        .command("ai")
+        .description("Interact with aYOUne AI services");
+    // ay ai actions — list all AI endpoints
+    ai.command("actions")
+        .description("List all registered AI API actions")
+        .action(async () => {
+        try {
+            const opts = { ...program.opts() };
+            spinner.start({ text: "Fetching AI actions...", color: "magenta" });
+            const res = await apiCallHandler("config", "ayouneapiactions", "get", null, {
+                q: "ai",
+                limit: 200,
+                responseFormat: "json",
+            });
+            if (!(res === null || res === void 0 ? void 0 : res.payload)) {
+                spinner.error({ text: "No AI actions found" });
+                return;
+            }
+            const actions = (Array.isArray(res.payload) ? res.payload : [])
+                .filter((a) => a.nameSpace === "ai" && !a.deprecated)
+                .map((a) => ({
+                operationId: a.operationId || "",
+                method: (a.method || "GET").toUpperCase(),
+                endpoint: a.endpoint || "",
+                description: a.shortDescription || a.description || "",
+            }));
+            const formattedRes = {
+                payload: actions,
+                meta: { responseTime: 0, pageInfo: { totalEntries: actions.length, page: 1, totalPages: 1 } },
+            };
+            handleResponseFormatOptions(opts, formattedRes);
+            spinner.success({ text: `Found ${actions.length} AI actions` });
+            spinner.stop();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to fetch AI actions" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay ai conversations — list AI conversations
+    ai.command("conversations")
+        .description("List AI conversations")
+        .option("-l, --limit <number>", "Limit", parseInt, 20)
+        .option("-p, --page <number>", "Page", parseInt, 1)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching AI conversations...", color: "magenta" });
+            const res = await apiCallHandler("ai", "conversations", "get", null, {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            });
+            const { plainResult, result, content } = 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: `Got ${total} AI conversations` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("ai-conversations", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list conversations" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay ai prompts — list AI prompt templates
+    ai.command("prompts")
+        .description("List AI prompt templates")
+        .option("-l, --limit <number>", "Limit", parseInt, 20)
+        .option("-p, --page <number>", "Page", parseInt, 1)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching AI prompts...", color: "magenta" });
+            const res = await apiCallHandler("ai", "prompts", "get", null, {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            });
+            const { plainResult, result, content } = 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: `Got ${total} AI prompts` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("ai-prompts", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to list prompts" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay ai ask <prompt> — send a prompt to AI
+    ai.command("ask <prompt...>")
+        .description("Send a prompt to aYOUne AI")
+        .option("--conversation <id>", "Continue an existing conversation")
+        .option("--model <model>", "AI model to use")
+        .action(async (promptWords, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const prompt = promptWords.join(" ");
+            spinner.start({ text: "Sending prompt to AI...", color: "magenta" });
+            const body = { prompt };
+            if (opts.conversation)
+                body.conversationId = opts.conversation;
+            if (opts.model)
+                body.model = opts.model;
+            const res = await apiCallHandler("ai", "ask", "post", body, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            });
+            const { plainResult, result, content } = handleResponseFormatOptions(opts, res);
+            spinner.success({ text: "AI response received" });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("ai-ask", opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "AI request failed" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay ai generate <type> <prompt> — generate content
+    ai.command("generate <type> <prompt...>")
+        .description("Generate content (text, image, video)")
+        .addHelpText("after", `
+Types: text, image, video
+
+Examples:
+  ay ai generate text "Write a product description for..."
+  ay ai generate image "A modern office building"`)
+        .action(async (type, promptWords, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const prompt = promptWords.join(" ");
+            const typeHostMap = {
+                text: "text-generation",
+                image: "image-generation",
+                video: "video-generation",
+            };
+            const host = typeHostMap[type];
+            if (!host) {
+                spinner.error({ text: `Unknown type: ${type}. Use: text, image, video` });
+                process.exit(EXIT_GENERAL_ERROR);
+            }
+            spinner.start({ text: `Generating ${type}...`, color: "magenta" });
+            const response = await api({
+                baseURL: `https://${host}.ayoune.app`,
+                method: "post",
+                url: "/generate",
+                data: { prompt },
+                params: {
+                    responseFormat: opts.responseFormat,
+                    verbosity: opts.verbosity,
+                },
+                headers: {
+                    Authorization: `Bearer ${localStorage.getItem("token")}`,
+                },
+            });
+            const res = response.data;
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `${type} generation complete` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile(`ai-generate-${type}`, opts, res);
+        }
+        catch (e) {
+            spinner.error({ text: e.message || `${type} generation failed` });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createAliasCommand.js

@@ -0,0 +1,106 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import path from "path";
+import os from "os";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+import { spinner } from "../../index.js";
+const ALIASES_PATH = path.join(os.homedir(), ".config", "ayoune", "aliases.json");
+export function loadAliases() {
+    if (!existsSync(ALIASES_PATH)) {
+        return {};
+    }
+    try {
+        return JSON.parse(readFileSync(ALIASES_PATH, "utf-8"));
+    }
+    catch (_a) {
+        return {};
+    }
+}
+function saveAliases(aliases) {
+    const dir = path.dirname(ALIASES_PATH);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(ALIASES_PATH, JSON.stringify(aliases, null, 2), "utf-8");
+}
+export function createAliasCommand(program) {
+    const alias = program
+        .command("alias")
+        .description("Manage custom command aliases")
+        .addHelpText("after", `
+Examples:
+  ay alias set ll "list leads"       Create alias 'll' for 'list leads'
+  ay alias list                      Show all custom aliases
+  ay alias remove ll                 Remove the 'll' alias`);
+    alias
+        .command("set <name> <command>")
+        .description("Create or update a custom alias")
+        .action((name, command) => {
+        try {
+            const aliases = loadAliases();
+            aliases[name] = command;
+            saveAliases(aliases);
+            spinner.success({ text: `Alias '${name}' set to '${command}'` });
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to save alias" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+    alias
+        .command("list")
+        .description("List all custom aliases")
+        .action(() => {
+        const aliases = loadAliases();
+        const entries = Object.entries(aliases);
+        if (entries.length === 0) {
+            console.log("No custom aliases defined.");
+            return;
+        }
+        for (const [name, command] of entries) {
+            console.log(`  ${name} -> ${command}`);
+        }
+    });
+    alias
+        .command("remove <name>")
+        .description("Remove a custom alias")
+        .action((name) => {
+        try {
+            const aliases = loadAliases();
+            if (!(name in aliases)) {
+                spinner.error({ text: `Alias '${name}' not found` });
+                process.exit(EXIT_MISUSE);
+            }
+            delete aliases[name];
+            saveAliases(aliases);
+            spinner.success({ text: `Alias '${name}' removed` });
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to remove alias" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}
+export function registerUserAliases(program) {
+    const aliases = loadAliases();
+    for (const [name, command] of Object.entries(aliases)) {
+        // Check if we'd conflict with a built-in command
+        const existing = program.commands.find((cmd) => cmd.name() === name || cmd.aliases().includes(name));
+        if (existing)
+            continue;
+        program
+            .command(name)
+            .description(`Alias for '${command}'`)
+            .allowUnknownOption()
+            .allowExcessArguments()
+            .action(async (...args) => {
+            // Re-parse with the aliased command substituted in
+            const argv = process.argv.slice(0, 2).concat(command.split(/\s+/));
+            // Append any extra args passed after the alias
+            const extraArgs = args.slice(0, -1); // last arg is the Command object
+            if (Array.isArray(extraArgs[0])) {
+                argv.push(...extraArgs[0]);
+            }
+            program.parse(argv);
+        });
+    }
+}

package/lib/commands/createAuditCommand.js

@@ -0,0 +1,49 @@
+import { Argument } from "commander";
+import { localStorage } from "../helpers/localStorage.js";
+import { handleAuditOperation } from "../operations/handleAuditOperation.js";
+import { promptAudits } from "../prompts/promptAudits.js";
+import { handleSingleAuditOperation } from "../operations/handleSingleAuditOperation.js";
+import yaml from "js-yaml";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+export function createAuditCommand(program) {
+    program
+        .command("audit")
+        .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 to get the audit from").default(localStorage.getItem("lastId"), `The last used id (${localStorage.getItem("lastId")})`))
+        .alias("history")
+        .description("View the change history of an entry")
+        .addHelpText("after", `
+Examples:
+  ay audit contacts 64a1b2c3d4e5     View audit trail for a contact
+  ay history                          View audit for last used entry`)
+        .action(async (collection, id, options) => {
+        try {
+            if (!collection) {
+                spinner.error({ text: "Missing required argument: collection. Run a list or get command first, or provide it explicitly." });
+                process.exit(EXIT_MISUSE);
+            }
+            if (!id) {
+                spinner.error({ text: "Missing required argument: id. Provide an entry ID explicitly." });
+                process.exit(EXIT_MISUSE);
+            }
+            const opts = { ...program.opts(), ...options };
+            const { data, content, result, meta } = await handleAuditOperation(collection, id, {
+                ...opts,
+            });
+            if (!process.stdin.isTTY) {
+                spinner.error({ text: "The audit command requires an interactive terminal for audit selection" });
+                process.exit(EXIT_MISUSE);
+            }
+            const selectedAudit = await promptAudits(result);
+            const { singleData, singleContent, singleResult, singleMeta } = await handleSingleAuditOperation(collection, id, selectedAudit, {
+                ...opts,
+            });
+            console.log(yaml.dump(singleContent));
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

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);
+        }
+    });
+}