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

main
ts 282 lines 11 KB
Raw
1 import * as Lambda from "@alchemy.run/aws/Lambda";
2 import * as S3 from "@alchemy.run/aws/S3";
3 import * as Duration from "effect/Duration";
4 import * as Effect from "effect/Effect";
5 import { HttpServerRequest } from "effect/http/HttpServerRequest";
6 import * as HttpServerResponse from "effect/http/HttpServerResponse";
7 import * as Layer from "effect/Layer";
8 import * as Schema from "effect/Schema";
9 import * as Stream from "effect/Stream";
10
11 export class VersionedObjectFunction extends Lambda.Function<VersionedObjectFunction>()(
12 "VersionedObjectFunction",
13 ) {}
14
15 const bucket = (name: string) =>
16 S3.Bucket(name, {
17 versioning: "Enabled",
18 forceDestroy: true,
19 });
20
21 const Tags = Schema.Array(Schema.Struct({ Key: Schema.String, Value: Schema.String }));
22 const Objects = Schema.Array(
23 Schema.Struct({
24 Key: Schema.String,
25 VersionId: Schema.optional(Schema.String),
26 }),
27 );
28
29 export default VersionedObjectFunction.make(
30 {
31 main: import.meta.url,
32 functionUrl: true,
33 timeout: Duration.seconds(30),
34 memorySize: 512,
35 },
36 Effect.gen(function* () {
37 const buckets = yield* Effect.all({
38 GetObject: bucket("GetObjectBucket"),
39 PutObject: bucket("PutObjectBucket"),
40 HeadObject: bucket("HeadObjectBucket"),
41 GetObjectAttributes: bucket("GetObjectAttributesBucket"),
42 CopyObject: bucket("CopyObjectBucket"),
43 CopySource: bucket("CopySourceBucket"),
44 UnboundSource: bucket("UnboundSourceBucket"),
45 DeleteObject: bucket("DeleteObjectBucket"),
46 DeleteObjects: bucket("DeleteObjectsBucket"),
47 ListObjectsV2: bucket("ListObjectsV2Bucket"),
48 ListObjectVersions: bucket("ListObjectVersionsBucket"),
49 GetObjectTagging: bucket("GetObjectTaggingBucket"),
50 PutObjectTagging: bucket("PutObjectTaggingBucket"),
51 DeleteObjectTagging: bucket("DeleteObjectTaggingBucket"),
52 PresignPutObject: bucket("PresignPutObjectBucket"),
53 });
54 const info = yield* Effect.forEach(Object.entries(buckets), ([name, resource]) =>
55 Effect.gen(function* () {
56 const bucketName = yield* resource.bucketName;
57 const bucketArn = yield* resource.bucketArn;
58 return Effect.gen(function* () {
59 return [name, { bucketName: yield* bucketName, bucketArn: yield* bucketArn }] as const;
60 });
61 }),
62 );
63 const get = yield* S3.GetObject(buckets.GetObject);
64 const put = yield* S3.PutObject(buckets.PutObject);
65 const head = yield* S3.HeadObject(buckets.HeadObject);
66 const attributes = yield* S3.GetObjectAttributes(buckets.GetObjectAttributes);
67 const copy = yield* S3.CopyObject(buckets.CopyObject);
68 yield* S3.GetObject(buckets.CopySource);
69 const remove = yield* S3.DeleteObject(buckets.DeleteObject);
70 const removeMany = yield* S3.DeleteObjects(buckets.DeleteObjects);
71 const list = yield* S3.ListObjectsV2(buckets.ListObjectsV2);
72 const versions = yield* S3.ListObjectVersions(buckets.ListObjectVersions);
73 const getTags = yield* S3.GetObjectTagging(buckets.GetObjectTagging);
74 const putTags = yield* S3.PutObjectTagging(buckets.PutObjectTagging);
75 const deleteTags = yield* S3.DeleteObjectTagging(buckets.DeleteObjectTagging);
76 const presignPut = yield* S3.PresignPutObject(buckets.PresignPutObject);
77
78 return {
79 fetch: Effect.gen(function* () {
80 const request = yield* HttpServerRequest;
81 const url = yield* Effect.sync(() => new URL(request.originalUrl));
82 const operation = url.pathname.slice(1);
83 if (operation === "info") {
84 return yield* HttpServerResponse.json(Object.fromEntries(yield* Effect.all(info)));
85 }
86 const Key = url.searchParams.get("key") ?? "versions.txt";
87 const VersionId = url.searchParams.get("versionId") ?? undefined;
88 switch (operation) {
89 case "GetObject":
90 return yield* get({ Key, VersionId }).pipe(
91 Effect.flatMap((result) =>
92 Effect.gen(function* () {
93 const body = yield* Stream.mkString(Stream.decodeText(result.Body!));
94 return yield* HttpServerResponse.json({
95 body,
96 versionId: result.VersionId,
97 });
98 }),
99 ),
100 Effect.catchTag(["NoSuchKey", "NoSuchVersion", "MethodNotAllowed"], (error) =>
101 HttpServerResponse.json(
102 { tag: error._tag },
103 { status: error._tag === "MethodNotAllowed" ? 405 : 404 },
104 ),
105 ),
106 );
107 case "PutObject":
108 return yield* HttpServerResponse.json(yield* put({ Key, Body: yield* request.text }));
109 case "HeadObject":
110 return yield* head({ Key, VersionId }).pipe(
111 Effect.flatMap((result) =>
112 HttpServerResponse.json({
113 versionId: result.VersionId,
114 length: result.ContentLength,
115 }),
116 ),
117 Effect.catchTag("NotFound", (error) =>
118 HttpServerResponse.json({ tag: error._tag }, { status: 404 }),
119 ),
120 Effect.catchTag("MethodNotAllowed", (error) =>
121 HttpServerResponse.json(
122 {
123 tag: error._tag,
124 deleteMarker: error.DeleteMarker,
125 lastModified: error.LastModified,
126 },
127 { status: 405 },
128 ),
129 ),
130 );
131 case "GetObjectAttributes":
132 return yield* attributes({
133 Key,
134 VersionId,
135 ObjectAttributes: ["ETag", "ObjectSize"],
136 }).pipe(
137 Effect.flatMap((result) => HttpServerResponse.json(result)),
138 Effect.catchTag(["NoSuchVersion", "MethodNotAllowed"], (error) =>
139 HttpServerResponse.json(
140 { tag: error._tag },
141 { status: error._tag === "MethodNotAllowed" ? 405 : 404 },
142 ),
143 ),
144 );
145 case "CopyObject":
146 return yield* copy({
147 Key,
148 CopySource: url.searchParams.get("source")!,
149 }).pipe(
150 Effect.flatMap((result) => HttpServerResponse.json(result)),
151 Effect.catchTag("AccessDeniedException", (error) =>
152 HttpServerResponse.json(
153 { tag: error._tag, message: error.message },
154 { status: 403 },
155 ),
156 ),
157 Effect.catchTag(["NoSuchVersion", "NoSuchKey", "InvalidRequest"], (error) =>
158 HttpServerResponse.json(
159 { tag: error._tag },
160 { status: error._tag === "InvalidRequest" ? 400 : 404 },
161 ),
162 ),
163 );
164 case "DeleteObject":
165 return yield* HttpServerResponse.json(yield* remove({ Key, VersionId }));
166 case "DeleteObjects": {
167 const objects = yield* request.json.pipe(
168 Effect.flatMap(Schema.decodeUnknownEffect(Objects)),
169 );
170 return yield* HttpServerResponse.json(
171 yield* removeMany({ Delete: { Objects: [...objects] } }),
172 );
173 }
174 case "ListObjectsV2":
175 return yield* HttpServerResponse.json(
176 yield* list({
177 Prefix: url.searchParams.get("prefix") ?? undefined,
178 MaxKeys: 1,
179 ContinuationToken: url.searchParams.get("token") ?? undefined,
180 }),
181 );
182 case "ListObjectVersions":
183 return yield* HttpServerResponse.json(
184 yield* versions({
185 Prefix: url.searchParams.get("prefix") ?? undefined,
186 MaxKeys: 1,
187 KeyMarker: url.searchParams.get("keyMarker") ?? undefined,
188 VersionIdMarker: url.searchParams.get("versionMarker") ?? undefined,
189 }),
190 );
191 case "GetObjectTagging":
192 return yield* getTags({ Key, VersionId }).pipe(
193 Effect.flatMap((result) => HttpServerResponse.json(result)),
194 Effect.catchTag(
195 ["NoSuchVersion", "NoSuchKey", "MethodNotAllowed", "AccessDeniedException"],
196 (error) =>
197 HttpServerResponse.json(
198 { tag: error._tag },
199 {
200 status:
201 error._tag === "MethodNotAllowed"
202 ? 405
203 : error._tag === "AccessDeniedException"
204 ? 403
205 : 404,
206 },
207 ),
208 ),
209 );
210 case "PutObjectTagging": {
211 const tags = yield* request.json.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Tags)));
212 return yield* putTags({
213 Key,
214 VersionId,
215 Tagging: { TagSet: [...tags] },
216 }).pipe(
217 Effect.flatMap((result) => HttpServerResponse.json(result)),
218 Effect.catchTag(
219 ["NoSuchVersion", "NoSuchKey", "MethodNotAllowed", "AccessDeniedException"],
220 (error) =>
221 HttpServerResponse.json(
222 { tag: error._tag },
223 {
224 status:
225 error._tag === "MethodNotAllowed"
226 ? 405
227 : error._tag === "AccessDeniedException"
228 ? 403
229 : 404,
230 },
231 ),
232 ),
233 );
234 }
235 case "DeleteObjectTagging":
236 return yield* deleteTags({ Key, VersionId }).pipe(
237 Effect.flatMap((result) => HttpServerResponse.json(result)),
238 Effect.catchTag(
239 ["NoSuchVersion", "NoSuchKey", "MethodNotAllowed", "AccessDeniedException"],
240 (error) =>
241 HttpServerResponse.json(
242 { tag: error._tag },
243 {
244 status:
245 error._tag === "MethodNotAllowed"
246 ? 405
247 : error._tag === "AccessDeniedException"
248 ? 403
249 : 404,
250 },
251 ),
252 ),
253 );
254 case "PresignPutObject":
255 return yield* HttpServerResponse.json({
256 url: yield* presignPut({ key: Key, contentType: "text/plain" }),
257 });
258 default:
259 return HttpServerResponse.text("Not found", { status: 404 });
260 }
261 }).pipe(Effect.orDie),
262 };
263 }).pipe(
264 Effect.provide(
265 Layer.mergeAll(
266 S3.GetObjectHttp,
267 S3.PutObjectHttp,
268 S3.HeadObjectHttp,
269 S3.GetObjectAttributesHttp,
270 S3.CopyObjectHttp,
271 S3.DeleteObjectHttp,
272 S3.DeleteObjectsHttp,
273 S3.ListObjectsV2Http,
274 S3.ListObjectVersionsHttp,
275 S3.GetObjectTaggingHttp,
276 S3.PutObjectTaggingHttp,
277 S3.DeleteObjectTaggingHttp,
278 S3.PresignPutObjectHttp,
279 ),
280 ),
281 ),
282 );