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

main
ts 287 lines 8.17 KB
Raw
1 import * as Fly from "@alchemy.run/fly";
2 import { expect } from "@alchemy.run/test";
3 import * as Test from "@alchemy.run/test/Alchemy";
4 import * as machines from "@distilled.cloud/fly-io/machines";
5 import * as Provider from "alchemy/Provider";
6 import * as Effect from "effect/Effect";
7 import { MinimumLogLevel } from "effect/References";
8 import * as Result from "effect/Result";
9 import * as Schedule from "effect/Schedule";
10
11 const { test } = Test.make({ providers: Fly.providers() });
12
13 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
14
15 // Deterministic HMAC material. Never logged.
16 const HMAC_A: ReadonlyArray<number> = Array.from({ length: 32 }, (_, i) => (i * 7 + 3) % 256);
17 const HMAC_B: ReadonlyArray<number> = Array.from({ length: 32 }, (_, i) => (i * 11 + 5) % 256);
18
19 const waitUntilGone = (appName: string, secretName: string) =>
20 machines
21 .getSecretKey({
22 app_name: appName,
23 secret_name: secretName,
24 })
25 .pipe(
26 Effect.as("found" as const),
27 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
28 Effect.repeat({
29 schedule: Schedule.spaced("1 second"),
30 until: (status) => status === "gone",
31 times: 10,
32 }),
33 );
34
35 const waitAppGone = (appName: string) =>
36 machines.getApp({ app_name: appName }).pipe(
37 Effect.as("found" as const),
38 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
39 Effect.repeat({
40 schedule: Schedule.spaced("1 second"),
41 until: (status) => status === "gone",
42 times: 10,
43 }),
44 );
45
46 /**
47 * Ungated probe: hit listSecretKeys without KMS entitlement so the
48 * distilled tag stays pinned. A missing app is `NotFound` when the token
49 * can use KMS; otherwise the typed entitlement tag is asserted.
50 */
51 test.provider(
52 "listSecretKeys probe asserts a typed tag",
53 () =>
54 Effect.gen(function* () {
55 const result = yield* Effect.result(
56 machines.listSecretKeys({
57 app_name: "alchemy-kms-probe-missing",
58 }),
59 );
60 expect(Result.isFailure(result)).toBe(true);
61 if (Result.isFailure(result)) {
62 expect(["NotFound", "Forbidden"]).toContain(result.failure._tag);
63 }
64 }).pipe(logLevel),
65 {
66 tags: ["provider:fly", "provider:fly:machine", "provider:fly:secretkey", "live"],
67 timeout: 90_000,
68 },
69 );
70
71 test.provider(
72 "create, update, and delete a secret key",
73 (stack) =>
74 Effect.gen(function* () {
75 yield* stack.destroy();
76
77 const created = yield* stack.deploy(
78 Effect.gen(function* () {
79 const app = yield* Fly.App("Site");
80 const key = yield* Fly.SecretKey("Signing", {
81 app,
82 type: "hs256",
83 value: HMAC_A,
84 });
85 return { app, key };
86 }),
87 );
88
89 expect(created.key.appName).toEqual(created.app.appName);
90 expect(created.key.name).toEqual(expect.any(String));
91 expect(created.key.name.length).toBeGreaterThan(0);
92 expect(created.key.type).toEqual("hs256");
93
94 const fetched = yield* machines.getSecretKey({
95 app_name: created.key.appName,
96 secret_name: created.key.name,
97 });
98 expect(fetched.name).toEqual(created.key.name);
99 expect(fetched.type).toEqual("hs256");
100
101 const updated = yield* stack.deploy(
102 Effect.gen(function* () {
103 const app = yield* Fly.App("Site");
104 const key = yield* Fly.SecretKey("Signing", {
105 app,
106 type: "hs256",
107 value: HMAC_B,
108 });
109 return { app, key };
110 }),
111 );
112
113 expect(updated.key.appName).toEqual(created.key.appName);
114 expect(updated.key.name).toEqual(created.key.name);
115 expect(updated.key.type).toEqual("hs256");
116
117 const refetched = yield* machines.getSecretKey({
118 app_name: updated.key.appName,
119 secret_name: updated.key.name,
120 });
121 expect(refetched.name).toEqual(updated.key.name);
122
123 yield* stack.destroy();
124
125 const keyGone = yield* waitUntilGone(created.key.appName, created.key.name);
126 expect(keyGone).toEqual("gone");
127 const appGone = yield* waitAppGone(created.app.appName);
128 expect(appGone).toEqual("gone");
129 }).pipe(logLevel),
130 {
131 tags: [
132 "provider:fly",
133 "provider:fly:app",
134 "provider:fly:machine",
135 "provider:fly:secretkey",
136 "live",
137 ],
138 timeout: 120_000,
139 },
140 );
141
142 test.provider(
143 "generate a nacl_sign key",
144 (stack) =>
145 Effect.gen(function* () {
146 yield* stack.destroy();
147
148 const created = yield* stack.deploy(
149 Effect.gen(function* () {
150 const app = yield* Fly.App("Site");
151 const key = yield* Fly.SecretKey("Generated", {
152 app,
153 type: "nacl_sign",
154 });
155 return { app, key };
156 }),
157 );
158
159 expect(created.key.type).toEqual("nacl_sign");
160 expect(created.key.publicKey).toEqual(expect.any(String));
161
162 const fetched = yield* machines.getSecretKey({
163 app_name: created.key.appName,
164 secret_name: created.key.name,
165 });
166 expect(fetched.type).toEqual("nacl_sign");
167 expect(fetched.public_key).toEqual(created.key.publicKey);
168
169 yield* stack.destroy();
170
171 const gone = yield* waitUntilGone(created.key.appName, created.key.name);
172 expect(gone).toEqual("gone");
173 }).pipe(logLevel),
174 {
175 tags: [
176 "provider:fly",
177 "provider:fly:app",
178 "provider:fly:machine",
179 "provider:fly:secretkey",
180 "live",
181 ],
182 timeout: 120_000,
183 },
184 );
185
186 test.provider(
187 "replace when name changes",
188 (stack) =>
189 Effect.gen(function* () {
190 yield* stack.destroy();
191
192 const created = yield* stack.deploy(
193 Effect.gen(function* () {
194 const app = yield* Fly.App("Site");
195 const key = yield* Fly.SecretKey("ReplaceKey", {
196 app,
197 type: "nacl_sign",
198 });
199 return { app, key };
200 }),
201 );
202
203 const nextName = created.key.name.slice(0, -1) + (created.key.name.endsWith("z") ? "y" : "z");
204
205 const replaced = yield* stack.deploy(
206 Effect.gen(function* () {
207 const app = yield* Fly.App("Site");
208 const key = yield* Fly.SecretKey("ReplaceKey", {
209 app,
210 name: nextName,
211 type: "nacl_sign",
212 });
213 return { app, key };
214 }),
215 );
216
217 expect(replaced.key.name).toEqual(nextName);
218 expect(replaced.key.name).not.toEqual(created.key.name);
219 expect(replaced.key.appName).toEqual(created.key.appName);
220
221 const fetched = yield* machines.getSecretKey({
222 app_name: replaced.key.appName,
223 secret_name: replaced.key.name,
224 });
225 expect(fetched.name).toEqual(replaced.key.name);
226
227 const oldGone = yield* waitUntilGone(created.key.appName, created.key.name);
228 expect(oldGone).toEqual("gone");
229
230 yield* stack.destroy();
231
232 const gone = yield* waitUntilGone(replaced.key.appName, replaced.key.name);
233 expect(gone).toEqual("gone");
234 }).pipe(logLevel),
235 {
236 tags: [
237 "provider:fly",
238 "provider:fly:app",
239 "provider:fly:machine",
240 "provider:fly:secretkey",
241 "live",
242 ],
243 timeout: 120_000,
244 },
245 );
246
247 test.provider(
248 "list enumerates the deployed secret key",
249 (stack) =>
250 Effect.gen(function* () {
251 yield* stack.destroy();
252
253 const deployed = yield* stack.deploy(
254 Effect.gen(function* () {
255 const app = yield* Fly.App("Site");
256 const key = yield* Fly.SecretKey("ListKey", {
257 app,
258 type: "nacl_sign",
259 });
260 return { app, key };
261 }),
262 );
263
264 const provider = yield* Provider.findProvider(Fly.SecretKey);
265 const all = yield* provider.list();
266 const found = all.find(
267 (key) => key.appName === deployed.key.appName && key.name === deployed.key.name,
268 );
269 expect(found).toBeDefined();
270 expect(found?.type).toEqual(deployed.key.type);
271
272 yield* stack.destroy();
273
274 const gone = yield* waitUntilGone(deployed.key.appName, deployed.key.name);
275 expect(gone).toEqual("gone");
276 }).pipe(logLevel),
277 {
278 tags: [
279 "provider:fly",
280 "provider:fly:app",
281 "provider:fly:machine",
282 "provider:fly:secretkey",
283 "live",
284 ],
285 timeout: 120_000,
286 },
287 );