@mtakla/cronops 0.1.1-rc6 → 0.1.1-rc7

package/README.md

@@ -47,6 +47,7 @@ CronOps is built and optimized to run as a Docker container itself.
 
 ```sh
 docker run \
+  -p 8083:8083 \
   -v ./config:/config \
   -v ./data:/io/source \
   -v ./data:/io/target \
@@ -118,12 +119,12 @@ docker compose pull && docker compose up -d
 
 in the same directory where `compose.yaml` has been created. 
 
-### Enable admin Web-API
+### Admin Web-API
 
 To enable **admin Web-API**, just set `CROPS_API_KEY` environment variable. Details, see [Configuration](#configuration) section below.
 
 
-### Manual installation
+## Manual installation
 
 This requires [Node.js](https://nodejs.org/) (>= v24) to be installed on your server. 
 
@@ -146,15 +147,15 @@ This will ...
 
 - download the latest version of dotenvx & cronops 
 - load the environment settings defined in the `.env` file
-- start the cronops service with the loaded environment settings 
+- start the CronOps service with the loaded environment settings 
 - create config directory in `./config` if it doesn't exist
 - create logs directory in `./logs` if it doesn't exist
 
 You can now add job configuration files to `./config/jobs` directory. Each YAML file in this directory defines a job. The server will hot reload when job files are added, modified, or removed.
 
-### Use in your code
+## Use in your code
 
-Install CronOps in your code using npm
+Install CronOps in your project using npm
 
 ```
 npm install @mtakla/cronops --save
@@ -193,8 +194,8 @@ runner.onFinished(() => {
   console.log("job finished!");
 });
 
-runner.onError(() => {
-  console.log("job finished!");
+runner.onError((err) => {
+  console.log(`job failed with ${err.message}`);
 });
 
 // finally schedule job
@@ -362,7 +363,7 @@ For jobs of action type `exec` the following environment variables are available
 | `CROPS_TEMP_DIR`   | absolute path to the configured temp directory                   |
 | `CROPS_LOG_DIR`    | absolute path to the configured log directory                    |
 | `CROPS_DRY_RUN`    | "true", if dry_run mode is enabled                               |
-| `CROPS_VERBOSE`    | "true", if dry_run mode is enabled                               |
+| `CROPS_VERBOSE`    | "true", if verbose mode is enabled                               |
 
 
 If the exec action is configured to run on selected `source` files:

package/config/jobs/example-job.yaml

@@ -12,4 +12,4 @@ source:
     - "**/*.log"
 target:
   dir: /outbox
-  retention: "20s"
+  retention: "22s"

package/dist/api/openapi.d.ts

@@ -12,19 +12,144 @@ export declare const openapi: {
                 bearerFormat: string;
             };
         };
+        parameters: {
+            JobId: {
+                name: string;
+                in: string;
+                required: boolean;
+                schema: {
+                    type: string;
+                };
+            };
+        };
+        schemas: {
+            Job: {
+                type: string;
+                additionalProperties: boolean;
+                properties: {
+                    id: {
+                        type: string;
+                        example: string;
+                    };
+                    cron: {
+                        type: string;
+                        minLength: number;
+                        example: string;
+                    };
+                    action: {
+                        type: string;
+                        enum: string[];
+                        example: string;
+                    };
+                    command: {
+                        type: string;
+                    };
+                    shell: {
+                        anyOf: ({
+                            type: string;
+                            minLength?: never;
+                        } | {
+                            type: string;
+                            minLength: number;
+                        })[];
+                    };
+                    args: {
+                        type: string;
+                        items: {
+                            type: string;
+                            minLength: number;
+                        };
+                        minItems: number;
+                    };
+                    env: {
+                        type: string;
+                        propertyNames: {
+                            type: string;
+                            pattern: string;
+                        };
+                        additionalProperties: {
+                            type: string;
+                        };
+                    };
+                    source: {
+                        type: string;
+                        additionalProperties: boolean;
+                        properties: {
+                            dir: {
+                                type: string;
+                                minLength: number;
+                            };
+                            includes: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                    minLength: number;
+                                };
+                                minItems: number;
+                            };
+                            excludes: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                    minLength: number;
+                                };
+                                minItems: number;
+                            };
+                        };
+                    };
+                    target: {
+                        type: string;
+                        additionalProperties: boolean;
+                        properties: {
+                            dir: {
+                                type: string;
+                                minLength: number;
+                            };
+                            archive_name: {
+                                type: string;
+                                minLength: number;
+                            };
+                            permissions: {
+                                type: string;
+                                additionalProperties: boolean;
+                                properties: {
+                                    owner: {
+                                        type: string;
+                                        minLength: number;
+                                    };
+                                    file_mode: {
+                                        type: string;
+                                        minLength: number;
+                                    };
+                                    dir_mode: {
+                                        type: string;
+                                        minLength: number;
+                                    };
+                                };
+                            };
+                            retention: {
+                                type: string;
+                                minLength: number;
+                            };
+                        };
+                    };
+                    dry_run: {
+                        type: string;
+                    };
+                    verbose: {
+                        type: string;
+                    };
+                    enabled: {
+                        type: string;
+                    };
+                };
+            };
+        };
     };
