@mtakla/cronops 0.1.1-rc2.4

package/dist/handlers/FileMoveHandler.js

@@ -0,0 +1,16 @@
+import { AbstractHandler } from "./AbstractHandler.js";
+export class FileMoveHandler 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.deleteEmptySourceDirs(ctx);
+        }
+        await super.cleanup(ctx, fileHistory);
+    }
+}

package/dist/index.js

@@ -0,0 +1,17 @@
+import { JobScheduler } from "./tasks/JobScheduler.js";
+import { JobModel } from "./models/JobModel.js";
+import { JobRunnerSetup } from "./models/JobRunnerSetup.js";
+import { JobLoader } from "./tasks/JobLoader.js";
+import { JobRunner } from "./tasks/JobRunner.js";
+export function createJobLoader(options = {}) {
+    return new JobLoader(options);
+}
+export function createJobScheduler(options = {}) {
+    return new JobScheduler(options);
+}
+export function createJobRunner(job, options = {}) {
+    const setup = new JobRunnerSetup(options);
+    setup.validateJob(job);
+    return new JobRunner(new JobModel(job), setup);
+}
+export default { createJobLoader, createJobScheduler, createJobRunner };

package/dist/models/FileHistoryModel.js

@@ -0,0 +1,45 @@
+export class FileHistoryModel {
+    data;
+    changed;
+    included = new Set();
+    outdated = new Set();
+    constructor(data = { source: {}, target: {} }) {
+        this.data = data;
+        this.changed = false;
+    }
+    updateSourceEntry(path, entry) {
+        const prev = this.data.source[path];
+        const added = prev === undefined;
+        const changed = added || prev[0] !== entry[0];
+        if (changed) {
+            this.data.source[path] = entry;
+            this.changed = true;
+        }
+        this.included.add(path);
+        return { changed, added };
+    }
+    addTargetEntry(path, entry) {
+        this.data.target[path] = entry;
+        this.changed = true;
+    }
+    markTargetOutdated(path) {
+        if (path in this.data.target)
+            this.outdated.add(path);
+    }
+    cleanup() {
+        const useless = new Set(Object.keys(this.data.source)).difference(this.included);
+        for (const path of useless)
+            this._removeEntry("source", path);
+        for (const path of this.outdated)
+            this._removeEntry("target", path);
+        this.included.clear();
+        this.outdated.clear();
+        return [...useless];
+    }
+    _removeEntry(type, path) {
+        if (path in this.data[type]) {
+            delete this.data[type][path];
+            this.changed = true;
+        }
+    }
+}

package/dist/models/JobModel.js

@@ -0,0 +1,35 @@
+import { format } from "date-fns";
+export class JobModel {
+    id;
+    action;
+    command = "";
+    shell;
+    args = [];
+    env = {};
+    cron = "* * * * *";
+    source = {};
+    target = {};
+    dry_run = false;
+    verbose = false;
+    enabled = true;
+    constructor(data, config = {}) {
+        Object.assign(this, config);
+        Object.assign(this, data);
+    }
+    get sourceIncludes() {
+        return this.source?.includes ?? ["**/*"];
+    }
+    get sourceExcludes() {
+        return this.source?.excludes ?? [];
+    }
+    get targetArchiveName() {
+        return this.resolveDatePattern(this.target?.archive_name ?? "{{yyyy-MM-dd_HH-mm-ss}}.tgz");
+    }
+    get targetPermissions() {
+        const perm = this.target?.permissions;
+        return `${perm?.owner ?? ":"}:${perm?.file_mode ?? ""}:${perm?.dir_mode ?? ""}`;
+    }
+    resolveDatePattern(input, date = new Date()) {
+        return input.replace(/\{\{(.+?)\}\}/g, (_, pattern) => format(date, pattern));
+    }
+}

package/dist/models/JobRunnerContext.js

