@mtakla/cronops 0.1.1-rc4 → 0.1.1-rc5

package/dist/api/openapi.d.ts

@@ -0,0 +1,261 @@
+export declare const openapi: {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+    };
+    components: {
+        securitySchemes: {
+            ApiKeyBearer: {
+                type: string;
+                scheme: string;
+                bearerFormat: string;
+            };
+        };
+    };
+    tags: ({
+        name: string;
+        description: string;
+        externalDocs?: never;
+    } | {
+        name: string;
+        description: string;
+        externalDocs: {
+            description: string;
+            url: string;
+        };
+    })[];
+    paths: {
+        "/health": {
+            get: {
+                summary: string;
+                tags: string[];
+                security: never[];
+                responses: {
+                    "200": {
+                        description: string;
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: string;
+                                    properties: {
+                                        status: {
+                                            type: string;
+                                            example: string;
+                                        };
+                                        active_jobs: {
+                                            type: string;
+                                            example: number;
+                                        };
+                                    };
+                                    required: string[];
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        "/docs": {
+            get: {
+                summary: string;
+                tags: string[];
+                security: never[];
+                responses: {
+                    "200": {
+                        description: string;
+                    };
+                };
+            };
+        };
+        "/openapi.json": {
+            get: {
+                summary: string;
+                tags: string[];
+                security: never[];
+                responses: {
+                    "200": {
+                        description: string;
+                        content: {
+                            "application/json": {};
+                        };
+                    };
+                };
+            };
+        };
+        "/api/jobs/trigger/{jobId}": {
+            post: {
+                summary: string;
+                tags: string[];
+                parameters: {
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                }[];
+                responses: {
+                    "200": {
+                        description: string;
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: string;
+                                    properties: {
+                                        triggered: {
+                                            type: string;
+                                            example: boolean;
+                                        };
+                                        jobId: {
+                                            type: string;
+                                            example: string;
+                                        };
+                                    };
+                                    required: string[];
+                                };
+                            };
+                        };
+                    };
+                    "404": {
+                        description: string;
+                    };
+                };
+            };
+        };
+        "/api/jobs/pause/{jobId}": {
+            post: {
+                summary: string;
+                tags: string[];
+                parameters: {
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                }[];
+                responses: {
+                    "200": {
+                        description: string;
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: string;
+                                    properties: {
+                                        paused: {
+                                            type: string;
+                                            example: boolean;
+                                        };
+                                        jobId: {
+                                            type: string;
+                                            example: string;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        "/api/jobs/resume/{jobId}": {
+            post: {
+                summary: string;
+                tags: string[];
+                parameters: {
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                }[];
+                responses: {
+                    "200": {
+                        description: string;
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: string;
+                                    properties: {
+                                        resumed: {
+                                            type: string;
+                                            example: boolean;
+                                        };
+                                        jobId: {
+                                            type: string;
+                                            example: string;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        "/api/jobs/pause/": {
+            post: {
+                summary: string;
+                tags: string[];
+                responses: {
+                    "200": {
+                        description: string;
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: string;
+                                    properties: {
+                                        paused: {
+                                            type: string;
+                                            example: boolean;
+                                        };
+                                        jobs: {
+                                            type: string;
+                                            example: number;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        "/api/jobs/resume/": {
+            post: {
+                summary: string;
+                tags: string[];
+                responses: {
+                    "200": {
+                        description: string;
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: string;
+                                    properties: {
+                                        resumed: {
+                                            type: string;
+                                            example: boolean;
+                                        };
+                                        jobs: {
+                                            type: string;
+                                            example: number;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    servers: {
+        url: string;
+    }[];
+    security: {
+        ApiKeyBearer: never[];
+    }[];
+};

package/dist/api/webapi.d.ts

@@ -0,0 +1,7 @@
+import type { JobScheduler } from "../tasks/JobScheduler.js";
+declare module "fastify" {
+    interface FastifyInstance {
+        scheduler: JobScheduler;
+    }
+}
+export default function (scheduler: JobScheduler): void;

package/dist/errors/JobError.d.ts

@@ -0,0 +1,5 @@
+export declare class JobError extends Error {
+    readonly jobId: string;
+    constructor(jobId: string, message: string, cause?: Error);
+    static throw(jobId: string, message: string, cause?: Error | undefined): void;
+}

package/dist/handlers/AbstractHandler.d.ts

@@ -0,0 +1,23 @@
+import type { JobRunnerSetup } from "../models/JobRunnerSetup.js";
+import type { ActionHandler, SourceFile, RunnerContext, FileHistory } from "../types/Task.types.js";
+import type { Job } from "../types/Config.types.js";
+export declare abstract class AbstractHandler implements ActionHandler {
+    protected setup: JobRunnerSetup;
+    constructor(setup: JobRunnerSetup);
+    validateJob(_job: Job): void;
+    process(_ctx: RunnerContext): Promise<void>;
+    processFiles(_ctx: RunnerContext, _entries: string[], _fileHistory: FileHistory): Promise<void>;
+    protected assertSourceConfigExists(job: Job): void;
+    protected assertTargetConfigExists(job: Job): void;
+    protected assertSourceDirExist(job: Job): void;
+    protected processSources(ctx: RunnerContext, entries: string[], fileHistory?: FileHistory, processor?: (ctx: RunnerContext, entry: SourceFile, fileHistory?: FileHistory) => Promise<void>): Promise<void>;
+    protected copyOrMoveFile(ctx: RunnerContext, entry: SourceFile, fileHistory?: FileHistory): Promise<void>;
+    protected deleteFile(ctx: RunnerContext, { sourcePath }: SourceFile): Promise<void>;
+    protected createArchive(ctx: RunnerContext, entries: string[], fileHistory: FileHistory): Promise<void>;
+    protected deleteEmptySourceDirs(ctx: RunnerContext): Promise<void>;
+    protected createTargetDirs(ctx: RunnerContext, entries: string[]): Promise<void>;
+    protected setTargetDirPermissions(ctx: RunnerContext): Promise<void>;
+    protected cleanup(ctx: RunnerContext, fileHistory: FileHistory): Promise<void>;
+    private setTargetFilePermissions;
+    private getFolderPermissionPromises;
+}

package/dist/handlers/ExecHandler.d.ts

@@ -0,0 +1,14 @@
+import { AbstractHandler } from "./AbstractHandler.js";
+import type { ActionHandler, FileHistory, RunnerContext, SourceFile } from "../types/Task.types.js";
+import type { Job } from "../types/Config.types.js";
+export declare class ExecHandler extends AbstractHandler implements ActionHandler {
+    validateJob(job: Job): void;
+    process(ctx: RunnerContext): Promise<void>;
+    processFiles(ctx: RunnerContext, entries: string[], fileHistory: FileHistory): Promise<void>;
+    protected exec(ctx: RunnerContext, entry?: SourceFile): Promise<void>;
+    protected createVars(ctx: RunnerContext, entry?: SourceFile): {
+        vars: Record<string, string>;
+        env: Record<string, string>;
+    };
+    protected resolveVars(str: string, vars: Record<string, string>): string;
+}

package/dist/handlers/FileArchiveHandler.d.ts

@@ -0,0 +1,7 @@
+import type { Job } from "../types/Config.types.js";
+import type { ActionHandler, FileHistory, RunnerContext } from "../types/Task.types.js";
+import { AbstractHandler } from "./AbstractHandler.js";
+export declare class FileArchiveHandler extends AbstractHandler implements ActionHandler {
+    validateJob(job: Job): void;
+    processFiles(ctx: RunnerContext, entries: string[], fileHistory: FileHistory): Promise<void>;
+}

package/dist/handlers/FileCopyHandler.d.ts

@@ -0,0 +1,7 @@
+import type { ActionHandler, RunnerContext, FileHistory } from "../types/Task.types.js";
+import { AbstractHandler } from "./AbstractHandler.js";
+import type { Job } from "../types/Config.types.js";
+export declare class FileCopyHandler extends AbstractHandler implements ActionHandler {
+    validateJob(job: Job): void;
+    processFiles(ctx: RunnerContext, entries: string[], fileHistory: FileHistory): Promise<void>;
+}

package/dist/handlers/FileDeleteHandler.d.ts

@@ -0,0 +1,7 @@
+import type { Job } from "../types/Config.types.js";
+import type { ActionHandler, FileHistory, RunnerContext } from "../types/Task.types.js";
+import { AbstractHandler } from "./AbstractHandler.js";
+export declare class FileDeleteHandler extends AbstractHandler implements ActionHandler {
+    validateJob(_job: Job): void;
+    processFiles(ctx: RunnerContext, entries: string[], fileHistory: FileHistory): Promise<void>;
+}

package/dist/handlers/FileMoveHandler.d.ts

@@ -0,0 +1,7 @@
+import type { ActionHandler, FileHistory, RunnerContext } from "../types/Task.types.js";
+import { AbstractHandler } from "./AbstractHandler.js";
+import type { Job } from "../types/Config.types.js";
+export declare class FileMoveHandler extends AbstractHandler implements ActionHandler {
+    validateJob(job: Job): void;
+    processFiles(ctx: RunnerContext, entries: string[], fileHistory: FileHistory): Promise<void>;
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { JobScheduler } from "./tasks/JobScheduler.js";
+import { JobLoader } from "./tasks/JobLoader.js";
+import { JobRunner } from "./tasks/JobRunner.js";
+import type { Job } from "./types/Config.types.js";
+import type { LoaderOptions, RunnerOptions } from "./types/Options.types.js";
+export type { LoaderOptions, RunnerOptions } from "./types/Options.types.js";
+export type { RunnerResult } from "./types/Task.types.js";
+export type { Job } from "./types/Config.types.js";
+export declare function createJobLoader(options?: LoaderOptions): JobLoader;
+export declare function createJobScheduler(options?: RunnerOptions): JobScheduler;
+export declare function createJobRunner(job: Job, options?: RunnerOptions): JobRunner;
+declare const _default: {
+    createJobLoader: typeof createJobLoader;
+    createJobScheduler: typeof createJobScheduler;
+    createJobRunner: typeof createJobRunner;
+};
+export default _default;

package/dist/models/FileHistoryModel.d.ts

@@ -0,0 +1,16 @@
+import type { FileHistory, FileHistoryData } from "../types/Task.types";
+export declare class FileHistoryModel implements FileHistory {
+    data: FileHistoryData;
+    changed: boolean;
+    private included;
+    private outdated;
+    constructor(data?: FileHistoryData);
+    updateSourceEntry(path: string, entry: [number, number]): {
+        changed: boolean;
+        added: boolean;
+    };
+    addTargetEntry(path: string, entry: [number, number]): void;
+    markTargetOutdated(path: string): void;
+    cleanup(): string[];
+    private _removeEntry;
+}

package/dist/models/JobModel.d.ts

@@ -0,0 +1,21 @@
+import type { Job, JobAction, JobSource, JobTarget } from "../types/Config.types.js";
+export declare class JobModel {
+    id: string;
+    action: JobAction;
+    command: string;
+    shell: boolean | string | undefined;
+    args: string[];
+    env: Record<string, string>;
+    cron: string;
+    source: JobSource;
+    target: JobTarget;
+    dry_run: boolean;
+    verbose: boolean;
+    enabled: boolean;
+    constructor(data: Job, config?: {});
+    get sourceIncludes(): string[];
+    get sourceExcludes(): string[];
+    get targetArchiveName(): string;
+    get targetPermissions(): string;
+    private resolveDatePattern;
+}

package/dist/models/JobRunnerContext.d.ts

@@ -0,0 +1,22 @@
+import type { RunnerContext, RunnerResult } from "../types/Task.types.js";
+import type { JobModel } from "./JobModel.js";
+import { EventEmitter } from "node:events";
+import { PermissionModel } from "./PermissionModel.js";
+import type { JobRunnerSetup } from "./JobRunnerSetup.js";
+export declare class JobRunnerContext implements RunnerContext {
+    readonly job: JobModel;
+    readonly result: RunnerResult;
+    readonly startTime: number;
+    readonly sourceDir: string;
+    readonly targetDir: string;
+    readonly sourceDirs: Set<string>;
+    readonly targetDirs: Set<string>;
+    readonly targetPermissions: PermissionModel;
+    private events;
+    private logFd;
+    constructor(setup: JobRunnerSetup, job: JobModel, events?: EventEmitter, logFd?: number);
+    getLogFd(): number;
+    writeLog(msg: string): void;
+    processError(error: Error): void;
+    processActivity(action: string, path?: string, count?: number): void;
+}

package/dist/models/JobRunnerResult.d.ts

@@ -0,0 +1,12 @@
+import type { RunnerResult } from "../types/Task.types.js";
+export declare class JobRunnerResult implements RunnerResult {
+    copied: number;
+    deleted: number;
+    archived: number;
+    executed: number;
+    pruned: number;
+    errors: number;
+    startTime: number;
+    endTime: number;
+    get durationMs(): number;
+}

package/dist/models/JobRunnerSetup.d.ts

@@ -0,0 +1,26 @@
+import { type RunnerOptions } from "../types/Options.types.js";
+import { type Job, type JobAction } from "../types/Config.types.js";
+import type { AbstractHandler } from "../handlers/AbstractHandler.js";
+export declare class JobRunnerSetup implements RunnerOptions {
+    readonly sourceRoot: string;
+    readonly targetRoot: string;
+    readonly source2Root: string;
+    readonly target2Root: string;
+    readonly source3Root: string;
+    readonly target3Root: string;
+    readonly shell: string | boolean;
+    readonly configDir: string;
+    readonly tempDir: string;
+    readonly logDir: string;
+    readonly scriptDir: string;
+    private sourceRootDirs;
+    private targetRootDirs;
+    private handlerMap;
+    constructor(options?: RunnerOptions);
+    resolveSourceDir(relPath?: string): string;
+    resolveTargetDir(relPath?: string): string;
+    getActionHandler(action: JobAction): AbstractHandler;
+    validateJob(job: Job): void;
+    private _validateDir;
+    private _resolveDir;
+}

package/dist/models/PermissionModel.d.ts

@@ -0,0 +1,7 @@
+export declare class PermissionModel {
+    uid: number;
+    gid: number;
+    fileMode: number;
+    dirMode: number;
+    constructor(attr: string);
+}

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function start(): Promise<void>;

package/dist/tasks/AbstractTask.d.ts

@@ -0,0 +1,19 @@
+import { type ScheduledTask } from "node-cron";
+import { EventEmitter } from "node:events";
+import type { Task } from "../types/Task.types.js";
+export declare abstract class AbstractTask<T> implements Task {
+    protected cronTask: ScheduledTask;
+    protected events: EventEmitter<any>;
+    protected errorCount: number;
+    private isRunning;
+    constructor(cronStr?: string);
+    protected abstract run(): Promise<T>;
+    schedule(runImmediately?: boolean): void;
+    unschedule(): void;
+    execute(cb?: (result: T) => void): void;
+    onScheduled(cb: () => void): void;
+    onStarted(cb: () => void): void;
+    onFinished<T>(cb: (result: T) => void): void;
+    onError(cb: (error: Error) => void): void;
+    gracefulTerminate(timeout?: number): Promise<void>;
+}

package/dist/tasks/JobLoader.d.ts

@@ -0,0 +1,15 @@
+import { AbstractTask } from "./AbstractTask.js";
+import { type LoaderOptions } from "../types/Options.types.js";
+import { type Job } from "../types/Config.types.js";
+export declare class JobLoader extends AbstractTask<Job[]> {
+    configDir: string;
+    private firstRun;
+    private jobHistory;
+    constructor(options?: LoaderOptions);
+    protected run(): Promise<Job[]>;
+    loadJobs(): Promise<Job[]>;
+    onceLoaded(cb: (jobs: Job[]) => void): void;
+    onLoadingError(cb: (jobId: string, message: string) => void): void;
+    onJobLoaded(cb: (job: Job, isReload: boolean) => void): void;
+    onJobDeleted(cb: (jobId: string) => void): void;
+}

package/dist/tasks/JobRunner.d.ts

@@ -0,0 +1,19 @@
+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";
+import type { Job } from "../types/Config.types.js";
+export declare class JobRunner extends AbstractTask<RunnerResult> {
+    job: JobModel;
+    setup: JobRunnerSetup;
+    constructor(job: JobModel, setup: JobRunnerSetup);
+    onActivity(cb: (action: string, path: string, count: number) => void): void;
+    runJob(): Promise<JobRunnerResult>;
+    protected run(): Promise<JobRunnerResult>;
+    protected loadFileHistory(job: Job): Promise<FileHistory>;
+    protected saveFileHistory(job: Job, fileHistory: FileHistory): Promise<void>;
+    protected initLog(job: Job): number;
+    protected closeLog(fd: number, startTime: number, err?: Error): void;
+    protected renameLog(job: Job, tag: string): void;
+}

package/dist/tasks/JobScheduler.d.ts

@@ -0,0 +1,31 @@
+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 { RunnerOptions } from "../types/Options.types.js";
+export declare class JobScheduler extends AbstractTask<void> {
+    protected runnerSetup: JobRunnerSetup;
+    protected runnerMap: Map<string, JobRunner>;
+    private changed;
+    private isReload;
+    constructor(options?: RunnerOptions);
+    get scheduledJobs(): number;
+    get tempDir(): string;
+    protected run(): Promise<void>;
+    unscheduleAll(): void;
+    scheduleJobs(jobs: Job[], cb?: (count: number) => void): void;
+    scheduleJob(job: Job, defaults?: {}): void;
+    unscheduleJob(jobId: string): void;
+    isJobScheduled(jobId: string): boolean;
+    executeJob(jobId: string): void;
+    validateJob(job: Job): void;
+    getScheduledJobs(): Job[];
+    gracefulTerminate(timeout?: number): Promise<void>;
+    onChanged(cb: (initialConfig: boolean) => void): void;
+    onJobScheduled(cb: (job: Job, rescheduled: boolean) => 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;
+}

package/dist/tests/loadtest.d.ts

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

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

@@ -0,0 +1,34 @@
+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">;
+    command: z.ZodOptional<z.ZodString>;
+    shell: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    source: z.ZodOptional<z.ZodObject<{
+        dir: z.ZodOptional<z.ZodString>;
+        includes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        excludes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    target: z.ZodOptional<z.ZodObject<{
+        dir: z.ZodOptional<z.ZodString>;
+        archive_name: z.ZodOptional<z.ZodString>;
+        permissions: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodOptional<z.ZodString>;
+            file_mode: z.ZodOptional<z.ZodString>;
+            dir_mode: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        retention: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    dry_run: z.ZodOptional<z.ZodBoolean>;
+    verbose: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type Job = {
+    id: string;
+} & z.infer<typeof JobSchema>;
+export type JobAction = z.infer<typeof JobSchema.shape.action>;
+export type JobSource = z.infer<typeof JobSchema.shape.source>;
+export type JobTarget = z.infer<typeof JobSchema.shape.target>;

package/dist/types/Options.types.d.ts

@@ -0,0 +1,34 @@
+export type RunnerOptions = {
+    configDir?: string;
+    tempDir?: string;
+    logDir?: string;
+    sourceRoot?: string;
+    source2Root?: string;
+    source3Root?: string;
+    targetRoot?: string;
+    target2Root?: string;
+    target3Root?: string;
+    shell?: string | boolean;
+};
+export type LoaderOptions = {
+    configDir?: string;
+};
+export declare const ENV: {
+    readonly CONFIG_DIR: "CROPS_CONFIG_DIR";
+    readonly TEMP_DIR: "CROPS_TEMP_DIR";
+    readonly LOG_DIR: "CROPS_LOG_DIR";
+    readonly SOURCE_ROOT: "CROPS_SOURCE_ROOT";
+    readonly TARGET_ROOT: "CROPS_TARGET_ROOT";
+    readonly SOURCE_2_ROOT: "CROPS_SOURCE_2_ROOT";
+    readonly TARGET_2_ROOT: "CROPS_TARGET_2_ROOT";
+    readonly SOURCE_3_ROOT: "CROPS_SOURCE_3_ROOT";
+    readonly TARGET_3_ROOT: "CROPS_TARGET_3_ROOT";
+    readonly EXEC_SHELL: "CROPS_EXEC_SHELL";
+    readonly PLIMIT_SPAWN: "CROPS_PLIMIT_SPAWN";
+    readonly PLIMIT_FS: "CROPS_PLIMIT_FS";
+    readonly API_KEY: "CROPS_API_KEY";
+    readonly BASE_URL: "CROPS_BASE_URL";
+    readonly HOST: "CROPS_HOST";
+    readonly PORT: "CROPS_PORT";
+    readonly TZ: "TZ";
+};

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

@@ -0,0 +1,64 @@
+import type { Stats } from "fs-extra";
+import type { Job } from "./Config.types.js";
+import type { JobModel } from "../models/JobModel.js";
+import type { PermissionModel } from "../models/PermissionModel.js";
+export type RunnerResult = {
+    copied: number;
+    deleted: number;
+    archived: number;
+    executed: number;
+    pruned: number;
+    errors: number;
+    startTime: number;
+    endTime: number;
+    durationMs: number;
+};
+export type SourceFile = {
+    sourceEntry: string;
+    sourcePath: string;
+    stats: Stats;
+};
+export type FileHistoryData = {
+    source: Record<string, [number, number]>;
+    target: Record<string, [number, number]>;
+};
+export type FileHistory = {
+    data: FileHistoryData;
+    changed: boolean;
+    updateSourceEntry(path: string, [mtime, atime]: [number, number]): {
+        changed: boolean;
+        added: boolean;
+    };
+    addTargetEntry(path: string, [mtime, atime]: [number, number]): void;
+    markTargetOutdated(path: string): void;
+    cleanup(): string[];
+};
+export interface Task {
+    schedule(runImmediately?: boolean): void;
+    unschedule(): void;
+    execute(cb: () => void): void;
+    onScheduled(cb: () => void): void;
+    onStarted(cb: () => void): void;
+    onFinished<T>(cb: (result: T) => void): void;
+    onError(cb: (error: Error) => void): void;
+    gracefulTerminate(timeout: number): void;
+}
+export interface RunnerContext {
+    job: JobModel;
+    result: RunnerResult;
+    startTime: number;
+    sourceDir: string;
+    sourceDirs: Set<string>;
+    targetDir: string;
+    targetDirs: Set<string>;
+    targetPermissions: PermissionModel;
+    getLogFd(): number;
+    writeLog(message: string): void;
+    processActivity(action: string, path?: string, count?: number): void;
+    processError(error: Error): void;
+}
+export interface ActionHandler {
+    validateJob(Job: Job): void;
+    process(ctx: RunnerContext): Promise<void>;
+    processFiles(ctx: RunnerContext, entries: string[], fileHistory: FileHistory): Promise<void>;
+}

package/package.json

@@ -1,17 +1,30 @@
 {
    "name": "@mtakla/cronops",
-   "version": "0.1.1-rc4",
-   "description": "Cron-based cross-container server lifecycle management",
+   "version": "0.1.1-rc5",
+   "description": "Automated cross-container file lifecycle management with cron scheduling",
    "type": "module",
-   "author": "nevereven",
+   "author": "mtakla@nevereven",
    "license": "ISC",
+   "funding": {
+      "type": "buymeacoffee",
+      "url": "https://www.buymeacoffee.com/nevereven"
+   },
+   "homepage": "https://github.com/mtakla/cronops#readme",
+   "repository": {
+      "type": "git",
+      "url": "https://github.com/mtakla/cronops.git"
+   },
+   "bugs": {
+      "url": "https://github.com/mtakla/cronops/issues"
+   },
    "bin": {
-      "cronops": "dist/server.js"
+      "cronops": "./dist/server.js"
    },
    "main": "./dist/server.js",
    "types": "./dist/index.d.ts",
    "engines": {
-      "node": ">=24"
+      "node": ">=24.0.0",
+      "npm": ">=10.0.0"
    },
    "keywords": [
       "cron",
@@ -26,7 +39,7 @@
       "lifecycle",
       "cross-container"
    ],
-   "export": {
+   "exports": {
       ".": {
          "types": "./dist/index.d.ts",
          "import": "./dist/index.js"
@@ -42,15 +55,15 @@
       "chalk": "5.6.2",
       "date-fns": "4.1.0",
       "fast-glob": "3.3.3",
+      "fastify": "5.7.4",
       "figlet": "1.10.0",
       "fs-extra": "11.3.3",
-      "p-limit": "7.3.0",
       "node-cron": "4.2.1",
+      "p-limit": "7.3.0",
       "parse-duration": "2.1.5",
       "tar-fs": "3.1.1",
       "yaml": "2.8.2",
-      "zod": "4.3.6",
-      "fastify": "5.7.4"
+      "zod": "4.3.6"
    },
    "devDependencies": {
       "@biomejs/biome": "^2.3.6",
@@ -59,9 +72,8 @@
       "@types/shell-quote": "^1.7.5",
       "@types/tar-fs": "2.0.4",
       "@vitest/coverage-v8": "^4.0.14",
-      "typescript": "^5.9.3",
       "typedoc": "^0.28.16",
-      "tsx": "^4.21.0",
+      "typescript": "^5.9.3",
       "vitest": "^4.0.14"
    },
    "scripts": {
@@ -72,8 +84,9 @@
       "coverage": "vitest run --coverage",
       "loadtest": "tsc && node ./dist/tests/loadtest.js",
       "clean": "rm -rf dist",
-      "build": "tsc",
       "dev": "tsc && node ./dist/server.js",
+      "build": "tsc",
+      "build:types": "tsc --declaration",
       "docker:build": "docker build --load --target app -t ghcr.io/mtakla/cronops:latest .",
       "docker:build-docs": "docker build --load --target docs -t ghcr.io/mtakla/cronops-docs:latest ."
    }