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

main
ts 153 lines 5.53 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { S3BucketEventSource } from "@alchemy.run/aws/Server/S3BucketEventSource";
3 import * as Effect from "effect/Effect";
4 import * as Layer from "effect/Layer";
5 import * as Stream from "effect/Stream";
6
7 export const INCOMING_PREFIX = "incoming/";
8 export const INCOMING_SUFFIX = ".txt";
9 export const PROCESSED_PREFIX = "processed/";
10 export const RECEIVED_PREFIX = "deliveries/received/";
11 export const ACKNOWLEDGED_PREFIX = "deliveries/acknowledged/";
12
13 export const ServerEventBucket = AWS.S3.Bucket("ServerEventBucket", {
14 versioning: "Enabled",
15 forceDestroy: true,
16 });
17
18 export const artifactKey = (key: string, eventName: string, versionId: string) =>
19 `${PROCESSED_PREFIX}${[key, eventName, versionId].map(encodeURIComponent).join("/")}.txt`;
20
21 // Preserve the wire body for replay without competing with the ECS consumer.
22 const observedReceiveMessage = Layer.effect(
23 AWS.SQS.ReceiveMessage,
24 Effect.gen(function* () {
25 const receiveMessage = yield* AWS.SQS.ReceiveMessage;
26 const bucket = yield* ServerEventBucket;
27 const putObject = yield* AWS.S3.PutObject(bucket);
28 return Effect.fn(function* (queue: AWS.SQS.Queue) {
29 const receive = yield* receiveMessage(queue);
30 return Effect.fn(function* (request: AWS.SQS.ReceiveMessageRequest) {
31 const result = yield* receive(request);
32 yield* Effect.forEach(result.Messages ?? [], (message) =>
33 putObject({
34 Key: `${RECEIVED_PREFIX}${message.MessageId!}.json`,
35 Body: message.Body!,
36 ContentType: "application/json",
37 }).pipe(Effect.orDie),
38 );
39 return result;
40 });
41 });
42 }),
43 ).pipe(Layer.provide(AWS.SQS.ReceiveMessageHttp));
44
45 // The server acknowledges a batch only after the S3 handler completes.
46 const observedDeleteMessageBatch = Layer.effect(
47 AWS.SQS.DeleteMessageBatch,
48 Effect.gen(function* () {
49 const deleteMessageBatch = yield* AWS.SQS.DeleteMessageBatch;
50 const bucket = yield* ServerEventBucket;
51 const putObject = yield* AWS.S3.PutObject(bucket);
52 return Effect.fn(function* (queue: AWS.SQS.Queue) {
53 const remove = yield* deleteMessageBatch(queue);
54 return Effect.fn(function* (request: AWS.SQS.DeleteMessageBatchRequest) {
55 const result = yield* remove(request);
56 yield* Effect.forEach(result.Successful ?? [], (entry) =>
57 putObject({
58 Key: `${ACKNOWLEDGED_PREFIX}${entry.Id}.json`,
59 Body: "{}",
60 ContentType: "application/json",
61 }).pipe(Effect.orDie),
62 );
63 return result;
64 });
65 });
66 }),
67 ).pipe(Layer.provide(AWS.SQS.DeleteMessageBatchHttp));
68
69 const serverEvents = S3BucketEventSource.pipe(
70 Layer.provide(
71 Layer.mergeAll(observedReceiveMessage, observedDeleteMessageBatch).pipe(
72 Layer.provide(AWS.S3.PutObjectHttp),
73 ),
74 ),
75 );
76
77 export default class ServerEventTask extends AWS.ECS.Task<ServerEventTask>()(
78 "S3ServerEventTask",
79 {
80 main: import.meta.filename,
81 image: "oven/bun:1",
82 cpu: 256,
83 memory: 512,
84 container: {
85 linuxParameters: { initProcessEnabled: true },
86 stopTimeout: 2,
87 },
88 runtimePlatform: {
89 cpuArchitecture: "ARM64",
90 operatingSystemFamily: "LINUX",
91 },
92 },
93 Effect.gen(function* () {
94 const bucket = yield* ServerEventBucket;
95 const getObject = yield* AWS.S3.GetObject(bucket);
96 const putObject = yield* AWS.S3.PutObject(bucket);
97
98 yield* AWS.S3.consumeBucketEvents(
99 bucket,
100 {
101 events: ["s3:ObjectCreated:*", "s3:ObjectRemoved:*"],
102 prefix: INCOMING_PREFIX,
103 suffix: INCOMING_SUFFIX,
104 },
105 (events) =>
106 events.pipe(
107 Stream.runForEach((event) =>
108 Effect.gen(function* () {
109 const versionId = event.versionId;
110 if (!versionId) {
111 return yield* Effect.fail(new Error("Versioned S3 event omitted versionId"));
112 }
113 const key = yield* Effect.sync(() => artifactKey(event.key, event.type, versionId));
114 // Redelivery can arrive after the source version was deleted.
115 const recorded = yield* getObject({ Key: key }).pipe(
116 Effect.flatMap(({ Body }) => Stream.runDrain(Body!)),
117 Effect.as(true),
118 Effect.catchTag("NoSuchKey", () => Effect.succeed(false)),
119 );
120 if (recorded) return;
121 const object = event.type.startsWith("s3:ObjectCreated:")
122 ? yield* getObject({ Key: event.key, VersionId: versionId })
123 : undefined;
124 const content = object
125 ? yield* Stream.mkString(Stream.decodeText(object.Body!))
126 : undefined;
127 const body = yield* Effect.sync(() =>
128 JSON.stringify({
129 bucket: event.bucket,
130 key: event.key,
131 eventName: event.type,
132 versionId,
133 sequencer: event.sequencer,
134 size: event.size,
135 eTag: event.eTag,
136 content,
137 readVersionId: object?.VersionId,
138 }),
139 );
140 // The suffix still matches; only the prefix prevents recursion.
141 yield* putObject({
142 Key: key,
143 Body: body,
144 ContentType: "application/json",
145 });
146 }).pipe(Effect.orDie),
147 ),
148 ),
149 );
150
151 return { run: Effect.never };
152 }).pipe(Effect.provide(Layer.mergeAll(serverEvents, AWS.S3.GetObjectHttp, AWS.S3.PutObjectHttp))),
153 ) {}