@meetploy/cli 1.16.0 → 1.17.1

package/dist/index.js

@@ -147,6 +147,22 @@ function validateBindings(bindings, bindingType, configFile) {
     }
   }
 }
+function validateCronBindings(bindings, configFile) {
+  if (bindings === void 0) {
+    return;
+  }
+  for (const [bindingName, cronExpression] of Object.entries(bindings)) {
+    if (!BINDING_NAME_REGEX.test(bindingName)) {
+      throw new Error(`Invalid cron binding name '${bindingName}' in ${configFile}. Binding names must be uppercase with underscores (e.g., HOURLY_CLEANUP, DAILY_REPORT)`);
+    }
+    if (typeof cronExpression !== "string") {
+      throw new Error(`Cron binding '${bindingName}' in ${configFile} must have a string value (cron expression)`);
+    }
+    if (!CRON_EXPRESSION_REGEX.test(cronExpression.trim())) {
+      throw new Error(`Invalid cron expression '${cronExpression}' for binding '${bindingName}' in ${configFile}. Must be a valid cron expression with 5 fields (e.g., "0 * * * *", "*/5 * * * *")`);
+    }
+  }
+}
 function validateRelativePath(path, fieldName, configFile) {
   if (path === void 0) {
     return void 0;
@@ -202,6 +218,8 @@ function validatePloyConfig(config, configFile = "ploy.yaml", options = {}) {
   validateBindings(config.state, "state", configFile);
   validateBindings(config.fs, "fs", configFile);
   validateBindings(config.workflow, "workflow", configFile);
+  validateCronBindings(config.cron, configFile);
+  validateBindings(config.alarm, "alarm", configFile);
   if (config.ai !== void 0 && typeof config.ai !== "boolean") {
     throw new Error(`'ai' in ${configFile} must be a boolean`);
   }
@@ -277,7 +295,7 @@ function readAndValidatePloyConfigSync(projectDir, configPath, validationOptions
   return validatePloyConfig(config, configFile, validationOptions);
 }
 function hasBindings(config) {
-  return !!(config.env ?? config.db ?? config.queue ?? config.cache ?? config.state ?? config.fs ?? config.workflow ?? config.ai ?? config.auth);
+  return !!(config.env ?? config.db ?? config.queue ?? config.cache ?? config.state ?? config.fs ?? config.workflow ?? config.cron ?? config.alarm ?? config.ai ?? config.auth);
 }
 function parseDotEnv(content) {
   const result = {};
@@ -339,7 +357,7 @@ function getWorkerEntryPoint(projectDir, config) {
   }
   throw new Error("Could not find worker entry point. Specify 'main' in ploy.yaml");
 }
-var readFileAsync, DEFAULT_COMPATIBILITY_FLAGS, DEFAULT_COMPATIBILITY_DATE, BINDING_NAME_REGEX, RESOURCE_NAME_REGEX;
+var readFileAsync, DEFAULT_COMPATIBILITY_FLAGS, DEFAULT_COMPATIBILITY_DATE, BINDING_NAME_REGEX, RESOURCE_NAME_REGEX, CRON_EXPRESSION_REGEX;
 var init_ploy_config = __esm({
   "../tools/dist/ploy-config.js"() {
     readFileAsync = promisify(readFile$1);
@@ -347,6 +365,7 @@ var init_ploy_config = __esm({
     DEFAULT_COMPATIBILITY_DATE = "2025-04-02";
     BINDING_NAME_REGEX = /^[A-Z][A-Z0-9_]*$/;
     RESOURCE_NAME_REGEX = /^[a-z][a-z0-9_]*$/;
+    CRON_EXPRESSION_REGEX = /^(\*|[0-9,\-/]+)\s+(\*|[0-9,\-/]+)\s+(\*|[0-9,\-/]+)\s+(\*|[0-9,\-/]+)\s+(\*|[0-9,\-/]+)$/;
   }
 });
 
@@ -379,6 +398,72 @@ var init_cli = __esm({
   }
 });
 
+// ../emulator/dist/runtime/alarm-runtime.js
+var ALARM_RUNTIME_CODE;
+var init_alarm_runtime = __esm({
+  "../emulator/dist/runtime/alarm-runtime.js"() {
+    ALARM_RUNTIME_CODE = `
+export function initializeAlarm(alarmName, serviceUrl) {
+  function parseOptions(options) {
+    if (options === undefined || options === null) {
+      return { payload: undefined, intervalMs: undefined };
+    }
+    if (typeof options === "object" && options !== null && ("payload" in options || "intervalMs" in options)) {
+      return { payload: options.payload, intervalMs: options.intervalMs };
+    }
+    return { payload: options, intervalMs: undefined };
+  }
+
+  return {
+    async set(id, scheduledTime, options) {
+      const ts = typeof scheduledTime === "number" ? scheduledTime : scheduledTime.getTime();
+      const { payload, intervalMs } = parseOptions(options);
+      const response = await fetch(serviceUrl + "/alarm/set", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ alarmName, id, scheduledTime: ts, payload, intervalMs }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("Alarm set failed: " + errorText);
+      }
+    },
+
+    async get(id) {
+      const response = await fetch(serviceUrl + "/alarm/get", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ alarmName, id }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("Alarm get failed: " + errorText);
+      }
+
+      const result = await response.json();
+      return result.alarm ?? null;
+    },
+
+    async delete(id) {
+      const response = await fetch(serviceUrl + "/alarm/delete", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ alarmName, id }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("Alarm delete failed: " + errorText);
+      }
+    },
+  };
+}
+`;
+  }
+});
+
 // ../emulator/dist/runtime/cache-runtime.js
 var CACHE_RUNTIME_CODE;
 var init_cache_runtime = __esm({
@@ -1252,6 +1337,12 @@ function generateWrapperCode(config, mockServiceUrl, envVars) {
       bindings.push(`  ${bindingName}: initializeWorkflow("${workflowName}", "${mockServiceUrl}"),`);
     }
   }
+  if (config.alarm) {
+    imports.push('import { initializeAlarm } from "__ploy_alarm_runtime__";');
+    for (const [bindingName, alarmName] of Object.entries(config.alarm)) {
+      bindings.push(`  ${bindingName}: initializeAlarm("${alarmName}", "${mockServiceUrl}"),`);
+    }
+  }
   imports.push('import userWorker from "__ploy_user_worker__";');
   const workflowHandlerCode = config.workflow ? `
   // Handle workflow execution requests
@@ -1280,6 +1371,63 @@ function generateWrapperCode(config, mockServiceUrl, envVars) {
       }
     }
   }` : "";
+  const cronHandlerCode = config.cron ? `
+  // Handle cron trigger delivery
+  if (request.headers.get("X-Ploy-Cron-Trigger") === "true") {
+    const cronExpression = request.headers.get("X-Ploy-Cron-Expression");
+    const scheduledTime = parseInt(request.headers.get("X-Ploy-Cron-Scheduled-Time") || String(Date.now()), 10);
+
+    if (cronExpression && userWorker.scheduled) {
+      let noRetryFlag = false;
+      const event = {
+        cron: cronExpression,
+        scheduledTime,
+        noRetry() { noRetryFlag = true; }
+      };
+      try {
+        await userWorker.scheduled(event, injectedEnv, ctx);
+        return new Response(JSON.stringify({ success: true, noRetry: noRetryFlag }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        return new Response(JSON.stringify({ success: false, error: String(error) }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+
+    return new Response(JSON.stringify({ success: false, error: "No scheduled handler defined" }), {
+      status: 404,
+      headers: { "Content-Type": "application/json" }
+    });
+  }` : "";
+  const alarmHandlerCode = config.alarm ? `
+  // Handle alarm fire delivery
+  if (request.headers.get("X-Ploy-Alarm-Fire") === "true") {
+    const alarmId = request.headers.get("X-Ploy-Alarm-Id");
+    const alarmName = request.headers.get("X-Ploy-Alarm-Name");
+    const alarmTime = request.headers.get("X-Ploy-Alarm-Time");
+    if (alarmId && userWorker.alarm) {
+      const body = await request.json().catch(() => ({}));
+      try {
+        await userWorker.alarm({
+          id: alarmId,
+          scheduledTime: parseInt(alarmTime || "0", 10),
+          payload: body.payload,
+          intervalMs: body.intervalMs
+        }, injectedEnv, ctx);
+        return new Response(JSON.stringify({ success: true }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        return new Response(JSON.stringify({ success: false, error: String(error) }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+  }` : "";
   const queueHandlerCode = config.queue ? `
   // Handle queue message delivery
   if (request.headers.get("X-Ploy-Queue-Delivery") === "true") {
@@ -1323,6 +1471,8 @@ ${bindings.join("\n")}
 export default {
   async fetch(request, env, ctx) {
     const injectedEnv = { ...env, ...ployBindings };${envVarsCode}
+    ${cronHandlerCode}
+    ${alarmHandlerCode}
     ${workflowHandlerCode}
     ${queueHandlerCode}
 
@@ -1370,6 +1520,10 @@ function createRuntimePlugin(_config) {
         path: "__ploy_workflow_runtime__",
         namespace: "ploy-runtime"
       }));
+      build2.onResolve({ filter: /^__ploy_alarm_runtime__$/ }, () => ({
+        path: "__ploy_alarm_runtime__",
+        namespace: "ploy-runtime"
+      }));
       build2.onLoad({ filter: /^__ploy_db_runtime__$/, namespace: "ploy-runtime" }, () => ({
         contents: DB_RUNTIME_CODE,
         loader: "ts"
@@ -1394,6 +1548,10 @@ function createRuntimePlugin(_config) {
         contents: WORKFLOW_RUNTIME_CODE,
         loader: "ts"
       }));
+      build2.onLoad({ filter: /^__ploy_alarm_runtime__$/, namespace: "ploy-runtime" }, () => ({
+        contents: ALARM_RUNTIME_CODE,
+        loader: "ts"
+      }));
     }
   };
 }
@@ -1430,6 +1588,7 @@ async function bundleWorker(options) {
 var NODE_BUILTINS;
 var init_bundler = __esm({
   "../emulator/dist/bundler/bundler.js"() {
+    init_alarm_runtime();
     init_cache_runtime();
     init_db_runtime();
     init_fs_runtime();
@@ -1693,6 +1852,306 @@ var init_workerd_config = __esm({
   "../emulator/dist/config/workerd-config.js"() {
   }
 });
+
+// ../emulator/dist/services/alarm-service.js
+function createAlarmHandlers(db) {
+  const setHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { alarmName, id, scheduledTime, payload, intervalMs } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      const scheduledTimeSec = Math.floor(scheduledTime / 1e3);
+      db.prepare(`INSERT OR REPLACE INTO alarm_entries (id, alarm_name, scheduled_time, payload, interval_ms, status, created_at)
+				 VALUES (?, ?, ?, ?, ?, 'pending', ?)`).run(id, alarmName, scheduledTimeSec, payload !== void 0 ? JSON.stringify(payload) : null, intervalMs ?? null, now);
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const getHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { alarmName, id } = body;
+      const row = db.prepare(`SELECT id, scheduled_time, payload, interval_ms FROM alarm_entries
+					 WHERE alarm_name = ? AND id = ? AND status = 'pending'`).get(alarmName, id);
+      if (!row) {
+        return c.json({ alarm: null });
+      }
+      return c.json({
+        alarm: {
+          id: row.id,
+          scheduledTime: row.scheduled_time * 1e3,
+          payload: row.payload ? JSON.parse(row.payload) : void 0,
+          intervalMs: row.interval_ms ?? void 0
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const deleteHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { alarmName, id } = body;
+      db.prepare(`DELETE FROM alarm_entries WHERE alarm_name = ? AND id = ?`).run(alarmName, id);
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  return {
+    setHandler,
+    getHandler,
+    deleteHandler
+  };
+}
+function createAlarmProcessor(db, workerUrl) {
+  let interval = null;
+  async function processAlarms() {
+    const now = Math.floor(Date.now() / 1e3);
+    const rows = db.prepare(`SELECT id, alarm_name, scheduled_time, payload, interval_ms
+				 FROM alarm_entries
+				 WHERE status = 'pending' AND scheduled_time <= ?
+				 ORDER BY scheduled_time ASC
+				 LIMIT 50`).all(now);
+    for (const row of rows) {
+      const startTime = Date.now();
+      try {
+        const response = await fetch(workerUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Ploy-Alarm-Fire": "true",
+            "X-Ploy-Alarm-Id": row.id,
+            "X-Ploy-Alarm-Name": row.alarm_name,
+            "X-Ploy-Alarm-Time": String(row.scheduled_time * 1e3)
+          },
+          body: JSON.stringify({
+            scheduledTime: row.scheduled_time * 1e3,
+            payload: row.payload ? JSON.parse(row.payload) : void 0,
+            intervalMs: row.interval_ms ?? void 0
+          })
+        });
+        const durationMs = Date.now() - startTime;
+        if (response.ok) {
+          if (row.interval_ms) {
+            const nextTimeSec = row.scheduled_time + Math.floor(row.interval_ms / 1e3);
+            db.prepare(`UPDATE alarm_entries SET scheduled_time = ? WHERE id = ? AND alarm_name = ?`).run(nextTimeSec, row.id, row.alarm_name);
+          } else {
+            db.prepare(`UPDATE alarm_entries SET status = 'fired' WHERE id = ? AND alarm_name = ?`).run(row.id, row.alarm_name);
+          }
+          db.prepare(`INSERT INTO alarm_executions (alarm_id, alarm_name, scheduled_time, status, duration_ms, created_at)
+						 VALUES (?, ?, ?, 'completed', ?, ?)`).run(row.id, row.alarm_name, row.scheduled_time, durationMs, now);
+        } else {
+          db.prepare(`INSERT INTO alarm_executions (alarm_id, alarm_name, scheduled_time, status, error, duration_ms, created_at)
+						 VALUES (?, ?, ?, 'failed', ?, ?, ?)`).run(row.id, row.alarm_name, row.scheduled_time, `HTTP ${String(response.status)}`, durationMs, now);
+          db.prepare(`UPDATE alarm_entries SET scheduled_time = ? WHERE id = ? AND alarm_name = ?`).run(now + 5, row.id, row.alarm_name);
+        }
+      } catch (err) {
+        const durationMs = Date.now() - startTime;
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        db.prepare(`INSERT INTO alarm_executions (alarm_id, alarm_name, scheduled_time, status, error, duration_ms, created_at)
+					 VALUES (?, ?, ?, 'failed', ?, ?, ?)`).run(row.id, row.alarm_name, row.scheduled_time, errorMessage, durationMs, now);
+        db.prepare(`UPDATE alarm_entries SET scheduled_time = ? WHERE id = ? AND alarm_name = ?`).run(now + 5, row.id, row.alarm_name);
+      }
+    }
+  }
+  return {
+    start() {
+      if (interval) {
+        return;
+      }
+      interval = setInterval(() => {
+        processAlarms().catch(() => {
+        });
+      }, 1e3);
+    },
+    stop() {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+    }
+  };
+}
+var init_alarm_service = __esm({
+  "../emulator/dist/services/alarm-service.js"() {
+  }
+});
+function parseCronField(field, min, max) {
+  const values = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    const trimmed = part.trim();
+    if (trimmed === "*") {
+      for (let i = min; i <= max; i++) {
+        values.add(i);
+      }
+      continue;
+    }
+    const stepMatch = trimmed.match(/^(.+)\/(\d+)$/);
+    if (stepMatch) {
+      const step = parseInt(stepMatch[2], 10);
+      const base = stepMatch[1];
+      let start = min;
+      let end = max;
+      if (base !== "*") {
+        const rangeMatch2 = base.match(/^(\d+)-(\d+)$/);
+        if (rangeMatch2) {
+          start = parseInt(rangeMatch2[1], 10);
+          end = parseInt(rangeMatch2[2], 10);
+        } else {
+          start = parseInt(base, 10);
+        }
+      }
+      if (start < min || start > max || end < min || end > max) {
+        throw new Error(`Cron field range ${start}-${end} is out of bounds (${min}-${max})`);
+      }
+      for (let i = start; i <= end; i += step) {
+        values.add(i);
+      }
+      continue;
+    }
+    const rangeMatch = trimmed.match(/^(\d+)-(\d+)$/);
+    if (rangeMatch) {
+      const start = parseInt(rangeMatch[1], 10);
+      const end = parseInt(rangeMatch[2], 10);
+      if (start < min || start > max || end < min || end > max) {
+        throw new Error(`Cron field range ${start}-${end} is out of bounds (${min}-${max})`);
+      }
+      for (let i = start; i <= end; i++) {
+        values.add(i);
+      }
+      continue;
+    }
+    const num = parseInt(trimmed, 10);
+    if (isNaN(num)) {
+      throw new Error(`Invalid cron field value: '${trimmed}' (expected number, range, step, or wildcard)`);
+    }
+    if (num < min || num > max) {
+      throw new Error(`Cron field value ${num} is out of range (${min}-${max})`);
+    }
+    values.add(num);
+  }
+  return { values };
+}
+function parseCronExpression(expression) {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new Error(`Invalid cron expression: ${expression} (expected 5 fields)`);
+  }
+  return [
+    parseCronField(parts[0], 0, 59),
+    parseCronField(parts[1], 0, 23),
+    parseCronField(parts[2], 1, 31),
+    parseCronField(parts[3], 1, 12),
+    parseCronField(parts[4], 0, 6)
+  ];
+}
+function cronMatchesDate(fields, date) {
+  const minute = date.getMinutes();
+  const hour = date.getHours();
+  const dayOfMonth = date.getDate();
+  const month = date.getMonth() + 1;
+  const dayOfWeek = date.getDay();
+  return fields[0].values.has(minute) && fields[1].values.has(hour) && fields[2].values.has(dayOfMonth) && fields[3].values.has(month) && fields[4].values.has(dayOfWeek);
+}
+function createCronScheduler(db, cronBindings, workerUrl) {
+  let interval = null;
+  const parsedCrons = /* @__PURE__ */ new Map();
+  let lastCheckedMinute = -1;
+  for (const [name, expression] of Object.entries(cronBindings)) {
+    try {
+      const fields = parseCronExpression(expression);
+      parsedCrons.set(name, { expression, fields });
+    } catch (err) {
+      error(`Failed to parse cron expression for '${name}': ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  async function checkCrons() {
+    const now = /* @__PURE__ */ new Date();
+    const currentMinute = Math.floor(now.getTime() / 6e4);
+    if (currentMinute === lastCheckedMinute) {
+      return;
+    }
+    lastCheckedMinute = currentMinute;
+    for (const [name, cron] of parsedCrons) {
+      if (cronMatchesDate(cron.fields, now)) {
+        await triggerScheduledHandler(db, name, cron.expression, now, workerUrl);
+      }
+    }
+  }
+  return {
+    start() {
+      if (interval) {
+        return;
+      }
+      log(`Cron scheduler started with ${parsedCrons.size} trigger(s)`);
+      for (const [name, cron] of parsedCrons) {
+        log(`  ${name}: ${cron.expression}`);
+      }
+      interval = setInterval(() => {
+        checkCrons().catch((err) => {
+          error(`Cron check error: ${err instanceof Error ? err.message : String(err)}`);
+        });
+      }, 15e3);
+      checkCrons().catch(() => {
+      });
+    },
+    stop() {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+    }
+  };
+}
+async function triggerScheduledHandler(db, cronName, cronExpression, triggerTime, workerUrl) {
+  const executionId = randomUUID();
+  const now = Math.floor(Date.now() / 1e3);
+  db.prepare(`INSERT INTO cron_executions (id, cron_name, cron_expression, status, triggered_at)
+		 VALUES (?, ?, ?, 'running', ?)`).run(executionId, cronName, cronExpression, now);
+  log(`[cron] Triggering '${cronName}' (${cronExpression}) execution=${executionId}`);
+  try {
+    const response = await fetch(workerUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Ploy-Cron-Trigger": "true",
+        "X-Ploy-Cron-Name": cronName,
+        "X-Ploy-Cron-Expression": cronExpression,
+        "X-Ploy-Cron-Execution-Id": executionId,
+        "X-Ploy-Cron-Scheduled-Time": String(triggerTime.getTime())
+      },
+      body: JSON.stringify({
+        cron: cronExpression,
+        scheduledTime: triggerTime.getTime()
+      })
+    });
+    const completedAt = Math.floor(Date.now() / 1e3);
+    const durationMs = Date.now() - triggerTime.getTime();
+    if (response.ok) {
+      db.prepare(`UPDATE cron_executions SET status = 'completed', completed_at = ?, duration_ms = ? WHERE id = ?`).run(completedAt, durationMs, executionId);
+      log(`[cron] '${cronName}' completed successfully (${durationMs}ms)`);
+    } else {
+      const errorText = await response.text();
+      db.prepare(`UPDATE cron_executions SET status = 'failed', completed_at = ?, duration_ms = ?, error = ? WHERE id = ?`).run(completedAt, durationMs, errorText, executionId);
+      error(`[cron] '${cronName}' failed: ${errorText}`);
+    }
+  } catch (err) {
+    const completedAt = Math.floor(Date.now() / 1e3);
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    db.prepare(`UPDATE cron_executions SET status = 'failed', completed_at = ?, error = ? WHERE id = ?`).run(completedAt, errorMessage, executionId);
+    error(`[cron] '${cronName}' error: ${errorMessage}`);
+  }
+}
+var init_cron_service = __esm({
+  "../emulator/dist/services/cron-service.js"() {
+    init_logger();
+  }
+});
 function getProjectHash(projectDir) {
   return createHash("sha256").update(projectDir).digest("hex").slice(0, 12);
 }
@@ -2035,6 +2494,8 @@ function createDashboardRoutes(app, dbManager2, config) {
       state: config.state,
       fs: config.fs,
       workflow: config.workflow,
+      cron: config.cron,
+      alarm: config.alarm,
       auth: config.auth
     });
   });