@@ -0,0 +1,49 @@
+import { EventEmitter } from "node:events";
+import { PermissionModel } from "./PermissionModel.js";
+import { JobRunnerResult } from "./JobRunnerResult.js";
+import { fsyncSync, writeSync } from "node:fs";
+import { join } from "node:path";
+export class JobRunnerContext {
+    job;
+    result;
+    startTime;
+    sourceDir;
+    targetDir;
+    sourceDirs;
+    targetDirs;
+    targetPermissions;
+    events;
+    logFd;
+    constructor(setup, job, events = new EventEmitter(), logFd = 0) {
+        this.job = job;
+        this.startTime = Date.now();
+        this.sourceDir = setup.resolveSourceDir(job.source?.dir);
+        this.targetDir = job.dry_run ? join(setup.tempDir, job.id) : setup.resolveTargetDir(job.target?.dir);
+        this.sourceDirs = new Set();
+        this.targetDirs = new Set();
+        this.targetPermissions = new PermissionModel(job.targetPermissions);
+        this.result = new JobRunnerResult();
+        this.events = events;
+        this.logFd = logFd;
+    }
+    getLogFd() {
+        return this.logFd;
+    }
+    writeLog(msg) {
+        if (this.logFd)
+            writeSync(this.logFd, `${msg}\n`);
+    }
+    processError(error) {
+        this.result.errors++;
+        this.writeLog(String(error));
+        this.events.emit("error", error);
+    }
+    processActivity(action, path, count) {
+        if (this.logFd) {
+            writeSync(this.logFd, `✔ ${action} ${path ? path : ""}\n`);
+            fsyncSync(this.logFd);
+        }
+        if (this.job.verbose)
+            this.events.emit("activity", action, path, count);
+    }
+}

package/dist/models/JobRunnerResult.js

@@ -0,0 +1,13 @@
+export class JobRunnerResult {
+    copied = 0;
+    deleted = 0;
+    archived = 0;
+    executed = 0;
+    pruned = 0;
+    errors = 0;
+    startTime = Date.now();
+    endTime = Date.now();
+    get durationMs() {
+        return this.endTime - this.startTime;
+    }
+}

package/dist/models/JobRunnerSetup.js

