@tolinax/ayoune-cli 2026.4.0 → 2026.6.0

package/lib/commands/createDbCommand.js

@@ -0,0 +1,286 @@
+import chalk from "chalk";
+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);
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return (bytes / Math.pow(1024, i)).toFixed(1) + " " + units[i];
+}
+export function createDbCommand(program) {
+    const db = program
+        .command("db")
+        .description("MongoDB database operations (copy, stats, scheduled replication)")
+        .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")
+        .addHelpText("after", `
+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) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            // Validate input
+            if (!opts.collections && !opts.all) {
+                cliError("Provide --collections or --all", EXIT_MISUSE);
+            }
+            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);
+            }
+            if (!opts.to.startsWith("mongodb")) {
+                cliError("--to must be a MongoDB URI (mongodb:// or mongodb+srv://)", EXIT_MISUSE);
+            }
+            let query;
+            if (opts.query) {
+                try {
+                    query = JSON.parse(opts.query);
+                }
+                catch (_a) {
+                    cliError("--query must be valid JSON", EXIT_MISUSE);
+                }
+            }
+            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();
+                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)`) : ""}`,
+                });
+            });
+            spinner.stop();
+            // Display summary
+            const wrapped = {
+                payload: summary,
+                meta: {
+                    totalCopied: summary.totalCopied,
+                    totalErrors: summary.totalErrors,
+                    duration: summary.duration,
+                },
+            };
+            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();
+            }
+            if (summary.totalErrors > 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
+        .command("list")
+        .alias("ls")
+        .description("List all scheduled copy jobs")
+        .action(async (options) => {
+        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);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list schedules", 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` });
+        }
+        else {
+            cliError(`No schedule found with ID "${id}"`, 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) => {
+        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();
+        }
+        catch (e) {
+            cliError(e.message || "Scheduled run failed", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ─── ay db stats <uri> ──────────────────────────────────────────
+    db.command("stats <uri>")
+        .description("Show database statistics (collections, doc counts, sizes)")
+        .addHelpText("after", `
+Examples:
+  ay db stats "mongodb+srv://user:pass@cluster.mongodb.net/mydb"
+  ay db stats "mongodb://localhost:27017/testdb" -r table`)
+        .action(async (uri, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (!uri.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.stop();
+            const wrapped = {
+                payload: stats,
+                meta: {
+                    database: stats.database,
+                    collectionCount: stats.collections.length,
+                    totalSize: formatBytes(stats.totalSize),
+                },
+            };
+            if (opts.responseFormat === "json" || opts.responseFormat === "yaml") {
+                handleResponseFormatOptions(opts, wrapped);
+            }
+            else {
+                console.log(chalk.cyan.bold(`\n  Database: ${stats.database}\n`));
+                console.log(`  ${chalk.dim("Total size:")} ${formatBytes(stats.totalSize)}`);
+                console.log(`  ${chalk.dim("Collections:")} ${stats.collections.length}\n`);
+                for (const col of stats.collections) {
+                    console.log(`  ${chalk.white(col.name)}: ${col.documents.toLocaleString()} docs ${chalk.dim(`(${formatBytes(col.size)})`)}`);
+                }
+                console.log();
+            }
+        }
+        catch (e) {
+            cliError(e.message || "Failed to get stats", EXIT_GENERAL_ERROR);
+        }
+    });
+}
+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 || "—",
+    };
+}

package/lib/commands/createProgram.js

@@ -47,6 +47,8 @@ import { createStatusCommand } from "./createStatusCommand.js";
 import { createSelfHostUpdateCommand } from "./createSelfHostUpdateCommand.js";
 import { createContextCommand } from "./createContextCommand.js";
 import { createAccessCommand } from "./createAccessCommand.js";
+import { createAggregateCommand } from "./createAggregateCommand.js";
+import { createDbCommand } from "./createDbCommand.js";
 import { secureStorage } from "../helpers/secureStorage.js";
 import { login } from "../api/login.js";
 import { loadConfig } from "../helpers/configLoader.js";
