@mtakla/cronops 0.1.1-rc2.4

package/dist/api/openapi.js

@@ -0,0 +1,229 @@
+import { number } from "zod";
+export const openapi = {
+    openapi: "3.0.3",
+    info: { title: "CronOps Web API", version: "1.0.0" },
+    components: {
+        securitySchemes: {
+            ApiKeyBearer: {
+                type: "http",
+                scheme: "bearer",
+                bearerFormat: "hex-256",
+            },
+        },
+    },
+    tags: [
+        {
+            name: "public",
+            description: "Public api",
+        },
+        {
+            name: "jobs",
+            description: "CronOps job related tasks",
+        },
+        {
+            name: "admin",
+            description: "CronOps admin tasks",
+        },
+        {
+            name: "user",
+            description: "Operations about user",
+            externalDocs: {
+                description: "Find out more about our store",
+                url: "http://swagger.io",
+            },
+        },
+    ],
+    paths: {
+        "/health": {
+            get: {
+                summary: "Health check",
+                tags: ["public"],
+                security: [],
+                responses: {
+                    "200": {
+                        description: "OK",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        status: { type: "string", example: "ok" },
+                                        active_jobs: { type: "integer", example: 3 },
+                                    },
+                                    required: ["status", "active_jobs"],
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        "/docs": {
+            get: {
+                summary: "OpenApi docs",
+                tags: ["public"],
+                security: [],
+                responses: {
+                    "200": {
+                        description: "OK",
+                    },
+                },
+            },
+        },
+        "/openapi.json": {
+            get: {
+                summary: "OpenApi specs",
+                tags: ["public"],
+                security: [],
+                responses: {
+                    "200": {
+                        description: "OK",
+                        content: {
+                            "application/json": {},
+                        },
+                    },
+                },
+            },
+        },
+        "/api/jobs/trigger/{jobId}": {
+            post: {
+                summary: "Trigger a job",
+                tags: ["jobs"],
+                parameters: [
+                    {
+                        name: "jobId",
+                        in: "path",
+                        required: true,
+                        schema: { type: "string" },
+                    },
+                ],
+                responses: {
+                    "200": {
+                        description: "Triggered",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        triggered: { type: "boolean", example: true },
+                                        jobId: { type: "string", example: "job-123" },
+                                    },
+                                    required: ["triggered", "jobId"],
+                                },
+                            },
+                        },
+                    },
+                    "404": {
+                        description: "Job not found",
+                    },
+                },
+            },
+        },
+        "/api/jobs/pause/{jobId}": {
+            post: {
+                summary: "Pause a job",
+                tags: ["jobs"],
+                parameters: [
+                    {
+                        name: "jobId",
+                        in: "path",
+                        required: true,
+                        schema: { type: "string" },
+                    },
+                ],
+                responses: {
+                    "200": {
+                        description: "Paused",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        paused: { type: "boolean", example: true },
+                                        jobId: { type: "string", example: "job-123" },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        "/api/jobs/resume/{jobId}": {
+            post: {
+                summary: "Resume a job",
+                tags: ["jobs"],
+                parameters: [
+                    {
+                        name: "jobId",
+                        in: "path",
+                        required: true,
+                        schema: { type: "string" },
+                    },
+                ],
+                responses: {
+                    "200": {
+                        description: "Resumed",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        resumed: { type: "boolean", example: true },
+                                        jobId: { type: "string", example: "job-123" },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        "/api/jobs/pause/": {
+            post: {
+                summary: "Pause all jobs",
+                tags: ["jobs"],
+                responses: {
+                    "200": {
+                        description: "Paused",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        paused: { type: "boolean", example: true },
+                                        jobs: { type: number, example: 4 },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        "/api/jobs/resume/": {
+            post: {
+                summary: "Resume all jobs",
+                tags: ["jobs"],
+                responses: {
+                    "200": {
+                        description: "Resumed",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        resumed: { type: "boolean", example: true },
+                                        jobs: { type: number, example: 4 },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+    servers: [{ url: "http://localhost:3000" }],
+    security: [{ ApiKeyBearer: [] }],
+};

package/dist/api/webapi.js

@@ -0,0 +1,75 @@
+import Fastify from "fastify";
+import chalk from "chalk";
+import { ENV } from "../types/Options.types.js";
+import { openapi } from "./openapi.js";
+const app = Fastify();
+const port = Number(process.env[ENV.PORT] ?? 8118);
+const host = process.env[ENV.HOST] ?? "127.0.0.1";
+const baseUrl = process.env[ENV.BASE_URL] ?? "http://127.0.0.1:8118";
+const apiKey = process.env[ENV.API_KEY];
+app.addHook("preHandler", async (request, reply) => {
+    if (request.method === "OPTIONS" || !request.url.startsWith("/api"))
+        return;
+    const auth = request.headers.authorization;
+    const token = auth?.startsWith("Bearer ") ? auth.slice(7) : undefined;
+    if (!token || token !== apiKey) {
+        return reply.code(401).send("Unauthorized");
+    }
+});
+app.get("/docs", async (_, reply) => {
+    reply.type("text/html").send(`
+      <!doctype html>
+      <html>
+         <head>
+            <meta charset="utf-8" />
+            <title>CronOps API</title>
+            <script type="module" src="https://unpkg.com/rapidoc/dist/rapidoc-min.js"></script>
+         </head>
+         <body>
+            <rapi-doc spec-url="/openapi.json"></rapi-doc>
+         </body>
+      </html>`);
+});
+app.get("/openapi.json", async () => {
+    return { ...openapi, servers: [{ url: "" }, { url: `${baseUrl}` }] };
+});
+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("/api/jobs/trigger/:jobId", async (request, reply) => {
+    const { jobId } = request.params;
+    const jobScheduler = request.server.scheduler;
+    if (!jobScheduler.isJobScheduled(jobId)) {
+        return reply.code(404).send();
+    }
+    await jobScheduler.executeJob(jobId);
+    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 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(` - Add 'HTTP Bearer' header on each /api HTTP request`);
+    }
+    else {
+        app.decorate("scheduler", scheduler);
+        app.listen({ port, host }, (err) => {
+            if (err) {
+                console.log(chalk.red(`Web API disabled. ${err?.message}`));
+            }
+            else {
+                console.log(`\nWeb API enabled. HTTP Server is listening on port ${port} ...`);
+                console.log(` ⎆ API endpoint ${baseUrl}/api (secured)`);
+                console.log(` ⎆ OpenAPI docs ${baseUrl}/docs`);
+                console.log(` ⎆ Health check ${baseUrl}/health`);
+            }
+        });
+    }
+}

package/dist/api.js

@@ -0,0 +1,44 @@
+import Fastify from "fastify";
+import { ENV } from "./types/Options.types.js";
+import chalk from "chalk";
+const app = Fastify();
+const port = Number(process.env[ENV.PORT] ?? 8778);
+const apiKey = process.env[ENV.API_KEY];
+app.addHook("preHandler", async (request, reply) => {
+    const key = request.headers["x-api-key"];
+    if (!apiKey || key !== apiKey) {
+        reply.code(401).send("Unauthorized");
+    }
+});
+app.get("/status", async () => {
+    return { status: "ok" };
+});
+app.post("/trigger/:jobId", async (request) => {
+    const { jobId } = request.params;
+    return { triggered: true, jobId };
+});
+app.post("/terminate", async () => {
+    return { terminating: true };
+});
+export default function () {
+    if (!apiKey || !/^[0-9a-f]{64}$/i.test(apiKey)) {
+        console.log(chalk.red(`Web-API not enabled: No valid API key found!`));
+        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(` - Set it via the environment variable CROPS_API_KEY`);
+    }
+    else {
+        app.listen({ port }, (err, address) => {
+            if (err) {
+                console.log(chalk.red(`Web API not running. ${err?.message}`));
+            }
+            else {
+                console.log(`Web API listening on port ${port} ...`);
+                console.log(`⎆ server running on ${address}`);
+                console.log(`⎆ to get server status, type           curl -X GET http://localhost:${port}/status`);
+                console.log(`⎆ to trigger a job manually, type      curl -X POST http://localhost:${port}/trigger/{job-id}`);
+                console.log(`⎆ to gracefully terminate server,type  curl -X POST http://localhost:${port}/terminate`);
+            }
+        });
+    }
+}

package/dist/errors/JobError.js

@@ -0,0 +1,10 @@
+export class JobError extends Error {
+    jobId;
+    constructor(message, jobId, cause) {
+        super(message, cause);
+        this.jobId = jobId;
+    }
+    static throw(jobId, message, cause) {
+        throw new JobError(jobId, message, cause);
+    }
+}

package/dist/handlers/AbstractHandler.js

@@ -0,0 +1,162 @@
+import fsx, { ensureDir } from "fs-extra";
+import tar from "tar-fs";
+import pLimit from "p-limit";
+import parse from "parse-duration";
+import { createGzip } from "node:zlib";
+import { pipeline } from "node:stream/promises";
+import { dirname, join, sep } from "node:path";
+import { createWriteStream } from "node:fs";
+import { JobError } from "../errors/JobError.js";
+const limit = pLimit(64);
+export class AbstractHandler {
+    setup;
+    constructor(setup) {
+        this.setup = setup;
+    }
+    validateJob(_job) { }
+    async process(_ctx) { }
+    async processFiles(_ctx, _entries, _fileHistory) { }
+    assertSourceConfigExists(job) {
+        if (!job.source)
+            JobError.throw(job.id, `Missing 'source' specs. Please check your config file.`);
+    }
+    assertTargetConfigExists(job) {
+        if (!job.target)
+            JobError.throw(job.id, `Missing 'target' specs.Please check your config file.`);
+    }
+    assertSourceDirExist(job) {
+        this.assertSourceConfigExists(job);
+        const sourceDir = this.setup.resolveSourceDir(job.source?.dir);
+        if (!fsx.pathExistsSync(sourceDir))
+            JobError.throw(job.id, `missing source dir '${sourceDir}'!`);
+    }
+    async processSources(ctx, entries, fileHistory, processor) {
+        const { sourceDir } = ctx;
+        await Promise.all(entries.map((sourceEntry) => {
+            const sourcePath = join(sourceDir, sourceEntry);
+            return limit(async () => {
+                try {
+                    const stats = await fsx.stat(sourcePath);
+                    const { changed } = fileHistory ? fileHistory.updateSourceEntry(sourcePath, [stats.mtimeMs, ctx.startTime]) : { changed: true };
+                    if (changed && processor)
+                        await processor.bind(this)(ctx, { sourceEntry, sourcePath, stats }, fileHistory);
+                }
+                catch (error) {
+                    ctx.processError(new Error(`Cannot process source entry '${sourceEntry}'.\n └─ ${String(error)}`));
+                }
+            });
+        }));
+    }
+    async copyOrMoveFile(ctx, entry, fileHistory) {
+        const { job, result, targetDir, targetPermissions } = ctx;
+        const { sourcePath, sourceEntry, stats } = entry;
+        const targetPath = join(targetDir, sourceEntry);
+        await fsx.copyFile(sourcePath, targetPath);
+        result.copied++;
+        await fsx.utimes(targetPath, stats.atime, stats.mtime);
+        await this.setTargetFilePermissions(targetPath, targetPermissions);
+        if (fileHistory)
+            fileHistory.addTargetEntry(targetPath, [stats.mtimeMs, ctx.startTime]);
+        ctx.processActivity("COPIED", targetPath, ctx.result.copied);
+        if (job.action === "move") {
+            await this.deleteFile(ctx, entry);
+        }
+    }
+    async deleteFile(ctx, { sourcePath }) {
+        const { job, result, sourceDir, sourceDirs } = ctx;
+        if (!job.dry_run) {
+            await fsx.remove(sourcePath);
+            let current = dirname(sourcePath);
+            while (current.length > sourceDir.length && !sourceDirs.has(current)) {
+                sourceDirs.add(current);
+                current = dirname(current);
+            }
+            ctx.processActivity("DELETED", sourcePath, ctx.result.deleted);
+        }
+        result.deleted++;
+    }
+    async createArchive(ctx, entries, fileHistory) {
+        if (entries.length > 0 && !ctx.result.errors) {
+            const { job, sourceDir, targetDir, targetPermissions, result } = ctx;
+            const dest = join(targetDir, job.targetArchiveName);
+            if (fileHistory.changed || !fsx.pathExistsSync(dest)) {
+                await ensureDir(targetDir);
+                try {
+                    await pipeline(tar.pack(sourceDir, { entries }), createGzip(), createWriteStream(dest));
+                }
+                catch (err) {
+                    ctx.processError(err instanceof Error ? err : new Error("Compression error!"));
+                }
+                await this.setTargetFilePermissions(dest, targetPermissions);
+                ctx.targetDirs.add(targetDir);
+                fileHistory.addTargetEntry(dest, [result.startTime, result.startTime]);
+                result.archived = entries.length;
+                ctx.processActivity("ARCHIVED", dest, result.archived);
+            }
+        }
+    }
+    async deleteEmptySourceDirs(ctx) {
+        const { job, sourceDirs } = ctx;
+        if (!job.dry_run) {
+            const sortedDirs = Array.from(sourceDirs).sort((a, b) => b.split(sep).length - a.split(sep).length);
+            for (const dir of sortedDirs) {
+                try {
+                    await fsx.rmdir(dir);
+                }
+                catch { }
+            }
+        }
+    }
+    async createTargetDirs(ctx, entries) {
+        const { targetDir, targetDirs } = ctx;
+        for (const entry of entries)
+            targetDirs.add(dirname(join(targetDir, entry)));
+        targetDirs.add(targetDir);
+        await Promise.all(Array.from(targetDirs).map((dir) => limit(() => fsx.ensureDir(dir))));
+    }
+    async setTargetDirPermissions(ctx) {
+        const folderPromises = new Map();
+        for (const dir of ctx.targetDirs)
+            this.getFolderPermissionPromises(ctx, dir, folderPromises);
+        await Promise.all(folderPromises.values());
+    }
+    async cleanup(ctx, fileHistory) {
+        const { job } = ctx;
+        const retentionMs = parse(job.target?.retention) ?? 0;
+        const targetScanPromises = Object.keys(fileHistory.data.target).map((path) => {
+            return limit(async () => {
+                const ttime = fileHistory.data.target[path]?.[1] ?? 0;
+                if (await fsx.pathExists(path)) {
+                    if (retentionMs > 0 && ctx.startTime - (ttime + retentionMs) >= 0) {
+                        await fsx.remove(path);
+                        fileHistory.markTargetOutdated(path);
+                        ctx.result.pruned++;
+                        ctx.processActivity("PRUNED", path, ctx.result.pruned);
+                    }
+                }
+                else
+                    fileHistory.markTargetOutdated(path);
+            });
+        });
+        await Promise.all(targetScanPromises);
+        fileHistory.cleanup();
+    }
+    async setTargetFilePermissions(destPath, perms, isDir = false) {
+        if (perms.uid >= 0 && perms.gid >= 0)
+            await fsx.chown(destPath, perms.uid, perms.gid);
+        await fsx.chmod(destPath, isDir ? perms.dirMode : perms.fileMode);
+    }
+    getFolderPermissionPromises(ctx, dirPath, folderPromises) {
+        if (dirPath.length < ctx.targetDir.length || folderPromises.has(dirPath))
+            return;
+        folderPromises.set(dirPath, limit(async () => {
+            try {
+                await this.setTargetFilePermissions(dirPath, ctx.targetPermissions, true);
+            }
+            catch (error) {
+                ctx.processError(new Error(`Cannot chmod on folder '${dirPath}'. ${error}`));
+            }
+        }));
+        this.getFolderPermissionPromises(ctx, dirname(dirPath), folderPromises);
+    }
+}

package/dist/handlers/ExecHandler.js

@@ -0,0 +1,103 @@
+import { spawn } from "node:child_process";
+import { parse } from "node:path";
+import { JobError } from "../errors/JobError.js";
+import { AbstractHandler } from "./AbstractHandler.js";
+export class ExecHandler extends AbstractHandler {
+    validateJob(job) {
+        if (!job.command)
+            JobError.throw(job.id, "Missing job command for execution");
+    }
+    async process(ctx) {
+        await this.exec(ctx);
+    }
+    async processFiles(ctx, entries, fileHistory) {
+        if (entries.length > 0) {
+            await this.processSources(ctx, entries, fileHistory, this.exec);
+        }
+        await super.cleanup(ctx, fileHistory);
+    }
+    async exec(ctx, entry) {
+        const { targetDir } = ctx;
+        const verbose = ctx.job.verbose === true;
+        await new Promise((resolve, reject) => {
+            const { vars, env } = this.createVars(ctx, entry);
+            let done = false;
+            let pid;
+            const cmd = this.resolveVars(ctx.job.command, vars);
+            const args = ctx.job.args.map((arg) => this.resolveVars(arg, vars));
+            const finish = (err) => {
+                if (!done) {
+                    done = true;
+                    if (err)
+                        reject(err);
+                    else {
+                        ctx.result.executed++;
+                        ctx.processActivity("EXECUTED", `Process successfully terminated (pid: ${pid})`, ctx.result.executed);
+                        resolve();
+                    }
+                }
+            };
+            const logFd = ctx.getLogFd();
+            const child = spawn(cmd, args, {
+                stdio: ["ignore", verbose ? logFd : "ignore", verbose ? logFd : "ignore"],
+                shell: ctx.job.shell ?? this.setup.shell,
+                env: { ...process.env, ...env },
+                cwd: targetDir,
+            });
+            pid = child.pid;
+            ctx.writeLog(`◉ Subprocess started (pid:${pid}) ➜ ${cmd} [${args}]`);
+            child.once("close", (code, signal) => {
+                if (code === 0)
+                    finish();
+                else
+                    finish(new Error(`✖ Subprocess (pid:${pid}) failed (code=${code}, signal=${signal})`));
+            });
+            child.once("error", (err) => finish(err));
+        });
+    }
+    createVars(ctx, entry) {
+        const vars = {
+            jobId: ctx.job.id,
+            sourceDir: ctx.sourceDir,
+            targetDir: ctx.targetDir,
+            scriptDir: this.setup.scriptDir,
+            tempDir: this.setup.tempDir,
+            logDir: this.setup.logDir,
+            file: "",
+            fileDir: "",
+            fileBase: "",
+            fileName: "",
+            fileExt: "",
+        };
+        if (entry) {
+            const { dir: fileDir, base: fileBase, name: fileName, ext: fileExt } = parse(entry.sourcePath);
+            Object.assign(vars, { file: entry.sourcePath, fileDir, fileBase, fileName, fileExt });
+        }
+        const env = {};
+        for (const [key, value] of Object.entries(ctx.job.env))
+            env[key] = this.resolveVars(value, vars);
+        Object.assign(env, {
+            CROPS_JOB_ID: vars.jobId,
+            CROPS_SOURCE_DIR: ctx.sourceDir,
+            CROPS_TARGET_DIR: ctx.targetDir,
+            CROPS_SCRIPT_DIR: vars.scriptDir,
+            CROPS_TEMP_DIR: vars.tempDir,
+            CROPS_LOG_DIR: vars.logDir,
+            CROPS_DRY_RUN: `${ctx.job.dry_run}`,
+            CROPS_VERBOSE: `${ctx.job.verbose}`,
+        });
+        if (entry) {
+            Object.assign(env, {
+                CROPS_FILE: vars.file,
+                CROPS_FILE_DIR: vars.fileDir,
+                CROPS_FILE_BASE: vars.fileBase,
+                CROPS_FILE_NAME: vars.fileName,
+                CROPS_FILE_EXT: vars.fileExt,
+            });
+        }
+        return { vars, env };
+    }
+    resolveVars(str, vars) {
+        return str.replace(/\{(\w+)\}/g, (_, key) => vars[key] ?? "");
+    }
+}

package/dist/handlers/FileArchiveHandler.js

@@ -0,0 +1,15 @@
+import { AbstractHandler } from "./AbstractHandler.js";
+export class FileArchiveHandler extends AbstractHandler {
+    validateJob(job) {
+        super.assertSourceDirExist(job);
+        super.assertTargetConfigExists(job);
+    }
+    async processFiles(ctx, entries, fileHistory) {
+        if (entries.length > 0) {
+            await super.processSources(ctx, entries, fileHistory);
+            await super.createArchive(ctx, entries, fileHistory);
+            await super.setTargetDirPermissions(ctx);
+        }
+        await super.cleanup(ctx, fileHistory);
+    }
+}

package/dist/handlers/FileCopyHandler.js

@@ -0,0 +1,15 @@
+import { AbstractHandler } from "./AbstractHandler.js";
+export class FileCopyHandler extends AbstractHandler {
+    validateJob(job) {
+        super.assertSourceDirExist(job);
+        super.assertTargetConfigExists(job);
+    }
+    async processFiles(ctx, entries, fileHistory) {
+        if (entries.length > 0) {
+            await super.createTargetDirs(ctx, entries);
+            await super.processSources(ctx, entries, fileHistory, this.copyOrMoveFile);
+            await super.setTargetDirPermissions(ctx);
+        }
+        await super.cleanup(ctx, fileHistory);
+    }
+}

package/dist/handlers/FileDeleteHandler.js

@@ -0,0 +1,13 @@
+import { AbstractHandler } from "./AbstractHandler.js";
+export class FileDeleteHandler extends AbstractHandler {
+    validateJob(job) {
+        super.assertSourceDirExist(job);
+    }
+    async processFiles(ctx, entries, fileHistory) {
+        if (entries.length > 0) {
+            await super.processSources(ctx, entries, fileHistory, this.deleteFile);
+            await super.deleteEmptySourceDirs(ctx);
+        }
+        await super.cleanup(ctx, fileHistory);
+    }
+}