Merge pull request #1951 from Automattic/feat/cloudflare-durable-cron

Run durable WordPress cron on Cloudflare

Author: chubes4

packages/runtime-cloudflare/README.md

@@ -16,7 +16,9 @@ The same revision transaction persists bounded user-managed files under `wp-cont
 
 The Worker forwards browser cookies directly to Playground and disables Playground's internal cookie store, preventing an empty per-isolate store from replacing a valid browser session after cold restart.
 
-The bundled MDI source is pinned to immutable commit `2a8ee7f6a46e1d64b4606f1ee3c97e14032dc96c` from [MDI PR #139](https://github.com/Automattic/markdown-database-integration/pull/139). The bundle generator, worker provenance, and source-contract test use the same revision.
+A minute Cloudflare Cron Trigger drains at most five due WordPress events or 25 seconds of work per invocation. Each event receives its own Durable Object lease and canonical R2 revision transaction. Direct `/wp-cron.php` requests are disabled so callbacks cannot bypass that transaction boundary.
+
+The bundled MDI source is pinned to immutable commit `bf6d434d1673fdd86d777501f7eaec292d32ad1f`, including [MDI PR #141](https://github.com/Automattic/markdown-database-integration/pull/141). The bundle generator, worker provenance, and source-contract test use the same revision.
 
 WordPress server files, browser assets, and pinned runtime dependencies are separate deployment artifacts, never Worker-module imports. `generate:cloudflare-wordpress-runtime-corpus` emits a deterministic server ZIP containing only `isWordPressRuntimeFile()` entries, one concatenated browser-asset blob containing the complete supported `wp-admin`, `wp-includes`, and bundled-theme surface, and the pinned SQLite integration ZIP. Checked-in manifests record content-addressed R2 keys, hashes, budgets, provenance, and each browser asset's exact byte range. Cold boot validates and streams the server ZIP into PHP MEMFS while loading SQLite integration from R2. Browser requests use one bounded R2 range read, validate the selected bytes, and populate an immutable artifact-versioned Worker cache. Runtime requests never fetch WordPress or SQLite integration release archives from third-party origins.
 

packages/runtime-cloudflare/assets/markdown-database-integration-canonical-seed.json

@@ -1,6 +1,6 @@
 {
     "schema": "wp-codebox/cloudflare-canonical-mdi-seed/v1",
-    "markdownDatabaseIntegrationRevision": "2a8ee7f6a46e1d64b4606f1ee3c97e14032dc96c",
+    "markdownDatabaseIntegrationRevision": "bf6d434d1673fdd86d777501f7eaec292d32ad1f",
     "wordpressInstallSeedSha256": "7212b89f1c01f98a23b89e9a2dd2b214306a85c10adb0355b9c7a6005b4fe822",
     "archiveSha256": "4f05439e26a63ef749de250a9b56ee3467697b1b1a166aeb90c5660ecfc9e845",
     "files": [

packages/runtime-cloudflare/assets/markdown-database-integration-runtime.zip

@@ -41,7 +41,7 @@ const wordpressWpContentRuntimeBaselinePaths = new Set((wordpressRuntimeArtifact
   .filter((file) => file.path.startsWith("wordpress/wp-content/"))
   .map((file) => file.path.slice("wordpress/wp-content/".length))
   .filter(isCanonicalWpContentPath))
-const MARKDOWN_DATABASE_INTEGRATION_REVISION = "2a8ee7f6a46e1d64b4606f1ee3c97e14032dc96c"
+const MARKDOWN_DATABASE_INTEGRATION_REVISION = "bf6d434d1673fdd86d777501f7eaec292d32ad1f"
 const SITE_URL = "https://wp-codebox-runtime.invalid"
 const DATABASE_PATH = "/wordpress/wp-content/database/.ht.sqlite"
 const MARKDOWN_ROOT = "/wordpress/wp-content/markdown"
@@ -54,6 +54,8 @@ const R2_MARKDOWN_OBJECT_PREFIX = "sites/default/markdown/objects"
 const R2_WORDPRESS_PAGE_PREFIX = "sites/default/pages"
 const WORDPRESS_PAGE_CACHE_SCHEMA = "v2"
 const PUBLIC_WP_CONTENT_EXTENSION = /\.(?:css|js|mjs|json|txt|xml|woff2?|ttf|otf|eot|svg|png|jpe?g|gif|webp|avif|ico)$/i
+const MAX_CRON_EVENTS_PER_INVOCATION = 5
+const MAX_CRON_INVOCATION_MS = 25_000
 const SERIALIZED_MARKDOWN_MUTATION_CODE = `<?php
 define('SHORTINIT', true);
 require '/wordpress/wp-load.php';