@@ -0,0 +1,105 @@
+import os from "node:os";
+import cron from "node-cron";
+import { join, resolve, sep } from "node:path";
+import { ENV } from "../types/Options.types.js";
+import { JobError } from "../errors/JobError.js";
+import { JobSchema } from "../types/Config.types.js";
+import { ExecHandler } from "../handlers/ExecHandler.js";
+import { FileCopyHandler } from "../handlers/FileCopyHandler.js";
+import { FileMoveHandler } from "../handlers/FileMoveHandler.js";
+import { FileArchiveHandler } from "../handlers/FileArchiveHandler.js";
+import { FileDeleteHandler } from "../handlers/FileDeleteHandler.js";
+export class JobRunnerSetup {
+    sourceRoot;
+    targetRoot;
+    source2Root;
+    target2Root;
+    source3Root;
+    target3Root;
+    shell;
+    configDir;
+    tempDir;
+    logDir;
+    scriptDir;
+    sourceRootDirs;
+    targetRootDirs;
+    handlerMap = new Map();
+    constructor(options = {}) {
+        this.sourceRoot = resolve(options.sourceRoot ?? process.env[ENV.SOURCE_ROOT] ?? "./");
+        this.targetRoot = resolve(options.targetRoot ?? process.env[ENV.TARGET_ROOT] ?? "./");
+        this.source2Root = resolve(options.source2Root ?? process.env[ENV.SOURCE_2_ROOT] ?? "./");
+        this.target2Root = resolve(options.target2Root ?? process.env[ENV.TARGET_2_ROOT] ?? "./");
+        this.source3Root = resolve(options.source3Root ?? process.env[ENV.SOURCE_3_ROOT] ?? "./");
+        this.target3Root = resolve(options.target3Root ?? process.env[ENV.TARGET_3_ROOT] ?? "./");
+        this.configDir = resolve(options.configDir ?? process.env[ENV.CONFIG_DIR] ?? "./config");
+        this.tempDir = resolve(options.tempDir ?? process.env[ENV.TEMP_DIR] ?? join(os.tmpdir(), "cronops"));
+        this.logDir = resolve(options.logDir ?? process.env[ENV.LOG_DIR] ?? join(os.homedir(), ".cronops"));
+        this.shell = options.shell ?? parseShellSettings(process.env[ENV.EXEC_SHELL]) ?? false;
+        this.scriptDir = join(this.configDir, "scripts");
+        this.sourceRootDirs = [this.sourceRoot, this.source2Root, this.source3Root];
+        this.targetRootDirs = [this.targetRoot, this.target2Root, this.target3Root];
+        this.handlerMap.set("exec", new ExecHandler(this));
+        this.handlerMap.set("copy", new FileCopyHandler(this));
+        this.handlerMap.set("move", new FileMoveHandler(this));
+        this.handlerMap.set("archive", new FileArchiveHandler(this));
+        this.handlerMap.set("delete", new FileDeleteHandler(this));
+    }
+    resolveSourceDir(relPath = "./") {
+        return this._resolveDir(relPath, this.sourceRootDirs);
+    }
+    resolveTargetDir(relPath = "./") {
+        return this._resolveDir(relPath, this.targetRootDirs);
+    }
+    getActionHandler(action) {
+        const handler = this.handlerMap.get(action);
+        if (!handler)
+            throw new Error(`No handler registered for action '${action}'!`);
+        return handler;
+    }
+    validateJob(job) {
+        const res = JobSchema.safeParse(job);
+        if (!res.success)
+            JobError.throw(job.id, `Invalid job definition. ${res.error.issues[0]?.message}`, res.error);
+        this._validateDir(job.source?.dir, job.id);
+        this._validateDir(job.target?.dir, job.id);
+        if (job.cron && !cron.validate(job.cron))
+            JobError.throw(job.id, `invalid cron string '${job.cron}'!`);
+        const handler = this.getActionHandler(job.action);
+        handler.validateJob(job);
+    }
+    _validateDir(path = "./", jobId) {
+        let issue;
+        if (path.includes(".."))
+            issue = "Directory traversal ('..') is not allowed!";
+        else if (path.startsWith("$")) {
+            const digit = path.charCodeAt(1) - 48;
+            const nextChar = path.charAt(2);
+            if (!(digit > 0 && digit <= 3))
+                issue = "Only $1, $2, and $3 are supported as root prefixes.";
+            else if (nextChar !== "" && nextChar !== sep)
+                issue = `Prefix $${digit} must be followed by a path separator ('${sep}').`;
+        }
+        if (issue)
+            JobError.throw(jobId, issue);
+    }
+    _resolveDir(relPath, rootDirArray) {
+        if (!relPath.startsWith("$")) {
+            return resolve(join(rootDirArray[0], relPath));
+        }
+        const idx = relPath.charCodeAt(1) - 49;
+        if (idx >= 0 && idx < 3 && (relPath.charAt(2) === "" || relPath.charAt(2) === sep)) {
+            return resolve(join(rootDirArray[idx] || "./", relPath.slice(2)));
+        }
+        throw new Error(`Invalid dir prefix '${relPath}'! Allowed prefixes are $1, $2, or $3, followed by '${sep}'`);
+    }
+}
+function parseShellSettings(shellStr) {
+    if (!shellStr)
+        return false;
+    const normalized = shellStr.trim().toLowerCase();
+    if (normalized === "true")
+        return true;
+    if (normalized === "false")
+        return false;
+    return shellStr;
+}

package/dist/models/PermissionModel.js

@@ -0,0 +1,13 @@
+export class PermissionModel {
+    uid;
+    gid;
+    fileMode;
+    dirMode;
+    constructor(attr) {
+        const [uidStr, gidStr, fileModeStr, dirModeStr] = attr.split(":");
+        this.uid = parseInt(uidStr || "", 10);
+        this.gid = parseInt(gidStr || "", 10);
+        this.fileMode = parseInt(fileModeStr || "660", 8);
+        this.dirMode = parseInt(dirModeStr || "770", 8);
+    }
+}

