@phnx-labs/agents-cli 1.22.55 → 1.22.56

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.22.56
+
+- **Scheduled routines claim a durable per-occurrence slot, so a duplicate delivery or a catch-up of the same slot can't double-launch (PHNX-3215).** The forward-timer path keyed its single-fire claim on croner's `currentRun()`, which is the jittered wall-clock fire instant, not the aligned schedule boundary — so two timer callbacks for one occurrence minted different run ids and both launched, and a live fire never collided with its catch-up twin. The scheduler now floors the fire to the aligned `(routine, scheduledFor)` boundary (`fireSlot`/`alignedSlotForFire`), the same derivation catch-up uses, making the atomic slot claim a structural guarantee (SING-15/16, self-overlap SING-13). Source: `cli/src/lib/scheduler.ts`, `cli/src/lib/scheduling/routines.ts`, `cli/src/lib/overdue.ts`.
+
+- **Managed-share Open Graph cards render in Cloudflare instead of failing on every new publish (PHNX-2835).** The Worker upload now carries Yoga and resvg as compiled WebAssembly modules alongside the bundled JavaScript and fonts. The previous single-file bundle decoded the WASM into byte arrays and compiled it at request time; Node accepted that in tests, but Cloudflare workerd forbids runtime WASM code generation, so a new share's lazy `<slug>.png` render failed. A real-workerd regression test now renders and validates the PNG, and a genuine renderer failure returns a diagnostic `500` instead of falling through as a missing cover. Source: `cli/src/lib/share/{worker-template,provision}.ts`.
+
 ## 1.22.55
 
 - **Managed shares generate their Open Graph cover server-side (PHNX-2835).** Publishing HTML to `share.agents-cli.sh` no longer launches local Chromium. The Worker lazily renders a deterministic 1200×630 AGI card with Satori and resvg-wasm, bundles Inter and JetBrains Mono, inherits the canonical page's visibility gate, and caches the PNG in R2. BYO endpoints keep their local screenshot fallback. An explicit missing `AGENTS_SHARE_BROWSER` or `PUPPETEER_EXECUTABLE_PATH` now fails loudly instead of silently falling through. Source: `cli/src/lib/share/{capture,publish,worker-template}.ts`.

package/dist/commands/share.js

