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

main
ts 150 lines 5.69 KB
Raw
1 import * as Lambda from "@alchemy.run/aws/Lambda";
2 import * as S3 from "@alchemy.run/aws/S3";
3 import * as Effect from "effect/Effect";
4 import { HttpServerRequest } from "effect/http/HttpServerRequest";
5 import * as HttpServerResponse from "effect/http/HttpServerResponse";
6 import * as Layer from "effect/Layer";
7 import * as Stream from "effect/Stream";
8
9 // Derived writes stay outside the watched prefix to avoid recursive events.
10 const INCOMING_PREFIX = "incoming/";
11 const PROCESSED_PREFIX = "processed/";
12
13 const recordKey = (key: string, eventName: string, versionId: string) => {
14 const path = [key, eventName, versionId].map(encodeURIComponent).join("/");
15 return `${PROCESSED_PREFIX}${path}.json`;
16 };
17
18 export class BucketEventSourceFunction extends Lambda.Function<BucketEventSourceFunction>()(
19 "BucketEventSourceFunction",
20 ) {}
21
22 export default BucketEventSourceFunction.make(
23 {
24 main: import.meta.url,
25 functionUrl: true,
26 },
27 Effect.gen(function* () {
28 const bucket = yield* S3.Bucket("EventSourceBucket", {
29 forceDestroy: true,
30 versioning: "Enabled",
31 });
32
33 const putObject = yield* S3.PutObject(bucket);
34 const getObject = yield* S3.GetObject(bucket);
35 const BucketName = yield* bucket.bucketName;
36
37 yield* S3.consumeBucketEvents(
38 bucket,
39 {
40 events: ["s3:ObjectCreated:*", "s3:ObjectRemoved:*"],
41 prefix: INCOMING_PREFIX,
42 },
43 (stream) =>
44 stream.pipe(
45 Stream.runForEach((event) =>
46 Effect.gen(function* () {
47 const versionId = event.versionId;
48 if (!versionId) {
49 return yield* Effect.fail(
50 new Error("Versioned bucket notification omitted versionId"),
51 );
52 }
53 const key = yield* Effect.sync(() => recordKey(event.key, event.type, versionId));
54 // Redelivery can arrive after the source version was deleted.
55 const recorded = yield* getObject({ Key: key }).pipe(
56 Effect.flatMap(({ Body }) => Stream.runDrain(Body!)),
57 Effect.as(true),
58 Effect.catchTag("NoSuchKey", () => Effect.succeed(false)),
59 );
60 if (recorded) return;
61 const object = event.type.startsWith("s3:ObjectCreated:")
62 ? yield* getObject({
63 Key: event.key,
64 VersionId: versionId,
65 })
66 : undefined;
67 const content = object
68 ? yield* Stream.mkString(Stream.decodeText(object.Body!))
69 : undefined;
70 const body = yield* Effect.sync(() =>
71 JSON.stringify({
72 bucket: event.bucket,
73 key: event.key,
74 eventName: event.type,
75 versionId,
76 sequencer: event.sequencer,
77 size: event.size,
78 eTag: event.eTag,
79 content,
80 readVersionId: object?.VersionId,
81 }),
82 );
83 yield* putObject({
84 Key: key,
85 Body: body,
86 ContentType: "application/json",
87 });
88 }).pipe(Effect.orDie),
89 ),
90 ),
91 );
92
93 return {
94 fetch: Effect.gen(function* () {
95 const request = yield* HttpServerRequest;
96 const url = yield* Effect.sync(() => new URL(request.originalUrl));
97 const pathname = url.pathname;
98
99 if (request.method === "GET" && pathname === "/bucket-name") {
100 // The first event after a cold start can observe not-yet-hydrated
101 // resource Outputs — answer 503 so the test retries instead of
102 // recording "undefined" as the bucket name.
103 const bucketName = yield* BucketName;
104 if (!bucketName) {
105 return HttpServerResponse.text("Outputs not hydrated yet", {
106 status: 503,
107 });
108 }
109 return yield* HttpServerResponse.json({ bucketName });
110 }
111
112 if (request.method === "POST" && pathname === "/put") {
113 const body = (yield* request.json) as { key: string; value: string };
114 const result = yield* putObject({
115 Key: `${INCOMING_PREFIX}${body.key}`,
116 Body: body.value,
117 ContentType: "text/plain",
118 });
119 return yield* HttpServerResponse.json({
120 ok: true,
121 versionId: result.VersionId,
122 });
123 }
124
125 if (request.method === "GET" && pathname === "/processed") {
126 const key = url.searchParams.get("key");
127 const eventName = url.searchParams.get("eventName");
128 const versionId = url.searchParams.get("versionId");
129 if (!key || !eventName || !versionId) {
130 return HttpServerResponse.text("Missing key, eventName, or versionId", { status: 400 });
131 }
132 const storedKey = yield* Effect.sync(() => recordKey(key, eventName, versionId));
133 return yield* getObject({ Key: storedKey }).pipe(
134 Effect.flatMap((result) => Stream.mkString(Stream.decodeText(result.Body!))),
135 Effect.flatMap((text) => Effect.try(() => JSON.parse(text))),
136 Effect.flatMap((processed) => HttpServerResponse.json({ processed })),
137 // Object not written yet — the test polls until it appears.
138 Effect.catchTag("NoSuchKey", () =>
139 HttpServerResponse.json({ processed: null }, { status: 404 }),
140 ),
141 );
142 }
143
144 return yield* HttpServerResponse.json({ error: "Not found", pathname }, { status: 404 });
145 }).pipe(Effect.orDie),
146 };
147 }).pipe(
148 Effect.provide(Layer.mergeAll(Lambda.BucketEventSource, S3.PutObjectHttp, S3.GetObjectHttp)),
149 ),
150 );