package/dist/server.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import fsx from "fs-extra";
+import figlet from "figlet";
+import webapi from "./api/webapi.js";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { JobLoader } from "./tasks/JobLoader.js";
+import { JobScheduler } from "./tasks/JobScheduler.js";
+const plural = (n, noun) => `${n > 0 ? n : "no"} ${noun}${n !== 1 ? "s" : ""}`;
+const appDir = join(dirname(fileURLToPath(import.meta.url)), "..");
+export async function start() {
+    const jobLoader = new JobLoader();
+    const jobScheduler = new JobScheduler();
+    try {
+        const packageJSON = await fsx.readJSON(join(appDir, "package.json"));
+        console.log(figlet.textSync("CronOps", { horizontalLayout: "fitted" }));
+        console.log(chalk.cyan.bold(`\n☰ CronOps v${packageJSON.version}`) + chalk.cyan.italic(` »Omnia coniuncta sunt«`));
+        console.log(`Monitoring job configs in ${join(jobLoader.configDir, "jobs")} ...`);
+        await fsx.emptyDir(jobScheduler.tempDir);
+        webapi(jobScheduler);
+    }
+    catch (err) {
+        console.error(`CronOps initialization error. ${err instanceof Error ? err.stack : err}`);
+        console.error(`Please check environment settings.`);
+        process.exit(1);
+    }
+    jobLoader.onLoadingError((entry, message) => {
+        console.log(`🔴 Error loading job '${entry}'. ${message}`);
+    });
+    jobLoader.onJobLoaded((job) => {
+        if (job.enabled !== false)
+            jobScheduler.scheduleJob(job);
+    });
+    jobLoader.onJobDeleted((jobId) => {
+        jobScheduler.unscheduleJob(jobId);
+    });
+    jobScheduler.onChanged((isReload) => {
+        const jobs = jobScheduler.getScheduledJobs();
+        console.log(`\nJob config ${isReload ? "changed" : "loaded"} (${plural(jobs.length, "active job")})`);
+        for (const job of jobs) {
+            console.log(` 🕔 [${job.id}] scheduled (${chalk.greenBright(job.cron)})${job.dry_run ? " 👋 DRY-RUN mode!" : ""}`);
+        }
+    });
+    jobScheduler.onJobError((job, err) => {
+        console.error(chalk.red(`[${job.id}] ERROR ${err.message}`));
+    });
+    jobScheduler.onJobActivity((job, action, path, count) => {
+        if (action === "COPIED")
+            console.log(`[${job.id}] ⛃ COPIED → '${path}'`);
+        else if (action === "DELETED")
+            console.log(`[${job.id}] ⛃ DELETED '${path}'`);
+        else if (action === "ARCHIVED")
+            console.log(`[${job.id}] ⛃ ARCHIVED ${plural(count, "file")} to '${path}'`);
+        else if (action === "EXECUTED")
+            console.log(`[${job.id}] ➤➤ EXECUTED '${path}'`);
+        else if (action === "PRUNED")
+            console.log(`[${job.id}] ⛃ PRUNED target file '${path}'`);
+    });
+    jobScheduler.onJobFinished((job, stat) => {
+        if (!job.verbose && stat.copied + stat.deleted + stat.archived + stat.executed > 0) {
+            if (stat.copied > 0 && stat.deleted > 0)
+                console.log(`[${job.id}] ✔ MOVED ${stat.copied} in ${stat.durationMs}ms`);
+            else if (stat.copied > 0)
+                console.log(`[${job.id}] ✔ COPIED ${plural(stat.copied, "file")} in ${stat.durationMs}ms`);
+            else if (stat.deleted > 0)
+                console.log(`[${job.id}] ✔ DELETED ${plural(stat.deleted, "file")} in ${stat.durationMs}ms`);
+            else if (stat.archived > 0)
+                console.log(`[${job.id}] ✔ ARCHIVED ${plural(stat.archived, "file")} in ${stat.durationMs}ms`);
+            else if (stat.executed === 1)
+                console.log(`[${job.id}] ✔ Command EXECUTED in ${stat.durationMs}ms`);
+            else if (stat.executed > 1)
+                console.log(`[${job.id}] ✔ Command EXECUTED on ${plural(stat.executed, "file")} in ${stat.durationMs}ms`);
+        }
+    });
+    process.on("SIGTERM", async () => {
+        console.log("SIGTERM received. Shutting down CronOps ...");
+        if (jobLoader)
+            await jobLoader.gracefulTerminate(2000);
+        if (jobScheduler)
+            await jobScheduler.gracefulTerminate(2000);
+        process.exit(0);
+    });
+    process.on("uncaughtException", (err, origin) => {
+        console.error(`Unexpected Termination. Origin: ${origin}. ${err instanceof Error ? err.stack : err}`);
+        process.exit(-1);
+    });
+    jobLoader.schedule(true);
+    jobScheduler.schedule();
+}
+await start();

package/dist/tasks/AbstractTask.js