@@ -13,7 +13,7 @@ import { DEFAULT_BUCKET_NAME, DEFAULT_CF_BUNDLE, DEFAULT_SHARE_DOMAIN, DEFAULT_W
 import { addCustomDomain, configureBucketLifecycle, createBucket, deployWorker, enableWorkersDev, findZoneId, hashWorkerScript, putWorkerSecret, updateWorker, WORKER_PHOENIX_ID_BASE_SECRET, setWorkerSecret, } from '../lib/share/provision.js';
 import { publishFile, resolveShareUsername, parseMetaEntries, sanitizeLabel, resolveShareVisibility, scanShareContent, formatSensitiveContentError, SHARE_VISIBILITY_LEVELS, } from '../lib/share/publish.js';
 import { deleteShare, resolveDeleteTarget } from '../lib/share/delete.js';
-import { renderWorkerScript } from '../lib/share/worker-template.js';
+import { renderWorkerBundle } from '../lib/share/worker-template.js';
 import { analyticsEnabled } from '../lib/share/analytics.js';
 import { phoenixIdBaseForDeploy, resolveShareBackend, } from '../lib/share/backend.js';
 import { resolveGitHubUsername } from '../lib/git.js';
@@ -54,7 +54,7 @@ export function formatSharePublishResult(result, json = false) {
 export function shareTemplateStatus(cfg) {
     if (!cfg.templateHash)
         return 'unknown';
-    return cfg.templateHash === hashWorkerScript(renderWorkerScript()) ? 'current' : 'outdated';
+    return cfg.templateHash === hashWorkerScript(renderWorkerBundle().script) ? 'current' : 'outdated';
 }
 export async function runShareEdit(target, opts) {
     // Same public-listing gate as publish: label + every metadata value are
@@ -1155,7 +1155,8 @@ export async function runShareProvision(opts) {
     const bucketName = opts.bucket;
     const token = generateWriteToken();
     const requestedDomain = cleanHostname(opts.domain) ?? DEFAULT_SHARE_DOMAIN;
-    const script = renderWorkerScript();
+    const worker = renderWorkerBundle();
+    const script = worker.script;
     const spin = ora('Provisioning on Cloudflare…').start();
     try {
         const provisionOpts = opts.request ? { request: opts.request } : {};
@@ -1163,7 +1164,7 @@ export async function runShareProvision(opts) {
         spin.text = `R2 bucket '${bucketName}' ready`;
         await configureBucketLifecycle(apiToken, accountId, bucketName, provisionOpts);
         spin.text = `R2 bucket '${bucketName}' lifecycle ready`;
-        await deployWorker(apiToken, accountId, workerName, script, bucketName, provisionOpts);
+        await deployWorker(apiToken, accountId, workerName, worker, bucketName, provisionOpts);
         spin.text = `Worker '${workerName}' deployed`;
         await setWorkerSecret(apiToken, accountId, workerName, token, provisionOpts);
         spin.text = `Worker '${workerName}' write token set`;
@@ -1230,14 +1231,14 @@ export async function runShareUpdate(opts = {}) {
         throw new Error("Share endpoint has no Cloudflare account id — `agents artifacts share update` cannot call the API. Pass --account <id>, or re-run 'agents artifacts share join'.");
     }
     const writeToken = readWriteToken();
-    const script = renderWorkerScript();
+    const worker = renderWorkerBundle();
     const phoenixIdBase = phoenixIdBaseForDeploy({ managed: opts.managed }, cfg);
     const provisionOpts = {
         ...(opts.request ? { request: opts.request } : {}),
         force: opts.force,
         ...(phoenixIdBase !== undefined ? { phoenixIdBase } : {}),
     };
-    const result = await updateWorker(apiToken, accountId, cfg.workerName, cfg.bucketName, script, writeToken, cfg.templateHash, provisionOpts);
+    const result = await updateWorker(apiToken, accountId, cfg.workerName, cfg.bucketName, worker, writeToken, cfg.templateHash, provisionOpts);
     if (!result.skipped) {
         writeShareConfig({ ...cfg, accountId, templateHash: result.templateHash });
     }

package/dist/lib/overdue.js

@@ -13,48 +13,18 @@
  */
 import * as fs from 'fs';
 import { Cron } from 'croner';
-import { listJobs, getLatestRun, resolveJobFilePath, isPastEndAt, isOneShotRoutine, jobRunsOnThisDevice } from './scheduling/routines.js';
+import { alignedSlotForFire, listJobs, getLatestRun, resolveJobFilePath, isPastEndAt, isOneShotRoutine, jobRunsOnThisDevice } from './scheduling/routines.js';
 import { notifyDesktop } from './menubar/notify-desktop.js';
 // Tolerance between "expected fire" and "recorded run start" — accounts for
 // the small gap between the cron tick and when the runner writes meta.json.
 const GRACE_MS = 60_000;
-const DAY_MS = 24 * 60 * 60 * 1000;
-/**
- * Lookback windows, narrowest first. A fixed one-week window silently blinded
- * detection to any cron whose gap exceeds it: `0 9 1,13,25 * *` has 12-day gaps,
- * so `nextRun(now - 7d)` jumped past `now`, the walk returned null, and the
- * routine was never flagged overdue on any device — no missed record, no
- * catch-up, permanently. Monthly, quarterly and annual routines were all in that
- * class.
- *
- * A wider window is only tried when the narrower one found nothing, so a dense
- * schedule (every minute, hourly, daily) never walks more than a week of
- * occurrences. A sparse schedule has few occurrences to walk by definition.
- */
-const LOOKBACK_WINDOWS_MS = [7 * DAY_MS, 32 * DAY_MS, 93 * DAY_MS, 400 * DAY_MS];
-/** Compute the most recent fire of `pattern` at or before `now`. Croner's
- *  `previousRun()` returns the cron instance's own last fire, which is null
- *  on a freshly-constructed instance — so we walk `nextRun(cursor)` forward
- *  from a week ago and keep the last fire still ≤ now. */
+/** Compute the most recent fire of `pattern` at or before `now`. Delegates to
+ *  {@link alignedSlotForFire} so overdue detection (`missedRunId`) and the live
+ *  forward-timer dispatch (`slotRunId`) key on the SAME occurrence identity — a
+ *  missed fire and its live twin for one UTC slot then collide by construction
+ *  (SING-15). */
 function previousExpectedFire(cron, now) {
-    for (const window of LOOKBACK_WINDOWS_MS) {
-        let cursor = new Date(now.getTime() - window);
-        let last = null;
-        // Cap iterations: an every-minute schedule yields ≤ 10080 steps over a week;
-        // 20k is a paranoia bound against pathological patterns. Only a schedule
-        // that found nothing in the narrower window reaches a wider one, and such a
-        // schedule is sparse, so the cap is never the binding constraint.
-        for (let i = 0; i < 20000; i++) {
-            const next = cron.nextRun(cursor);
-            if (!next || next.getTime() > now.getTime())
-                break;
-            last = next;
-            cursor = next;
-        }
-        if (last)
-            return last;
-    }
-    return null;
+    return alignedSlotForFire(cron, now);
 }
 /**
  * When a routine started existing, and therefore the earliest fire it can

package/dist/lib/scheduler.d.ts

@@ -5,13 +5,32 @@
  * process creates a single JobScheduler instance that loads enabled jobs
  * on startup and reloads them on SIGHUP.
  */
+import { Cron } from 'croner';
 import type { JobConfig } from './scheduling/routines.js';
 /** How a fire was triggered, carrying the scheduler's intended UTC slot time. */
 export interface TriggerContext {
-    /** The cron slot this callback fires for (croner `currentRun()`), for the
-     *  single-fire claim keyed on (routine, scheduledFor). */
+    /** The ALIGNED cron slot this callback fires for, for the single-fire claim
+     *  keyed on (routine, scheduledFor). Derived by {@link fireSlot} — NOT croner's
+     *  raw `currentRun()`, which carries wall-clock jitter. */
     scheduledFor?: Date;
 }
+/**
+ * The aligned occurrence boundary a fire callback belongs to — the value the
+ * single-fire `(routine, scheduledFor)` claim keys on.
+ *
+ * croner's `currentRun()` inside a fire callback is the JITTERED wall-clock
+ * trigger instant (it carries milliseconds — verified against croner 10.x), not
+ * the aligned schedule boundary. Keying `slotRunId` on it directly minted a
+ * distinct run id per delivery, so two callbacks for one occurrence each claimed
+ * a different run dir and both launched, and a live fire never collided with its
+ * catch-up twin (`missedRunId`, which keys on the aligned boundary). Flooring the
+ * fire to its schedule boundary via {@link alignedSlotForFire} makes the claim a
+ * structural claim on the occurrence identity (SING-15). Always returns a
+ * concrete Date — `currentRun()` falls back to now, and an unresolvable boundary
+ * falls back to the fire instant — so the forward path never dispatches without a
+ * durable slot key.
+ */
+export declare function fireSlot(cron: Cron): Date;
 /** In-memory cron scheduler that triggers a callback when jobs fire. */
 export declare class JobScheduler {
     private jobs;

package/dist/lib/scheduler.js

@@ -6,7 +6,27 @@
  * on startup and reloads them on SIGHUP.
  */
 import { Cron } from 'croner';
-import { listJobs, deleteJob, isPastEndAt, isPastOneShotRoutine, isOneShotRoutine, setJobEnabled, shouldPurgeCompletedOneShotRoutine, jobRunsOnThisDevice, hasAmbiguousDevicePin, routineOwnerDevice, } from './scheduling/routines.js';
+import { alignedSlotForFire, listJobs, deleteJob, isPastEndAt, isPastOneShotRoutine, isOneShotRoutine, setJobEnabled, shouldPurgeCompletedOneShotRoutine, jobRunsOnThisDevice, hasAmbiguousDevicePin, routineOwnerDevice, } from './scheduling/routines.js';
+/**
+ * The aligned occurrence boundary a fire callback belongs to — the value the
+ * single-fire `(routine, scheduledFor)` claim keys on.
+ *
+ * croner's `currentRun()` inside a fire callback is the JITTERED wall-clock
+ * trigger instant (it carries milliseconds — verified against croner 10.x), not
+ * the aligned schedule boundary. Keying `slotRunId` on it directly minted a
+ * distinct run id per delivery, so two callbacks for one occurrence each claimed
+ * a different run dir and both launched, and a live fire never collided with its
+ * catch-up twin (`missedRunId`, which keys on the aligned boundary). Flooring the
+ * fire to its schedule boundary via {@link alignedSlotForFire} makes the claim a
+ * structural claim on the occurrence identity (SING-15). Always returns a
+ * concrete Date — `currentRun()` falls back to now, and an unresolvable boundary
+ * falls back to the fire instant — so the forward path never dispatches without a
+ * durable slot key.
+ */
+export function fireSlot(cron) {
+    const fire = cron.currentRun() ?? new Date();
+    return alignedSlotForFire(cron, fire) ?? fire;
+}
 /** In-memory cron scheduler that triggers a callback when jobs fire. */
 export class JobScheduler {
     jobs = new Map();
@@ -75,10 +95,13 @@ export class JobScheduler {
                 return;
             }
             try {
-                // croner hands the callback its own Cron instance; `currentRun()` is the
-                // UTC time THIS invocation was scheduled for — the single-fire slot key.
-                // A duplicate delivery for the same slot resolves to one run downstream.
-                await this.onTrigger(config, { scheduledFor: self.currentRun() ?? undefined });
+                // scheduledFor is the ALIGNED occurrence boundary (fireSlot), not croner's
+                // jittered currentRun(): the single-fire claim keys on (routine,
+                // scheduledFor), so the key must be the occurrence identity or a live fire
+                // and its catch-up twin (missedRunId) won't collide and two deliveries of
+                // one slot each mint a distinct id. fireSlot always returns a Date, so the
+                // forward path always carries a durable claim (SING-15).
+                await this.onTrigger(config, { scheduledFor: fireSlot(self) });
             }
             catch (err) {
                 console.error(`Job '${config.name}' failed:`, err.message);

package/dist/lib/scheduling/routines.d.ts

@@ -6,6 +6,7 @@
  * run metadata persistence, prompt variable expansion, and one-shot "at" time
  * scheduling.
  */
+import { Cron } from 'croner';
 import { type ResolvedExecutionContext, type ProjectResolution, type PlacementMode, type RoutineKind, type ContextFsProbe } from '../routine-context.js';
 import type { AgentId, RunStrategy } from '../types.js';
 import type { LoopConfig } from '../loop.js';
@@ -837,6 +838,26 @@ export declare function getRunDir(jobName: string, runId: string): string;
  * for the same UTC slot are one record.
  */
 export declare function slotRunId(scheduledFor: Date | string): string;
+/**
+ * The aligned schedule boundary a fire belongs to: the most recent occurrence of
+ * `cron` at or before `at`.
+ *
+ * This is the occurrence IDENTITY that {@link slotRunId} (forward dispatch) and
+ * `missedRunId` (catchup.ts) must both key on. croner's `currentRun()` inside a
+ * fire callback is the JITTERED wall-clock trigger instant (it carries
+ * milliseconds — verified), not the aligned boundary, so keying `slotRunId`
+ * directly on it produced a distinct id per delivery: two callbacks for one
+ * occurrence each claimed a different run dir and both launched, and a live fire
+ * never collided with its catch-up twin (which keys on the aligned
+ * `previousExpectedFire`). Flooring both to this boundary is what makes the
+ * single-fire claim a structural claim on `(routine, scheduledFor)` (SING-15).
+ *
+ * croner's `previousRun()` takes no argument and returns null on a freshly
+ * constructed instance, so we walk `nextRun(cursor)` forward from a lookback
+ * window and keep the last fire still ≤ `at` — the same derivation catchup's
+ * overdue detection has always used.
+ */
+export declare function alignedSlotForFire(cron: Cron, at: Date): Date | null;
 /**
  * Atomically CLAIM a run directory. Returns true on a successful claim, false
  * when the directory already exists (another caller — even in a separate process

package/dist/lib/scheduling/routines.js

@@ -1518,6 +1518,62 @@ export function slotRunId(scheduledFor) {
     const iso = typeof scheduledFor === 'string' ? scheduledFor : scheduledFor.toISOString();
     return iso.replace(/[:.]/g, '-');
 }
+/**
+ * Lookback windows for {@link alignedSlotForFire}, narrowest first. A wider
+ * window is tried ONLY when the narrower one found no fire, so:
+ *  - a dense schedule (every-minute) resolves in the 1-hour window — ~60 steps,
+ *    not ~10080 — which matters because the forward-timer path now runs this on
+ *    every fire (a live fire is milliseconds past its boundary, so the narrowest
+ *    window always contains it);
+ *  - a sparse schedule (`0 9 1,13,25 * *` has 12-day gaps; monthly/quarterly/
+ *    annual) still resolves, because a fixed short window silently blinded
+ *    overdue detection to any cron whose gap exceeded it.
+ * A narrower window can only ever find the true most-recent fire ≤ `at` or
+ * nothing (never a wrong boundary), so prepending the cheap windows is
+ * behavior-preserving for the sparse-schedule overdue path.
+ */
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+const SLOT_LOOKBACK_WINDOWS_MS = [HOUR_MS, DAY_MS, 7 * DAY_MS, 32 * DAY_MS, 93 * DAY_MS, 400 * DAY_MS];
+/**
+ * The aligned schedule boundary a fire belongs to: the most recent occurrence of
+ * `cron` at or before `at`.
+ *
+ * This is the occurrence IDENTITY that {@link slotRunId} (forward dispatch) and
+ * `missedRunId` (catchup.ts) must both key on. croner's `currentRun()` inside a
+ * fire callback is the JITTERED wall-clock trigger instant (it carries
+ * milliseconds — verified), not the aligned boundary, so keying `slotRunId`
+ * directly on it produced a distinct id per delivery: two callbacks for one
+ * occurrence each claimed a different run dir and both launched, and a live fire
+ * never collided with its catch-up twin (which keys on the aligned
+ * `previousExpectedFire`). Flooring both to this boundary is what makes the
+ * single-fire claim a structural claim on `(routine, scheduledFor)` (SING-15).
+ *
+ * croner's `previousRun()` takes no argument and returns null on a freshly
+ * constructed instance, so we walk `nextRun(cursor)` forward from a lookback
+ * window and keep the last fire still ≤ `at` — the same derivation catchup's
+ * overdue detection has always used.
+ */
+export function alignedSlotForFire(cron, at) {
+    for (const window of SLOT_LOOKBACK_WINDOWS_MS) {
+        let cursor = new Date(at.getTime() - window);
+        let last = null;
+        // Cap iterations: an every-minute schedule yields ≤ 10080 steps over a week;
+        // 20k is a paranoia bound against pathological patterns. Only a schedule that
+        // found nothing in the narrower window reaches a wider one, and such a
+        // schedule is sparse, so the cap is never the binding constraint.
+        for (let i = 0; i < 20000; i++) {
+            const next = cron.nextRun(cursor);
+            if (!next || next.getTime() > at.getTime())
+                break;
+            last = next;
+            cursor = next;
+        }
+        if (last)
+            return last;
+    }
+    return null;
+}
 /**
  * Atomically CLAIM a run directory. Returns true on a successful claim, false
  * when the directory already exists (another caller — even in a separate process

package/dist/lib/share/provision.d.ts

@@ -1,3 +1,4 @@
+import type { WorkerBundle } from './worker-template.js';
 export declare const SHARE_LIFECYCLE_RULE_ID = "agents-share-expire-objects";
 export declare const SHARE_LIFECYCLE_RETENTION_DAYS = 366;
 interface R2LifecycleRule {
@@ -50,7 +51,7 @@ export declare function mergeShareLifecycleRule(existing?: R2LifecycleRule[], ru
 /** Ensure the share bucket self-cleans old objects. Exact per-link expiry is enforced by the Worker. */
 export declare function configureBucketLifecycle(apiToken: string, accountId: string, bucketName: string, opts?: ProvisionOptions): Promise<void>;
 /** Upload the module Worker with an R2 binding (`BUCKET`). Secrets are set via the Workers Secrets API. */
-export declare function deployWorker(apiToken: string, accountId: string, workerName: string, script: string, bucketName: string, opts?: ProvisionOptions): Promise<void>;
+export declare function deployWorker(apiToken: string, accountId: string, workerName: string, worker: string | WorkerBundle, bucketName: string, opts?: ProvisionOptions): Promise<void>;
 /** sha256 of the rendered Worker script, so a deployed endpoint can be compared
  * against the current `worker-template.ts` without redeploying to find out. */
 export declare function hashWorkerScript(script: string): string;
@@ -100,7 +101,7 @@ export type UpdateWorkerOpts = ProvisionOptions & {
  * re-setting the secret to its own value after every deploy gets the same
  * outcome without depending on an unverified upload-time flag.
  */
-export declare function updateWorker(apiToken: string, accountId: string, workerName: string, bucketName: string, script: string, writeToken: string, previousHash: string | undefined, opts?: UpdateWorkerOpts): Promise<UpdateWorkerResult>;
+export declare function updateWorker(apiToken: string, accountId: string, workerName: string, bucketName: string, worker: string | WorkerBundle, writeToken: string, previousHash: string | undefined, opts?: UpdateWorkerOpts): Promise<UpdateWorkerResult>;
 /** Add/update a secret_text binding using Cloudflare's Workers Secrets API. */
 export declare function putWorkerSecret(apiToken: string, accountId: string, workerName: string, name: string, text: string, opts?: ProvisionOptions): Promise<void>;
 /** Add/update the WRITE_TOKEN binding using Cloudflare's Workers Secrets API. */

package/dist/lib/share/provision.js

@@ -77,7 +77,7 @@ export async function configureBucketLifecycle(apiToken, accountId, bucketName,
     });
 }
 /** Upload the module Worker with an R2 binding (`BUCKET`). Secrets are set via the Workers Secrets API. */
-export async function deployWorker(apiToken, accountId, workerName, script, bucketName, opts = {}) {
+export async function deployWorker(apiToken, accountId, workerName, worker, bucketName, opts = {}) {
     const request = opts.request ?? defaultCloudflareRequester;
     const metadata = {
         main_module: 'worker.js',
@@ -88,7 +88,11 @@ export async function deployWorker(apiToken, accountId, workerName, script, buck
     };
     const form = new FormData();
     form.set('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }));
-    form.set('worker.js', new Blob([script], { type: 'application/javascript+module' }), 'worker.js');
+    const bundle = typeof worker === 'string' ? { script: worker, modules: [] } : worker;
+    form.set('worker.js', new Blob([bundle.script], { type: 'application/javascript+module' }), 'worker.js');
+    for (const module of bundle.modules) {
+        form.set(module.name, new Blob([module.contents], { type: module.contentType }), module.name);
+    }
     await request({
         apiToken,
         method: 'PUT',
@@ -130,7 +134,8 @@ export const WORKER_PHOENIX_ID_BASE_SECRET = 'PHOENIX_ID_BASE';
  * re-setting the secret to its own value after every deploy gets the same
  * outcome without depending on an unverified upload-time flag.
  */
-export async function updateWorker(apiToken, accountId, workerName, bucketName, script, writeToken, previousHash, opts = {}) {
+export async function updateWorker(apiToken, accountId, workerName, bucketName, worker, writeToken, previousHash, opts = {}) {
+    const script = typeof worker === 'string' ? worker : worker.script;
     const templateHash = hashWorkerScript(script);
     if (!opts.force && previousHash === templateHash) {
         // Script is current so we skip the upload (which would wipe secrets). A
@@ -142,7 +147,7 @@ export async function updateWorker(apiToken, accountId, workerName, bucketName,
         }
         return { templateHash, skipped: true };
     }
-    await deployWorker(apiToken, accountId, workerName, script, bucketName, opts);
+    await deployWorker(apiToken, accountId, workerName, worker, bucketName, opts);
     // Script upload clears bindings/secrets (see JSDoc above). If re-applying
     // WRITE_TOKEN fails here, the live Worker has no write token — every
     // `agents artifacts share` publish/delete 401s until a re-run of `agents artifacts share update`

package/dist/lib/share/worker-template.d.ts

@@ -1,4 +1,27 @@
-/** Bundle the Worker and its renderer into one uploadable ES module. */
+/**
+ * Render the Worker source. Pure — the R2 binding + token are wired at deploy time.
+ *
+ * The literal below still spells the CLI `agents share` in its provenance comment,
+ * its root response, and its gallery title, even though the command is now
+ * `agents artifacts share` (RUSH-2580). That is deliberate: `hashWorkerScript` of
+ * this exact text is what `shareTemplateStatus` compares a provisioned endpoint's
+ * recorded `templateHash` against, so editing ANY byte here marks every already-
+ * deployed endpoint `outdated` — which makes `agents artifacts share list` refuse
+ * until its owner re-runs `agents artifacts share update`. Cosmetic renames are not
+ * worth that; change this text only alongside a real Worker behavior change.
+ */
+export interface WorkerModule {
+    name: string;
+    contentType: 'application/wasm';
+    contents: Uint8Array<ArrayBuffer>;
+}
+export interface WorkerBundle {
+    script: string;
+    modules: WorkerModule[];
+}
+/** Bundle the Worker renderer into an ES module plus workerd-compiled WASM modules. */
+export declare function renderWorkerBundle(): WorkerBundle;
+/** Single-file representation for direct Node tests, which cannot import compiled WASM modules. */
 export declare function renderWorkerScript(): string;
 /** Unbundled Worker source. Kept separate so esbuild can resolve npm modules. */
 export declare function renderWorkerSource(): string;

package/dist/lib/share/worker-template.js

@@ -1,81 +1,53 @@
 import { buildSync } from 'esbuild';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-// The Cloudflare Worker that fronts the R2 share bucket.
-//
-// One tiny Worker does both sides:
-//   - PUT  /<username>/<slug>  — write-gated by authorizeWrite's THREE principals
-//     (not a fallback chain — each is a distinct legitimate identity):
-//       1. Static WRITE_TOKEN (BYO Cloudflare) — checked first when the presented
-//          bearer equals env.WRITE_TOKEN. owner = env.SHARE_NAMESPACE or the
-//          path's first segment.
-//       2. Phoenix bearer — otherwise GET ${env.PHOENIX_ID_BASE}/api/v1/auth/me
-//          with that bearer → {userId,email}; 401 if absent/invalid.
-//          customMetadata.owner = userId (stable). The path's first segment MUST
-//          equal handleFromEmail(email) (the public handle, e.g. muqsitnawaz),
-//          so one user cannot write another's prefix (403 namespace mismatch).
-//          A __handles/<handle> claim binds the handle to the first userId that
-//          writes it; a different userId gets 409 handle taken.
-//       3. __share HMAC cookie — the signed-in viewer's identity cookie (same
-//          {userId,email} identityFromCookie verifies for GET). Lets the shared
-//          page's inline visibility control PATCH with credentials:'include' and
-//          no bearer; SameSite=Lax blocks it cross-site, and the same namespace/
-//          owner checks confine it to the holder's own pages. Applies to PUT,
-//          PATCH, and DELETE alike, since all three share authorizeWrite.
-//     A managed deployment sets PHOENIX_ID_BASE; BYO sets WRITE_TOKEN; the
-//     platform endpoint may set both. Fail loud (401) when none authenticates.
-//     Writes the body to R2 via the BUCKET binding, storing visibility
-//     (public|unlisted|me|org), owner, org_domain (org only), an optional
-//     expires-at, plus provenance (agent/session/host/repo/date), a label, and
-//     any `--meta` entries in object metadata. me/org require a Phoenix
-//     identity (BYO WRITE_TOKEN cannot publish them). org from a public inbox
-//     domain is 400. Overwriting an existing slug first copies the current
-//     object to <slug>/rev-<ts>-<rand> (revision history) unless
-//     x-share-no-revision is set.
-//   - PATCH /<username>/<slug> — authenticated metadata-only edit. Rewrites the
-//     exact existing body with all HTTP/custom metadata preserved except the
-//     explicitly requested label/arbitrary metadata changes; never revisions.
-//     Conditional put (onlyIf etagMatches) so a concurrent republish 409s
-//     instead of rolling the body back. Phoenix requires customMetadata.owner
-//     === auth.owner (fail closed when the stamp is missing); WRITE_TOKEN is
-//     the admin repair path.
-//   - GET  /<username>/<slug>  — public|unlisted are anonymous; me requires the
-//     Phoenix owner, org requires a same-domain Phoenix identity (Bearer, then
-//     HMAC cookie, then phoenix_ticket). Unauthenticated me/org 302s to
-//     Phoenix login (or 401 JSON if PHOENIX_ID_BASE is unset). 410s (and lazily
-//     deletes) once its expiry has passed. A bucket lifecycle rule is the durable
-//     sweeper; this is the immediate gate.
-//   - GET  /<username>/<slug>?revisions=json — machine-readable history of the
-//     retained prior versions under that slug, newest first.
-//   - GET  /<username>         — public gallery of that user's shares (HTML).
-//   - GET  /<username>?format=json — public machine-readable listing of that user's
-//     ACTIVE shares (`agents artifacts share list`). Same single-segment path as the HTML
-//     gallery and gated on the SAME "does <username>/ hold any object" check, so it
-//     only intercepts a genuine namespace — a legacy flat slug with ?format=json
-//     still serves its real content, never a fake empty listing.
-//   - GET  /<slug>             — backward-compat flat slug (legacy shares before
-//     per-user namespaces).
-//
-// Emitted as a string, so it compiles into `dist/**` and ships with no
-// package.json#files change. `provision.ts` uploads
-// this verbatim as an ES-module Worker with a BUCKET (R2) binding + a WRITE_TOKEN secret.
-/**
- * Render the Worker source. Pure — the R2 binding + token are wired at deploy time.
- *
- * The literal below still spells the CLI `agents share` in its provenance comment,
- * its root response, and its gallery title, even though the command is now
- * `agents artifacts share` (RUSH-2580). That is deliberate: `hashWorkerScript` of
- * this exact text is what `shareTemplateStatus` compares a provisioned endpoint's
- * recorded `templateHash` against, so editing ANY byte here marks every already-
- * deployed endpoint `outdated` — which makes `agents artifacts share list` refuse
- * until its owner re-runs `agents artifacts share update`. Cosmetic renames are not
- * worth that; change this text only alongside a real Worker behavior change.
- */
-let bundledWorkerScript;
-/** Bundle the Worker and its renderer into one uploadable ES module. */
+let bundledWorker;
+let nodeWorkerScript;
+/** Bundle the Worker renderer into an ES module plus workerd-compiled WASM modules. */
+export function renderWorkerBundle() {
+    if (bundledWorker)
+        return bundledWorker;
+    const result = buildSync({
+        stdin: {
+            contents: renderWorkerSource(),
+            loader: 'js',
+            resolveDir: dirname(fileURLToPath(import.meta.url)),
+            sourcefile: 'agents-share-worker.js',
+        },
+        bundle: true,
+        format: 'esm',
+        platform: 'browser',
+        target: 'es2022',
+        write: false,
+        outdir: 'worker-bundle',
+        assetNames: '[name]-[hash]',
+        minify: true,
+        // Fonts are plain data and can live in JavaScript. WASM must remain a
+        // compiled module: workerd deliberately forbids runtime code generation,
+        // so esbuild's `binary` loader produces a bundle that works in Node but
+        // throws "Wasm code generation disallowed by embedder" in Cloudflare.
+        loader: { '.wasm': 'copy', '.woff': 'binary' },
+    });
+    const script = result.outputFiles.find((output) => output.path.endsWith('.js'));
+    if (!script)
+        throw new Error('Worker bundling produced no JavaScript output.');
+    const modules = result.outputFiles
+        .filter((output) => output.path.endsWith('.wasm'))
+        .map((output) => ({
+        name: output.path.split('/').pop(),
+        contentType: 'application/wasm',
+        contents: new Uint8Array(output.contents),
+    }));
+    if (modules.length !== 2) {
+        throw new Error(`Worker bundling produced ${modules.length} WASM modules; expected yoga and resvg.`);
+    }
+    bundledWorker = { script: script.text, modules };
+    return bundledWorker;
+}
+/** Single-file representation for direct Node tests, which cannot import compiled WASM modules. */
 export function renderWorkerScript() {
-    if (bundledWorkerScript)
-        return bundledWorkerScript;
+    if (nodeWorkerScript)
+        return nodeWorkerScript;
     const result = buildSync({
         stdin: {
             contents: renderWorkerSource(),
@@ -93,9 +65,9 @@ export function renderWorkerScript() {
     });
     const output = result.outputFiles[0];
     if (!output)
-        throw new Error('Worker bundling produced no JavaScript output.');
-    bundledWorkerScript = output.text;
-    return bundledWorkerScript;
+        throw new Error('Worker test bundling produced no JavaScript output.');
+    nodeWorkerScript = output.text;
+    return nodeWorkerScript;
 }
 /** Unbundled Worker source. Kept separate so esbuild can resolve npm modules. */
 export function renderWorkerSource() {
@@ -491,13 +463,22 @@ export default {
 
             const pageHtml = await page.text();
             const meta = page.customMetadata || {};
-            const png = await hooks.renderOgCard({
-              title: meta['og-title'] || extractHtmlMeta(pageHtml, 'title') || meta.label || segments[1],
-              description: meta['og-description'] || extractHtmlMeta(pageHtml, 'description') || '',
-              handle: segments[0],
-              visibility: pageVisibility,
-              orgDomain: meta.org_domain || '',
-            });
+            let png;
+            try {
+              png = await hooks.renderOgCard({
+                title: meta['og-title'] || extractHtmlMeta(pageHtml, 'title') || meta.label || segments[1],
+                description: meta['og-description'] || extractHtmlMeta(pageHtml, 'description') || '',
+                handle: segments[0],
+                visibility: pageVisibility,
+                orgDomain: meta.org_domain || '',
+              });
+            } catch (error) {
+              const detail = error instanceof Error ? error.message : String(error);
+              return new Response('OG card render failed: ' + detail, {
+                status: 500,
+                headers: { 'content-type': 'text/plain; charset=utf-8' },
+              });
+            }
             const beforeStore = await env.BUCKET.get(pagePath);
             if (!beforeStore || beforeStore.etag !== page.etag) { existingCover = null; continue; }
             await env.BUCKET.put(path, png, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.55",
+  "version": "1.22.56",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",