The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import { EmailMessage } from "cloudflare:email"; |
| 2 | /// <reference types="vite/client" /> |
| 3 | // Mirrors the runtime-feature playgrounds of `@cloudflare/vite-plugin`: |
| 4 | // `bindings`, `durable-objects`, `block-concurrency-while`, `workflows`, |
| 5 | // `websockets`, `ctx-exports`, `same-worker-service-bindings`, |
| 6 | // `importable-env`, `explicit-resource-management`, `cron-triggers`, |
| 7 | // `email-worker`, `stream-binding`, `external-durable-objects` and |
| 8 | // `external-workflows`. |
| 9 | // Each route is the playground's handler for the spec it backs. |
| 10 | import { |
| 11 | DurableObject, |
| 12 | WorkerEntrypoint, |
| 13 | WorkflowEntrypoint, |
| 14 | env as importedEnv, |
| 15 | } from "cloudflare:workers"; |
| 16 | import type { WorkflowEvent, WorkflowStep } from "cloudflare:workers"; |
| 17 | import type { Counter as ExternalCounter } from "../worker-b/index.ts"; |
| 18 | import image from "./image.png?inline"; |
| 19 | |
| 20 | interface Env { |
| 21 | KV: KVNamespace; |
| 22 | IMAGES: ImagesBinding; |
| 23 | WAE: AnalyticsEngineDataset; |
| 24 | RATE_LIMITER: RateLimit; |
| 25 | COUNTERS: DurableObjectNamespace<Counter>; |
| 26 | LEGACY: DurableObjectNamespace; |
| 27 | KV_BACKED?: DurableObjectNamespace<KvBacked>; |
| 28 | INITIALIZED: DurableObjectNamespace<BlockConcurrency>; |
| 29 | WEBSOCKET_SERVER: DurableObjectNamespace<WebSocketServer>; |
| 30 | MY_WORKFLOW: Workflow; |
| 31 | EXTERNAL_COUNTERS: DurableObjectNamespace<ExternalCounter>; |
| 32 | EXTERNAL_WORKFLOW: Workflow; |
| 33 | NAMED_ENTRYPOINT: Service<NamedEntrypoint>; |
| 34 | LEGACY_ENTRYPOINT: Fetcher; |
| 35 | EMAIL: SendEmail; |
| 36 | STREAM: StreamBinding; |
| 37 | "importable-env_VAR": string; |
| 38 | "importable-env_SECRET": string; |
| 39 | } |
| 40 | |
| 41 | // `importable-env`: the env import resolves at module scope. |
| 42 | const importedVar = (importedEnv as unknown as Env)["importable-env_VAR"]; |
| 43 | |
| 44 | // `durable-objects` |
| 45 | export class Counter extends DurableObject { |
| 46 | #log: Array<string> = []; |
| 47 | |
| 48 | async getCounterValue() { |
| 49 | return ((await this.ctx.storage.get("value")) as number) || 0; |
| 50 | } |
| 51 | |
| 52 | record(value: string) { |
| 53 | this.#log.push(value); |
| 54 | } |
| 55 | |
| 56 | getLog() { |
| 57 | return this.#log; |
| 58 | } |
| 59 | |
| 60 | async increment(amount = 1) { |
| 61 | const value = (((await this.ctx.storage.get("value")) as number) || 0) + amount; |
| 62 | await this.ctx.storage.put("value", value); |
| 63 | return value; |
| 64 | } |
| 65 | |
| 66 | async decrement(amount = 1) { |
| 67 | const value = (((await this.ctx.storage.get("value")) as number) || 0) - amount; |
| 68 | await this.ctx.storage.put("value", value); |
| 69 | return value; |
| 70 | } |
| 71 | } |
| 72 | |
| 73 | // `durable-objects`: a class that doesn't extend `DurableObject`. |
| 74 | export class Legacy { |
| 75 | fetch() { |
| 76 | return new Response("Legacy Durable Object"); |
| 77 | } |
| 78 | } |
| 79 | |
| 80 | // `block-concurrency-while` |
| 81 | // `durable-objects`: a class declared `storage: "legacy-kv"`, which has no |
| 82 | // SQL storage. |
| 83 | export class KvBacked extends DurableObject { |
| 84 | hasSql() { |
| 85 | try { |
| 86 | this.ctx.storage.sql.exec("SELECT 1"); |
| 87 | return true; |
| 88 | } catch { |
| 89 | return false; |
| 90 | } |
| 91 | } |
| 92 | } |
| 93 | |
| 94 | export class BlockConcurrency extends DurableObject { |
| 95 | #isInitialized = false; |
| 96 | |
| 97 | constructor(ctx: DurableObjectState, env: Env) { |
| 98 | super(ctx, env); |
| 99 | void this.ctx.blockConcurrencyWhile(async () => { |
| 100 | this.#isInitialized = true; |
| 101 | }); |
| 102 | } |
| 103 | |
| 104 | get isInitialized() { |
| 105 | return this.#isInitialized; |
| 106 | } |
| 107 | } |
| 108 | |
| 109 | // `websockets` |
| 110 | export class WebSocketServer extends DurableObject { |
| 111 | override fetch() { |
| 112 | const { 0: client, 1: server } = new WebSocketPair(); |
| 113 | this.ctx.acceptWebSocket(server); |
| 114 | return new Response(null, { status: 101, webSocket: client }); |
| 115 | } |
| 116 | |
| 117 | override async webSocketMessage(ws: WebSocket, data: string | ArrayBuffer) { |
| 118 | ws.send(`Durable Object received client message: '${data}' of type '${typeof data}'.`); |
| 119 | } |
| 120 | } |
| 121 | |
| 122 | // `workflows` |
| 123 | export class MyWorkflow extends WorkflowEntrypoint { |
| 124 | override async run(_: WorkflowEvent<unknown>, step: WorkflowStep) { |
| 125 | await step.do("first step", async () => ({ output: "First step result" })); |
| 126 | await step.sleep("sleep", "1 second"); |
| 127 | await step.do("second step", async () => ({ output: "Second step result" })); |
| 128 | return "Workflow output"; |
| 129 | } |
| 130 | } |
| 131 | |
| 132 | // `ctx-exports` and `same-worker-service-bindings` |
| 133 | export class NamedEntrypoint extends WorkerEntrypoint { |
| 134 | multiply(a: number, b: number) { |
| 135 | return a * b; |
| 136 | } |
| 137 | |
| 138 | greet() { |
| 139 | return "Hello World from a Worker Entrypoint"; |
| 140 | } |
| 141 | } |
| 142 | |
| 143 | // `same-worker-service-bindings`: a plain object entrypoint. |
| 144 | export const legacy = { |
| 145 | fetch() { |
| 146 | return new Response("Legacy Worker entrypoint"); |
| 147 | }, |
| 148 | }; |
| 149 | |
| 150 | const workflowRoutes = async (workflow: Workflow, url: URL) => { |
| 151 | const id = url.searchParams.get("id") ?? undefined; |
| 152 | if (url.pathname.endsWith("/create")) { |
| 153 | let instance: WorkflowInstance; |
| 154 | try { |
| 155 | instance = await workflow.create(id === undefined ? undefined : { id }); |
| 156 | } catch (error) { |
| 157 | if (!(error instanceof Error && error.message.includes("instance.already_exists"))) { |
| 158 | throw error; |
| 159 | } |
| 160 | instance = await workflow.get(id!); |
| 161 | } |
| 162 | return Response.json({ id: instance.id, status: await instance.status() }); |
| 163 | } |
| 164 | return Response.json(await (await workflow.get(id!)).status()); |
| 165 | }; |
| 166 | |
| 167 | const entries = (value: object) => |
| 168 | Object.entries(value) |
| 169 | .filter(([key]) => key.startsWith("importable-env_")) |
| 170 | .map(([key, value]) => ({ key, value })); |
| 171 | |
| 172 | export default { |
| 173 | async fetch(request: Request, env: Env, ctx: ExecutionContext) { |
| 174 | const url = new URL(request.url); |
| 175 | const name = url.searchParams.get("name") ?? "default"; |
| 176 | switch (url.pathname) { |
| 177 | // `bindings` |
| 178 | case "/kv": { |
| 179 | const value = Math.floor(Date.now() * Math.random()).toString(36); |
| 180 | await env.KV.put("value", value); |
| 181 | return value === (await env.KV.get("value")) |
| 182 | ? new Response("KV binding works") |
| 183 | : new Response("KV binding failed to set value", { status: 500 }); |
| 184 | } |
| 185 | case "/images": { |
| 186 | const response = await fetch(image); |
| 187 | const info = await env.IMAGES.info(response.body!); |
| 188 | return info.format === "image/png" |
| 189 | ? new Response("Images binding works") |
| 190 | : new Response("Images binding returns an incorrect format", { status: 500 }); |
| 191 | } |
| 192 | case "/ae": |
| 193 | env.WAE.writeDataPoint({ doubles: [2, 3] }); |
| 194 | return new Response("AE binding works"); |
| 195 | case "/rate-limit": { |
| 196 | const key = url.searchParams.get("key") ?? "shared-key"; |
| 197 | const { success: first } = await env.RATE_LIMITER.limit({ key }); |
| 198 | const { success: second } = await env.RATE_LIMITER.limit({ key }); |
| 199 | return new Response(`Rate limit binding works: first: ${first}, second: ${second}`); |
| 200 | } |
| 201 | // `durable-objects` |
| 202 | case "/do": |
| 203 | case "/do/increment": |
| 204 | case "/do/decrement": { |
| 205 | const stub = env.COUNTERS.get(env.COUNTERS.idFromName(name)); |
| 206 | const count = url.pathname.endsWith("/increment") |
| 207 | ? await stub.increment() |
| 208 | : url.pathname.endsWith("/decrement") |
| 209 | ? await stub.decrement() |
| 210 | : await stub.getCounterValue(); |
| 211 | return new Response(`Durable Object '${name}' count: ${count}`); |
| 212 | } |
| 213 | case "/do/kv-backed": |
| 214 | return Response.json({ |
| 215 | hasSql: await env.KV_BACKED!.get(env.KV_BACKED!.idFromName("kv")).hasSql(), |
| 216 | }); |
| 217 | case "/do/legacy": |
| 218 | return env.LEGACY.get(env.LEGACY.idFromName("test")).fetch(request); |
| 219 | case "/do/rpc-ordering": { |
| 220 | const stub = env.COUNTERS.get(env.COUNTERS.idFromName(name)); |
| 221 | await Promise.all(Array.from({ length: 100 }, (_, i) => stub.record(`call-${i}`))); |
| 222 | const actual = await stub.getLog(); |
| 223 | const expected = Array.from({ length: 100 }, (_, i) => `call-${i}`); |
| 224 | return Response.json({ inOrder: JSON.stringify(actual) === JSON.stringify(expected) }); |
| 225 | } |
| 226 | // `block-concurrency-while` |
| 227 | case "/do/block-concurrency": { |
| 228 | const stub = env.INITIALIZED.get(env.INITIALIZED.idFromName("test-id")); |
| 229 | return Response.json({ isInitialized: await stub.isInitialized }); |
| 230 | } |
| 231 | // `websockets` |
| 232 | case "/websocket": |
| 233 | if (request.headers.get("Upgrade") !== "websocket") { |
| 234 | return new Response("Durable Object expected Upgrade: websocket", { status: 426 }); |
| 235 | } |
| 236 | return env.WEBSOCKET_SERVER.get(env.WEBSOCKET_SERVER.idFromName("id")).fetch(request); |
| 237 | // `workflows` and `external-workflows` |
| 238 | case "/workflow/create": |
| 239 | case "/workflow/get": |
| 240 | return workflowRoutes(env.MY_WORKFLOW, url); |
| 241 | case "/external-workflow/create": |
| 242 | case "/external-workflow/get": |
| 243 | return workflowRoutes(env.EXTERNAL_WORKFLOW, url); |
| 244 | // `external-durable-objects` |
| 245 | case "/external-do": |
| 246 | case "/external-do/increment": { |
| 247 | const stub = env.EXTERNAL_COUNTERS.get(env.EXTERNAL_COUNTERS.idFromName(name)); |
| 248 | const count = url.pathname.endsWith("/increment") |
| 249 | ? await stub.increment() |
| 250 | : await stub.getCounterValue(); |
| 251 | return new Response(`From worker-a: ${JSON.stringify({ name, count })}`); |
| 252 | } |
| 253 | // `ctx-exports` |
| 254 | case "/ctx-exports/worker-entrypoint": { |
| 255 | const exports = ctx.exports as unknown as { NamedEntrypoint: Service<NamedEntrypoint> }; |
| 256 | return new Response(await exports.NamedEntrypoint.greet()); |
| 257 | } |
| 258 | // `same-worker-service-bindings` |
| 259 | case "/service/named": |
| 260 | return Response.json({ result: await env.NAMED_ENTRYPOINT.multiply(4, 5) }); |
| 261 | case "/service/legacy": |
| 262 | return env.LEGACY_ENTRYPOINT.fetch(request); |
| 263 | // `importable-env` |
| 264 | case "/importable-env": |
| 265 | return Response.json({ |
| 266 | importedAtModuleScope: importedVar, |
| 267 | handlerEnv: entries(env), |
| 268 | importedEnv: entries(importedEnv), |
| 269 | }); |
| 270 | // `explicit-resource-management` |
| 271 | case "/explicit-resource-management": { |
| 272 | const disposed: Array<string> = []; |
| 273 | { |
| 274 | await using _session = { |
| 275 | async [Symbol.asyncDispose]() { |
| 276 | disposed.push("session"); |
| 277 | }, |
| 278 | }; |
| 279 | using _socket = { |
| 280 | [Symbol.dispose]() { |
| 281 | disposed.push("socket"); |
| 282 | }, |
| 283 | }; |
| 284 | } |
| 285 | return Response.json(disposed); |
| 286 | } |
| 287 | // `cron-triggers` (cf-worker-header): an outbound fetch to the test's |
| 288 | // echo server, which reports the `CF-Worker` header it received. |
| 289 | case "/cf-worker-header": |
| 290 | return fetch(url.searchParams.get("echoUrl")!); |
| 291 | // Miniflare's outbound `cf.image` mock: the origin image is resized |
| 292 | // locally. |
| 293 | case "/cf-image": |
| 294 | return fetch(url.searchParams.get("imageUrl")!, { |
| 295 | cf: { image: { width: 4, format: "png" } }, |
| 296 | }); |
| 297 | // `stream-binding`: the binding fetches the bytes from `/video-asset`. |
| 298 | case "/video-asset": |
| 299 | return new Response(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7]), { |
| 300 | headers: { "Content-Type": "application/octet-stream" }, |
| 301 | }); |
| 302 | case "/stream/upload": { |
| 303 | const video = await env.STREAM.upload(`${url.origin}/video-asset`); |
| 304 | return Response.json({ preview: video.preview, id: video.id }); |
| 305 | } |
| 306 | // `cron-triggers` and `email-worker`: the handlers below record what |
| 307 | // they received. |
| 308 | case "/handled": |
| 309 | return Response.json({ |
| 310 | scheduled: await env.KV.get("scheduled"), |
| 311 | email: await env.KV.get("email"), |
| 312 | }); |
| 313 | case "/send": { |
| 314 | const raw = [ |
| 315 | 'From: "Sending email test" <sender@example.com>', |
| 316 | "To: recipient@example.com", |
| 317 | "Subject: An email generated in a Worker", |
| 318 | `Message-ID: <${crypto.randomUUID()}@example.com>`, |
| 319 | `Date: ${new Date().toUTCString()}`, |
| 320 | "Content-Type: text/plain", |
| 321 | "", |
| 322 | "Congratulations, you just sent an email from a Worker.", |
| 323 | ].join("\r\n"); |
| 324 | await env.EMAIL.send(new EmailMessage("sender@example.com", "recipient@example.com", raw)); |
| 325 | return new Response("Email message sent successfully!"); |
| 326 | } |
| 327 | } |
| 328 | return new Response("vite-runtime-worker"); |
| 329 | }, |
| 330 | |
| 331 | async scheduled(controller: ScheduledController, env: Env) { |
| 332 | await env.KV.put("scheduled", controller.cron || "manual"); |
| 333 | }, |
| 334 | |
| 335 | async email(message: ForwardableEmailMessage, env: Env) { |
| 336 | const raw = await new Response(message.raw).text(); |
| 337 | await env.KV.put("email", `${message.from} ${raw.includes("Hi there") ? "Hi there" : ""}`); |
| 338 | }, |
| 339 | }; |