@@ -0,0 +1,71 @@
+import cron, {} from "node-cron";
+import { setTimeout } from "node:timers/promises";
+import { EventEmitter } from "node:events";
+import { ENV } from "../types/Options.types.js";
+export class AbstractTask {
+    cronTask;
+    events = new EventEmitter();
+    errorCount = 0;
+    isRunning = false;
+    constructor(cronStr = "* * * * *") {
+        const asyncRunner = async () => {
+            if (!this.isRunning) {
+                this.isRunning = true;
+                try {
+                    this.events.emit("started");
+                    this.events.emit("finished", await this.run());
+                }
+                catch (err) {
+                    this.events.emit("error", err instanceof Error ? err : new Error(String(err)));
+                }
+                finally {
+                    this.isRunning = false;
+                }
+            }
+        };
+        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone ?? process.env[ENV.TZ] ?? "UTC";
+        if (!cron.validate(cronStr))
+            throw new Error(`Initialization error. Invalid cron string (${cronStr}).`);
+        this.cronTask = cron.createTask(cronStr, asyncRunner, { timezone });
+    }
+    schedule(runImmediately = false) {
+        if (runImmediately)
+            this.cronTask.once("task:started", () => this.execute());
+        this.cronTask.start();
+    }
+    unschedule() {
+        this.events.removeAllListeners();
+        this.cronTask.destroy();
+    }
+    execute(cb) {
+        const status = this.cronTask.getStatus();
+        if (status === "destroyed")
+            throw new Error("Invalid task state (destroyed)");
+        if (status === "running" || this.isRunning)
+            throw new Error("Invalid task state (running)");
+        if (cb)
+            this.events.once("finished", cb);
+        this.cronTask.execute();
+    }
+    onScheduled(cb) {
+        this.cronTask.on("task:started", cb);
+    }
+    onStarted(cb) {
+        this.events.on("started", cb);
+    }
+    onFinished(cb) {
+        this.events.on("finished", cb);
+    }
+    onError(cb) {
+        this.errorCount++;
+        this.events.on("error", (error) => cb(error));
+    }
+    async gracefulTerminate(timeout = 500) {
+        if (this.cronTask.getStatus() !== "destroyed")
+            await this.cronTask.destroy();
+        const startTime = Date.now();
+        while (this.isRunning && Date.now() - startTime < timeout) {
+            await setTimeout(20);
+        }
+    }
+}

package/dist/tasks/JobLoader.js

@@ -0,0 +1,73 @@
+import fsx from "fs-extra";
+import YAML from "yaml";
+import glob from "fast-glob";
+import { join, dirname, resolve, basename } from "node:path";
+import { AbstractTask } from "./AbstractTask.js";
+import { ZodError } from "zod";
+import { fileURLToPath } from "node:url";
+import { FileHistoryModel } from "../models/FileHistoryModel.js";
+import { ENV } from "../types/Options.types.js";
+import { JobSchema } from "../types/Config.types.js";
+const appDir = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const entry2id = (str) => join(dirname(str), basename(str, ".yaml"));
+export class JobLoader extends AbstractTask {
+    configDir;
+    firstRun = true;
+    jobHistory;
+    constructor(options = {}) {
+        super("*/8 * * * * *");
+        this.configDir = resolve(options.configDir ?? process.env[ENV.CONFIG_DIR] ?? "./config");
+        this.jobHistory = new FileHistoryModel();
+    }
+    async run() {
+        const result = [];
+        const ttime = Date.now();
+        const jobsDir = join(this.configDir, "jobs");
+        if (this.firstRun && !fsx.pathExistsSync(jobsDir))
+            try {
+                await fsx.copy(join(appDir, "config"), this.configDir);
+            }
+            catch {
+            }
+        const entries = await glob(["**/*.yaml"], { cwd: jobsDir });
+        this.firstRun = false;
+        for (const entry of entries) {
+            const jobFile = join(jobsDir, entry);
+            try {
+                const stats = await fsx.stat(jobFile);
+                const { changed, added } = this.jobHistory.updateSourceEntry(entry, [stats.mtimeMs, ttime]);
+                if (changed) {
+                    const jobConfig = JobSchema.parse(YAML.parse(await fsx.readFile(jobFile, "utf-8")));
+                    const job = { id: entry2id(entry), ...jobConfig };
+                    result.push(job);
+                    this.events.emit("job-loaded", job, !added);
+                }
+            }
+            catch (err) {
+                const msg = err instanceof ZodError ? `${err.issues[0]?.message}` : String(err);
+                this.events.emit("job-loader-error", entry, msg);
+            }
+        }
+        const removedJobs = this.jobHistory.cleanup();
+        for (const entry of removedJobs) {
+            this.events.emit("job-deleted", entry2id(entry));
+        }
+        this.events.emit("loaded", result);
+        return result;
+    }
+    async loadJobs() {
+        return await this.run();
+    }
+    onceLoaded(cb) {
+        this.events.on("loaded", cb);
+    }
+    onLoadingError(cb) {
+        this.events.on("job-loader-error", cb);
+    }
+    onJobLoaded(cb) {
+        this.events.on("job-loaded", cb);
+    }
+    onJobDeleted(cb) {
+        this.events.on("job-deleted", cb);
+    }
+}

