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

main
ts 417 lines 16 KB
Raw
1 import crypto from "node:crypto";
2 import * as CodeArtifact from "@alchemy.run/aws/CodeArtifact";
3 import * as Lambda from "@alchemy.run/aws/Lambda";
4 import * as S3 from "@alchemy.run/aws/S3";
5 import * as Duration from "effect/Duration";
6 import * as Effect from "effect/Effect";
7 import { HttpServerRequest } from "effect/http/HttpServerRequest";
8 import * as HttpServerResponse from "effect/http/HttpServerResponse";
9 import * as Layer from "effect/Layer";
10 import * as Redacted from "effect/Redacted";
11 import * as Schedule from "effect/Schedule";
12 import * as Stream from "effect/Stream";
13 import path from "pathe";
14
15 const main = path.resolve(import.meta.dirname, "handler.ts");
16
17 // Deterministic, lowercase CodeArtifact identifiers scoped to this suite
18 // (distinct from Repository.test.ts's `alchemy-test-ca` domain).
19 export const DOMAIN = "alchemy-test-ca-bind";
20 export const REPO = "alchemy-test-ca-bind-repo";
21 export const MIRROR = "alchemy-test-ca-bind-mirror";
22 const FORMAT = "generic" as const;
23 const NAMESPACE = "alchemy";
24 const PKG = "test-package";
25 const ASSET = "artifact.txt";
26
27 const contentFor = (version: string) => `hello codeartifact ${version}`;
28
29 export class CodeArtifactTestFunction extends Lambda.Function<Lambda.Function>()(
30 "CodeArtifactTestFunction",
31 ) {}
32
33 export default CodeArtifactTestFunction.make(
34 {
35 main,
36 functionUrl: true,
37 // The publish → copy → dispose flows fan out several SDK calls; AWS's
38 // 3s default would intermittently time out.
39 timeout: Duration.seconds(60),
40 },
41 Effect.gen(function* () {
42 const domain = yield* CodeArtifact.Domain("Domain", {
43 domainName: DOMAIN,
44 });
45 const repo = yield* CodeArtifact.Repository("Repo", {
46 domain: domain.domainName,
47 repositoryName: REPO,
48 });
49 const mirror = yield* CodeArtifact.Repository("Mirror", {
50 domain: domain.domainName,
51 repositoryName: MIRROR,
52 });
53
54 // Marker store for the event source (events may arrive on another
55 // Lambda instance, so they must be observable out-of-band).
56 const bucket = yield* S3.Bucket("EventBucket", { forceDestroy: true });
57 const putObject = yield* S3.PutObject(bucket);
58 const getObject = yield* S3.GetObject(bucket);
59
60 // --- domain-scoped binding ---
61 const getToken = yield* CodeArtifact.GetAuthorizationToken(domain);
62
63 // --- repository-scoped bindings ---
64 const getEndpoint = yield* CodeArtifact.GetRepositoryEndpoint(repo);
65 const listPackages = yield* CodeArtifact.ListPackages(repo);
66 const describePackage = yield* CodeArtifact.DescribePackage(repo);
67 const describeVersion = yield* CodeArtifact.DescribePackageVersion(repo);
68 const listVersions = yield* CodeArtifact.ListPackageVersions(repo);
69 const listAssets = yield* CodeArtifact.ListPackageVersionAssets(repo);
70 const listDeps = yield* CodeArtifact.ListPackageVersionDependencies(repo);
71 const getReadme = yield* CodeArtifact.GetPackageVersionReadme(repo);
72 const getAsset = yield* CodeArtifact.GetPackageVersionAsset(repo);
73 const publish = yield* CodeArtifact.PublishPackageVersion(repo);
74 const updateStatus = yield* CodeArtifact.UpdatePackageVersionsStatus(repo);
75 const putOrigin = yield* CodeArtifact.PutPackageOriginConfiguration(repo);
76 const deletePackage = yield* CodeArtifact.DeletePackage(repo);
77
78 // --- mirror-scoped bindings (destination of the copy) ---
79 const copyToMirror = yield* CodeArtifact.CopyPackageVersions(mirror);
80 const listMirrorPackages = yield* CodeArtifact.ListPackages(mirror);
81 const disposeMirror = yield* CodeArtifact.DisposePackageVersions(mirror);
82 const deleteMirrorVersions = yield* CodeArtifact.DeletePackageVersions(mirror);
83 const deleteMirrorPackage = yield* CodeArtifact.DeletePackage(mirror);
84
85 // --- event source ---
86 // CodeArtifact publishes every package version change to the default
87 // bus; write a marker object per event so /events/probe can observe the
88 // delivery out-of-band.
89 yield* CodeArtifact.consumePackageVersionStateChanges(
90 { repositories: [REPO, MIRROR] },
91 (events) =>
92 Stream.runForEach(events, (event) =>
93 putObject({
94 Key: `events/${event.detail.packageVersion}`,
95 Body: JSON.stringify(event.detail),
96 ContentType: "application/json",
97 }).pipe(Effect.orDie, Effect.asVoid),
98 ),
99 );
100
101 const publishVersion = Effect.fn(function* (version: string, unfinished: boolean) {
102 const content = contentFor(version);
103 const sha = yield* Effect.sync(() =>
104 crypto.createHash("sha256").update(content).digest("hex"),
105 );
106 return yield* publish({
107 format: FORMAT,
108 namespace: NAMESPACE,
109 package: PKG,
110 packageVersion: version,
111 assetName: ASSET,
112 assetContent: content,
113 assetSHA256: sha,
114 ...(unfinished ? { unfinished: true } : {}),
115 });
116 });
117
118 return {
119 fetch: Effect.gen(function* () {
120 const request = yield* HttpServerRequest;
121 const url = new URL(request.originalUrl);
122 const pathname = url.pathname;
123 const param = (name: string) => url.searchParams.get(name) ?? "";
124
125 // Mint a domain authorization token; prove it comes back Redacted.
126 if (request.method === "GET" && pathname === "/token") {
127 const res = yield* getToken({ duration: "15 minutes" });
128 const token = res.authorizationToken;
129 return yield* HttpServerResponse.json({
130 redacted: Redacted.isRedacted(token),
131 length: (Redacted.isRedacted(token) ? Redacted.value(token) : (token ?? "")).length,
132 });
133 }
134
135 if (request.method === "GET" && pathname === "/endpoint") {
136 const res = yield* getEndpoint({ format: FORMAT });
137 return yield* HttpServerResponse.json({
138 endpoint: res.repositoryEndpoint,
139 });
140 }
141
142 // Delete the test package from both repositories so a retried test
143 // body starts from a clean slate — republishing an already-Published
144 // generic version raises the (deterministic) ConflictException.
145 if (request.method === "POST" && pathname === "/reset") {
146 yield* deletePackage({
147 format: FORMAT,
148 namespace: NAMESPACE,
149 package: PKG,
150 }).pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.void));
151 yield* deleteMirrorPackage({
152 format: FORMAT,
153 namespace: NAMESPACE,
154 package: PKG,
155 }).pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.void));
156 return yield* HttpServerResponse.json({ reset: true });
157 }
158
159 if (request.method === "POST" && pathname === "/publish") {
160 const res = yield* publishVersion(param("version"), param("unfinished") === "1");
161 return yield* HttpServerResponse.json({ status: res.status });
162 }
163
164 if (request.method === "GET" && pathname === "/package") {
165 const res = yield* describePackage({
166 format: FORMAT,
167 namespace: NAMESPACE,
168 package: PKG,
169 });
170 return yield* HttpServerResponse.json({
171 name: res.package?.name,
172 format: res.package?.format,
173 namespace: res.package?.namespace,
174 });
175 }
176
177 if (request.method === "GET" && pathname === "/version") {
178 const res = yield* describeVersion({
179 format: FORMAT,
180 namespace: NAMESPACE,
181 package: PKG,
182 packageVersion: param("version"),
183 });
184 return yield* HttpServerResponse.json({
185 version: res.packageVersion?.version,
186 status: res.packageVersion?.status,
187 });
188 }
189
190 if (request.method === "GET" && pathname === "/packages") {
191 const res = yield* listPackages({});
192 return yield* HttpServerResponse.json({
193 names: (res.packages ?? []).map((p) => p.package),
194 });
195 }
196
197 if (request.method === "GET" && pathname === "/versions") {
198 const res = yield* listVersions({
199 format: FORMAT,
200 namespace: NAMESPACE,
201 package: PKG,
202 });
203 return yield* HttpServerResponse.json({
204 versions: (res.versions ?? []).map((v) => v.version),
205 });
206 }
207
208 if (request.method === "GET" && pathname === "/assets") {
209 const res = yield* listAssets({
210 format: FORMAT,
211 namespace: NAMESPACE,
212 package: PKG,
213 packageVersion: param("version"),
214 });
215 return yield* HttpServerResponse.json({
216 assets: (res.assets ?? []).map((a) => a.name),
217 });
218 }
219
220 if (request.method === "GET" && pathname === "/asset") {
221 const res = yield* getAsset({
222 format: FORMAT,
223 namespace: NAMESPACE,
224 package: PKG,
225 packageVersion: param("version"),
226 asset: ASSET,
227 });
228 const content = yield* Stream.mkString(Stream.decodeText(res.asset!)).pipe(Effect.orDie);
229 return yield* HttpServerResponse.json({ content });
230 }
231
232 // Generic packages have no readme — CodeArtifact answers with the
233 // typed ResourceNotFoundException ("The readme file of this package
234 // version is not found"); surface the tag instead of dying.
235 if (request.method === "GET" && pathname === "/readme") {
236 const res = yield* getReadme({
237 format: FORMAT,
238 namespace: NAMESPACE,
239 package: PKG,
240 packageVersion: param("version"),
241 }).pipe(
242 Effect.map((r) => ({ readme: r.readme ?? "", error: undefined })),
243 Effect.catchTag(["ResourceNotFoundException", "ValidationException"], (e) =>
244 Effect.succeed({ readme: undefined, error: e._tag }),
245 ),
246 );
247 return yield* HttpServerResponse.json(res);
248 }
249
250 // Generic packages record no dependency manifest — surfaces the
251 // typed not-found/validation error instead of dying.
252 if (request.method === "GET" && pathname === "/deps") {
253 const res = yield* listDeps({
254 format: FORMAT,
255 namespace: NAMESPACE,
256 package: PKG,
257 packageVersion: param("version"),
258 }).pipe(
259 Effect.map((r) => ({
260 dependencies: (r.dependencies ?? []).map((d) => d.package),
261 error: undefined,
262 })),
263 Effect.catchTag(["ResourceNotFoundException", "ValidationException"], (e) =>
264 Effect.succeed({ dependencies: undefined, error: e._tag }),
265 ),
266 );
267 return yield* HttpServerResponse.json(res);
268 }
269
270 if (request.method === "POST" && pathname === "/status") {
271 const res = yield* updateStatus({
272 format: FORMAT,
273 namespace: NAMESPACE,
274 package: PKG,
275 versions: [param("version")],
276 targetStatus: param("target"),
277 });
278 return yield* HttpServerResponse.json({
279 successful: Object.keys(res.successfulVersions ?? {}),
280 });
281 }
282
283 if (request.method === "POST" && pathname === "/origin") {
284 const res = yield* putOrigin({
285 format: FORMAT,
286 namespace: NAMESPACE,
287 package: PKG,
288 restrictions: { publish: "ALLOW", upstream: "BLOCK" },
289 });
290 return yield* HttpServerResponse.json({
291 restrictions: res.originConfiguration?.restrictions,
292 });
293 }
294
295 if (request.method === "POST" && pathname === "/copy") {
296 const res = yield* copyToMirror({
297 sourceRepository: REPO,
298 format: FORMAT,
299 namespace: NAMESPACE,
300 package: PKG,
301 versions: [param("version")],
302 });
303 return yield* HttpServerResponse.json({
304 successful: Object.keys(res.successfulVersions ?? {}),
305 });
306 }
307
308 if (request.method === "GET" && pathname === "/mirror/packages") {
309 const res = yield* listMirrorPackages({});
310 return yield* HttpServerResponse.json({
311 names: (res.packages ?? []).map((p) => p.package),
312 });
313 }
314
315 if (request.method === "POST" && pathname === "/mirror/dispose") {
316 const res = yield* disposeMirror({
317 format: FORMAT,
318 namespace: NAMESPACE,
319 package: PKG,
320 versions: [param("version")],
321 });
322 return yield* HttpServerResponse.json({
323 successful: Object.keys(res.successfulVersions ?? {}),
324 });
325 }
326
327 if (request.method === "POST" && pathname === "/mirror/delete-versions") {
328 const res = yield* deleteMirrorVersions({
329 format: FORMAT,
330 namespace: NAMESPACE,
331 package: PKG,
332 versions: [param("version")],
333 });
334 return yield* HttpServerResponse.json({
335 successful: Object.keys(res.successfulVersions ?? {}),
336 });
337 }
338
339 if (request.method === "POST" && pathname === "/mirror/delete-package") {
340 yield* deleteMirrorPackage({
341 format: FORMAT,
342 namespace: NAMESPACE,
343 package: PKG,
344 }).pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.void));
345 return yield* HttpServerResponse.json({ deleted: true });
346 }
347
348 // Publish a fresh version, then poll for the event-source marker the
349 // state-change handler wrote to S3 (bounded well under the 60s
350 // function timeout).
351 if (request.method === "GET" && pathname === "/events/probe") {
352 const version = param("version");
353 // A retried probe re-publishes the same version — CodeArtifact
354 // rejects updates to a Published generic version with the typed
355 // ConflictException; the event already fired, so just poll.
356 yield* publishVersion(version, false).pipe(
357 Effect.catchTag("ConflictException", () => Effect.succeed(undefined)),
358 );
359 const seen = yield* getObject({ Key: `events/${version}` }).pipe(
360 Effect.retry({
361 while: (e): boolean => e._tag === "NoSuchKey",
362 schedule: Schedule.spaced("2 seconds"),
363 times: 12,
364 }),
365 Effect.map(() => true),
366 Effect.catchTag("NoSuchKey", () => Effect.succeed(false)),
367 );
368 return yield* HttpServerResponse.json({ seen, version });
369 }
370
371 return yield* HttpServerResponse.json(
372 { error: "Not found", method: request.method, pathname },
373 { status: 404 },
374 );
375 }).pipe(
376 // Surface typed errors in the 500 body so the test's transient-retry
377 // logs show the real failure instead of an opaque Internal Server
378 // Error.
379 Effect.catch((e) =>
380 HttpServerResponse.json(
381 {
382 error: (e as { _tag?: string })._tag ?? "UnknownError",
383 message: String(e),
384 },
385 { status: 500 },
386 ),
387 ),
388 Effect.orDie,
389 ),
390 };
391 }).pipe(
392 Effect.provide(
393 Layer.mergeAll(
394 Lambda.EventSource,
395 CodeArtifact.GetAuthorizationTokenHttp,
396 CodeArtifact.GetRepositoryEndpointHttp,
397 CodeArtifact.ListPackagesHttp,
398 CodeArtifact.DescribePackageHttp,
399 CodeArtifact.DescribePackageVersionHttp,
400 CodeArtifact.ListPackageVersionsHttp,
401 CodeArtifact.ListPackageVersionAssetsHttp,
402 CodeArtifact.ListPackageVersionDependenciesHttp,
403 CodeArtifact.GetPackageVersionReadmeHttp,
404 CodeArtifact.GetPackageVersionAssetHttp,
405 CodeArtifact.PublishPackageVersionHttp,
406 CodeArtifact.UpdatePackageVersionsStatusHttp,
407 CodeArtifact.PutPackageOriginConfigurationHttp,
408 CodeArtifact.CopyPackageVersionsHttp,
409 CodeArtifact.DisposePackageVersionsHttp,
410 CodeArtifact.DeletePackageVersionsHttp,
411 CodeArtifact.DeletePackageHttp,
412 S3.PutObjectHttp,
413 S3.GetObjectHttp,
414 ),
415 ),
416 ),
417 );