@@ -2559,6 +3020,123 @@ function createDashboardRoutes(app, dbManager2, config) {
       return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
     }
   });
+  app.get("/api/cron/:binding/executions", (c) => {
+    const binding = c.req.param("binding");
+    const cronExpression = config.cron?.[binding];
+    const limit = parseInt(c.req.query("limit") ?? "20", 10);
+    if (!cronExpression) {
+      return c.json({ error: "Cron binding not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const executions = db.prepare(`SELECT id, cron_name, cron_expression, status, error, duration_ms, triggered_at, completed_at, created_at
+					 FROM cron_executions
+					 WHERE cron_name = ?
+					 ORDER BY triggered_at DESC
+					 LIMIT ?`).all(binding, limit);
+      return c.json({
+        cronExpression,
+        executions: executions.map((e) => ({
+          id: e.id,
+          status: e.status.toUpperCase(),
+          error: e.error,
+          durationMs: e.duration_ms,
+          triggeredAt: new Date(e.triggered_at * 1e3).toISOString(),
+          completedAt: e.completed_at ? new Date(e.completed_at * 1e3).toISOString() : null,
+          createdAt: new Date(e.created_at * 1e3).toISOString()
+        }))
+      });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/alarm/:binding/entries", (c) => {
+    const binding = c.req.param("binding");
+    const alarmName = config.alarm?.[binding];
+    const limit = parseInt(c.req.query("limit") ?? "20", 10);
+    const offset = parseInt(c.req.query("offset") ?? "0", 10);
+    if (!alarmName) {
+      return c.json({ error: "Alarm binding not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const total = db.prepare(`SELECT COUNT(*) as count FROM alarm_entries WHERE alarm_name = ?`).get(alarmName).count;
+      const entries = db.prepare(`SELECT id, scheduled_time, payload, interval_ms, status, created_at
+					 FROM alarm_entries
+					 WHERE alarm_name = ?
+					 ORDER BY scheduled_time DESC
+					 LIMIT ? OFFSET ?`).all(alarmName, limit, offset);
+      return c.json({
+        entries: entries.map((e) => ({
+          id: e.id,
+          scheduledTime: new Date(e.scheduled_time * 1e3).toISOString(),
+          payload: e.payload ? JSON.parse(e.payload) : null,
+          intervalMs: e.interval_ms,
+          status: e.status.toUpperCase(),
+          createdAt: new Date(e.created_at * 1e3).toISOString()
+        })),
+        total,
+        limit,
+        offset
+      });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/alarm/:binding/metrics", (c) => {
+    const binding = c.req.param("binding");
+    const alarmName = config.alarm?.[binding];
+    if (!alarmName) {
+      return c.json({ error: "Alarm binding not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const metrics = { pending: 0, fired: 0 };
+      const statusCounts = db.prepare(`SELECT status, COUNT(*) as count
+					 FROM alarm_entries
+					 WHERE alarm_name = ?
+					 GROUP BY status`).all(alarmName);
+      for (const row of statusCounts) {
+        if (row.status === "pending") {
+          metrics.pending = row.count;
+        } else if (row.status === "fired") {
+          metrics.fired = row.count;
+        }
+      }
+      return c.json({ metrics });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/alarm/:binding/executions", (c) => {
+    const binding = c.req.param("binding");
+    const alarmName = config.alarm?.[binding];
+    const limit = parseInt(c.req.query("limit") ?? "20", 10);
+    if (!alarmName) {
+      return c.json({ error: "Alarm binding not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const executions = db.prepare(`SELECT id, alarm_id, scheduled_time, status, error, duration_ms, created_at
+					 FROM alarm_executions
+					 WHERE alarm_name = ?
+					 ORDER BY created_at DESC
+					 LIMIT ?`).all(alarmName, limit);
+      return c.json({
+        executions: executions.map((e) => ({
+          id: e.id,
+          alarmId: e.alarm_id,
+          scheduledTime: new Date(e.scheduled_time * 1e3).toISOString(),
+          status: e.status.toUpperCase(),
+          error: e.error,
+          durationMs: e.duration_ms,
+          createdAt: new Date(e.created_at * 1e3).toISOString()
+        }))
+      });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
   if (hasDashboard) {
     app.get("/assets/*", (c) => {
       const path = c.req.path;
@@ -3269,6 +3847,12 @@ async function startMockServer(dbManager2, config, options = {}) {
     app.post("/fs/delete", fsHandlers.deleteHandler);
     app.post("/fs/list", fsHandlers.listHandler);
   }
+  if (config.alarm) {
+    const alarmHandlers = createAlarmHandlers(dbManager2.emulatorDb);
+    app.post("/alarm/set", alarmHandlers.setHandler);
+    app.post("/alarm/get", alarmHandlers.getHandler);
+    app.post("/alarm/delete", alarmHandlers.deleteHandler);
+  }
   if (config.auth) {
     const authHandlers = createAuthHandlers(dbManager2.emulatorDb);
     app.post("/auth/signup", authHandlers.signupHandler);
@@ -3301,6 +3885,7 @@ var DEFAULT_MOCK_SERVER_PORT;
 var init_mock_server = __esm({
   "../emulator/dist/services/mock-server.js"() {
     init_paths();
+    init_alarm_service();
     init_auth_service();
     init_cache_service();
     init_dashboard_routes();
@@ -3463,6 +4048,52 @@ CREATE TABLE IF NOT EXISTS fs_entries (
   created_at INTEGER DEFAULT (strftime('%s', 'now')),
   PRIMARY KEY (fs_name, key)
 );
+
+-- Cron executions table
+CREATE TABLE IF NOT EXISTS cron_executions (
+  id TEXT PRIMARY KEY,
+  cron_name TEXT NOT NULL,
+  cron_expression TEXT NOT NULL,
+  status TEXT DEFAULT 'running',
+  error TEXT,
+  duration_ms INTEGER,
+  triggered_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  created_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_cron_executions_name
+  ON cron_executions(cron_name, triggered_at);
+
+-- Alarm entries table (durable timers, optionally recurring)
+CREATE TABLE IF NOT EXISTS alarm_entries (
+  id TEXT NOT NULL,
+  alarm_name TEXT NOT NULL,
+  scheduled_time INTEGER NOT NULL,
+  payload TEXT,
+  interval_ms INTEGER,
+  status TEXT DEFAULT 'pending',
+  created_at INTEGER DEFAULT (strftime('%s', 'now')),
+  PRIMARY KEY (alarm_name, id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_alarm_entries_status_time
+  ON alarm_entries(status, scheduled_time);
+
+-- Alarm execution log
+CREATE TABLE IF NOT EXISTS alarm_executions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  alarm_id TEXT NOT NULL,
+  alarm_name TEXT NOT NULL,
+  scheduled_time INTEGER NOT NULL,
+  status TEXT DEFAULT 'pending',
+  error TEXT,
+  duration_ms INTEGER,
+  created_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_alarm_executions_name
+  ON alarm_executions(alarm_name, created_at);
 `;
   }
 });
@@ -3479,6 +4110,8 @@ var init_emulator = __esm({
     init_env();
     init_ploy_config2();
     init_workerd_config();
+    init_alarm_service();
+    init_cron_service();
     init_mock_server();
     init_queue_service();
     init_logger();
@@ -3494,6 +4127,8 @@ var init_emulator = __esm({
       workerdProcess = null;
       fileWatcher = null;
       queueProcessor = null;
+      cronScheduler = null;
+      alarmProcessor = null;
       resolvedEnvVars = {};
       constructor(options = {}) {
         const port = options.port ?? 8787;
@@ -3561,6 +4196,18 @@ var init_emulator = __esm({
             this.queueProcessor.start();
             debug("Queue processor started", this.options.verbose);
           }
+          if (this.config.cron) {
+            const workerUrl2 = `http://${this.options.host}:${String(this.options.port)}`;
+            this.cronScheduler = createCronScheduler(this.dbManager.emulatorDb, this.config.cron, workerUrl2);
+            this.cronScheduler.start();
+            debug("Cron scheduler started", this.options.verbose);
+          }
+          if (this.config.alarm) {
+            const workerUrl2 = `http://${this.options.host}:${String(this.options.port)}`;
+            this.alarmProcessor = createAlarmProcessor(this.dbManager.emulatorDb, workerUrl2);
+            this.alarmProcessor.start();
+            debug("Alarm processor started", this.options.verbose);
+          }
           success(`Emulator running at http://${this.options.host}:${String(this.options.port)}`);
           log(`  Dashboard: http://${this.options.host}:${String(this.mockServer.port)}`);
           if (Object.keys(this.resolvedEnvVars).length > 0) {
@@ -3581,6 +4228,14 @@ var init_emulator = __esm({
           if (this.config.workflow) {
             log(`  Workflow bindings: ${Object.keys(this.config.workflow).join(", ")}`);
           }
+          if (this.config.cron) {
+            for (const [name, expr] of Object.entries(this.config.cron)) {
+              log(`  Cron: ${name} = ${expr}`);
+            }
+          }
+          if (this.config.alarm) {
+            log(`  Alarm bindings: ${Object.keys(this.config.alarm).join(", ")}`);
+          }
           this.setupSignalHandlers();
         } catch (err) {
           error(`Failed to start emulator: ${err instanceof Error ? err.message : String(err)}`);
@@ -3705,6 +4360,14 @@ var init_emulator = __esm({
         process.on("SIGTERM", handler);
       }
       async stop() {
+        if (this.cronScheduler) {
+          this.cronScheduler.stop();
+          this.cronScheduler = null;
+        }
+        if (this.alarmProcessor) {
+          this.alarmProcessor.stop();
+          this.alarmProcessor = null;
+        }
         if (this.queueProcessor) {
           this.queueProcessor.stop();
           this.queueProcessor = null;
@@ -5600,6 +6263,24 @@ ${varProps}
       properties.push(`	${bindingName}: WorkflowBinding;`);
     }
   }
+  if (config.fs) {
+    const fsKeys = Object.keys(config.fs);
+    if (fsKeys.length > 0) {
+      imports.push("FileStorageBinding");
+      for (const bindingName of fsKeys) {
+        properties.push(`	${bindingName}: FileStorageBinding;`);
+      }
+    }
+  }
+  if (config.alarm) {
+    const alarmKeys = Object.keys(config.alarm);
+    if (alarmKeys.length > 0) {
+      imports.push("AlarmBinding");
+      for (const bindingName of alarmKeys) {
+        properties.push(`	${bindingName}: AlarmBinding;`);
+      }
+    }
+  }
   const lines = [
     "// This file is auto-generated by `ploy types`. Do not edit manually.",
     ""
@@ -5641,7 +6322,7 @@ async function typesCommand(options = {}) {
     console.error("Error: ploy.yaml not found in current directory");
     process.exit(1);
   }
-  const hasBindings2 = config.env || config.ai || config.db || config.queue || config.cache || config.state || config.workflow;
+  const hasBindings2 = config.env || config.ai || config.db || config.queue || config.cache || config.state || config.workflow || config.fs || config.alarm || config.cron;
   if (!hasBindings2) {
     console.log("No bindings found in ploy.yaml. Generating empty Env.");
   }