@tolinax/ayoune-cli 2026.6.0 → 2026.7.0

package/lib/commands/createDbCommand.js

@@ -1,14 +1,11 @@
 import chalk from "chalk";
+import inquirer from "inquirer";
 import { spinner } from "../../index.js";
 import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
 import { cliError } from "../helpers/cliError.js";
 import { handleResponseFormatOptions } from "../helpers/handleResponseFormatOptions.js";
-import { executeCopy, getDbStats } from "../db/copyEngine.js";
-import { addCopyConfig, loadCopyConfigs, removeCopyConfig, getDecryptedConfig, updateCopyConfigLastRun, maskUri, } from "../db/copyConfigStore.js";
-import { isCronDue, getNextRun, validateCron } from "../db/cronMatcher.js";
-function generateId() {
-    return Math.random().toString(36).substring(2, 10) + Date.now().toString(36);
-}
+import { apiCallHandler } from "../api/apiCallHandler.js";
+import { writeToTarget, getDbStats } from "../db/copyEngine.js";
 function formatBytes(bytes) {
     if (bytes === 0)
         return "0 B";
@@ -16,242 +13,232 @@ function formatBytes(bytes) {
     const i = Math.floor(Math.log(bytes) / Math.log(1024));
     return (bytes / Math.pow(1024, i)).toFixed(1) + " " + units[i];
 }
+function maskUri(uri) {
+    return uri.replace(/:\/\/([^:]+):([^@]+)@/, "://***:***@");
+}
 export function createDbCommand(program) {
     const db = program
         .command("db")
-        .description("MongoDB database operations (copy, stats, scheduled replication)")
+        .description("Copy query results to external databases, manage targets")
         .addHelpText("after", `
 Examples:
-  ay db copy --from "mongodb://..." --to "mongodb://..." --collections "users,orders"
-  ay db copy --from "mongodb://..." --to "mongodb://..." --all --schedule "0 */6 * * *"
-  ay db schedules list
-  ay db stats "mongodb+srv://..."`);
-    // ─── ay db copy ─────────────────────────────────────────────────
-    db.command("copy")
-        .description("Copy data between MongoDB instances")
-        .requiredOption("--from <uri>", "Source MongoDB connection URI")
-        .requiredOption("--to <uri>", "Target MongoDB connection URI")
-        .option("--collections <list>", "Comma-separated collection names")
-        .option("--all", "Copy all collections")
-        .option("--query <json>", "JSON filter query for source documents")
-        .option("--drop", "Drop target collection before copying")
-        .option("--upsert", "Upsert documents by _id (idempotent, safe to re-run)")
-        .option("--batch-size <number>", "Documents per batch", parseInt, 1000)
-        .option("--schedule <cron>", "Save as scheduled copy (cron expression) instead of executing")
+  ay db copy                          Interactive: pick target, pick query
+  ay db copy my-local-db              Pick query for target "my-local-db"
+  ay db copy my-local-db active-users Fully autonomous: run query, write to target
+  ay db targets list                  List configured targets
+  ay db targets add                   Add a new target
+  ay db stats                         Show aYOUne database stats`);
+    // ─── ay db copy [target] [query] ───────────────────────────────
+    db.command("copy [target] [query]")
+        .description("Run a saved query and write results to a target database")
+        .option("--collection <name>", "Override target collection name")
+        .option("--write-mode <mode>", "Override write mode (insert, upsert, replace)")
         .addHelpText("after", `
+Runs a saved aggregation query and writes the results to a pre-configured target.
+Both target and query are resolved by slug. If omitted, you'll be prompted to select.
+
 Examples:
-  ay db copy --from "mongodb://..." --to "mongodb://..." --collections "users,orders"
-  ay db copy --from "mongodb://..." --to "mongodb://..." --all --drop
-  ay db copy --from "mongodb://..." --to "mongodb://..." --collections "logs" --query '{"status":"active"}'
-  ay db copy --from "mongodb://..." --to "mongodb://..." --all --upsert --schedule "0 */6 * * *"`)
-        .action(async (options) => {
+  ay db copy                                 Interactive mode
+  ay db copy my-local-db                     Select query interactively
+  ay db copy my-local-db active-users        Fully autonomous
+  ay db copy my-local-db active-users --collection results --write-mode upsert`)
+        .action(async (target, query, options) => {
+        var _a;
         try {
             const opts = { ...program.opts(), ...options };
-            // Validate input
-            if (!opts.collections && !opts.all) {
-                cliError("Provide --collections or --all", EXIT_MISUSE);
+            // Step 1: Resolve target
+            let targetData;
+            if (target) {
+                targetData = await resolveTarget(target);
             }
-            if (opts.collections && opts.all) {
-                cliError("Use either --collections or --all, not both", EXIT_MISUSE);
-            }
-            if (!opts.from.startsWith("mongodb")) {
-                cliError("--from must be a MongoDB URI (mongodb:// or mongodb+srv://)", EXIT_MISUSE);
+            else {
+                if (!process.stdin.isTTY)
+                    cliError("Provide target slug or use interactive mode", EXIT_MISUSE);
+                targetData = await promptTarget();
             }
-            if (!opts.to.startsWith("mongodb")) {
-                cliError("--to must be a MongoDB URI (mongodb:// or mongodb+srv://)", EXIT_MISUSE);
+            // Step 2: Resolve query
+            let queryData;
+            if (query) {
+                queryData = await resolveQuery(query);
             }
-            let query;
-            if (opts.query) {
-                try {
-                    query = JSON.parse(opts.query);
-                }
-                catch (_a) {
-                    cliError("--query must be valid JSON", EXIT_MISUSE);
-                }
+            else {
+                if (!process.stdin.isTTY)
+                    cliError("Provide query slug or use interactive mode", EXIT_MISUSE);
+                queryData = await promptQuery();
             }
-            const collections = opts.all ? ["*"] : opts.collections.split(",").map((c) => c.trim());
-            // Schedule mode
-            if (opts.schedule) {
-                const cronError = validateCron(opts.schedule);
-                if (cronError)
-                    cliError(`Invalid cron expression: ${cronError}`, EXIT_MISUSE);
-                const config = {
-                    id: generateId(),
-                    createdAt: new Date().toISOString(),
-                    from: maskUri(opts.from),
-                    to: maskUri(opts.to),
-                    fromUri: opts.from, // Will be encrypted by addCopyConfig
-                    toUri: opts.to,
-                    collections,
-                    query,
-                    drop: opts.drop || false,
-                    upsert: opts.upsert || false,
-                    batchSize: opts.batchSize,
-                    schedule: opts.schedule,
-                };
-                addCopyConfig(config);
-                const nextRun = getNextRun(opts.schedule);
-                console.log(chalk.green(`\n  Scheduled copy saved (ID: ${config.id})`));
-                console.log(chalk.dim(`  Source: ${config.from}`));
-                console.log(chalk.dim(`  Target: ${config.to}`));
-                console.log(chalk.dim(`  Collections: ${collections.join(", ")}`));
-                console.log(chalk.dim(`  Schedule: ${opts.schedule}`));
-                if (nextRun)
-                    console.log(chalk.dim(`  Next run: ${nextRun.toISOString()}`));
-                console.log();
-                console.log(chalk.yellow("  Set up a cron job to run scheduled copies:"));
-                console.log(chalk.dim("    Linux/macOS: crontab -e → */5 * * * * ay db schedules run"));
-                console.log(chalk.dim("    Windows: schtasks /create /tn ayoune-db-sync /tr \"ay db schedules run\" /sc minute /mo 5"));
-                console.log();
+            // Step 3: Execute query via aggregation API
+            const queryId = queryData._id;
+            spinner.start({ text: `Running query "${queryData.name}"...`, color: "magenta" });
+            const aggResult = await apiCallHandler("aggregation", `queries/execute/${queryId}`, "post");
+            spinner.stop();
+            const docs = Array.isArray(aggResult) ? aggResult : ((aggResult === null || aggResult === void 0 ? void 0 : aggResult.payload) || []);
+            if (!docs.length) {
+                spinner.success({ text: "Query returned 0 results — nothing to write" });
                 return;
             }
-            // Execute copy
-            spinner.start({ text: `Copying from ${maskUri(opts.from)} to ${maskUri(opts.to)}...`, color: "cyan" });
-            const summary = await executeCopy(opts.from, opts.to, collections, {
-                query,
-                drop: opts.drop,
-                upsert: opts.upsert,
-                batchSize: opts.batchSize,
-            }, (progress) => {
-                spinner.update({
-                    text: `${progress.collection}: ${progress.copied}/${progress.total} docs${progress.errors ? chalk.red(` (${progress.errors} errors)`) : ""}`,
-                });
-            });
+            console.log(chalk.dim(`  Query returned ${docs.length} documents\n`));
+            // Step 4: Write to target
+            const collection = opts.collection || targetData.targetCollection || ((_a = queryData.name) === null || _a === void 0 ? void 0 : _a.toLowerCase().replace(/\s+/g, "_")) || "query_results";
+            const writeMode = opts.writeMode || targetData.writeMode || "insert";
+            const batchSize = targetData.batchSize || 1000;
+            spinner.start({ text: `Writing ${docs.length} docs to ${maskUri(targetData.connectionUri)}/${collection}...`, color: "cyan" });
+            const result = await writeToTarget(targetData.connectionUri, targetData.database, collection, docs, writeMode, batchSize);
             spinner.stop();
-            // Display summary
+            // Step 5: Update target status via config-api
+            try {
+                await apiCallHandler("config", `datatargets/${targetData._id}`, "put", {
+                    lastUsed: new Date().toISOString(),
+                    lastStatus: result.errors > 0 ? "failed" : "success",
+                    lastResultCount: result.written,
+                    lastError: result.errors > 0 ? `${result.errors} write errors` : undefined,
+                });
+            }
+            catch (_b) {
+                // Non-critical — don't fail the copy if status update fails
+            }
+            // Output
             const wrapped = {
-                payload: summary,
-                meta: {
-                    totalCopied: summary.totalCopied,
-                    totalErrors: summary.totalErrors,
-                    duration: summary.duration,
+                payload: {
+                    target: targetData.name,
+                    query: queryData.name,
+                    collection,
+                    writeMode,
+                    written: result.written,
+                    errors: result.errors,
+                    duration: result.duration,
                 },
+                meta: { written: result.written, errors: result.errors },
             };
             if (opts.responseFormat === "json" || opts.responseFormat === "yaml") {
                 handleResponseFormatOptions(opts, wrapped);
             }
             else {
-                console.log(chalk.cyan.bold("\n  Copy Summary\n"));
-                for (const col of summary.collections) {
-                    const icon = col.errors === 0 ? chalk.green("●") : chalk.yellow("●");
-                    console.log(`  ${icon} ${col.name}: ${col.copied} docs copied${col.errors ? chalk.red(` (${col.errors} errors)`) : ""} ${chalk.dim(`(${col.duration}ms)`)}`);
-                }
-                console.log();
-                console.log(`  ${chalk.green(summary.totalCopied + " total")}${summary.totalErrors ? `  ${chalk.red(summary.totalErrors + " errors")}` : ""} ${chalk.dim(`in ${summary.duration}ms`)}`);
-                console.log();
+                const icon = result.errors === 0 ? chalk.green("●") : chalk.yellow("●");
+                console.log(`\n  ${icon} ${result.written} docs written to ${chalk.cyan(collection)}${result.errors ? chalk.red(` (${result.errors} errors)`) : ""} ${chalk.dim(`(${result.duration}ms)`)}\n`);
             }
-            if (summary.totalErrors > 0)
+            if (result.errors > 0)
                 process.exit(EXIT_GENERAL_ERROR);
         }
         catch (e) {
             cliError(e.message || "Copy failed", EXIT_GENERAL_ERROR);
         }
     });
-    // ─── ay db schedules ────────────────────────────────────────────
-    const schedules = db.command("schedules").alias("sched").description("Manage scheduled copy jobs");
-    // ay db schedules list
-    schedules
+    // ─── ay db targets ─────────────────────────────────────────────
+    const targets = db.command("targets").alias("t").description("Manage database targets");
+    // ay db targets list
+    targets
         .command("list")
         .alias("ls")
-        .description("List all scheduled copy jobs")
+        .description("List configured database targets")
+        .option("-l, --limit <number>", "Limit results", parseInt, 50)
         .action(async (options) => {
+        var _a, _b, _c, _d, _e;
         try {
             const opts = { ...program.opts(), ...options };
-            const configs = loadCopyConfigs();
-            if (configs.length === 0) {
-                console.log(chalk.dim("\n  No scheduled copies configured.\n"));
-                return;
-            }
-            const wrapped = { payload: configs.map(displayConfig), meta: { total: configs.length } };
-            handleResponseFormatOptions(opts, wrapped);
+            spinner.start({ text: "Fetching targets...", color: "cyan" });
+            const res = await apiCallHandler("config", "datatargets", "get", null, {
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            });
+            handleResponseFormatOptions(opts, res);
+            const total = (_e = (_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 : (_d = res.payload) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0;
+            spinner.success({ text: `${total} targets configured` });
         }
         catch (e) {
-            cliError(e.message || "Failed to list schedules", EXIT_GENERAL_ERROR);
+            cliError(e.message || "Failed to list targets", EXIT_GENERAL_ERROR);
         }
     });
-    // ay db schedules remove <id>
-    schedules
-        .command("remove <id>")
-        .alias("rm")
-        .description("Remove a scheduled copy job")
-        .action(async (id) => {
-        const removed = removeCopyConfig(id);
-        if (removed) {
-            spinner.success({ text: `Schedule ${id} removed` });
+    // ay db targets add
+    targets
+        .command("add")
+        .description("Add a new database target")
+        .option("--name <name>", "Target name")
+        .option("--uri <uri>", "MongoDB connection URI")
+        .option("--database <db>", "Database name")
+        .option("--collection <col>", "Default target collection name")
+        .option("--write-mode <mode>", "Write mode: insert, upsert, replace", "insert")
+        .action(async (options) => {
+        var _a;
+        try {
+            const opts = { ...program.opts(), ...options };
+            let { name, uri, database, collection, writeMode } = opts;
+            // Interactive prompts for missing fields
+            if (!name || !uri) {
+                if (!process.stdin.isTTY)
+                    cliError("Provide --name and --uri in non-interactive mode", EXIT_MISUSE);
+                const answers = await inquirer.prompt([
+                    ...(!name ? [{ type: "input", name: "name", message: "Target name:", validate: (v) => v.length > 0 || "Required" }] : []),
+                    ...(!uri ? [{ type: "input", name: "uri", message: "MongoDB connection URI:", validate: (v) => v.startsWith("mongodb") || "Must be a MongoDB URI" }] : []),
+                    ...(!database ? [{ type: "input", name: "database", message: "Database name (leave empty for URI default):" }] : []),
+                    ...(!collection ? [{ type: "input", name: "collection", message: "Default collection name (leave empty to derive from query):" }] : []),
+                ]);
+                name = name || answers.name;
+                uri = uri || answers.uri;
+                database = database || answers.database || undefined;
+                collection = collection || answers.collection || undefined;
+            }
+            spinner.start({ text: "Creating target...", color: "cyan" });
+            const body = {
+                name,
+                type: "mongodb",
+                connectionUri: uri,
+                database: database || undefined,
+                targetCollection: collection || undefined,
+                writeMode: writeMode || "insert",
+                active: true,
+            };
+            const res = await apiCallHandler("config", "datatargets", "post", body, {
+                responseFormat: opts.responseFormat,
+            });
+            const slug = ((_a = res.payload) === null || _a === void 0 ? void 0 : _a.slug) || name;
+            spinner.success({ text: `Target "${slug}" created — use with: ay db copy ${slug}` });
         }
-        else {
-            cliError(`No schedule found with ID "${id}"`, EXIT_GENERAL_ERROR);
+        catch (e) {
+            cliError(e.message || "Failed to create target", EXIT_GENERAL_ERROR);
         }
     });
-    // ay db schedules run
-    schedules
-        .command("run")
-        .description("Execute all copy jobs that are due now")
-        .option("--id <id>", "Run a specific schedule by ID")
-        .action(async (options) => {
+    // ay db targets remove <slug>
+    targets
+        .command("remove <slug>")
+        .alias("rm")
+        .description("Remove a database target")
+        .action(async (slug, options) => {
         try {
-            const configs = loadCopyConfigs();
-            const now = new Date();
-            const toRun = options.id
-                ? configs.filter((c) => c.id === options.id)
-                : configs.filter((c) => isCronDue(c.schedule, c.lastRun, now));
-            if (toRun.length === 0) {
-                console.log(chalk.dim("\n  No copies due.\n"));
-                return;
-            }
-            console.log(chalk.cyan(`\n  Running ${toRun.length} scheduled copies...\n`));
-            for (const config of toRun) {
-                const { fromUri, toUri } = getDecryptedConfig(config);
-                console.log(chalk.dim(`  ${config.id}: ${config.from} → ${config.to}`));
-                try {
-                    spinner.start({ text: `${config.id}: copying...`, color: "cyan" });
-                    const summary = await executeCopy(fromUri, toUri, config.collections, {
-                        query: config.query,
-                        drop: config.drop,
-                        upsert: config.upsert,
-                        batchSize: config.batchSize,
-                    }, (progress) => {
-                        spinner.update({
-                            text: `${config.id}: ${progress.collection} ${progress.copied}/${progress.total}`,
-                        });
-                    });
-                    updateCopyConfigLastRun(config.id, "success");
-                    spinner.success({ text: `${config.id}: ${summary.totalCopied} docs copied${summary.totalErrors ? `, ${summary.totalErrors} errors` : ""}` });
-                }
-                catch (e) {
-                    updateCopyConfigLastRun(config.id, "failed", e.message);
-                    spinner.error({ text: `${config.id}: ${e.message}` });
-                }
-            }
-            console.log();
+            const target = await resolveTarget(slug);
+            spinner.start({ text: `Removing target "${slug}"...`, color: "cyan" });
+            await apiCallHandler("config", `datatargets/${target._id}`, "delete");
+            spinner.success({ text: `Target "${slug}" removed` });
         }
         catch (e) {
-            cliError(e.message || "Scheduled run failed", EXIT_GENERAL_ERROR);
+            cliError(e.message || "Failed to remove target", EXIT_GENERAL_ERROR);
         }
     });
-    // ─── ay db stats <uri> ──────────────────────────────────────────
-    db.command("stats <uri>")
-        .description("Show database statistics (collections, doc counts, sizes)")
+    // ─── ay db stats [uri] ─────────────────────────────────────────
+    db.command("stats [uri]")
+        .description("Show database statistics (defaults to aYOUne database)")
         .addHelpText("after", `
+Defaults to MONGO_CONNECTSTRING when no URI is given.
+
 Examples:
-  ay db stats "mongodb+srv://user:pass@cluster.mongodb.net/mydb"
-  ay db stats "mongodb://localhost:27017/testdb" -r table`)
+  ay db stats
+  ay db stats "mongodb://other/db" -r table`)
         .action(async (uri, options) => {
         try {
             const opts = { ...program.opts(), ...options };
-            if (!uri.startsWith("mongodb")) {
+            const dbUri = uri || process.env.MONGO_CONNECTSTRING || process.env.MONGODB_URI;
+            if (!dbUri) {
+                cliError("No database URI. Set MONGO_CONNECTSTRING env var or pass a URI.", EXIT_MISUSE);
+            }
+            if (!dbUri.startsWith("mongodb")) {
                 cliError("URI must start with mongodb:// or mongodb+srv://", EXIT_MISUSE);
             }
-            spinner.start({ text: `Connecting to ${maskUri(uri)}...`, color: "cyan" });
-            const stats = await getDbStats(uri);
+            spinner.start({ text: `Connecting to ${maskUri(dbUri)}...`, color: "cyan" });
+            const stats = await getDbStats(dbUri);
             spinner.stop();
             const wrapped = {
                 payload: stats,
-                meta: {
-                    database: stats.database,
-                    collectionCount: stats.collections.length,
-                    totalSize: formatBytes(stats.totalSize),
-                },
+                meta: { database: stats.database, collectionCount: stats.collections.length, totalSize: formatBytes(stats.totalSize) },
             };
             if (opts.responseFormat === "json" || opts.responseFormat === "yaml") {
                 handleResponseFormatOptions(opts, wrapped);
@@ -271,16 +258,75 @@ Examples:
         }
     });
 }
-function displayConfig(config) {
-    const nextRun = getNextRun(config.schedule);
-    return {
-        id: config.id,
-        from: config.from,
-        to: config.to,
-        collections: config.collections.join(", "),
-        schedule: config.schedule,
-        nextRun: (nextRun === null || nextRun === void 0 ? void 0 : nextRun.toISOString()) || "—",
-        lastRun: config.lastRun || "never",
-        lastStatus: config.lastStatus || "—",
-    };
+// ─── Helpers ───────────────────────────────────────────────────────
+async function resolveTarget(slugOrId) {
+    const isObjectId = /^[a-f0-9]{24}$/i.test(slugOrId);
+    if (isObjectId) {
+        const res = await apiCallHandler("config", `datatargets/${slugOrId}`, "get");
+        if (!(res === null || res === void 0 ? void 0 : res.payload))
+            cliError(`Target not found: ${slugOrId}`, EXIT_GENERAL_ERROR);
+        return res.payload;
+    }
+    // Resolve by slug
+    const res = await apiCallHandler("config", "datatargets", "get", null, { slug: slugOrId, limit: 1 });
+    const entries = res === null || res === void 0 ? void 0 : res.payload;
+    if (!entries || (Array.isArray(entries) && entries.length === 0)) {
+        cliError(`No target found with slug "${slugOrId}"`, EXIT_GENERAL_ERROR);
+    }
+    return Array.isArray(entries) ? entries[0] : entries;
+}
+async function resolveQuery(slugOrId) {
+    const isObjectId = /^[a-f0-9]{24}$/i.test(slugOrId);
+    if (isObjectId) {
+        const res = await apiCallHandler("config", `queries/${slugOrId}`, "get");
+        if (!(res === null || res === void 0 ? void 0 : res.payload))
+            cliError(`Query not found: ${slugOrId}`, EXIT_GENERAL_ERROR);
+        return res.payload;
+    }
+    const res = await apiCallHandler("config", "queries", "get", null, { slug: slugOrId, limit: 1 });
+    const entries = res === null || res === void 0 ? void 0 : res.payload;
+    if (!entries || (Array.isArray(entries) && entries.length === 0)) {
+        cliError(`No query found with slug "${slugOrId}"`, EXIT_GENERAL_ERROR);
+    }
+    return Array.isArray(entries) ? entries[0] : entries;
+}
+async function promptTarget() {
+    spinner.start({ text: "Loading targets...", color: "cyan" });
+    const res = await apiCallHandler("config", "datatargets", "get", null, { limit: 100, active: true });
+    spinner.stop();
+    const targets = (res === null || res === void 0 ? void 0 : res.payload) || [];
+    if (targets.length === 0) {
+        cliError("No targets configured. Add one with: ay db targets add", EXIT_GENERAL_ERROR);
+    }
+    const choices = targets.map((t) => ({
+        name: `${t.name} ${chalk.dim(`(${maskUri(t.connectionUri)})`)}`,
+        value: t,
+    }));
+    const { selected } = await inquirer.prompt([
+        { type: "search-list", name: "selected", message: "Select target:", choices },
+    ]);
+    return selected;
+}
+async function promptQuery() {
+    spinner.start({ text: "Loading queries...", color: "magenta" });
+    const res = await apiCallHandler("config", "queries", "get", null, {
+        limit: 100,
+        "dataSource.source": "aggregation",
+    });
+    spinner.stop();
+    const queries = (res === null || res === void 0 ? void 0 : res.payload) || [];
+    if (queries.length === 0) {
+        cliError("No saved queries found. Create one with: ay agg save", EXIT_GENERAL_ERROR);
+    }
+    const choices = queries.map((q) => {
+        var _a;
+        return ({
+            name: `${q.name} ${chalk.dim(`(${((_a = q.dataSource) === null || _a === void 0 ? void 0 : _a.aggregationModel) || "?"})`)}`,
+            value: q,
+        });
+    });
+    const { selected } = await inquirer.prompt([
+        { type: "search-list", name: "selected", message: "Select query:", choices },
+    ]);
+    return selected;
 }

package/lib/db/copyEngine.js

@@ -1,67 +1,37 @@
 import { MongoClient } from "mongodb";
-export async function executeCopy(fromUri, toUri, collections, options, onProgress) {
+/**
+ * Writes aggregation query results to a target MongoDB collection.
+ * This is the core of the copy flow: query results from the aggregation API
+ * are written to an external MongoDB target.
+ */
+export async function writeToTarget(targetUri, database, collection, docs, writeMode, batchSize = 1000) {
     const startTime = Date.now();
-    const sourceClient = new MongoClient(fromUri);
-    const targetClient = new MongoClient(toUri);
-    const results = [];
+    const client = new MongoClient(targetUri);
+    let written = 0;
+    let errors = 0;
     try {
-        await sourceClient.connect();
-        await targetClient.connect();
-        const sourceDb = sourceClient.db();
-        const targetDb = targetClient.db();
-        // Resolve collections if --all was used
-        let collectionNames = collections;
-        if (collections.length === 1 && collections[0] === "*") {
-            const colls = await sourceDb.listCollections().toArray();
-            collectionNames = colls
-                .map((c) => c.name)
-                .filter((n) => !n.startsWith("system."));
-        }
-        for (const name of collectionNames) {
-            const colStart = Date.now();
-            let copied = 0;
-            let errors = 0;
-            const sourceCol = sourceDb.collection(name);
-            const targetCol = targetDb.collection(name);
-            if (options.drop) {
-                try {
-                    await targetCol.drop();
-                }
-                catch (_a) {
-                    // Collection may not exist — ignore
-                }
-            }
-            const query = options.query || {};
-            const total = await sourceCol.countDocuments(query);
-            onProgress({ collection: name, copied: 0, total, errors: 0 });
-            const cursor = sourceCol.find(query).batchSize(options.batchSize);
-            let batch = [];
-            for await (const doc of cursor) {
-                batch.push(doc);
-                if (batch.length >= options.batchSize) {
-                    const result = await writeBatch(targetCol, batch, options.upsert || false);
-                    copied += result.written;
-                    errors += result.errors;
-                    batch = [];
-                    onProgress({ collection: name, copied, total, errors });
-                }
+        await client.connect();
+        const db = database ? client.db(database) : client.db();
+        const col = db.collection(collection);
+        if (writeMode === "replace") {
+            try {
+                await col.drop();
             }
-            // Write remaining docs
-            if (batch.length > 0) {
-                const result = await writeBatch(targetCol, batch, options.upsert || false);
-                copied += result.written;
-                errors += result.errors;
-                onProgress({ collection: name, copied, total, errors });
+            catch (_a) {
+                // Collection may not exist
             }
-            results.push({ name, copied, errors, duration: Date.now() - colStart });
         }
-        const totalCopied = results.reduce((s, r) => s + r.copied, 0);
-        const totalErrors = results.reduce((s, r) => s + r.errors, 0);
-        return { collections: results, totalCopied, totalErrors, duration: Date.now() - startTime };
+        // Write in batches
+        for (let i = 0; i < docs.length; i += batchSize) {
+            const batch = docs.slice(i, i + batchSize);
+            const result = await writeBatch(col, batch, writeMode === "upsert");
+            written += result.written;
+            errors += result.errors;
+        }
+        return { written, errors, duration: Date.now() - startTime };
     }
     finally {
-        await sourceClient.close();
-        await targetClient.close();
+        await client.close();
     }
 }
 async function writeBatch(collection, docs, upsert) {
@@ -84,10 +54,8 @@ async function writeBatch(collection, docs, upsert) {
         }
     }
     catch (e) {
-        // Partial success on ordered:false — count what made it through
         const written = (_d = (_b = (_a = e.result) === null || _a === void 0 ? void 0 : _a.nInserted) !== null && _b !== void 0 ? _b : (_c = e.result) === null || _c === void 0 ? void 0 : _c.insertedCount) !== null && _d !== void 0 ? _d : 0;
-        const errorCount = docs.length - written;
-        return { written, errors: errorCount };
+        return { written, errors: docs.length - written };
     }
 }
 export async function getDbStats(uri) {
@@ -111,11 +79,7 @@ export async function getDbStats(uri) {
             }
         }
         collections.sort((a, b) => b.documents - a.documents);
-        return {
-            database: stats.db,
-            collections,
-            totalSize: stats.dataSize || 0,
-        };
+        return { database: stats.db, collections, totalSize: stats.dataSize || 0 };
     }
     finally {
         await client.close();

package/lib/helpers/updateNotifier.js

@@ -1,43 +1,50 @@
-import { execSync } from "child_process";
+import { exec } from "child_process";
 import chalk from "chalk";
 import { localStorage } from "./localStorage.js";
 const PKG_NAME = "@tolinax/ayoune-cli";
 const CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4 hours
 /**
- * Non-blocking update check. Compares installed version against npm registry.
- * Caches the result to avoid hammering npm on every invocation.
- * Prints a notice to stderr if a newer version is available.
+ * Non-blocking update check. Fires an async npm view in the background.
+ * Shows cached notice immediately if one exists; refreshes the cache asynchronously.
  */
 export function checkForUpdates(currentVersion) {
     try {
-        // Skip in CI environments
         if (process.env.CI || process.env.AYOUNE_NO_UPDATE_CHECK)
             return;
-        // Throttle: only check every CHECK_INTERVAL_MS
+        // Show cached notice immediately (zero latency)
+        const cached = localStorage.getItem("updateCheckLatest");
+        if (cached && cached !== currentVersion && isNewerVersion(cached, currentVersion)) {
+            printUpdateNotice(currentVersion, cached);
+        }
+        // Throttle the actual npm check
         const lastCheck = localStorage.getItem("updateCheckTimestamp");
-        if (lastCheck && Date.now() - parseInt(lastCheck, 10) < CHECK_INTERVAL_MS) {
-            // Still show cached notice if there was one
-            const cached = localStorage.getItem("updateCheckLatest");
-            if (cached && cached !== currentVersion) {
-                printUpdateNotice(currentVersion, cached);
-            }
+        if (lastCheck && Date.now() - parseInt(lastCheck, 10) < CHECK_INTERVAL_MS)
             return;
-        }
-        // Run npm view in background-ish (sync but with short timeout)
-        const latest = execSync(`npm view ${PKG_NAME} version`, {
-            encoding: "utf-8",
-            timeout: 5000,
-            stdio: ["pipe", "pipe", "ignore"],
-        }).trim();
-        localStorage.setItem("updateCheckTimestamp", String(Date.now()));
-        localStorage.setItem("updateCheckLatest", latest);
-        if (latest && latest !== currentVersion) {
-            printUpdateNotice(currentVersion, latest);
-        }
+        // Fire-and-forget: async check, never blocks startup
+        exec(`npm view ${PKG_NAME} version`, { timeout: 5000 }, (err, stdout) => {
+            if (err)
+                return;
+            const latest = stdout.trim();
+            if (latest) {
+                localStorage.setItem("updateCheckTimestamp", String(Date.now()));
+                localStorage.setItem("updateCheckLatest", latest);
+            }
+        });
     }
     catch (_a) {
-        // Silently ignore — network issues, npm not available, etc.
+        // Silently ignore
+    }
+}
+function isNewerVersion(latest, current) {
+    const l = latest.split(".").map(Number);
+    const c = current.split(".").map(Number);
+    for (let i = 0; i < Math.max(l.length, c.length); i++) {
+        if ((l[i] || 0) > (c[i] || 0))
+            return true;
+        if ((l[i] || 0) < (c[i] || 0))
+            return false;
     }
+    return false;
 }
 function printUpdateNotice(current, latest) {
     const msg = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tolinax/ayoune-cli",
-  "version": "2026.6.0",
+  "version": "2026.7.0",
   "description": "CLI for the aYOUne Business-as-a-Service platform",
   "type": "module",
   "main": "./index.js",
@@ -119,7 +119,6 @@
     "chalk": "^5.3.0",
     "chalk-animation": "^2.0.3",
     "commander": "^12.0.0",
-    "cron-parser": "^4.9.0",
     "figlet": "^1.7.0",
     "gradient-string": "^2.0.2",
     "inquirer": "^9.2.14",