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

main
ts 161 lines 6.18 KB
Raw
1 import * as GCP from "@alchemy.run/gcp";
2 import { ObjectRequestFailed } from "@alchemy.run/gcp/Storage/ObjectMedia";
3 import * as Data from "effect/Data";
4 import * as Effect from "effect/Effect";
5 import { serveProbes } from "../../bindingHost.ts";
6
7 /** Object key and content seeded into the read-side buckets. */
8 export const SEED_KEY = "seed/hello.txt";
9 export const SEED_TEXT = "hello from the seed object";
10
11 /**
12 * One bucket per binding, so each bucket's IAM policy shows exactly the
13 * role that binding grants.
14 */
15 const bucket = (id: string) =>
16 GCP.Storage.Bucket(id, { location: "US-CENTRAL1", forceDestroy: true });
17
18 const seeded = (id: string) =>
19 Effect.gen(function* () {
20 const target = yield* bucket(id);
21 yield* GCP.Storage.Object(`${id}Seed`, {
22 bucketName: target.bucketName,
23 key: SEED_KEY,
24 content: SEED_TEXT,
25 contentType: "text/plain",
26 });
27 return target;
28 });
29
30 export const ReadAssets = seeded("ReadAssets");
31 export const WriteAssets = bucket("WriteAssets");
32 export const ReadWriteAssets = bucket("ReadWriteAssets");
33 export const GetAssets = seeded("GetAssets");
34 export const PutAssets = bucket("PutAssets");
35 export const DeleteAssets = seeded("DeleteAssets");
36 export const SignAssets = seeded("SignAssets");
37
38 /**
39 * A 403 from the media endpoints: the fresh bucket grant has not
40 * propagated yet (`callProbe` retries on this tag).
41 */
42 class Forbidden extends Data.TaggedError("Forbidden")<{ message: string }> {}
43
44 const forbiddenAsTag = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
45 effect.pipe(
46 Effect.mapError((error) =>
47 error instanceof ObjectRequestFailed && error.status === 403
48 ? new Forbidden({ message: error.message })
49 : error,
50 ),
51 );
52
53 const text = (body: Uint8Array) => new TextDecoder().decode(body);
54
55 /**
56 * Effect-native Cloud Run service exercising every Cloud Storage binding
57 * as its own runtime service account. Deployed from
58 * {@link ../Bindings.test.ts}.
59 */
60 export default class StorageBindingsHost extends GCP.Function<StorageBindingsHost>()(
61 "StorageBindingsHost",
62 { main: import.meta.url, invokerIamDisabled: true },
63 Effect.gen(function* () {
64 const readBucket = yield* GCP.Storage.ReadBucket(ReadAssets);
65 const writeBucket = yield* GCP.Storage.WriteBucket(WriteAssets);
66 const readWriteBucket = yield* GCP.Storage.ReadWriteBucket(ReadWriteAssets);
67 const getObject = yield* GCP.Storage.GetObject(GetAssets);
68 const putObject = yield* GCP.Storage.PutObject(PutAssets);
69 const deleteObject = yield* GCP.Storage.DeleteObject(DeleteAssets);
70 const signGetObjectUrl = yield* GCP.Storage.SignGetObjectUrl(SignAssets);
71
72 return {
73 fetch: serveProbes({
74 readBucket: forbiddenAsTag(
75 Effect.gen(function* () {
76 const head = yield* readBucket.head(SEED_KEY);
77 const object = yield* readBucket.get(SEED_KEY);
78 const listed = yield* readBucket.list({ prefix: "seed/" });
79 const missingHead = yield* readBucket.head("missing.txt");
80 const missingGet = yield* readBucket.get("missing.txt");
81 return {
82 headName: head?.name,
83 headSize: head?.size,
84 text: object && text(object.body),
85 contentType: object?.contentType,
86 listed: listed.objects.map((item) => item.name),
87 missingHead: missingHead === undefined,
88 missingGet: missingGet === undefined,
89 };
90 }),
91 ),
92 writeBucketPut: forbiddenAsTag(
93 writeBucket
94 .put("written.txt", "hello from WriteBucket", {
95 contentType: "text/plain",
96 metadata: { source: "write-bucket" },
97 })
98 .pipe(Effect.map((object) => ({ name: object.name }))),
99 ),
100 writeBucketDelete: Effect.gen(function* () {
101 yield* writeBucket.delete("written.txt");
102 // Deleting a missing object succeeds.
103 yield* writeBucket.delete("missing.txt");
104 return { deleted: "written.txt" };
105 }),
106 readWriteBucket: forbiddenAsTag(
107 Effect.gen(function* () {
108 const put = yield* readWriteBucket.put("round-trip.txt", "hello from ReadWriteBucket");
109 const object = yield* readWriteBucket.get("round-trip.txt");
110 const listed = yield* readWriteBucket.list();
111 return {
112 putName: put.name,
113 text: object && text(object.body),
114 listed: listed.objects.map((item) => item.name),
115 };
116 }),
117 ),
118 readWriteBucketDelete: Effect.gen(function* () {
119 yield* readWriteBucket.delete("round-trip.txt");
120 const after = yield* readWriteBucket.head("round-trip.txt");
121 return { gone: after === undefined };
122 }),
123 getObject: forbiddenAsTag(
124 Effect.gen(function* () {
125 const object = yield* getObject({ object: SEED_KEY });
126 return { text: text(object.body), contentType: object.contentType };
127 }),
128 ),
129 getObjectMissing: forbiddenAsTag(getObject({ object: "missing.txt" })),
130 putObject: forbiddenAsTag(
131 putObject({
132 name: "put.bin",
133 body: new TextEncoder().encode("hello from PutObject"),
134 contentType: "application/octet-stream",
135 metadata: { source: "put-object" },
136 }).pipe(
137 Effect.map((object) => ({
138 name: object.name,
139 metadata: object.metadata,
140 })),
141 ),
142 ),
143 deleteObject: deleteObject({ object: SEED_KEY }).pipe(Effect.as({ deleted: SEED_KEY })),
144 deleteObjectMissing: deleteObject({ object: "missing.txt" }),
145 signGetObjectUrl: signGetObjectUrl({
146 object: SEED_KEY,
147 expiresIn: 600,
148 contentType: "text/plain",
149 }).pipe(Effect.map((url) => ({ url }))),
150 }),
151 };
152 }).pipe(
153 Effect.provide(GCP.Storage.ReadBucketHttp),
154 Effect.provide(GCP.Storage.WriteBucketHttp),
155 Effect.provide(GCP.Storage.ReadWriteBucketHttp),
156 Effect.provide(GCP.Storage.GetObjectHttp),
157 Effect.provide(GCP.Storage.PutObjectHttp),
158 Effect.provide(GCP.Storage.DeleteObjectHttp),
159 Effect.provide(GCP.Storage.SignGetObjectUrlHttp),
160 ),
161 ) {}