@@ -54,7 +56,13 @@ import { getLogo, getDescription, BRAND_BLUE } from "../helpers/logo.js";
 import { checkForUpdates } from "../helpers/updateNotifier.js";
 import { createRequire } from "module";
 const require = createRequire(import.meta.url);
-const pkg = require("../../../package.json");
+let pkg;
+try {
+    pkg = require("../../package.json"); // dist/ and npm install
+}
+catch (_a) {
+    pkg = require("../../../package.json"); // source tree (tests)
+}
 export function createProgram(program) {
     program
         .version(pkg.version || "0.0.0")
@@ -115,6 +123,8 @@ export function createProgram(program) {
     createPermissionsCommand(program);
     createTemplateCommand(program);
     createAccessCommand(program);
+    createAggregateCommand(program);
+    createDbCommand(program);
     createSetupCommand(program);
     createStatusCommand(program);
     createSelfHostUpdateCommand(program);
@@ -194,7 +204,7 @@ export function createProgram(program) {
         }
         // First-run onboarding: auto-login if no token stored
         const cmdName = thisCommand.name();
-        const skipAuth = ["login", "logout", "whoami", "completions", "alias", "config", "help", "setup", "status", "self-host-update", "context"];
+        const skipAuth = ["login", "logout", "whoami", "completions", "alias", "config", "help", "setup", "status", "self-host-update", "context", "db"];
         if (!skipAuth.includes(cmdName) && process.stdin.isTTY) {
             const token = secureStorage.getItem("token");
             if (!token) {

package/lib/commands/createStatusCommand.js

@@ -6,50 +6,63 @@ import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
 import { cliError } from "../helpers/cliError.js";
 import { handleResponseFormatOptions } from "../helpers/handleResponseFormatOptions.js";
 const CORE_SERVICES = [
-    { name: "config-api", module: "config", path: "healthz" },
-    { name: "auth", module: "auth", path: "healthz", customUrl: "auth" },
+    { name: "config-api", module: "config" },
+    { name: "auth", module: "auth" },
 ];
 const MODULE_SERVICES = {
-    crm: [{ name: "crm-api", module: "crm", path: "healthz" }],
-    marketing: [{ name: "marketing-api", module: "marketing", path: "healthz" }],
-    hr: [{ name: "hr-api", module: "hr", path: "healthz" }],
-    ecommerce: [{ name: "ecommerce-api", module: "ecommerce", path: "healthz" }],
-    pm: [{ name: "pm-api", module: "pm", path: "healthz" }],
-    devops: [{ name: "devops-api", module: "devops", path: "healthz" }],
-    accounting: [{ name: "accounting-api", module: "accounting", path: "healthz" }],
-    automation: [{ name: "automation-api", module: "automation", path: "healthz" }],
-    support: [{ name: "support-api", module: "support", path: "healthz" }],
-    reporting: [{ name: "reporting-api", module: "reporting", path: "healthz" }],
-    monitoring: [{ name: "monitoring-api", module: "monitoring", path: "healthz" }],
+    crm: [{ name: "crm-api", module: "crm" }],
+    marketing: [{ name: "marketing-api", module: "marketing" }],
+    hr: [{ name: "hr-api", module: "hr" }],
+    ecommerce: [{ name: "ecommerce-api", module: "ecommerce" }],
+    pm: [{ name: "pm-api", module: "pm" }],
+    devops: [{ name: "devops-api", module: "devops" }],
+    accounting: [{ name: "accounting-api", module: "accounting" }],
+    automation: [{ name: "automation-api", module: "automation" }],
+    support: [{ name: "support-api", module: "support" }],
+    reporting: [{ name: "reporting-api", module: "reporting" }],
+    monitoring: [{ name: "monitoring-api", module: "monitoring" }],
 };
-async function checkService(name, module, healthPath) {
-    var _a;
+function extractVersion(data) {
+    var _a, _b, _c, _d, _e;
+    return ((_b = (_a = data === null || data === void 0 ? void 0 : data.meta) === null || _a === void 0 ? void 0 : _a.version) === null || _b === void 0 ? void 0 : _b.core) || ((_d = (_c = data === null || data === void 0 ? void 0 : data.meta) === null || _c === void 0 ? void 0 : _c.version) === null || _d === void 0 ? void 0 : _d.host) || (data === null || data === void 0 ? void 0 : data.version) || ((_e = data === null || data === void 0 ? void 0 : data.payload) === null || _e === void 0 ? void 0 : _e.version) || undefined;
+}
+async function checkService(name, module) {
     const baseUrl = getModuleBaseUrl(module);
     const start = Date.now();
     try {
-        // Use api client directly to avoid handleAPIError calling process.exit()
         const response = await api({
             baseURL: baseUrl,
             method: "get",
-            url: healthPath,
+            url: "/",
             timeout: 10000,
             headers: {
                 Authorization: `Bearer ${secureStorage.getItem("token") || ""}`,
             },
         });
         const responseTime = Date.now() - start;
-        const res = response.data;
         return {
             service: name,
             url: baseUrl,
             status: "healthy",
             responseTime,
-            version: (res === null || res === void 0 ? void 0 : res.version) || ((_a = res === null || res === void 0 ? void 0 : res.payload) === null || _a === void 0 ? void 0 : _a.version) || undefined,
+            version: extractVersion(response.data),
         };
     }
     catch (e) {
         const responseTime = Date.now() - start;
         if (e.response) {
+            const data = e.response.data;
+            const version = extractVersion(data);
+            // A structured JSON response (even 404) with version info means the service is running
+            if (e.response.status < 500 && version) {
+                return {
+                    service: name,
+                    url: baseUrl,
+                    status: "healthy",
+                    responseTime,
+                    version,
+                };
+            }
             return {
                 service: name,
                 url: baseUrl,
@@ -101,7 +114,7 @@ Examples:
                 }
             }
             // Check services concurrently
-            const results = await Promise.all(servicesToCheck.map((svc) => checkService(svc.name, svc.module, svc.path)));
+            const results = await Promise.all(servicesToCheck.map((svc) => checkService(svc.name, svc.module)));
             spinner.stop();
             const healthy = results.filter((r) => r.status === "healthy").length;
             const unhealthy = results.filter((r) => r.status === "unhealthy").length;

package/lib/db/copyConfigStore.js

@@ -0,0 +1,88 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+const CONFIG_PATH = path.join(os.homedir(), ".config", "ayoune", "db-copies.json");
+const ALGORITHM = "aes-256-cbc";
+function deriveKey() {
+    const seed = `ayoune-cli:${os.hostname()}:${os.userInfo().username}`;
+    return crypto.createHash("sha256").update(seed).digest();
+}
+function encrypt(text) {
+    const key = deriveKey();
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+    let encrypted = cipher.update(text, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    return iv.toString("hex") + ":" + encrypted;
+}
+function decrypt(data) {
+    const key = deriveKey();
+    const [ivHex, encrypted] = data.split(":");
+    if (!ivHex || !encrypted)
+        return data;
+    try {
+        const iv = Buffer.from(ivHex, "hex");
+        const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+        let decrypted = decipher.update(encrypted, "hex", "utf8");
+        decrypted += decipher.final("utf8");
+        return decrypted;
+    }
+    catch (_a) {
+        return data;
+    }
+}
+export function maskUri(uri) {
+    return uri.replace(/:\/\/([^:]+):([^@]+)@/, "://***:***@");
+}
+export function loadCopyConfigs() {
+    if (!existsSync(CONFIG_PATH))
+        return [];
+    try {
+        return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    }
+    catch (_a) {
+        return [];
+    }
+}
+export function saveCopyConfigs(configs) {
+    const dir = path.dirname(CONFIG_PATH);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(configs, null, 2), "utf-8");
+}
+export function addCopyConfig(config) {
+    const configs = loadCopyConfigs();
+    // Encrypt URIs before saving
+    config.fromUri = encrypt(config.fromUri);
+    config.toUri = encrypt(config.toUri);
+    configs.push(config);
+    saveCopyConfigs(configs);
+}
+export function removeCopyConfig(id) {
+    const configs = loadCopyConfigs();
+    const filtered = configs.filter((c) => c.id !== id);
+    if (filtered.length === configs.length)
+        return false;
+    saveCopyConfigs(filtered);
+    return true;
+}
+export function getDecryptedConfig(config) {
+    return {
+        fromUri: decrypt(config.fromUri),
+        toUri: decrypt(config.toUri),
+    };
+}
+export function updateCopyConfigLastRun(id, status, error) {
+    const configs = loadCopyConfigs();
+    const config = configs.find((c) => c.id === id);
+    if (config) {
+        config.lastRun = new Date().toISOString();
+        config.lastStatus = status;
+        if (error)
+            config.lastError = error;
+        else
+            delete config.lastError;
+        saveCopyConfigs(configs);
+    }
+}

package/lib/db/copyEngine.js

@@ -0,0 +1,123 @@
+import { MongoClient } from "mongodb";
+export async function executeCopy(fromUri, toUri, collections, options, onProgress) {
+    const startTime = Date.now();
+    const sourceClient = new MongoClient(fromUri);
+    const targetClient = new MongoClient(toUri);
+    const results = [];
+    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 });
+                }
+            }
+            // 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 });
+            }
+            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 };
+    }
+    finally {
+        await sourceClient.close();
+        await targetClient.close();
+    }
+}
+async function writeBatch(collection, docs, upsert) {
+    var _a, _b, _c, _d;
+    try {
+        if (upsert) {
+            const ops = docs.map((doc) => ({
+                updateOne: {
+                    filter: { _id: doc._id },
+                    update: { $set: doc },
+                    upsert: true,
+                },
+            }));
+            const result = await collection.bulkWrite(ops, { ordered: false });
+            return { written: (result.upsertedCount || 0) + (result.modifiedCount || 0), errors: 0 };
+        }
+        else {
+            const result = await collection.insertMany(docs, { ordered: false });
+            return { written: result.insertedCount, errors: 0 };
+        }
+    }
+    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 };
+    }
+}
+export async function getDbStats(uri) {
+    const client = new MongoClient(uri);
+    try {
+        await client.connect();
+        const db = client.db();
+        const stats = await db.stats();
+        const collList = await db.listCollections().toArray();
+        const collections = [];
+        for (const col of collList) {
+            if (col.name.startsWith("system."))
+                continue;
+            try {
+                const count = await db.collection(col.name).estimatedDocumentCount();
+                const colStats = await db.command({ collStats: col.name });
+                collections.push({ name: col.name, documents: count, size: colStats.size || 0 });
+            }
+            catch (_a) {
+                collections.push({ name: col.name, documents: 0, size: 0 });
+            }
+        }
+        collections.sort((a, b) => b.documents - a.documents);
+        return {
+            database: stats.db,
+            collections,
+            totalSize: stats.dataSize || 0,
+        };
+    }
+    finally {
+        await client.close();
+    }
+}