-    tags: ({
+    tags: {
         name: string;
         description: string;
-        externalDocs?: never;
-    } | {
-        name: string;
-        description: string;
-        externalDocs: {
-            description: string;
-            url: string;
-        };
-    })[];
+    }[];
     paths: {
         "/health": {
             get: {
@@ -83,17 +208,78 @@ export declare const openapi: {
                 };
             };
         };
-        "/api/jobs/trigger/{jobId}": {
-            post: {
+        "/api/jobs": {
+            get: {
+                summary: string;
+                tags: string[];
+                responses: {
+                    "200": {
+                        description: string;
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: string;
+                                    items: {
+                                        $ref: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        "/api/jobs/{jobId}": {
+            get: {
                 summary: string;
                 tags: string[];
                 parameters: {
-                    name: string;
-                    in: string;
-                    required: boolean;
-                    schema: {
-                        type: string;
+                    $ref: string;
+                }[];
+                responses: {
+                    "200": {
+                        description: string;
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                    "404": {
+                        description: string;
+                    };
+                };
+            };
+        };
+        "/api/status": {
+            get: {
+                summary: string;
+                tags: string[];
+                responses: {
+                    "200": {
+                        description: string;
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: string;
+                                    items: {
+                                        $ref: string;
+                                    };
+                                };
+                            };
+                        };
                     };
+                };
+            };
+        };
+        "/api/trigger/{jobId}": {
+            post: {
+                summary: string;
+                tags: string[];
+                parameters: {
+                    $ref: string;
                 }[];
                 responses: {
                     "200": {
@@ -123,18 +309,10 @@ export declare const openapi: {
                 };
             };
         };
-        "/api/jobs/pause/{jobId}": {
+        "/api/pause": {
             post: {
                 summary: string;
                 tags: string[];
-                parameters: {
-                    name: string;
-                    in: string;
-                    required: boolean;
-                    schema: {
-                        type: string;
-                    };
-                }[];
                 responses: {
                     "200": {
                         description: string;
@@ -147,9 +325,9 @@ export declare const openapi: {
                                             type: string;
                                             example: boolean;
                                         };
-                                        jobId: {
+                                        jobs: {
                                             type: string;
-                                            example: string;
+                                            example: number;
                                         };
                                     };
                                 };
@@ -159,17 +337,12 @@ export declare const openapi: {
                 };
             };
         };
-        "/api/jobs/resume/{jobId}": {
+        "/api/pause/job/{jobId}": {
             post: {
                 summary: string;
                 tags: string[];
                 parameters: {
-                    name: string;
-                    in: string;
-                    required: boolean;
-                    schema: {
-                        type: string;
-                    };
+                    $ref: string;
                 }[];
                 responses: {
                     "200": {
@@ -179,7 +352,7 @@ export declare const openapi: {
                                 schema: {
                                     type: string;
                                     properties: {
-                                        resumed: {
+                                        paused: {
                                             type: string;
                                             example: boolean;
                                         };
@@ -195,10 +368,13 @@ export declare const openapi: {
                 };
             };
         };
-        "/api/jobs/pause/": {
+        "/api/resume/job/{jobId}": {
             post: {
                 summary: string;
                 tags: string[];
+                parameters: {
+                    $ref: string;
+                }[];
                 responses: {
                     "200": {
                         description: string;
@@ -207,13 +383,13 @@ export declare const openapi: {
                                 schema: {
                                     type: string;
                                     properties: {
-                                        paused: {
+                                        resumed: {
                                             type: string;
                                             example: boolean;
                                         };
-                                        jobs: {
+                                        jobId: {
                                             type: string;
-                                            example: number;
+                                            example: string;
                                         };
                                     };
                                 };
@@ -223,7 +399,7 @@ export declare const openapi: {
                 };
             };
         };
-        "/api/jobs/resume/": {
+        "/api/resume": {
             post: {
                 summary: string;
                 tags: string[];

package/dist/api/openapi.js

@@ -9,6 +9,84 @@ export const openapi = {
                 bearerFormat: "hex-256",
             },
         },
+        parameters: {
+            JobId: {
+                name: "jobId",
+                in: "path",
+                required: true,
+                schema: { type: "string" },
+            },
+        },
+        schemas: {
+            Job: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    id: { type: "string", example: "example-job" },
+                    cron: { type: "string", minLength: 1, example: "*/5 * * * *" },
+                    action: {
+                        type: "string",
+                        enum: ["exec", "call", "copy", "move", "delete", "archive"],
+                        example: "copy",
+                    },
+                    command: { type: "string" },
+                    shell: {
+                        anyOf: [{ type: "boolean" }, { type: "string", minLength: 1 }],
+                    },
+                    args: {
+                        type: "array",
+                        items: { type: "string", minLength: 1 },
+                        minItems: 1,
+                    },
+                    env: {
+                        type: "object",
+                        propertyNames: {
+                            type: "string",
+                            pattern: "^[A-Z_][A-Z0-9_]*$",
+                        },
+                        additionalProperties: { type: "string" },
+                    },
+                    source: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            dir: { type: "string", minLength: 1 },
+                            includes: {
+                                type: "array",
+                                items: { type: "string", minLength: 1 },
+                                minItems: 1,
+                            },
+                            excludes: {
+                                type: "array",
+                                items: { type: "string", minLength: 1 },
+                                minItems: 1,
+                            },
+                        },
+                    },
+                    target: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            dir: { type: "string", minLength: 1 },
+                            archive_name: { type: "string", minLength: 1 },
+                            permissions: {
+                                type: "object",
+                                additionalProperties: false,
+                                properties: {
+                                    owner: { type: "string", minLength: 1 },
+                                    file_mode: { type: "string", minLength: 1 },
+                                    dir_mode: { type: "string", minLength: 1 },
+                                },
+                            },
+                            retention: { type: "string", minLength: 1 },
+                        },
+                    },
+                    dry_run: { type: "boolean" },
+                    verbose: { type: "boolean" },
+                    enabled: { type: "boolean" },
+                },
+            },
+        },
     },
     tags: [
         {
@@ -17,19 +95,11 @@ export const openapi = {
         },
         {
             name: "jobs",
-            description: "CronOps job related tasks",
+            description: "job related api",
         },
         {
-            name: "admin",
-            description: "CronOps admin tasks",
-        },
-        {
-            name: "user",
-            description: "Operations about user",
-            externalDocs: {
-                description: "Find out more about our store",
-                url: "http://swagger.io",
-            },
+            name: "schedule",
+            description: "scheduling api",
         },
     ],
     paths: {
@@ -84,18 +154,69 @@ export const openapi = {
                 },
             },
         },
-        "/api/jobs/trigger/{jobId}": {
+        "/api/jobs": {
+            get: {
+                summary: "Get jobs",
+                tags: ["jobs"],
+                responses: {
+                    "200": {
+                        description: "Array of scheduled jobs",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "array",
+                                    items: { $ref: "#/components/schemas/Job" },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        "/api/jobs/{jobId}": {
+            get: {
+                summary: "Get a job",
+                tags: ["jobs"],
+                parameters: [{ $ref: "#/components/parameters/JobId" }],
+                responses: {
+                    "200": {
+                        description: "Array of scheduled jobs",
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/Job" },
+                            },
+                        },
+                    },
+                    "404": {
+                        description: "Job not found",
+                    },
+                },
+            },
+        },
+        "/api/status": {
+            get: {
+                summary: "Get status",
+                tags: ["schedule"],
+                responses: {
+                    "200": {
+                        description: "Array of scheduled jobs",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "array",
+                                    items: { $ref: "#/components/schemas/Job" },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        "/api/trigger/{jobId}": {
             post: {
                 summary: "Trigger a job",
-                tags: ["jobs"],
-                parameters: [
-                    {
-                        name: "jobId",
-                        in: "path",
-                        required: true,
-                        schema: { type: "string" },
-                    },
-                ],
+                tags: ["schedule"],
+                parameters: [{ $ref: "#/components/parameters/JobId" }],
                 responses: {
                     "200": {
                         description: "Triggered",
@@ -118,18 +239,10 @@ export const openapi = {
                 },
             },
         },
-        "/api/jobs/pause/{jobId}": {
+        "/api/pause": {
             post: {
-                summary: "Pause a job",
-                tags: ["jobs"],
-                parameters: [
-                    {
-                        name: "jobId",
-                        in: "path",
-                        required: true,
-                        schema: { type: "string" },
-                    },
-                ],
+                summary: "Pause jobs",
+                tags: ["schedule"],
                 responses: {
                     "200": {
                         description: "Paused",
@@ -139,7 +252,7 @@ export const openapi = {
                                     type: "object",
                                     properties: {
                                         paused: { type: "boolean", example: true },
-                                        jobId: { type: "string", example: "job-123" },
+                                        jobs: { type: "number", example: 4 },
                                     },
                                 },
                             },
@@ -148,27 +261,20 @@ export const openapi = {
                 },
             },
         },
-        "/api/jobs/resume/{jobId}": {
+        "/api/pause/job/{jobId}": {
             post: {
-                summary: "Resume a job",
-                tags: ["jobs"],
-                parameters: [
-                    {
-                        name: "jobId",
-                        in: "path",
-                        required: true,
-                        schema: { type: "string" },
-                    },
-                ],
+                summary: "Pause a job",
+                tags: ["schedule"],
+                parameters: [{ $ref: "#/components/parameters/JobId" }],
                 responses: {
                     "200": {
-                        description: "Resumed",
+                        description: "Paused",
                         content: {
                             "application/json": {
                                 schema: {
                                     type: "object",
                                     properties: {
-                                        resumed: { type: "boolean", example: true },
+                                        paused: { type: "boolean", example: true },
                                         jobId: { type: "string", example: "job-123" },
                                     },
                                 },
@@ -178,20 +284,21 @@ export const openapi = {
                 },
             },
         },
-        "/api/jobs/pause/": {
+        "/api/resume/job/{jobId}": {
             post: {
-                summary: "Pause all jobs",
-                tags: ["jobs"],
+                summary: "Resume a paused job",
+                tags: ["schedule"],
+                parameters: [{ $ref: "#/components/parameters/JobId" }],
                 responses: {
                     "200": {
-                        description: "Paused",
+                        description: "Resumed",
                         content: {
                             "application/json": {
                                 schema: {
                                     type: "object",
                                     properties: {
-                                        paused: { type: "boolean", example: true },
-                                        jobs: { type: "number", example: 4 },
+                                        resumed: { type: "boolean", example: true },
+                                        jobId: { type: "string", example: "job-123" },
                                     },
                                 },
                             },
@@ -200,10 +307,10 @@ export const openapi = {
                 },
             },
         },
-        "/api/jobs/resume/": {
+        "/api/resume": {
             post: {
-                summary: "Resume all jobs",
-                tags: ["jobs"],
+                summary: "Resume paused jobs",
+                tags: ["schedule"],
                 responses: {
                     "200": {
                         description: "Resumed",

package/dist/api/webapi.js

@@ -5,7 +5,7 @@ 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 baseUrl = process.env[ENV.BASE_URL] ?? `http://127.0.0.1:${port}`;
 const apiKey = process.env[ENV.API_KEY];
 app.addHook("preHandler", async (request, reply) => {
     if (request.method === "OPTIONS" || !request.url.startsWith("/api"))
@@ -38,7 +38,33 @@ app.get("/health", async (request, reply) => {
     const jobs = jobScheduler.getScheduledJobs();
     reply.code(200).send({ status: "ok", active_jobs: jobs.length });
 });
-app.post("/api/jobs/trigger/:jobId", async (request, reply) => {
+app.get("/api/jobs", async (request) => {
+    const jobScheduler = request.server.scheduler;
+    return jobScheduler.getScheduledJobs();
+});
+app.get("/api/jobs/:jobId", async (request, reply) => {
+    const { jobId } = request.params;
+    const jobScheduler = request.server.scheduler;
+    if (!jobScheduler.isJobScheduled(jobId)) {
+        return reply.code(404).send();
+    }
+    return jobScheduler.getJob(jobId);
+});
+app.get("/api/status", async (request) => {
+    const jobScheduler = request.server.scheduler;
+    return jobScheduler.getScheduledJobsInfo();
+});
+app.post("/api/pause", async (request) => {
+    const jobScheduler = request.server.scheduler;
+    await jobScheduler.pauseScheduling();
+    return { paused: true };
+});
+app.post("/api/resume", async (request) => {
+    const jobScheduler = request.server.scheduler;
+    await jobScheduler.resumeScheduling();
+    return { resumed: true };
+});
+app.post("/api/trigger/:jobId", async (request, reply) => {
     const { jobId } = request.params;
     const jobScheduler = request.server.scheduler;
     if (!jobScheduler.isJobScheduled(jobId)) {

package/dist/handlers/AbstractHandler.js

@@ -141,12 +141,12 @@ export class AbstractHandler {
         await Promise.all(targetScanPromises);
         fileHistory.cleanup();
     }
-    async setTargetFilePermissions(destPath, perms, isDir = false) {
+    async setTargetFilePermissions(destFile, perms, isDir = false) {
         const mode = isDir ? perms.dirMode : perms.fileMode;
         if (perms.uid >= 0 && perms.gid >= 0)
-            await fsx.chown(destPath, perms.uid, perms.gid);
+            await fsx.chown(destFile, perms.uid, perms.gid);
         if (mode >= 0)
-            await fsx.chmod(destPath, mode);
+            await fsx.chmod(destFile, mode);
     }
     getFolderPermissionPromises(ctx, dirPath, folderPromises) {
         if (dirPath.length < ctx.targetDir.length || folderPromises.has(dirPath))

package/dist/server.js

@@ -34,18 +34,25 @@ export async function start() {
         console.log(`🔴 Error loading job '${entry}'. ${message}`);
     });
     jobLoader.onJobLoaded((job) => {
-        if (job.enabled !== false)
-            jobScheduler.scheduleJob(job);
+        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")})`);
+        const jobs = jobScheduler.getScheduledJobsInfo();
+        console.log(`\nJob config ${isReload ? "changed" : "loaded"}`);
         for (const job of jobs) {
-            console.log(` 🕔 [${job.id}] scheduled (${chalk.greenBright(job.cron)})${job.dry_run ? " 👋 DRY-RUN mode!" : ""}`);
+            if (job.status !== "paused")
+                console.log(` 🕔 [${job.id}] scheduled (${chalk.greenBright(job.cron)})${job.dry_run ? " 👋 DRY-RUN mode!" : ""}`);
         }
+        for (const job of jobs) {
+            if (job.status === "paused")
+                console.log(` ⚫ [${job.id}] inactive`);
+        }
+    });
+    jobScheduler.onJobExecute((job) => {
+        console.error(`[${job.id}] triggered manually`);
     });
     jobScheduler.onJobError((job, err) => {
         console.error(chalk.red(`[${job.id}] ERROR ${err.message}`));

package/dist/tasks/AbstractTask.d.ts

@@ -1,17 +1,26 @@
 import { type ScheduledTask } from "node-cron";
 import { EventEmitter } from "node:events";
-import type { Task } from "../types/Task.types.js";
+import type { Task, TaskInfo } from "../types/Task.types.js";
 export declare abstract class AbstractTask<T> implements Task {
     protected cronTask: ScheduledTask;
     protected events: EventEmitter<any>;
     protected errorCount: number;
+    private runCount;
+    private isScheduled;
     private isRunning;
+    private isPaused;
+    private lastRun?;
+    private lastDuration?;
     constructor(cronStr?: string);
     protected abstract run(): Promise<T>;
     schedule(runImmediately?: boolean): void;
     unschedule(): void;
-    execute(cb?: (result: T) => void): void;
+    pause(): void;
+    resume(): void;
+    getInfo(): TaskInfo;
+    execute<T>(): Promise<T>;
     onScheduled(cb: () => void): void;
+    onExecute(cb: () => void): void;
     onStarted(cb: () => void): void;
     onFinished<T>(cb: (result: T) => void): void;
     onError(cb: (error: Error) => void): void;

package/dist/tasks/AbstractTask.js

@@ -6,20 +6,29 @@ export class AbstractTask {
     cronTask;
     events = new EventEmitter();
     errorCount = 0;
+    runCount = 0;
+    isScheduled = false;
     isRunning = false;
+    isPaused = false;
+    lastRun;
+    lastDuration;
     constructor(cronStr = "* * * * *") {
         const asyncRunner = async () => {
-            if (!this.isRunning) {
+            if (!this.isRunning && !this.isPaused) {
+                this.runCount++;
                 this.isRunning = true;
+                this.lastRun = Date.now();
                 try {
                     this.events.emit("started");
                     this.events.emit("finished", await this.run());
                 }
                 catch (err) {
+                    this.errorCount++;
                     this.events.emit("error", err instanceof Error ? err : new Error(String(err)));
                 }
                 finally {
                     this.isRunning = false;
+                    this.lastDuration = Date.now() - this.lastRun;
                 }
             }
         };
@@ -30,26 +39,45 @@ export class AbstractTask {
     }
     schedule(runImmediately = false) {
         if (runImmediately)
-            this.cronTask.once("task:started", () => this.execute());
+            this.cronTask.once("task:started", () => this.cronTask.execute());
         this.cronTask.start();
+        this.isScheduled = true;
     }
     unschedule() {
         this.events.removeAllListeners();
         this.cronTask.destroy();
+        this.isScheduled = false;
     }
-    execute(cb) {
+    pause() {
+        this.isPaused = true;
+    }
+    resume() {
+        this.isPaused = false;
+    }
+    getInfo() {
+        return {
+            status: this.isRunning ? "running" : this.isPaused ? "paused" : this.isScheduled ? "scheduled" : "unscheduled",
+            runCount: this.runCount,
+            errorCount: this.errorCount,
+            lastRun: this.lastRun,
+            lastDuration: this.lastDuration,
+        };
+    }
+    execute() {
         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();
+        this.events.emit("execute");
+        return this.cronTask.execute();
     }
     onScheduled(cb) {
         this.cronTask.on("task:started", cb);
     }
+    onExecute(cb) {
+        this.events.on("execute", cb);
+    }
     onStarted(cb) {
         this.events.on("started", cb);
     }
@@ -57,7 +85,6 @@ export class AbstractTask {
         this.events.on("finished", cb);
     }
     onError(cb) {
-        this.errorCount++;
         this.events.on("error", (error) => cb(error));
     }
     async gracefulTerminate(timeout = 500) {

package/dist/tasks/JobRunner.d.ts

@@ -1,5 +1,4 @@
 import { AbstractTask } from "./AbstractTask.js";
-import { JobRunnerResult } from "../models/JobRunnerResult.js";
 import type { JobModel } from "../models/JobModel.js";
 import type { JobRunnerSetup } from "../models/JobRunnerSetup.js";
 import type { RunnerResult, FileHistory } from "../types/Task.types.js";
@@ -9,8 +8,8 @@ export declare class JobRunner extends AbstractTask<RunnerResult> {
     setup: JobRunnerSetup;
     constructor(job: JobModel, setup: JobRunnerSetup);
     onActivity(cb: (action: string, path: string, count: number) => void): void;
-    runJob(): Promise<JobRunnerResult>;
-    protected run(): Promise<JobRunnerResult>;
+    runJob(): Promise<RunnerResult>;
+    protected run(): Promise<RunnerResult>;
     protected loadFileHistory(job: Job): Promise<FileHistory>;
     protected saveFileHistory(job: Job, fileHistory: FileHistory): Promise<void>;
     protected initLog(job: Job): number;

package/dist/tasks/JobRunner.js

@@ -4,7 +4,6 @@ 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;
@@ -22,10 +21,8 @@ export class JobRunner extends AbstractTask {
     }
     async run() {
         const { setup, job, events } = this;
-        if (job.enabled === false)
-            return new JobRunnerResult();
-        if (this.errorCount >= 25) {
-            job.enabled = false;
+        if (this.errorCount >= 31) {
+            this.pause();
             throw new Error("Too many errors. Job execution disabled!");
         }
         await ensureDir(setup.logDir);

package/dist/tasks/JobScheduler.d.ts

@@ -2,8 +2,9 @@ import { JobRunner } from "./JobRunner.js";
 import { JobRunnerSetup } from "../models/JobRunnerSetup.js";
 import { AbstractTask } from "./AbstractTask.js";
 import type { Job } from "../types/Config.types.js";
-import type { RunnerResult } from "../types/Task.types.js";
+import type { RunnerResult, TaskInfo } from "../types/Task.types.js";
 import type { RunnerOptions } from "../types/Options.types.js";
+type SchedulingInfo = Job & TaskInfo;
 export declare class JobScheduler extends AbstractTask<void> {
     protected runnerSetup: JobRunnerSetup;
     protected runnerMap: Map<string, JobRunner>;
@@ -13,19 +14,29 @@ export declare class JobScheduler extends AbstractTask<void> {
     get scheduledJobs(): number;
     get tempDir(): string;
     protected run(): Promise<void>;
+    pauseAll(): void;
+    resumeAll(): void;
     unscheduleAll(): void;
     scheduleJobs(jobs: Job[], cb?: (count: number) => void): void;
-    scheduleJob(job: Job, defaults?: {}): void;
+    scheduleJob(job: Job): void;
     unscheduleJob(jobId: string): void;
     isJobScheduled(jobId: string): boolean;
+    getJob(jobId: string): Job | undefined;
     executeJob(jobId: string): void;
     validateJob(job: Job): void;
+    pauseScheduling(): void;
+    resumeScheduling(): void;
+    pauseJobScheduling(jobId: string): void;
+    resumeJobScheduling(jobId: string): void;
     getScheduledJobs(): Job[];
+    getScheduledJobsInfo(): SchedulingInfo[];
     gracefulTerminate(timeout?: number): Promise<void>;
     onChanged(cb: (initialConfig: boolean) => void): void;
     onJobScheduled(cb: (job: Job, rescheduled: boolean) => void): void;
+    onJobExecute(cb: (job: Job) => void): void;
     onJobStarted(cb: (job: Job) => void): void;
     onJobFinished(cb: (job: Job, stat: RunnerResult) => void): void;
     onJobActivity(cb: (job: Job, activity: string, path: string, count: number) => void): void;
     onJobError(cb: (job: Job, err: Error) => void): void;
 }
+export {};

package/dist/tasks/JobScheduler.js

@@ -2,7 +2,6 @@ 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;
@@ -26,6 +25,14 @@ export class JobScheduler extends AbstractTask {
             this.isReload = true;
         }
     }
+    pauseAll() {
+        for (const runner of this.runnerMap.values())
+            runner.resume();
+    }
+    resumeAll() {
+        for (const runner of this.runnerMap.values())
+            runner.resume();
+    }
     unscheduleAll() {
         for (const runner of this.runnerMap.values())
             runner.unschedule();
@@ -39,23 +46,24 @@ export class JobScheduler extends AbstractTask {
         if (cb)
             cb(this.runnerMap.size);
     }
-    scheduleJob(job, defaults = {}) {
+    scheduleJob(job) {
         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);
+        const task = new JobRunner(new JobModel(job), this.runnerSetup);
         this.runnerMap.set(job.id, task);
         task.onScheduled(() => this.events.emit("job-scheduled", job, rescheduled));
+        task.onExecute(() => this.events.emit("job-execute", job));
         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();
+        if (job.enabled === false)
+            task.pause();
         this.changed = true;
     }
     unscheduleJob(jobId) {
@@ -69,6 +77,9 @@ export class JobScheduler extends AbstractTask {
     isJobScheduled(jobId) {
         return this.runnerMap.has(jobId);
     }
+    getJob(jobId) {
+        return this.runnerMap.get(jobId)?.job;
+    }
     executeJob(jobId) {
         if (!this.runnerMap.has(jobId))
             throw new Error(`Unknown job [${jobId}]!`);
@@ -77,9 +88,32 @@ export class JobScheduler extends AbstractTask {
     validateJob(job) {
         this.runnerSetup.validateJob(job);
     }
+    pauseScheduling() {
+        for (const task of this.runnerMap.values())
+            this.pauseJobScheduling(task.job.id);
+        this.changed = true;
+    }
+    resumeScheduling() {
+        for (const task of this.runnerMap.values())
+            this.resumeJobScheduling(task.job.id);
+        this.changed = true;
+    }
+    pauseJobScheduling(jobId) {
+        const task = this.runnerMap.get(jobId);
+        if (task)
+            task.pause();
+    }
+    resumeJobScheduling(jobId) {
+        const task = this.runnerMap.get(jobId);
+        if (task && task.job.enabled !== false)
+            task.resume();
+    }
     getScheduledJobs() {
         return Array.from(this.runnerMap.values()).map((runner) => runner.job);
     }
+    getScheduledJobsInfo() {
+        return Array.from(this.runnerMap.values()).map((runner) => Object.assign({}, runner.job, runner.getInfo()));
+    }
     async gracefulTerminate(timeout = 1000) {
         const jobRunnerTasks = [...this.runnerMap.values()];
         this.unscheduleAll();
@@ -93,6 +127,9 @@ export class JobScheduler extends AbstractTask {
     onJobScheduled(cb) {
         this.events.on("job-scheduled", cb);
     }
+    onJobExecute(cb) {
+        this.events.on("job-execute", cb);
+    }
     onJobStarted(cb) {
         this.events.on("job-started", cb);
     }

package/dist/types/Config.types.d.ts

@@ -2,7 +2,14 @@ import { z } from "zod";
 export declare const JobSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     cron: z.ZodOptional<z.ZodString>;
-    action: z.ZodLiteral<"exec" | "call" | "copy" | "move" | "delete" | "archive">;
+    action: z.ZodEnum<{
+        exec: "exec";
+        call: "call";
+        copy: "copy";
+        move: "move";
+        delete: "delete";
+        archive: "archive";
+    }>;
     command: z.ZodOptional<z.ZodString>;
     shell: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
     args: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/types/Config.types.js

@@ -2,7 +2,7 @@ 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"]),
+    action: z.enum(["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(),

package/dist/types/Task.types.d.ts

@@ -13,6 +13,13 @@ export type RunnerResult = {
     endTime: number;
     durationMs: number;
 };
+export type TaskInfo = {
+    status: "unscheduled" | "scheduled" | "running" | "paused";
+    runCount: number;
+    errorCount: number;
+    lastRun: number | undefined;
+    lastDuration: number | undefined;
+};
 export type SourceFile = {
     sourceEntry: string;
     sourcePath: string;
@@ -36,7 +43,7 @@ export type FileHistory = {
 export interface Task {
     schedule(runImmediately?: boolean): void;
     unschedule(): void;
-    execute(cb: () => void): void;
+    execute<T>(): Promise<T>;
     onScheduled(cb: () => void): void;
     onStarted(cb: () => void): void;
     onFinished<T>(cb: (result: T) => void): void;

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@mtakla/cronops",
-   "version": "0.1.1-rc6",
+   "version": "0.1.1-rc7",
    "description": "Automated cross-container file lifecycle management with cron scheduling",
    "type": "module",
    "author": "mtakla@nevereven",