@mtakla/cronops 0.1.1-rc2.4

package/dist/tasks/JobScheduler.js

@@ -0,0 +1,108 @@
+import { JobRunner } from "./JobRunner.js";
+import { JobModel } from "../models/JobModel.js";
+import { JobRunnerSetup } from "../models/JobRunnerSetup.js";
+import { AbstractTask } from "./AbstractTask.js";
+import { JobError } from "../errors/JobError.js";
+export class JobScheduler extends AbstractTask {
+    runnerSetup;
+    runnerMap;
+    changed = false;
+    isReload = false;
+    constructor(options = {}) {
+        super("*/5 * * * * *");
+        this.runnerSetup = new JobRunnerSetup(options);
+        this.runnerMap = new Map();
+    }
+    get scheduledJobs() {
+        return this.runnerMap.size;
+    }
+    get tempDir() {
+        return this.runnerSetup.tempDir;
+    }
+    async run() {
+        if (this.changed) {
+            this.changed = false;
+            this.events.emit("schedule-changed", this.isReload);
+            this.isReload = true;
+        }
+    }
+    unscheduleAll() {
+        for (const runner of this.runnerMap.values())
+            runner.unschedule();
+        this.runnerMap = new Map();
+        this.changed = true;
+    }
+    scheduleJobs(jobs, cb) {
+        this.unscheduleAll();
+        for (const jobEntry of jobs)
+            this.scheduleJob(jobEntry);
+        if (cb)
+            cb(this.runnerMap.size);
+    }
+    scheduleJob(job, defaults = {}) {
+        let rescheduled = false;
+        if (job.enabled === false)
+            JobError.throw(job.id, `Cannot schedule disabled job [${job.id}]!`);
+        this.runnerSetup.validateJob(job);
+        if (this.runnerMap.has(job.id)) {
+            this.runnerMap.get(job.id)?.unschedule();
+            rescheduled = true;
+        }
+        const task = new JobRunner(new JobModel(job, defaults), this.runnerSetup);
+        this.runnerMap.set(job.id, task);
+        task.onScheduled(() => this.events.emit("job-scheduled", job, rescheduled));
+        task.onStarted(() => this.events.emit("job-started", job));
+        task.onFinished((stat) => this.events.emit("job-finished", job, stat));
+        task.onActivity((activity, path, count) => this.events.emit("job-activity", job, activity, path, count));
+        task.onError((err) => this.events.emit("job-error", job, err));
+        task.schedule();
+        this.changed = true;
+    }
+    unscheduleJob(jobId) {
+        const task = this.runnerMap.get(jobId);
+        if (task) {
+            this.runnerMap.delete(jobId);
+            this.changed = true;
+            task.unschedule();
+        }
+    }
+    isJobScheduled(jobId) {
+        return this.runnerMap.has(jobId);
+    }
+    executeJob(jobId) {
+        if (!this.runnerMap.has(jobId))
+            throw new Error(`Unknown job [${jobId}]!`);
+        this.runnerMap.get(jobId)?.execute();
+    }
+    validateJob(job) {
+        this.runnerSetup.validateJob(job);
+    }
+    getScheduledJobs() {
+        return Array.from(this.runnerMap.values()).map((runner) => runner.job);
+    }
+    async gracefulTerminate(timeout = 1000) {
+        const jobRunnerTasks = [...this.runnerMap.values()];
+        this.unscheduleAll();
+        await super.gracefulTerminate(timeout);
+        for (const task of jobRunnerTasks)
+            await task.gracefulTerminate(timeout);
+    }
+    onChanged(cb) {
+        this.events.on("schedule-changed", cb);
+    }
+    onJobScheduled(cb) {
+        this.events.on("job-scheduled", cb);
+    }
+    onJobStarted(cb) {
+        this.events.on("job-started", cb);
+    }
+    onJobFinished(cb) {
+        this.events.on("job-finished", cb);
+    }
+    onJobActivity(cb) {
+        this.events.on("job-activity", cb);
+    }
+    onJobError(cb) {
+        this.events.on("job-error", cb);
+    }
+}

package/dist/tests/loadtest.js