package/dist/tasks/JobRunner.js

@@ -0,0 +1,100 @@
+import glob from "fast-glob";
+import { join } from "node:path";
+import { ensureDir, moveSync, readJSON, writeJSON } from "fs-extra/esm";
+import { AbstractTask } from "./AbstractTask.js";
+import { JobRunnerContext } from "../models/JobRunnerContext.js";
+import { closeSync, fsyncSync, openSync, writeSync } from "node:fs";
+import { JobRunnerResult } from "../models/JobRunnerResult.js";
+import { FileHistoryModel } from "../models/FileHistoryModel.js";
+export class JobRunner extends AbstractTask {
+    job;
+    setup;
+    constructor(job, setup) {
+        super(job.cron);
+        this.job = job;
+        this.setup = setup;
+    }
+    onActivity(cb) {
+        this.events.on("activity", cb);
+    }
+    async runJob() {
+        return await this.run();
+    }
+    async run() {
+        const { setup, job, events } = this;
+        if (job.enabled === false)
+            return new JobRunnerResult();
+        if (this.errorCount >= 25) {
+            job.enabled = false;
+            throw new Error("Too many errors. Job execution disabled!");
+        }
+        await ensureDir(setup.logDir);
+        const logFd = this.initLog(job);
+        const ctx = new JobRunnerContext(setup, job, events, logFd);
+        const handler = setup.getActionHandler(job.action);
+        try {
+            if (job.source) {
+                const entries = await glob(job.sourceIncludes, { cwd: ctx.sourceDir, ignore: job.sourceExcludes, dot: true, extglob: false });
+                const fileHistory = await this.loadFileHistory(job);
+                ctx.writeLog(`Processing source entries ...`);
+                await handler.processFiles(ctx, entries, fileHistory);
+                await this.saveFileHistory(job, fileHistory);
+            }
+            else {
+                await handler.process(ctx);
+            }
+            this.closeLog(logFd, ctx.startTime);
+        }
+        catch (err) {
+            this.closeLog(logFd, ctx.startTime, err instanceof Error ? err : new Error(String(err)));
+        }
+        ctx.result.endTime = Date.now();
+        return ctx.result;
+    }
+    async loadFileHistory(job) {
+        try {
+            const filePath = join(this.setup.logDir, `${job.id}.idx`);
+            return new FileHistoryModel(await readJSON(filePath));
+        }
+        catch {
+            return new FileHistoryModel();
+        }
+    }
+    async saveFileHistory(job, fileHistory) {
+        if (fileHistory.changed) {
+            try {
+                const filePath = join(this.setup.logDir, `${job.id}.idx`);
+                await writeJSON(filePath, fileHistory.data, { spaces: 4 });
+            }
+            catch { }
+        }
+    }
+    initLog(job) {
+        try {
+            const fd = openSync(join(this.setup.logDir, `${job.id}.log`), "w");
+            writeSync(fd, `====== CronOps log for job #${job.id}\n`);
+            writeSync(fd, `started: ${new Date().toISOString()}\n`);
+            writeSync(fd, `action: ${job.action}\n`);
+            return fd;
+        }
+        catch (error) {
+            this.events.emit("error", new Error(`Cannot create log file for job '${job.id}'.\n └─ ${String(error)}`));
+            return 0;
+        }
+    }
+    closeLog(fd, startTime, err) {
+        if (fd)
+            try {
+                if (err)
+                    writeSync(fd, `${String(err)}\n`);
+                writeSync(fd, `====== ${err ? "JOB FAILED" : "JOB FINISHED"}\n`);
+                writeSync(fd, `(duration: ${Date.now() - startTime}ms)\n`);
+                fsyncSync(fd);
+                closeSync(fd);
+            }
+            catch { }
+    }
+    renameLog(job, tag) {
+        moveSync(join(this.setup.logDir, `${job.id}.log`), join(this.setup.logDir, `${job.id}.${tag}.log`));
+    }
+}