@blokjs/trigger-cron 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# @blokjs/trigger-cron
+
+## 0.2.0
+
+### Minor Changes
+
+- Initial public release of Blok packages.
+
+  This release includes:
+
+  - Core packages: @blokjs/shared, @blokjs/helper, @blokjs/runner
+  - Node packages: @blokjs/api-call, @blokjs/if-else, @blokjs/react
+  - Trigger packages: pubsub, queue, webhook, websocket, worker, cron, grpc
+  - CLI tool: blokctl
+  - Editor support: @blokjs/lsp-server, @blokjs/syntax
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/shared@0.2.0
+  - @blokjs/helper@0.2.0
+  - @blokjs/runner@0.2.0

package/dist/CronTrigger.d.ts

@@ -0,0 +1,124 @@
+/**
+ * CronTrigger - Scheduled workflow execution based on cron expressions
+ *
+ * Extends TriggerBase to support scheduled triggers:
+ * - Cron expressions (e.g., "0 * * * *" for hourly)
+ * - Timezone-aware scheduling
+ * - Overlap prevention
+ * - Manual trigger support
+ *
+ * Uses the 'cron' package for cron parsing and scheduling.
+ */
+import type { CronTriggerOpts, HelperResponse } from "@blok/helper";
+import { DefaultLogger, type GlobalOptions, type BlokService, TriggerBase, type TriggerResponse } from "@blok/runner";
+import { CronJob } from "cron";
+/**
+ * Scheduled job information
+ */
+export interface ScheduledJob {
+    /** Unique job ID */
+    id: string;
+    /** Workflow path */
+    workflowPath: string;
+    /** Cron expression */
+    schedule: string;
+    /** Timezone */
+    timezone: string;
+    /** Allow overlapping executions */
+    overlap: boolean;
+    /** Whether the job is currently running */
+    running: boolean;
+    /** Last execution time */
+    lastRun?: Date;
+    /** Next scheduled time */
+    nextRun?: Date;
+    /** Internal CronJob instance */
+    job: CronJob;
+}
+/**
+ * Execution context passed to the workflow
+ */
+export interface CronExecutionContext {
+    /** Job ID */
+    jobId: string;
+    /** Scheduled time (when it was supposed to run) */
+    scheduledTime: Date;
+    /** Actual execution time */
+    executionTime: Date;
+    /** Cron expression */
+    schedule: string;
+    /** Timezone */
+    timezone: string;
+    /** Whether this is a manual trigger */
+    manual: boolean;
+}
+/**
+ * Workflow model with cron trigger configuration
+ */
+interface CronWorkflowModel {
+    path: string;
+    config: {
+        name: string;
+        version: string;
+        trigger?: {
+            cron?: CronTriggerOpts;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+}
+/**
+ * CronTrigger - Scheduled workflow execution
+ */
+export declare abstract class CronTrigger extends TriggerBase {
+    protected nodeMap: GlobalOptions;
+    protected readonly tracer: import("@opentelemetry/api").Tracer;
+    protected readonly logger: DefaultLogger;
+    protected jobs: Map<string, ScheduledJob>;
+    protected abstract nodes: Record<string, BlokService<unknown>>;
+    protected abstract workflows: Record<string, HelperResponse>;
+    constructor();
+    /**
+     * Load nodes into the node map
+     */
+    loadNodes(): void;
+    /**
+     * Load workflows into the workflow map
+     */
+    loadWorkflows(): void;
+    /**
+     * Convert cron DateTime to Date
+     * The cron package uses luxon DateTime which has toJSDate()
+     */
+    protected toDate(dateTime: unknown): Date;
+    /**
+     * Start the cron scheduler - main entry point
+     */
+    listen(): Promise<number>;
+    /**
+     * Stop all cron jobs
+     */
+    stop(): Promise<void>;
+    protected onHmrWorkflowChange(): Promise<void>;
+    /**
+     * Manually trigger a specific job
+     */
+    triggerJob(jobId: string): Promise<TriggerResponse | null>;
+    /**
+     * Get all scheduled jobs
+     */
+    getJobs(): ScheduledJob[];
+    /**
+     * Get all workflows that have cron triggers
+     */
+    protected getCronWorkflows(): CronWorkflowModel[];
+    /**
+     * Get workflow by path
+     */
+    protected getWorkflowByPath(path: string): CronWorkflowModel | null;
+    /**
+     * Execute a workflow
+     */
+    protected executeWorkflow(jobId: string, workflow: CronWorkflowModel, config: CronTriggerOpts, manual: boolean): Promise<TriggerResponse>;
+}
+export default CronTrigger;

package/dist/CronTrigger.js

@@ -0,0 +1,305 @@
+"use strict";
+/**
+ * CronTrigger - Scheduled workflow execution based on cron expressions
+ *
+ * Extends TriggerBase to support scheduled triggers:
+ * - Cron expressions (e.g., "0 * * * *" for hourly)
+ * - Timezone-aware scheduling
+ * - Overlap prevention
+ * - Manual trigger support
+ *
+ * Uses the 'cron' package for cron parsing and scheduling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronTrigger = void 0;
+const runner_1 = require("@blok/runner");
+const api_1 = require("@opentelemetry/api");
+const cron_1 = require("cron");
+const uuid_1 = require("uuid");
+/**
+ * CronTrigger - Scheduled workflow execution
+ */
+class CronTrigger extends runner_1.TriggerBase {
+    nodeMap = {};
+    tracer = api_1.trace.getTracer(process.env.PROJECT_NAME || "trigger-cron-workflow", process.env.PROJECT_VERSION || "0.0.1");
+    logger = new runner_1.DefaultLogger();
+    jobs = new Map();
+    constructor() {
+        super();
+        this.loadNodes();
+        this.loadWorkflows();
+    }
+    /**
+     * Load nodes into the node map
+     */
+    loadNodes() {
+        this.nodeMap.nodes = new runner_1.NodeMap();
+        const nodeKeys = Object.keys(this.nodes);
+        for (const key of nodeKeys) {
+            this.nodeMap.nodes.addNode(key, this.nodes[key]);
+        }
+    }
+    /**
+     * Load workflows into the workflow map
+     */
+    loadWorkflows() {
+        this.nodeMap.workflows = this.workflows;
+    }
+    /**
+     * Convert cron DateTime to Date
+     * The cron package uses luxon DateTime which has toJSDate()
+     */
+    toDate(dateTime) {
+        if (dateTime && typeof dateTime === "object" && "toJSDate" in dateTime) {
+            return dateTime.toJSDate();
+        }
+        return dateTime instanceof Date ? dateTime : new Date(dateTime);
+    }
+    /**
+     * Start the cron scheduler - main entry point
+     */
+    async listen() {
+        const startTime = this.startCounter();
+        try {
+            // Find all workflows with cron triggers
+            const cronWorkflows = this.getCronWorkflows();
+            if (cronWorkflows.length === 0) {
+                this.logger.log("No workflows with cron triggers found");
+                return this.endCounter(startTime);
+            }
+            // Create and start cron jobs for each workflow
+            for (const workflow of cronWorkflows) {
+                const config = workflow.config.trigger?.cron;
+                const jobId = `cron-${workflow.path}-${(0, uuid_1.v4)().slice(0, 8)}`;
+                this.logger.log(`Scheduling workflow: ${workflow.path} with schedule: ${config.schedule} (${config.timezone})`);
+                const job = new cron_1.CronJob(config.schedule, async () => {
+                    await this.executeWorkflow(jobId, workflow, config, false);
+                }, null, // onComplete
+                false, // start
+                config.timezone);
+                const scheduledJob = {
+                    id: jobId,
+                    workflowPath: workflow.path,
+                    schedule: config.schedule,
+                    timezone: config.timezone,
+                    overlap: config.overlap ?? false,
+                    running: false,
+                    nextRun: this.toDate(job.nextDate()),
+                    job,
+                };
+                this.jobs.set(jobId, scheduledJob);
+                // Start the job
+                job.start();
+                this.logger.log(`Job ${jobId} started. Next run: ${scheduledJob.nextRun}`);
+            }
+            this.logger.log(`Cron trigger started. ${this.jobs.size} job(s) scheduled`);
+            // Enable HMR in development mode
+            if (process.env.BLOK_HMR === "true" || process.env.NODE_ENV === "development") {
+                await this.enableHotReload();
+            }
+            return this.endCounter(startTime);
+        }
+        catch (error) {
+            this.logger.error(`Failed to start cron trigger: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Stop all cron jobs
+     */
+    async stop() {
+        for (const [jobId, scheduledJob] of this.jobs) {
+            scheduledJob.job.stop();
+            this.logger.log(`Job ${jobId} stopped`);
+        }
+        this.jobs.clear();
+        this.logger.log("Cron trigger stopped");
+    }
+    async onHmrWorkflowChange() {
+        this.logger.log("[HMR] Cron workflow changed, reloading...");
+        await this.waitForInFlightRequests();
+        await this.stop();
+        this.loadWorkflows();
+        await this.listen();
+    }
+    /**
+     * Manually trigger a specific job
+     */
+    async triggerJob(jobId) {
+        const scheduledJob = this.jobs.get(jobId);
+        if (!scheduledJob) {
+            this.logger.error(`Job not found: ${jobId}`);
+            return null;
+        }
+        // Get the workflow
+        const workflow = this.getWorkflowByPath(scheduledJob.workflowPath);
+        if (!workflow) {
+            this.logger.error(`Workflow not found: ${scheduledJob.workflowPath}`);
+            return null;
+        }
+        const config = workflow.config.trigger?.cron;
+        return this.executeWorkflow(jobId, workflow, config, true);
+    }
+    /**
+     * Get all scheduled jobs
+     */
+    getJobs() {
+        return Array.from(this.jobs.values()).map((job) => ({
+            ...job,
+            nextRun: this.toDate(job.job.nextDate()),
+        }));
+    }
+    /**
+     * Get all workflows that have cron triggers
+     */
+    getCronWorkflows() {
+        const workflows = [];
+        for (const [path, workflow] of Object.entries(this.nodeMap.workflows || {})) {
+            const workflowConfig = workflow._config;
+            if (workflowConfig?.trigger) {
+                const triggerType = Object.keys(workflowConfig.trigger)[0];
+                if (triggerType === "cron" && workflowConfig.trigger.cron) {
+                    workflows.push({
+                        path,
+                        config: workflowConfig,
+                    });
+                }
+            }
+        }
+        return workflows;
+    }
+    /**
+     * Get workflow by path
+     */
+    getWorkflowByPath(path) {
+        const workflow = this.nodeMap.workflows?.[path];
+        if (!workflow)
+            return null;
+        const workflowConfig = workflow._config;
+        return {
+            path,
+            config: workflowConfig,
+        };
+    }
+    /**
+     * Execute a workflow
+     */
+    async executeWorkflow(jobId, workflow, config, manual) {
+        const scheduledJob = this.jobs.get(jobId);
+        if (!scheduledJob) {
+            throw new Error(`Job not found: ${jobId}`);
+        }
+        // Check for overlap
+        if (scheduledJob.running && !scheduledJob.overlap) {
+            this.logger.log(`Skipping ${jobId}: previous execution still running (overlap disabled)`);
+            return { ctx: {}, metrics: {} };
+        }
+        const executionId = (0, uuid_1.v4)();
+        const lastDate = scheduledJob.job.lastDate();
+        const scheduledTime = lastDate ? new Date(lastDate) : new Date();
+        const executionTime = new Date();
+        const defaultMeter = api_1.metrics.getMeter("default");
+        const cronExecutions = defaultMeter.createCounter("cron_executions", {
+            description: "Cron job executions",
+        });
+        const cronErrors = defaultMeter.createCounter("cron_errors", {
+            description: "Cron job execution errors",
+        });
+        return new Promise((resolve) => {
+            this.tracer.startActiveSpan(`cron:${workflow.path}`, async (span) => {
+                scheduledJob.running = true;
+                try {
+                    const start = performance.now();
+                    // Initialize configuration for this workflow
+                    await this.configuration.init(workflow.path, this.nodeMap);
+                    // Create context
+                    const ctx = this.createContext(undefined, workflow.path, executionId);
+                    // Create execution context
+                    const cronContext = {
+                        jobId,
+                        scheduledTime,
+                        executionTime,
+                        schedule: config.schedule,
+                        timezone: config.timezone,
+                        manual,
+                    };
+                    // Populate request with cron context
+                    ctx.request = {
+                        body: cronContext,
+                        headers: {
+                            "x-cron-job-id": jobId,
+                            "x-cron-schedule": config.schedule,
+                            "x-cron-timezone": config.timezone,
+                            "x-cron-manual": String(manual),
+                        },
+                        query: {},
+                        params: {
+                            jobId,
+                            schedule: config.schedule,
+                        },
+                    };
+                    // Store cron context in vars
+                    if (!ctx.vars)
+                        ctx.vars = {};
+                    ctx.vars._cron_context = {
+                        jobId,
+                        scheduledTime: scheduledTime.toISOString(),
+                        executionTime: executionTime.toISOString(),
+                        schedule: config.schedule,
+                        timezone: config.timezone,
+                        manual: String(manual),
+                    };
+                    ctx.logger.log(`Executing cron job: ${jobId} (${manual ? "manual" : "scheduled"})`);
+                    // Execute workflow
+                    const response = await this.run(ctx);
+                    const end = performance.now();
+                    // Update job state
+                    scheduledJob.lastRun = executionTime;
+                    scheduledJob.nextRun = this.toDate(scheduledJob.job.nextDate());
+                    // Set span attributes
+                    span.setAttribute("success", true);
+                    span.setAttribute("job_id", jobId);
+                    span.setAttribute("workflow_path", workflow.path);
+                    span.setAttribute("schedule", config.schedule);
+                    span.setAttribute("timezone", config.timezone);
+                    span.setAttribute("manual", manual);
+                    span.setAttribute("elapsed_ms", end - start);
+                    span.setStatus({ code: api_1.SpanStatusCode.OK });
+                    // Record metrics
+                    cronExecutions.add(1, {
+                        env: process.env.NODE_ENV,
+                        job_id: jobId,
+                        workflow_name: this.configuration.name,
+                        manual: String(manual),
+                        success: "true",
+                    });
+                    ctx.logger.log(`Cron job completed in ${(end - start).toFixed(2)}ms: ${jobId}`);
+                    resolve(response);
+                }
+                catch (error) {
+                    const errorMessage = error.message;
+                    // Set span error
+                    span.setAttribute("success", false);
+                    span.recordException(error);
+                    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: errorMessage });
+                    // Record error metrics
+                    cronErrors.add(1, {
+                        env: process.env.NODE_ENV,
+                        job_id: jobId,
+                        workflow_name: this.configuration?.name || "unknown",
+                        manual: String(manual),
+                    });
+                    this.logger.error(`Cron job failed ${jobId}: ${errorMessage}`, error.stack);
+                    resolve({ ctx: {}, metrics: {} });
+                }
+                finally {
+                    scheduledJob.running = false;
+                    span.end();
+                }
+            });
+        });
+    }
+}
+exports.CronTrigger = CronTrigger;
+exports.default = CronTrigger;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CronTrigger.js","sourceRoot":"","sources":["../src/CronTrigger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CronTrigger - Scheduled workflow execution based on cron expressions\n *\n * Extends TriggerBase to support scheduled triggers:\n * - Cron expressions (e.g., \"0 * * * *\" for hourly)\n * - Timezone-aware scheduling\n * - Overlap prevention\n * - Manual trigger support\n *\n * Uses the 'cron' package for cron parsing and scheduling.\n */\n\nimport type { CronTriggerOpts, HelperResponse } from \"@blok/helper\";\nimport {\n\tDefaultLogger,\n\ttype GlobalOptions,\n\ttype BlokService,\n\tNodeMap,\n\tTriggerBase,\n\ttype TriggerResponse,\n} from \"@blok/runner\";\nimport type { Context, MetricsType, RequestContext } from \"@blok/shared\";\nimport { type Span, SpanStatusCode, metrics, trace } from \"@opentelemetry/api\";\nimport { CronJob } from \"cron\";\nimport { v4 as uuid } from \"uuid\";\n\n/**\n * Scheduled job information\n */\nexport interface ScheduledJob {\n\t/** Unique job ID */\n\tid: string;\n\t/** Workflow path */\n\tworkflowPath: string;\n\t/** Cron expression */\n\tschedule: string;\n\t/** Timezone */\n\ttimezone: string;\n\t/** Allow overlapping executions */\n\toverlap: boolean;\n\t/** Whether the job is currently running */\n\trunning: boolean;\n\t/** Last execution time */\n\tlastRun?: Date;\n\t/** Next scheduled time */\n\tnextRun?: Date;\n\t/** Internal CronJob instance */\n\tjob: CronJob;\n}\n\n/**\n * Execution context passed to the workflow\n */\nexport interface CronExecutionContext {\n\t/** Job ID */\n\tjobId: string;\n\t/** Scheduled time (when it was supposed to run) */\n\tscheduledTime: Date;\n\t/** Actual execution time */\n\texecutionTime: Date;\n\t/** Cron expression */\n\tschedule: string;\n\t/** Timezone */\n\ttimezone: string;\n\t/** Whether this is a manual trigger */\n\tmanual: boolean;\n}\n\n/**\n * Workflow model with cron trigger configuration\n */\ninterface CronWorkflowModel {\n\tpath: string;\n\tconfig: {\n\t\tname: string;\n\t\tversion: string;\n\t\ttrigger?: {\n\t\t\tcron?: CronTriggerOpts;\n\t\t\t[key: string]: unknown;\n\t\t};\n\t\t[key: string]: unknown;\n\t};\n}\n\n/**\n * CronTrigger - Scheduled workflow execution\n */\nexport abstract class CronTrigger extends TriggerBase {\n\tprotected nodeMap: GlobalOptions = {} as GlobalOptions;\n\tprotected readonly tracer = trace.getTracer(\n\t\tprocess.env.PROJECT_NAME || \"trigger-cron-workflow\",\n\t\tprocess.env.PROJECT_VERSION || \"0.0.1\",\n\t);\n\tprotected readonly logger = new DefaultLogger();\n\tprotected jobs: Map<string, ScheduledJob> = new Map();\n\n\t// Subclasses provide these\n\tprotected abstract nodes: Record<string, BlokService<unknown>>;\n\tprotected abstract workflows: Record<string, HelperResponse>;\n\n\tconstructor() {\n\t\tsuper();\n\t\tthis.loadNodes();\n\t\tthis.loadWorkflows();\n\t}\n\n\t/**\n\t * Load nodes into the node map\n\t */\n\tloadNodes(): void {\n\t\tthis.nodeMap.nodes = new NodeMap();\n\t\tconst nodeKeys = Object.keys(this.nodes);\n\t\tfor (const key of nodeKeys) {\n\t\t\tthis.nodeMap.nodes.addNode(key, this.nodes[key]);\n\t\t}\n\t}\n\n\t/**\n\t * Load workflows into the workflow map\n\t */\n\tloadWorkflows(): void {\n\t\tthis.nodeMap.workflows = this.workflows;\n\t}\n\n\t/**\n\t * Convert cron DateTime to Date\n\t * The cron package uses luxon DateTime which has toJSDate()\n\t */\n\tprotected toDate(dateTime: unknown): Date {\n\t\tif (dateTime && typeof dateTime === \"object\" && \"toJSDate\" in dateTime) {\n\t\t\treturn (dateTime as { toJSDate: () => Date }).toJSDate();\n\t\t}\n\t\treturn dateTime instanceof Date ? dateTime : new Date(dateTime as string | number);\n\t}\n\n\t/**\n\t * Start the cron scheduler - main entry point\n\t */\n\tasync listen(): Promise<number> {\n\t\tconst startTime = this.startCounter();\n\n\t\ttry {\n\t\t\t// Find all workflows with cron triggers\n\t\t\tconst cronWorkflows = this.getCronWorkflows();\n\n\t\t\tif (cronWorkflows.length === 0) {\n\t\t\t\tthis.logger.log(\"No workflows with cron triggers found\");\n\t\t\t\treturn this.endCounter(startTime);\n\t\t\t}\n\n\t\t\t// Create and start cron jobs for each workflow\n\t\t\tfor (const workflow of cronWorkflows) {\n\t\t\t\tconst config = workflow.config.trigger?.cron as CronTriggerOpts;\n\t\t\t\tconst jobId = `cron-${workflow.path}-${uuid().slice(0, 8)}`;\n\n\t\t\t\tthis.logger.log(`Scheduling workflow: ${workflow.path} with schedule: ${config.schedule} (${config.timezone})`);\n\n\t\t\t\tconst job = new CronJob(\n\t\t\t\t\tconfig.schedule,\n\t\t\t\t\tasync () => {\n\t\t\t\t\t\tawait this.executeWorkflow(jobId, workflow, config, false);\n\t\t\t\t\t},\n\t\t\t\t\tnull, // onComplete\n\t\t\t\t\tfalse, // start\n\t\t\t\t\tconfig.timezone,\n\t\t\t\t);\n\n\t\t\t\tconst scheduledJob: ScheduledJob = {\n\t\t\t\t\tid: jobId,\n\t\t\t\t\tworkflowPath: workflow.path,\n\t\t\t\t\tschedule: config.schedule,\n\t\t\t\t\ttimezone: config.timezone,\n\t\t\t\t\toverlap: config.overlap ?? false,\n\t\t\t\t\trunning: false,\n\t\t\t\t\tnextRun: this.toDate(job.nextDate()),\n\t\t\t\t\tjob,\n\t\t\t\t};\n\n\t\t\t\tthis.jobs.set(jobId, scheduledJob);\n\n\t\t\t\t// Start the job\n\t\t\t\tjob.start();\n\t\t\t\tthis.logger.log(`Job ${jobId} started. Next run: ${scheduledJob.nextRun}`);\n\t\t\t}\n\n\t\t\tthis.logger.log(`Cron trigger started. ${this.jobs.size} job(s) scheduled`);\n\n\t\t\t// Enable HMR in development mode\n\t\t\tif (process.env.BLOK_HMR === \"true\" || process.env.NODE_ENV === \"development\") {\n\t\t\t\tawait this.enableHotReload();\n\t\t\t}\n\n\t\t\treturn this.endCounter(startTime);\n\t\t} catch (error) {\n\t\t\tthis.logger.error(`Failed to start cron trigger: ${(error as Error).message}`);\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\t/**\n\t * Stop all cron jobs\n\t */\n\tasync stop(): Promise<void> {\n\t\tfor (const [jobId, scheduledJob] of this.jobs) {\n\t\t\tscheduledJob.job.stop();\n\t\t\tthis.logger.log(`Job ${jobId} stopped`);\n\t\t}\n\t\tthis.jobs.clear();\n\t\tthis.logger.log(\"Cron trigger stopped\");\n\t}\n\n\tprotected override async onHmrWorkflowChange(): Promise<void> {\n\t\tthis.logger.log(\"[HMR] Cron workflow changed, reloading...\");\n\t\tawait this.waitForInFlightRequests();\n\t\tawait this.stop();\n\t\tthis.loadWorkflows();\n\t\tawait this.listen();\n\t}\n\n\t/**\n\t * Manually trigger a specific job\n\t */\n\tasync triggerJob(jobId: string): Promise<TriggerResponse | null> {\n\t\tconst scheduledJob = this.jobs.get(jobId);\n\t\tif (!scheduledJob) {\n\t\t\tthis.logger.error(`Job not found: ${jobId}`);\n\t\t\treturn null;\n\t\t}\n\n\t\t// Get the workflow\n\t\tconst workflow = this.getWorkflowByPath(scheduledJob.workflowPath);\n\t\tif (!workflow) {\n\t\t\tthis.logger.error(`Workflow not found: ${scheduledJob.workflowPath}`);\n\t\t\treturn null;\n\t\t}\n\n\t\tconst config = workflow.config.trigger?.cron as CronTriggerOpts;\n\t\treturn this.executeWorkflow(jobId, workflow, config, true);\n\t}\n\n\t/**\n\t * Get all scheduled jobs\n\t */\n\tgetJobs(): ScheduledJob[] {\n\t\treturn Array.from(this.jobs.values()).map((job) => ({\n\t\t\t...job,\n\t\t\tnextRun: this.toDate(job.job.nextDate()),\n\t\t}));\n\t}\n\n\t/**\n\t * Get all workflows that have cron triggers\n\t */\n\tprotected getCronWorkflows(): CronWorkflowModel[] {\n\t\tconst workflows: CronWorkflowModel[] = [];\n\n\t\tfor (const [path, workflow] of Object.entries(this.nodeMap.workflows || {})) {\n\t\t\tconst workflowConfig = (workflow as unknown as { _config: CronWorkflowModel[\"config\"] })._config;\n\n\t\t\tif (workflowConfig?.trigger) {\n\t\t\t\tconst triggerType = Object.keys(workflowConfig.trigger)[0];\n\n\t\t\t\tif (triggerType === \"cron\" && workflowConfig.trigger.cron) {\n\t\t\t\t\tworkflows.push({\n\t\t\t\t\t\tpath,\n\t\t\t\t\t\tconfig: workflowConfig,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn workflows;\n\t}\n\n\t/**\n\t * Get workflow by path\n\t */\n\tprotected getWorkflowByPath(path: string): CronWorkflowModel | null {\n\t\tconst workflow = this.nodeMap.workflows?.[path];\n\t\tif (!workflow) return null;\n\n\t\tconst workflowConfig = (workflow as unknown as { _config: CronWorkflowModel[\"config\"] })._config;\n\t\treturn {\n\t\t\tpath,\n\t\t\tconfig: workflowConfig,\n\t\t};\n\t}\n\n\t/**\n\t * Execute a workflow\n\t */\n\tprotected async executeWorkflow(\n\t\tjobId: string,\n\t\tworkflow: CronWorkflowModel,\n\t\tconfig: CronTriggerOpts,\n\t\tmanual: boolean,\n\t): Promise<TriggerResponse> {\n\t\tconst scheduledJob = this.jobs.get(jobId);\n\t\tif (!scheduledJob) {\n\t\t\tthrow new Error(`Job not found: ${jobId}`);\n\t\t}\n\n\t\t// Check for overlap\n\t\tif (scheduledJob.running && !scheduledJob.overlap) {\n\t\t\tthis.logger.log(`Skipping ${jobId}: previous execution still running (overlap disabled)`);\n\t\t\treturn { ctx: {} as Context, metrics: {} as MetricsType };\n\t\t}\n\n\t\tconst executionId = uuid();\n\t\tconst lastDate = scheduledJob.job.lastDate();\n\t\tconst scheduledTime = lastDate ? new Date(lastDate as unknown as string | number) : new Date();\n\t\tconst executionTime = new Date();\n\n\t\tconst defaultMeter = metrics.getMeter(\"default\");\n\t\tconst cronExecutions = defaultMeter.createCounter(\"cron_executions\", {\n\t\t\tdescription: \"Cron job executions\",\n\t\t});\n\t\tconst cronErrors = defaultMeter.createCounter(\"cron_errors\", {\n\t\t\tdescription: \"Cron job execution errors\",\n\t\t});\n\n\t\treturn new Promise((resolve) => {\n\t\t\tthis.tracer.startActiveSpan(`cron:${workflow.path}`, async (span: Span) => {\n\t\t\t\tscheduledJob.running = true;\n\n\t\t\t\ttry {\n\t\t\t\t\tconst start = performance.now();\n\n\t\t\t\t\t// Initialize configuration for this workflow\n\t\t\t\t\tawait this.configuration.init(workflow.path, this.nodeMap);\n\n\t\t\t\t\t// Create context\n\t\t\t\t\tconst ctx: Context = this.createContext(undefined, workflow.path, executionId);\n\n\t\t\t\t\t// Create execution context\n\t\t\t\t\tconst cronContext: CronExecutionContext = {\n\t\t\t\t\t\tjobId,\n\t\t\t\t\t\tscheduledTime,\n\t\t\t\t\t\texecutionTime,\n\t\t\t\t\t\tschedule: config.schedule,\n\t\t\t\t\t\ttimezone: config.timezone,\n\t\t\t\t\t\tmanual,\n\t\t\t\t\t};\n\n\t\t\t\t\t// Populate request with cron context\n\t\t\t\t\tctx.request = {\n\t\t\t\t\t\tbody: cronContext,\n\t\t\t\t\t\theaders: {\n\t\t\t\t\t\t\t\"x-cron-job-id\": jobId,\n\t\t\t\t\t\t\t\"x-cron-schedule\": config.schedule,\n\t\t\t\t\t\t\t\"x-cron-timezone\": config.timezone,\n\t\t\t\t\t\t\t\"x-cron-manual\": String(manual),\n\t\t\t\t\t\t},\n\t\t\t\t\t\tquery: {},\n\t\t\t\t\t\tparams: {\n\t\t\t\t\t\t\tjobId,\n\t\t\t\t\t\t\tschedule: config.schedule,\n\t\t\t\t\t\t},\n\t\t\t\t\t} as unknown as RequestContext;\n\n\t\t\t\t\t// Store cron context in vars\n\t\t\t\t\tif (!ctx.vars) ctx.vars = {};\n\t\t\t\t\tctx.vars._cron_context = {\n\t\t\t\t\t\tjobId,\n\t\t\t\t\t\tscheduledTime: scheduledTime.toISOString(),\n\t\t\t\t\t\texecutionTime: executionTime.toISOString(),\n\t\t\t\t\t\tschedule: config.schedule,\n\t\t\t\t\t\ttimezone: config.timezone,\n\t\t\t\t\t\tmanual: String(manual),\n\t\t\t\t\t};\n\n\t\t\t\t\tctx.logger.log(`Executing cron job: ${jobId} (${manual ? \"manual\" : \"scheduled\"})`);\n\n\t\t\t\t\t// Execute workflow\n\t\t\t\t\tconst response: TriggerResponse = await this.run(ctx);\n\t\t\t\t\tconst end = performance.now();\n\n\t\t\t\t\t// Update job state\n\t\t\t\t\tscheduledJob.lastRun = executionTime;\n\t\t\t\t\tscheduledJob.nextRun = this.toDate(scheduledJob.job.nextDate());\n\n\t\t\t\t\t// Set span attributes\n\t\t\t\t\tspan.setAttribute(\"success\", true);\n\t\t\t\t\tspan.setAttribute(\"job_id\", jobId);\n\t\t\t\t\tspan.setAttribute(\"workflow_path\", workflow.path);\n\t\t\t\t\tspan.setAttribute(\"schedule\", config.schedule);\n\t\t\t\t\tspan.setAttribute(\"timezone\", config.timezone);\n\t\t\t\t\tspan.setAttribute(\"manual\", manual);\n\t\t\t\t\tspan.setAttribute(\"elapsed_ms\", end - start);\n\t\t\t\t\tspan.setStatus({ code: SpanStatusCode.OK });\n\n\t\t\t\t\t// Record metrics\n\t\t\t\t\tcronExecutions.add(1, {\n\t\t\t\t\t\tenv: process.env.NODE_ENV,\n\t\t\t\t\t\tjob_id: jobId,\n\t\t\t\t\t\tworkflow_name: this.configuration.name,\n\t\t\t\t\t\tmanual: String(manual),\n\t\t\t\t\t\tsuccess: \"true\",\n\t\t\t\t\t});\n\n\t\t\t\t\tctx.logger.log(`Cron job completed in ${(end - start).toFixed(2)}ms: ${jobId}`);\n\n\t\t\t\t\tresolve(response);\n\t\t\t\t} catch (error) {\n\t\t\t\t\tconst errorMessage = (error as Error).message;\n\n\t\t\t\t\t// Set span error\n\t\t\t\t\tspan.setAttribute(\"success\", false);\n\t\t\t\t\tspan.recordException(error as Error);\n\t\t\t\t\tspan.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });\n\n\t\t\t\t\t// Record error metrics\n\t\t\t\t\tcronErrors.add(1, {\n\t\t\t\t\t\tenv: process.env.NODE_ENV,\n\t\t\t\t\t\tjob_id: jobId,\n\t\t\t\t\t\tworkflow_name: this.configuration?.name || \"unknown\",\n\t\t\t\t\t\tmanual: String(manual),\n\t\t\t\t\t});\n\n\t\t\t\t\tthis.logger.error(`Cron job failed ${jobId}: ${errorMessage}`, (error as Error).stack);\n\n\t\t\t\t\tresolve({ ctx: {} as Context, metrics: {} as MetricsType });\n\t\t\t\t} finally {\n\t\t\t\t\tscheduledJob.running = false;\n\t\t\t\t\tspan.end();\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t}\n}\n\nexport default CronTrigger;\n"]}

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @blok/trigger-cron
+ *
+ * Cron/scheduled trigger for Blok workflows.
+ * Execute workflows on a schedule using cron expressions.
+ *
+ * Features:
+ * - Standard cron expression syntax
+ * - Timezone-aware scheduling
+ * - Overlap prevention
+ * - Manual trigger support
+ * - Job management API
+ *
+ * @example
+ * ```typescript
+ * import { CronTrigger } from "@blok/trigger-cron";
+ *
+ * class MyCronTrigger extends CronTrigger {
+ *   protected nodes = myNodes;
+ *   protected workflows = myWorkflows;
+ * }
+ *
+ * const trigger = new MyCronTrigger();
+ * await trigger.listen();
+ *
+ * // List all scheduled jobs
+ * const jobs = trigger.getJobs();
+ *
+ * // Manually trigger a job
+ * await trigger.triggerJob("cron-my-workflow-abc123");
+ * ```
+ *
+ * Workflow Definition:
+ * ```typescript
+ * Workflow({ name: "daily-cleanup", version: "1.0.0" })
+ *   .addTrigger("cron", {
+ *     schedule: "0 2 * * *",  // Run at 2 AM daily
+ *     timezone: "America/New_York",
+ *     overlap: false,
+ *   })
+ *   .addStep({ ... });
+ * ```
+ *
+ * Cron Expression Format:
+ * ```
+ * * * * * * *
+ * │ │ │ │ │ │
+ * │ │ │ │ │ └── Day of week (0-7, Sun=0,7)
+ * │ │ │ │ └──── Month (1-12)
+ * │ │ │ └────── Day of month (1-31)
+ * │ │ └──────── Hour (0-23)
+ * │ └────────── Minute (0-59)
+ * └──────────── Second (0-59, optional)
+ * ```
+ *
+ * Common schedules:
+ * - "* * * * *" - Every minute
+ * - "0 * * * *" - Every hour
+ * - "0 0 * * *" - Every day at midnight
+ * - "0 0 * * 0" - Every Sunday at midnight
+ * - "0 0 1 * *" - First day of every month
+ */
+export { CronTrigger, type ScheduledJob, type CronExecutionContext, } from "./CronTrigger";
+export type { CronTriggerOpts } from "@blok/helper";

package/dist/index.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * @blok/trigger-cron
+ *
+ * Cron/scheduled trigger for Blok workflows.
+ * Execute workflows on a schedule using cron expressions.
+ *
+ * Features:
+ * - Standard cron expression syntax
+ * - Timezone-aware scheduling
+ * - Overlap prevention
+ * - Manual trigger support
+ * - Job management API
+ *
+ * @example
+ * ```typescript
+ * import { CronTrigger } from "@blok/trigger-cron";
+ *
+ * class MyCronTrigger extends CronTrigger {
+ *   protected nodes = myNodes;
+ *   protected workflows = myWorkflows;
+ * }
+ *
+ * const trigger = new MyCronTrigger();
+ * await trigger.listen();
+ *
+ * // List all scheduled jobs
+ * const jobs = trigger.getJobs();
+ *
+ * // Manually trigger a job
+ * await trigger.triggerJob("cron-my-workflow-abc123");
+ * ```
+ *
+ * Workflow Definition:
+ * ```typescript
+ * Workflow({ name: "daily-cleanup", version: "1.0.0" })
+ *   .addTrigger("cron", {
+ *     schedule: "0 2 * * *",  // Run at 2 AM daily
+ *     timezone: "America/New_York",
+ *     overlap: false,
+ *   })
+ *   .addStep({ ... });
+ * ```
+ *
+ * Cron Expression Format:
+ * ```
+ * * * * * * *
+ * │ │ │ │ │ │
+ * │ │ │ │ │ └── Day of week (0-7, Sun=0,7)
+ * │ │ │ │ └──── Month (1-12)
+ * │ │ │ └────── Day of month (1-31)
+ * │ │ └──────── Hour (0-23)
+ * │ └────────── Minute (0-59)
+ * └──────────── Second (0-59, optional)
+ * ```
+ *
+ * Common schedules:
+ * - "* * * * *" - Every minute
+ * - "0 * * * *" - Every hour
+ * - "0 0 * * *" - Every day at midnight
+ * - "0 0 * * 0" - Every Sunday at midnight
+ * - "0 0 1 * *" - First day of every month
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronTrigger = void 0;
+// Core exports
+var CronTrigger_1 = require("./CronTrigger");
+Object.defineProperty(exports, "CronTrigger", { enumerable: true, get: function () { return CronTrigger_1.CronTrigger; } });
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,35 @@
+{
+	"name": "@blokjs/trigger-cron",
+	"version": "0.2.0",
+	"description": "Cron/scheduled trigger for Blok workflows - supports cron expressions and interval-based scheduling",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"scripts": {
+		"build": "rm -rf dist && bun run tsc",
+		"build:dev": "tsc --watch",
+		"test": "vitest run",
+		"test:dev": "vitest"
+	},
+	"author": "Deskree Technologies Inc.",
+	"license": "Apache-2.0",
+	"dependencies": {
+		"@blokjs/helper": "workspace:*",
+		"@blokjs/runner": "workspace:*",
+		"@blokjs/shared": "workspace:*",
+		"@opentelemetry/api": "^1.9.0",
+		"cron": "^4.4.0",
+		"uuid": "^11.1.0"
+	},
+	"devDependencies": {
+		"@types/cron": "^2.4.3",
+		"@types/node": "^22.15.21",
+		"@types/uuid": "^11.0.0",
+		"typescript": "^5.8.3",
+		"vitest": "^4.0.18"
+	},
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/src/CronTrigger.test.ts

@@ -0,0 +1,119 @@
+/**
+ * CronTrigger Tests
+ */
+
+import { describe, expect, it, vi } from "vitest";
+
+describe("CronTrigger", () => {
+	describe("ScheduledJob Interface", () => {
+		it("should accept valid scheduled job structure", () => {
+			const mockJob = {
+				nextDate: () => new Date(),
+				lastDate: () => new Date(),
+				start: vi.fn(),
+				stop: vi.fn(),
+			};
+
+			const scheduledJob = {
+				id: "cron-test-abc123",
+				workflowPath: "daily-cleanup",
+				schedule: "0 2 * * *",
+				timezone: "America/New_York",
+				overlap: false,
+				running: false,
+				lastRun: new Date(),
+				nextRun: new Date(),
+				job: mockJob,
+			};
+
+			expect(scheduledJob.id).toBe("cron-test-abc123");
+			expect(scheduledJob.schedule).toBe("0 2 * * *");
+			expect(scheduledJob.timezone).toBe("America/New_York");
+			expect(scheduledJob.overlap).toBe(false);
+		});
+	});
+
+	describe("CronExecutionContext Interface", () => {
+		it("should create valid execution context", () => {
+			const context = {
+				jobId: "cron-job-123",
+				scheduledTime: new Date("2024-01-01T02:00:00Z"),
+				executionTime: new Date("2024-01-01T02:00:01Z"),
+				schedule: "0 2 * * *",
+				timezone: "UTC",
+				manual: false,
+			};
+
+			expect(context.jobId).toBe("cron-job-123");
+			expect(context.scheduledTime.toISOString()).toBe("2024-01-01T02:00:00.000Z");
+			expect(context.manual).toBe(false);
+		});
+
+		it("should support manual trigger context", () => {
+			const context = {
+				jobId: "cron-job-456",
+				scheduledTime: new Date(),
+				executionTime: new Date(),
+				schedule: "0 * * * *",
+				timezone: "Europe/London",
+				manual: true,
+			};
+
+			expect(context.manual).toBe(true);
+		});
+	});
+
+	describe("CronTriggerOpts Schema", () => {
+		it("should validate cron trigger configuration", () => {
+			const validConfig = {
+				schedule: "0 * * * *",
+				timezone: "America/Los_Angeles",
+				overlap: false,
+			};
+
+			expect(validConfig.schedule).toBe("0 * * * *");
+			expect(validConfig.timezone).toBe("America/Los_Angeles");
+			expect(validConfig.overlap).toBe(false);
+		});
+
+		it("should support common cron expressions", () => {
+			const schedules = [
+				{ expr: "* * * * *", desc: "Every minute" },
+				{ expr: "0 * * * *", desc: "Every hour" },
+				{ expr: "0 0 * * *", desc: "Every day at midnight" },
+				{ expr: "0 0 * * 0", desc: "Every Sunday" },
+				{ expr: "0 0 1 * *", desc: "First day of month" },
+				{ expr: "*/5 * * * *", desc: "Every 5 minutes" },
+				{ expr: "0 9-17 * * 1-5", desc: "Hourly, 9-5 on weekdays" },
+			];
+
+			for (const schedule of schedules) {
+				expect(schedule.expr).toBeDefined();
+				expect(schedule.desc).toBeDefined();
+			}
+		});
+	});
+
+	describe("Timezone Support", () => {
+		it("should support common timezones", () => {
+			const timezones = [
+				"UTC",
+				"America/New_York",
+				"America/Los_Angeles",
+				"Europe/London",
+				"Europe/Paris",
+				"Asia/Tokyo",
+				"Australia/Sydney",
+			];
+
+			for (const tz of timezones) {
+				const config = {
+					schedule: "0 0 * * *",
+					timezone: tz,
+					overlap: false,
+				};
+				expect(config.timezone).toBe(tz);
+			}
+		});
+	});
+});

package/src/CronTrigger.ts

@@ -0,0 +1,432 @@
+/**
+ * CronTrigger - Scheduled workflow execution based on cron expressions
+ *
+ * Extends TriggerBase to support scheduled triggers:
+ * - Cron expressions (e.g., "0 * * * *" for hourly)
+ * - Timezone-aware scheduling
+ * - Overlap prevention
+ * - Manual trigger support
+ *
+ * Uses the 'cron' package for cron parsing and scheduling.
+ */
+
+import type { CronTriggerOpts, HelperResponse } from "@blokjs/helper";
+import {
+	DefaultLogger,
+	type GlobalOptions,
+	type BlokService,
+	NodeMap,
+	TriggerBase,
+	type TriggerResponse,
+} from "@blokjs/runner";
+import type { Context, MetricsType, RequestContext } from "@blokjs/shared";
+import { type Span, SpanStatusCode, metrics, trace } from "@opentelemetry/api";
+import { CronJob } from "cron";
+import { v4 as uuid } from "uuid";
+
+/**
+ * Scheduled job information
+ */
+export interface ScheduledJob {
+	/** Unique job ID */
+	id: string;
+	/** Workflow path */
+	workflowPath: string;
+	/** Cron expression */
+	schedule: string;
+	/** Timezone */
+	timezone: string;
+	/** Allow overlapping executions */
+	overlap: boolean;
+	/** Whether the job is currently running */
+	running: boolean;
+	/** Last execution time */
+	lastRun?: Date;
+	/** Next scheduled time */
+	nextRun?: Date;
+	/** Internal CronJob instance */
+	job: CronJob;
+}
+
+/**
+ * Execution context passed to the workflow
+ */
+export interface CronExecutionContext {
+	/** Job ID */
+	jobId: string;
+	/** Scheduled time (when it was supposed to run) */
+	scheduledTime: Date;
+	/** Actual execution time */
+	executionTime: Date;
+	/** Cron expression */
+	schedule: string;
+	/** Timezone */
+	timezone: string;
+	/** Whether this is a manual trigger */
+	manual: boolean;
+}
+
+/**
+ * Workflow model with cron trigger configuration
+ */
+interface CronWorkflowModel {
+	path: string;
+	config: {
+		name: string;
+		version: string;
+		trigger?: {
+			cron?: CronTriggerOpts;
+			[key: string]: unknown;
+		};
+		[key: string]: unknown;
+	};
+}
+
+/**
+ * CronTrigger - Scheduled workflow execution
+ */
+export abstract class CronTrigger extends TriggerBase {
+	protected nodeMap: GlobalOptions = {} as GlobalOptions;
+	protected readonly tracer = trace.getTracer(
+		process.env.PROJECT_NAME || "trigger-cron-workflow",
+		process.env.PROJECT_VERSION || "0.0.1",
+	);
+	protected readonly logger = new DefaultLogger();
+	protected jobs: Map<string, ScheduledJob> = new Map();
+
+	// Subclasses provide these
+	protected abstract nodes: Record<string, BlokService<unknown>>;
+	protected abstract workflows: Record<string, HelperResponse>;
+
+	constructor() {
+		super();
+		this.loadNodes();
+		this.loadWorkflows();
+	}
+
+	/**
+	 * Load nodes into the node map
+	 */
+	loadNodes(): void {
+		this.nodeMap.nodes = new NodeMap();
+		const nodeKeys = Object.keys(this.nodes);
+		for (const key of nodeKeys) {
+			this.nodeMap.nodes.addNode(key, this.nodes[key]);
+		}
+	}
+
+	/**
+	 * Load workflows into the workflow map
+	 */
+	loadWorkflows(): void {
+		this.nodeMap.workflows = this.workflows;
+	}
+
+	/**
+	 * Convert cron DateTime to Date
+	 * The cron package uses luxon DateTime which has toJSDate()
+	 */
+	protected toDate(dateTime: unknown): Date {
+		if (dateTime && typeof dateTime === "object" && "toJSDate" in dateTime) {
+			return (dateTime as { toJSDate: () => Date }).toJSDate();
+		}
+		return dateTime instanceof Date ? dateTime : new Date(dateTime as string | number);
+	}
+
+	/**
+	 * Start the cron scheduler - main entry point
+	 */
+	async listen(): Promise<number> {
+		const startTime = this.startCounter();
+
+		try {
+			// Find all workflows with cron triggers
+			const cronWorkflows = this.getCronWorkflows();
+
+			if (cronWorkflows.length === 0) {
+				this.logger.log("No workflows with cron triggers found");
+				return this.endCounter(startTime);
+			}
+
+			// Create and start cron jobs for each workflow
+			for (const workflow of cronWorkflows) {
+				const config = workflow.config.trigger?.cron as CronTriggerOpts;
+				const jobId = `cron-${workflow.path}-${uuid().slice(0, 8)}`;
+
+				this.logger.log(`Scheduling workflow: ${workflow.path} with schedule: ${config.schedule} (${config.timezone})`);
+
+				const job = new CronJob(
+					config.schedule,
+					async () => {
+						await this.executeWorkflow(jobId, workflow, config, false);
+					},
+					null, // onComplete
+					false, // start
+					config.timezone,
+				);
+
+				const scheduledJob: ScheduledJob = {
+					id: jobId,
+					workflowPath: workflow.path,
+					schedule: config.schedule,
+					timezone: config.timezone,
+					overlap: config.overlap ?? false,
+					running: false,
+					nextRun: this.toDate(job.nextDate()),
+					job,
+				};
+
+				this.jobs.set(jobId, scheduledJob);
+
+				// Start the job
+				job.start();
+				this.logger.log(`Job ${jobId} started. Next run: ${scheduledJob.nextRun}`);
+			}
+
+			this.logger.log(`Cron trigger started. ${this.jobs.size} job(s) scheduled`);
+
+			// Enable HMR in development mode
+			if (process.env.BLOK_HMR === "true" || process.env.NODE_ENV === "development") {
+				await this.enableHotReload();
+			}
+
+			return this.endCounter(startTime);
+		} catch (error) {
+			this.logger.error(`Failed to start cron trigger: ${(error as Error).message}`);
+			throw error;
+		}
+	}
+
+	/**
+	 * Stop all cron jobs
+	 */
+	async stop(): Promise<void> {
+		for (const [jobId, scheduledJob] of this.jobs) {
+			scheduledJob.job.stop();
+			this.logger.log(`Job ${jobId} stopped`);
+		}
+		this.jobs.clear();
+		this.logger.log("Cron trigger stopped");
+	}
+
+	protected override async onHmrWorkflowChange(): Promise<void> {
+		this.logger.log("[HMR] Cron workflow changed, reloading...");
+		await this.waitForInFlightRequests();
+		await this.stop();
+		this.loadWorkflows();
+		await this.listen();
+	}
+
+	/**
+	 * Manually trigger a specific job
+	 */
+	async triggerJob(jobId: string): Promise<TriggerResponse | null> {
+		const scheduledJob = this.jobs.get(jobId);
+		if (!scheduledJob) {
+			this.logger.error(`Job not found: ${jobId}`);
+			return null;
+		}
+
+		// Get the workflow
+		const workflow = this.getWorkflowByPath(scheduledJob.workflowPath);
+		if (!workflow) {
+			this.logger.error(`Workflow not found: ${scheduledJob.workflowPath}`);
+			return null;
+		}
+
+		const config = workflow.config.trigger?.cron as CronTriggerOpts;
+		return this.executeWorkflow(jobId, workflow, config, true);
+	}
+
+	/**
+	 * Get all scheduled jobs
+	 */
+	getJobs(): ScheduledJob[] {
+		return Array.from(this.jobs.values()).map((job) => ({
+			...job,
+			nextRun: this.toDate(job.job.nextDate()),
+		}));
+	}
+
+	/**
+	 * Get all workflows that have cron triggers
+	 */
+	protected getCronWorkflows(): CronWorkflowModel[] {
+		const workflows: CronWorkflowModel[] = [];
+
+		for (const [path, workflow] of Object.entries(this.nodeMap.workflows || {})) {
+			const workflowConfig = (workflow as unknown as { _config: CronWorkflowModel["config"] })._config;
+
+			if (workflowConfig?.trigger) {
+				const triggerType = Object.keys(workflowConfig.trigger)[0];
+
+				if (triggerType === "cron" && workflowConfig.trigger.cron) {
+					workflows.push({
+						path,
+						config: workflowConfig,
+					});
+				}
+			}
+		}
+
+		return workflows;
+	}
+
+	/**
+	 * Get workflow by path
+	 */
+	protected getWorkflowByPath(path: string): CronWorkflowModel | null {
+		const workflow = this.nodeMap.workflows?.[path];
+		if (!workflow) return null;
+
+		const workflowConfig = (workflow as unknown as { _config: CronWorkflowModel["config"] })._config;
+		return {
+			path,
+			config: workflowConfig,
+		};
+	}
+
+	/**
+	 * Execute a workflow
+	 */
+	protected async executeWorkflow(
+		jobId: string,
+		workflow: CronWorkflowModel,
+		config: CronTriggerOpts,
+		manual: boolean,
+	): Promise<TriggerResponse> {
+		const scheduledJob = this.jobs.get(jobId);
+		if (!scheduledJob) {
+			throw new Error(`Job not found: ${jobId}`);
+		}
+
+		// Check for overlap
+		if (scheduledJob.running && !scheduledJob.overlap) {
+			this.logger.log(`Skipping ${jobId}: previous execution still running (overlap disabled)`);
+			return { ctx: {} as Context, metrics: {} as MetricsType };
+		}
+
+		const executionId = uuid();
+		const lastDate = scheduledJob.job.lastDate();
+		const scheduledTime = lastDate ? new Date(lastDate as unknown as string | number) : new Date();
+		const executionTime = new Date();
+
+		const defaultMeter = metrics.getMeter("default");
+		const cronExecutions = defaultMeter.createCounter("cron_executions", {
+			description: "Cron job executions",
+		});
+		const cronErrors = defaultMeter.createCounter("cron_errors", {
+			description: "Cron job execution errors",
+		});
+
+		return new Promise((resolve) => {
+			this.tracer.startActiveSpan(`cron:${workflow.path}`, async (span: Span) => {
+				scheduledJob.running = true;
+
+				try {
+					const start = performance.now();
+
+					// Initialize configuration for this workflow
+					await this.configuration.init(workflow.path, this.nodeMap);
+
+					// Create context
+					const ctx: Context = this.createContext(undefined, workflow.path, executionId);
+
+					// Create execution context
+					const cronContext: CronExecutionContext = {
+						jobId,
+						scheduledTime,
+						executionTime,
+						schedule: config.schedule,
+						timezone: config.timezone,
+						manual,
+					};
+
+					// Populate request with cron context
+					ctx.request = {
+						body: cronContext,
+						headers: {
+							"x-cron-job-id": jobId,
+							"x-cron-schedule": config.schedule,
+							"x-cron-timezone": config.timezone,
+							"x-cron-manual": String(manual),
+						},
+						query: {},
+						params: {
+							jobId,
+							schedule: config.schedule,
+						},
+					} as unknown as RequestContext;
+
+					// Store cron context in vars
+					if (!ctx.vars) ctx.vars = {};
+					ctx.vars._cron_context = {
+						jobId,
+						scheduledTime: scheduledTime.toISOString(),
+						executionTime: executionTime.toISOString(),
+						schedule: config.schedule,
+						timezone: config.timezone,
+						manual: String(manual),
+					};
+
+					ctx.logger.log(`Executing cron job: ${jobId} (${manual ? "manual" : "scheduled"})`);
+
+					// Execute workflow
+					const response: TriggerResponse = await this.run(ctx);
+					const end = performance.now();
+
+					// Update job state
+					scheduledJob.lastRun = executionTime;
+					scheduledJob.nextRun = this.toDate(scheduledJob.job.nextDate());
+
+					// Set span attributes
+					span.setAttribute("success", true);
+					span.setAttribute("job_id", jobId);
+					span.setAttribute("workflow_path", workflow.path);
+					span.setAttribute("schedule", config.schedule);
+					span.setAttribute("timezone", config.timezone);
+					span.setAttribute("manual", manual);
+					span.setAttribute("elapsed_ms", end - start);
+					span.setStatus({ code: SpanStatusCode.OK });
+
+					// Record metrics
+					cronExecutions.add(1, {
+						env: process.env.NODE_ENV,
+						job_id: jobId,
+						workflow_name: this.configuration.name,
+						manual: String(manual),
+						success: "true",
+					});
+
+					ctx.logger.log(`Cron job completed in ${(end - start).toFixed(2)}ms: ${jobId}`);
+
+					resolve(response);
+				} catch (error) {
+					const errorMessage = (error as Error).message;
+
+					// Set span error
+					span.setAttribute("success", false);
+					span.recordException(error as Error);
+					span.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
+
+					// Record error metrics
+					cronErrors.add(1, {
+						env: process.env.NODE_ENV,
+						job_id: jobId,
+						workflow_name: this.configuration?.name || "unknown",
+						manual: String(manual),
+					});
+
+					this.logger.error(`Cron job failed ${jobId}: ${errorMessage}`, (error as Error).stack);
+
+					resolve({ ctx: {} as Context, metrics: {} as MetricsType });
+				} finally {
+					scheduledJob.running = false;
+					span.end();
+				}
+			});
+		});
+	}
+}
+
+export default CronTrigger;

package/src/index.ts

@@ -0,0 +1,72 @@
+/**
+ * @blokjs/trigger-cron
+ *
+ * Cron/scheduled trigger for Blok workflows.
+ * Execute workflows on a schedule using cron expressions.
+ *
+ * Features:
+ * - Standard cron expression syntax
+ * - Timezone-aware scheduling
+ * - Overlap prevention
+ * - Manual trigger support
+ * - Job management API
+ *
+ * @example
+ * ```typescript
+ * import { CronTrigger } from "@blokjs/trigger-cron";
+ *
+ * class MyCronTrigger extends CronTrigger {
+ *   protected nodes = myNodes;
+ *   protected workflows = myWorkflows;
+ * }
+ *
+ * const trigger = new MyCronTrigger();
+ * await trigger.listen();
+ *
+ * // List all scheduled jobs
+ * const jobs = trigger.getJobs();
+ *
+ * // Manually trigger a job
+ * await trigger.triggerJob("cron-my-workflow-abc123");
+ * ```
+ *
+ * Workflow Definition:
+ * ```typescript
+ * Workflow({ name: "daily-cleanup", version: "1.0.0" })
+ *   .addTrigger("cron", {
+ *     schedule: "0 2 * * *",  // Run at 2 AM daily
+ *     timezone: "America/New_York",
+ *     overlap: false,
+ *   })
+ *   .addStep({ ... });
+ * ```
+ *
+ * Cron Expression Format:
+ * ```
+ * * * * * * *
+ * │ │ │ │ │ │
+ * │ │ │ │ │ └── Day of week (0-7, Sun=0,7)
+ * │ │ │ │ └──── Month (1-12)
+ * │ │ │ └────── Day of month (1-31)
+ * │ │ └──────── Hour (0-23)
+ * │ └────────── Minute (0-59)
+ * └──────────── Second (0-59, optional)
+ * ```
+ *
+ * Common schedules:
+ * - "* * * * *" - Every minute
+ * - "0 * * * *" - Every hour
+ * - "0 0 * * *" - Every day at midnight
+ * - "0 0 * * 0" - Every Sunday at midnight
+ * - "0 0 1 * *" - First day of every month
+ */
+
+// Core exports
+export {
+	CronTrigger,
+	type ScheduledJob,
+	type CronExecutionContext,
+} from "./CronTrigger";
+
+// Re-export types from helper for convenience
+export type { CronTriggerOpts } from "@blokjs/helper";

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+	"ts-node": {
+		"transpileOnly": true
+	},
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "es2022",
+		"lib": ["ES2022"],
+		"declaration": true,
+		"strict": true,
+		"noImplicitAny": true,
+		"strictNullChecks": true,
+		"noImplicitThis": true,
+		"alwaysStrict": true,
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": false,
+		"inlineSourceMap": true,
+		"inlineSources": true,
+		"experimentalDecorators": true,
+		"emitDecoratorMetadata": true,
+		"skipLibCheck": true,
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"moduleResolution": "bundler"
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist", "**/*.test.ts"]
+}