@@ -0,0 +1,102 @@
+import fsx from "fs-extra";
+import { createJobScheduler } from "../index.js";
+let time = Date.now();
+await fsx.emptyDir("./build/loadtest");
+await fsx.ensureDir("./build/loadtest/copied");
+await fsx.ensureDir("./build/loadtest/moved");
+const jobs = [
+    {
+        id: "copy",
+        action: "copy",
+        cron: "0 0 */5 * *",
+        source: {
+            dir: "/node_modules",
+            includes: ["**/**"],
+        },
+        target: {
+            dir: "/build/loadtest/copied",
+        },
+    },
+    {
+        id: "move",
+        action: "move",
+        cron: "0 0 */5 * *",
+        source: {
+            dir: "/build/loadtest/copied",
+            includes: ["**/**"],
+        },
+        target: {
+            dir: "/build/loadtest/moved",
+        },
+    },
+    {
+        id: "archive",
+        action: "archive",
+        cron: "0 0 */5 * *",
+        source: {
+            dir: "/build/loadtest/moved",
+            includes: ["**/**"],
+        },
+        target: {
+            dir: "/build/loadtest",
+            archive_name: "loadtest.tgz",
+        },
+    },
+    {
+        id: "execute",
+        action: "exec",
+        command: "chmod",
+        args: ["ugo+rwx", "{file}"],
+        cron: "0 0 */5 * *",
+        source: {
+            dir: "/build/loadtest/moved",
+            includes: ["**/*.ts"],
+        },
+        target: {
+            dir: "/build/loadtest/moved",
+        },
+    },
+    {
+        id: "delete",
+        action: "delete",
+        cron: "0 0 */5 * *",
+        source: {
+            dir: "/build/loadtest/moved",
+            includes: ["**/**"],
+        },
+    },
+];
+const scheduler = createJobScheduler({
+    logDir: "./build/loadtest",
+});
+scheduler.onJobStarted((job) => {
+    console.log(`Starting job [${job.id}] ...`);
+    time = Date.now();
+});
+scheduler.onJobFinished((job, { copied, deleted, archived, executed }) => {
+    console.log(`✔ Done in ${Date.now() - time}ms (${copied} copied, ${deleted} deleted, ${archived} archived, ${executed} executed)`);
+    if (job.id === "copy")
+        scheduler.executeJob("move");
+    else if (job.id === "move")
+        scheduler.executeJob("execute");
+    else if (job.id === "execute")
+        scheduler.executeJob("archive");
+    else if (job.id === "archive")
+        scheduler.executeJob("delete");
+    else
+        done();
+});
+scheduler.onJobError((job, err) => {
+    console.log(`${job.id} failed. ${String(err)}`);
+});
+scheduler.scheduleJobs(jobs, () => {
+    scheduler.executeJob("copy");
+});
+async function done() {
+    fsx.rmdirSync("./build/loadtest/copied");
+    fsx.rmdirSync("./build/loadtest/moved");
+    if (!fsx.pathExistsSync("./build/loadtest/loadtest.tgz"))
+        throw Error("Archive should exist!");
+    await scheduler.gracefulTerminate();
+    process.exit(0);
+}

package/dist/types/Config.types.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export const JobSchema = z.strictObject({
+    id: z.string().optional(),
+    cron: z.string().min(1).optional(),
+    action: z.literal(["exec", "call", "copy", "move", "delete", "archive"]),
+    command: z.string().optional(),
+    shell: z.boolean().or(z.string().min(1)).optional(),
+    args: z.array(z.string().min(1)).min(1).optional(),
+    env: z.record(z.string().regex(/^[A-Z_][A-Z0-9_]*$/), z.string()).optional(),
+    source: z
+        .strictObject({
+        dir: z.string().min(1).optional(),
+        includes: z.array(z.string().min(1)).min(1).optional(),
+        excludes: z.array(z.string().min(1)).min(1).optional(),
+    })
+        .optional(),
+    target: z
+        .strictObject({
+        dir: z.string().min(1).optional(),
+        archive_name: z.string().min(1).optional(),
+        permissions: z
+            .strictObject({
+            owner: z.string().min(1).optional(),
+            file_mode: z.string().min(1).optional(),
+            dir_mode: z.string().min(1).optional(),
+        })
+            .optional(),
+        retention: z.string().min(1).optional(),
+    })
+        .optional(),
+    dry_run: z.boolean().optional(),
+    verbose: z.boolean().optional(),
+    enabled: z.boolean().optional(),
+});

package/dist/types/Options.types.js

@@ -0,0 +1,19 @@
+export const ENV = {
+    CONFIG_DIR: "CROPS_CONFIG_DIR",
+    TEMP_DIR: "CROPS_TEMP_DIR",
+    LOG_DIR: "CROPS_LOG_DIR",
+    SOURCE_ROOT: "CROPS_SOURCE_ROOT",
+    TARGET_ROOT: "CROPS_TARGET_ROOT",
+    SOURCE_2_ROOT: "CROPS_SOURCE_2_ROOT",
+    TARGET_2_ROOT: "CROPS_TARGET_2_ROOT",
+    SOURCE_3_ROOT: "CROPS_SOURCE_3_ROOT",
+    TARGET_3_ROOT: "CROPS_TARGET_3_ROOT",
+    EXEC_SHELL: "CROPS_EXEC_SHELL",
+    PLIMIT_SPAWN: "CROPS_PLIMIT_SPAWN",
+    PLIMIT_FS: "CROPS_PLIMIT_FS",
+    API_KEY: "CROPS_API_KEY",
+    BASE_URL: "CROPS_BASE_URL",
+    HOST: "CROPS_HOST",
+    PORT: "CROPS_PORT",
+    TZ: "TZ",
+};

package/dist/types/Task.types.js

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

package/dist/webapi.js

