@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 125 lines 4.87 KB
Raw
1 /**
2 * Media & messaging worker — Browser Rendering, Images, Stream, Secrets
3 * Store, and outbound Email, one route per feature. Under `alchemy dev`
4 * every binding is served by a local simulator (Chrome for BROWSER, sharp
5 * for IMAGES, an on-disk store for STREAM and email) except `IMAGES_REMOTE`,
6 * which opted into `dev: { remote: true }` and proxies to the real Images
7 * service. The inbound `email()` handler lives on {@link InboxWorker} — see
8 * the note there.
9 */
10 import puppeteer from "@cloudflare/puppeteer";
11 import type * as cf from "@cloudflare/workers-types";
12 import { EmailMessage } from "cloudflare:email";
13
14 const PAGE_HTML =
15 "<html><head><title>Cloudflare Dev</title></head>" +
16 "<body><h1>Hello from the local browser</h1></body></html>";
17
18 interface SendEmailLike {
19 send(message: unknown): Promise<{ messageId: string }>;
20 }
21
22 interface Env {
23 BROWSER: unknown;
24 IMAGES: cf.ImagesBinding;
25 IMAGES_REMOTE: cf.ImagesBinding;
26 STREAM: cf.StreamBinding;
27 EMAIL: SendEmailLike;
28 API_KEY: { get(): Promise<string> };
29 }
30
31 const imagesInfo = async (images: cf.ImagesBinding, request: Request) => {
32 const info = await images.info(request.body as unknown as cf.ReadableStream<Uint8Array>);
33 return Response.json(info);
34 };
35
36 export default {
37 async fetch(request: Request, env: Env): Promise<Response> {
38 const url = new URL(request.url);
39 try {
40 switch (url.pathname) {
41 case "/secret": {
42 // Secrets Store secret via the `secrets_store_secret` binding —
43 // the exact seeded value round-trips.
44 return Response.json({ value: await env.API_KEY.get() });
45 }
46 case "/browser/title": {
47 // Browser Rendering the way real users drive it — through
48 // @cloudflare/puppeteer. Locally this launches a real Chrome.
49 const browser = await puppeteer.launch(env.BROWSER as any);
50 try {
51 const page = await browser.newPage();
52 await page.setContent(PAGE_HTML);
53 const title = await page.title();
54 const heading = await page.$eval("h1", (el) => el.textContent);
55 return Response.json({ title, heading });
56 } finally {
57 await browser.close();
58 }
59 }
60 case "/images/info":
61 return imagesInfo(env.IMAGES, request);
62 case "/images/info-remote":
63 // Same call, but through the `Alchemy.remote()`-piped binding —
64 // served by the REAL Images service even during `alchemy dev`.
65 return imagesInfo(env.IMAGES_REMOTE, request);
66 case "/images/transform": {
67 const width = Number(url.searchParams.get("width") ?? "4");
68 const output = await env.IMAGES.input(
69 request.body as unknown as cf.ReadableStream<Uint8Array>,
70 )
71 .transform({ width })
72 .output({ format: "image/png" });
73 return output.response() as unknown as Response;
74 }
75 case "/stream/upload": {
76 // The local simulator (like Miniflare's stream plugin) accepts a
77 // ReadableStream of the video bytes in place of a URL; the
78 // published types only declare the URL overload.
79 const upload = env.STREAM.upload as unknown as (
80 input: ReadableStream | string,
81 params?: cf.StreamUrlUploadParams,
82 ) => Promise<cf.StreamVideo>;
83 const video = await upload(request.body as unknown as ReadableStream, {
84 meta: { title: "cloudflare-dev-example" },
85 creator: "alchemy",
86 });
87 return Response.json(video);
88 }
89 case "/stream/details": {
90 const video = await env.STREAM.video(url.searchParams.get("id")!).details();
91 return Response.json(video);
92 }
93 case "/stream/delete": {
94 await env.STREAM.video(url.searchParams.get("id")!).delete();
95 return Response.json({ deleted: true });
96 }
97 case "/email/send": {
98 // send_email binding: locally the message is persisted as an
99 // `.eml` under `.alchemy/local/email` instead of being delivered.
100 const marker = url.searchParams.get("marker") ?? "no-marker";
101 const raw = [
102 "From: sender <sender@example.com>",
103 "To: recipient <allowed@example.com>",
104 `Message-ID: <${marker}@example.com>`,
105 "MIME-Version: 1.0",
106 "Content-Type: text/plain",
107 "",
108 `marker:${marker}`,
109 ].join("\r\n");
110 const result = await env.EMAIL.send(
111 new EmailMessage("sender@example.com", "allowed@example.com", raw),
112 );
113 return Response.json({ ok: true, messageId: result.messageId });
114 }
115 default:
116 return new Response("ok");
117 }
118 } catch (e) {
119 return Response.json(
120 { ok: false, message: e instanceof Error ? e.message : String(e) },
121 { status: 500 },
122 );
123 }
124 },
125 };