package/lib/db/cronMatcher.js

@@ -0,0 +1,42 @@
+import cronParser from "cron-parser";
+/**
+ * Determines whether a cron-scheduled job is due for execution.
+ * Returns true if the current time has passed the next scheduled run after lastRun.
+ */
+export function isCronDue(expression, lastRun, now = new Date()) {
+    try {
+        if (!lastRun)
+            return true; // Never run before → always due
+        const lastRunDate = new Date(lastRun);
+        const interval = cronParser.parseExpression(expression, { currentDate: lastRunDate });
+        const nextRun = interval.next().toDate();
+        return now >= nextRun;
+    }
+    catch (_a) {
+        return false; // Invalid cron expression
+    }
+}
+/**
+ * Returns the next scheduled run time for a cron expression.
+ */
+export function getNextRun(expression, after = new Date()) {
+    try {
+        const interval = cronParser.parseExpression(expression, { currentDate: after });
+        return interval.next().toDate();
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/**
+ * Validates a cron expression. Returns null if valid, error message if invalid.
+ */
+export function validateCron(expression) {
+    try {
+        cronParser.parseExpression(expression);
+        return null;
+    }
+    catch (e) {
+        return e.message || "Invalid cron expression";
+    }
+}

package/lib/db/types.js

@@ -0,0 +1 @@
+export {};