@@ -0,0 +1,52 @@
+import Fastify from "fastify";
+import chalk from "chalk";
+import { ENV } from "./types/Options.types.js";
+const app = Fastify();
+const port = Number(process.env[ENV.PORT] ?? 8778);
+const host = process.env[ENV.HOST] ?? "127.0.0.1";
+const apiKey = process.env[ENV.API_KEY];
+app.addHook("preHandler", async (request, reply) => {
+    if (request.url === "/health")
+        return;
+    const key = request.headers["x-api-key"];
+    if (!apiKey || key !== apiKey) {
+        reply.code(401).send("Unauthorized");
+    }
+});
+app.get("/health", async (request, reply) => {
+    const jobScheduler = request.server.scheduler;
+    const jobs = jobScheduler.getScheduledJobs();
+    reply.code(200).send({ status: "ok", active_jobs: jobs.length });
+});
+app.post("/trigger/:jobId", async (request) => {
+    const { jobId } = request.params;
+    return { triggered: true, jobId };
+});
+app.post("/terminate", async () => {
+    return { terminating: true };
+});
+export default function (scheduler) {
+    if (!apiKey || !/^[0-9a-f]{64}$/i.test(apiKey)) {
+        console.log(chalk.red(`Web API is disabled. No valid API key configured!`));
+        console.log(`\nTo use the CronOps admin Web API:`);
+        console.log(` - Generate a hex‑encoded 256‑bit secret (e.g. 'openssl rand -hex 32')`);
+        console.log(` - Configure api-key via environment variable CROPS_API_KEY`);
+        console.log(` - Use 'x-api-key' header on each web admin HTTP request`);
+    }
+    else {
+        app.decorate("scheduler", scheduler);
+        app.listen({ port, host }, (err, address) => {
+            if (err) {
+                console.log(chalk.red(`Web API is disabled. ${err?.message}`));
+            }
+            else {
+                console.log(`\nWeb API listening on port ${port} ...`);
+                console.log(`⎆ to get server health status, type    curl -X GET ${address}/health`);
+                console.log(`⎆ to list scheduled jobs status, type  curl -X GET ${address}/status¹`);
+                console.log(`⎆ to trigger a job manually*, type     curl -X POST ${address}/trigger/{job-id}¹`);
+                console.log(`⎆ to gracefully terminate server,type  curl -X POST ${address}/terminate¹"`);
+                console.log(`¹for authentication use curl option -H "x-api-key: YOUR_API_KEY" `);
+            }
+        });
+    }
+}

package/package.json

@@ -0,0 +1,81 @@
+{
+   "name": "@mtakla/cronops",
+   "version": "0.1.1-rc2.4",
+   "description": "Cron-based cross-container server lifecycle management",
+   "type": "module",
+   "author": "nevereven",
+   "license": "ISC",
+   "bin": {
+      "cronops": "dist/server.js"
+   },
+   "main": "./dist/server.js",
+   "types": "./dist/index.d.ts",
+   "engines": {
+      "node": ">=24"
+   },
+   "keywords": [
+      "cron",
+      "file",
+      "glob",
+      "exec",
+      "copy",
+      "move",
+      "archive",
+      "docker",
+      "scheduler",
+      "lifecycle",
+      "cross-container"
+   ],
+   "export": {
+      ".": {
+         "types": "./dist/index.d.ts",
+         "import": "./dist/index.js"
+      }
+   },
+   "files": [
+      "dist",
+      "config",
+      "LICENSE",
+      "README.md"
+   ],
+   "dependencies": {
+      "chalk": "5.6.2",
+      "date-fns": "4.1.0",
+      "fast-glob": "3.3.3",
+      "figlet": "1.10.0",
+      "fs-extra": "11.3.3",
+      "p-limit": "7.3.0",
+      "node-cron": "4.2.1",
+      "parse-duration": "2.1.5",
+      "tar-fs": "3.1.1",
+      "yaml": "2.8.2",
+      "zod": "4.3.6",
+      "fastify": "5.7.4"
+   },
+   "devDependencies": {
+      "@biomejs/biome": "^2.3.6",
+      "@types/fs-extra": "^11.0.4",
+      "@types/node": "^25.0.3",
+      "@types/shell-quote": "^1.7.5",
+      "@types/tar-fs": "2.0.4",
+      "@vitest/coverage-v8": "^4.0.14",
+      "typescript": "^5.9.3",
+      "typedoc": "^0.28.16",
+      "tsx": "^4.21.0",
+      "vitest": "^4.0.14"
+   },
+   "scripts": {
+      "check": "biome check",
+      "check:fix": "biome check --write",
+      "test": "vitest run",
+      "docs": "typedoc",
+      "coverage": "vitest run --coverage",
+      "loadtest": "tsc && node ./dist/tests/loadtest.js",
+      "clean": "rm -rf dist",
+      "build": "tsc",
+      "dev": "tsc && node ./dist/server.js",
+      "start": "node ./dist/server.js",
+      "docker:build": "docker build -t ghcr.io/mtakla/cronops:latest -t ghcr.io/mtakla/cronops:0.1 .",
+      "docker:push": "docker push ghcr.io/mtakla/cronops:latest"
+   }
+}