@@ -91,6 +93,35 @@ if (empty($option_rows)) {
 }
 $changes = $runtime->flush();
 echo json_encode(['revisionValue' => $value, 'previousPostFound' => !empty($previous_rows), 'postId' => $post_id, 'wordpressVersion' => $wp_version, 'canonicalChanges' => $changes]);`
+const NEXT_CRON_EVENT_CODE = `<?php
+require '/wordpress/wp-load.php';
+$ready = wp_get_ready_cron_jobs();
+if (empty($ready)) {
+    echo json_encode(['executed' => false], JSON_THROW_ON_ERROR);
+    return;
+}
+ksort($ready, SORT_NUMERIC);
+foreach ($ready as $timestamp => $hooks) {
+    ksort($hooks, SORT_STRING);
+    foreach ($hooks as $hook => $events) {
+        ksort($events, SORT_STRING);
+        foreach ($events as $event) {
+            $schedule = $event['schedule'] ?? false;
+            $args = $event['args'] ?? array();
+            if ($schedule) {
+                $rescheduled = wp_reschedule_event((int) $timestamp, $schedule, $hook, $args, true);
+                if (is_wp_error($rescheduled)) throw new RuntimeException($rescheduled->get_error_message());
+            }
+            $unscheduled = wp_unschedule_event((int) $timestamp, $hook, $args, true);
+            if (is_wp_error($unscheduled)) throw new RuntimeException($unscheduled->get_error_message());
+            do_action_ref_array($hook, $args);
+            $GLOBALS['wpdb']->flush_canonical_writes();
+            echo json_encode(['executed' => true, 'hook' => $hook, 'timestamp' => (int) $timestamp], JSON_THROW_ON_ERROR);
+            return;
+        }
+    }
+}
+echo json_encode(['executed' => false], JSON_THROW_ON_ERROR);`
 interface Env {
   WORDPRESS_STATE: DurableObjectNamespace
   WORDPRESS_STATE_BUCKET: R2Bucket
@@ -101,6 +132,7 @@ interface Env {
 
 export default {
   async fetch(request: Request, env: Env): Promise<Response> {
+    if (new URL(request.url).pathname === "/wp-cron.php") return new Response("WordPress cron is managed by the Cloudflare scheduled handler.", { status: 404 })
     const coordinator = env.WORDPRESS_STATE.getByName("default")
     const wpContentResponse = await serveWordPressWpContent(request, env.WORDPRESS_STATE_BUCKET, coordinator)
     if (wpContentResponse) return wpContentResponse
@@ -120,6 +152,10 @@ export default {
     }
     return runCoordinatedWordPressRequest(request, env, coordinator, route.kind)
   },
+  async scheduled(controller: ScheduledController, env: Env): Promise<void> {
+    const evidence = await runScheduledWordPressCron(env, controller.scheduledTime)
+    console.log(JSON.stringify(evidence))
+  },
 }
 
 interface MarkdownManifestFile {
@@ -174,6 +210,15 @@ interface Runtime {
   pointer: MarkdownPointer
 }
 
+interface CronInvocationEvidence {
+  schema: "wp-codebox/cloudflare-cron/v1"
+  scheduledTime: number
+  startedAt: string
+  completedAt: string
+  events: Array<{ hook: string; timestamp: number; revision: string }>
+  status: "completed" | "bounded" | "no-canonical-state"
+}
+
 let cachedRuntime: { baseRevision: string; promise: Promise<Runtime> } | undefined
 const LEASE_ACQUISITION_TIMEOUT_MS = 100_000
 
@@ -539,6 +584,61 @@ async function runSyntheticMutation(runtime: Runtime): Promise<{ response: Respo
   return { response: Response.json({ schema: "wp-codebox/cloudflare-wordpress-mutation/v1", source: "entry-worker-primary-runtime", ...mutation, canonicalFiles: collectRuntimeFiles(runtime.php, MARKDOWN_ROOT).length, markdownDatabaseIntegrationRevision: MARKDOWN_DATABASE_INTEGRATION_REVISION, sqlitePersisted: false }), canonicalChanges: mutation.canonicalChanges }
 }
 
+async function runScheduledWordPressCron(env: Env, scheduledTime: number): Promise<CronInvocationEvidence> {
+  const started = Date.now()
+  const evidence: CronInvocationEvidence = {
+    schema: "wp-codebox/cloudflare-cron/v1",
+    scheduledTime,
+    startedAt: new Date(started).toISOString(),
+    completedAt: "",
+    events: [],
+    status: "completed",
+  }
+  const coordinator = env.WORDPRESS_STATE.getByName("default")
+  const requestUrl = `${SITE_URL}/wp-cron.php?doing_wp_cron=${scheduledTime}`
+  while (evidence.events.length < MAX_CRON_EVENTS_PER_INVOCATION && Date.now() - started < MAX_CRON_INVOCATION_MS) {
+    const lease = await acquireLease(coordinator, requestUrl)
+    if (!lease.pointer) {
+      await releaseLease(coordinator, requestUrl, lease)
+      evidence.status = "no-canonical-state"
+      break
+    }
+    let runtime: Runtime | undefined
+    let finalized = false
+    try {
+      runtime = await getRuntime(env, lease.pointer, SITE_URL)
+      const event = await runNextCronEvent(runtime)
+      if (!event.executed) {
+        await releaseLease(coordinator, requestUrl, lease)
+        finalized = true
+        await discardRuntime(runtime)
+        break
+      }
+      const next = await persistRuntime(env.WORDPRESS_STATE_BUCKET, runtime, event.canonicalChanges)
+      await commitLease(coordinator, requestUrl, lease, next)
+      finalized = true
+      evidence.events.push({ hook: event.hook, timestamp: event.timestamp, revision: next.revision })
+      await discardRuntime(runtime)
+    } catch (error) {
+      if (!finalized) await abortLease(coordinator, requestUrl, lease)
+      if (runtime) await discardRuntime(runtime)
+      throw error
+    }
+  }
+  if (evidence.events.length === MAX_CRON_EVENTS_PER_INVOCATION || Date.now() - started >= MAX_CRON_INVOCATION_MS) evidence.status = "bounded"
+  evidence.completedAt = new Date().toISOString()
+  return evidence
+}
+
+async function runNextCronEvent(runtime: Runtime): Promise<{ executed: false } | { executed: true; hook: string; timestamp: number; canonicalChanges: MarkdownChanges }> {
+  runtime.php.writeFile(MARKDOWN_CHANGES_PATH, new TextEncoder().encode(JSON.stringify({ created: [], changed: [], deleted: [] })))
+  const output = (await runtime.php.run({ code: NEXT_CRON_EVENT_CODE })).text.trim()
+  const event = JSON.parse(output) as { executed: boolean; hook?: string; timestamp?: number }
+  if (!event.executed) return { executed: false }
+  if (!event.hook || !Number.isSafeInteger(event.timestamp)) throw new Error("WordPress cron returned invalid event evidence.")
+  return { executed: true, hook: event.hook, timestamp: event.timestamp!, canonicalChanges: readCanonicalChanges(runtime.php) }
+}
+
 async function health(runtime: Runtime): Promise<Response> {
   const phpVersion = (await runtime.php.run({ code: "<?php echo PHP_VERSION;" })).text.trim()
   return cloudflareRuntimeHealthResponse({ schema: CLOUDFLARE_RUNTIME_HEALTH_SCHEMA, marker: CLOUDFLARE_RUNTIME_HEALTH_MARKER, wordpressVersion: runtime.wordpressVersion, phpVersion, runtime: { backend: "wordpress-playground", environment: "wordpress" }, evidence: { initialization: "completed", execution: "completed", initializationScope: "isolate" } })
@@ -1065,6 +1165,10 @@ function patchCanonicalRuntimePoliciesAtInit(php: PHP): void {
 	remove_action( 'init', 'wp_schedule_delete_old_privacy_export_files' );
 	remove_action( 'init', 'wp_schedule_update_checks' );
 }
+// This runtime has an explicit scheduled handler, so cron events are canonical.
+add_filter( 'markdown_database_integration_ephemeral_option_names', static function ( $names ) {
+	return array_values( array_diff( $names, array( 'cron' ) ) );
+} );
 // Rewrite rules are derived for each runtime; keep them out of canonical MDI state.
 add_filter( 'pre_update_option_rewrite_rules', static function ( $value, $old_value ) {
 	return $old_value;

packages/runtime-cloudflare/src/worker.ts

@@ -5,6 +5,7 @@
   "compatibility_date": "2026-07-18",
   "compatibility_flags": ["nodejs_compat"],
   "limits": { "cpu_ms": 300000 },
+	"triggers": { "crons": ["* * * * *"] },
 	"r2_buckets": [
 		{ "binding": "WORDPRESS_STATE_BUCKET", "bucket_name": "wp-codebox-runtime-chubes" }
 	],

packages/runtime-cloudflare/wrangler.jsonc

@@ -1,7 +1,7 @@
 <?php
 declare( strict_types=1 );
 
-const MDI_REVISION = '2a8ee7f6a46e1d64b4606f1ee3c97e14032dc96c';
+const MDI_REVISION = 'bf6d434d1673fdd86d777501f7eaec292d32ad1f';
 const REQUIRED_PATHS = array(
 	'_options/siteurl.json', '_options/home.json', '_tables/users.json', '_tables/usermeta.json',
 	'_tables/terms.json', '_tables/term_taxonomy.json', '_tables/termmeta.json', '_tables/postmeta.json',

scripts/build-cloudflare-canonical-mdi-seed.php

@@ -1,7 +1,7 @@
 import { readFile, writeFile } from "node:fs/promises"
 import { decodeZip, encodeZip } from "@php-wasm/stream-compression"
 
-const revision = "2a8ee7f6a46e1d64b4606f1ee3c97e14032dc96c"
+const revision = "bf6d434d1673fdd86d777501f7eaec292d32ad1f"
 const jsonMachineRevision = "8bf0b0ff6ff60ab480778eaa5ad7d505b442c2d4"
 const archiveUrl = `https://codeload.github.com/Automattic/markdown-database-integration/zip/${revision}`
 const jsonMachineArchiveUrl = `https://codeload.github.com/halaxa/json-machine/zip/${jsonMachineRevision}`