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

main
ts 172 lines 6.05 KB
Raw
1 import * as ACME from "@alchemy.run/acme";
2 import * as Cloudflare from "@alchemy.run/cloudflare";
3 import { CloudflareEnvironment } from "@alchemy.run/cloudflare";
4 import { findZoneByName } from "@alchemy.run/cloudflare/Zone";
5 import { expect } from "@alchemy.run/test";
6 import * as Test from "@alchemy.run/test/Alchemy";
7 import { Jose } from "@distilled.cloud/acme";
8 import * as acme from "@distilled.cloud/acme/acme";
9 import * as dns from "@distilled.cloud/cloudflare/dns";
10 import * as Effect from "effect/Effect";
11 import * as Layer from "effect/Layer";
12 import * as Redacted from "effect/Redacted";
13 import * as Result from "effect/Result";
14 import * as Stream from "effect/Stream";
15
16 const { test } = Test.make({
17 providers: Layer.mergeAll(ACME.providers(), Cloudflare.providers()),
18 });
19 const ca = ACME.LetsEncryptStaging;
20 const zoneName = process.env.CLOUDFLARE_TEST_DNS_ZONE_NAME ?? "alchemy-test-2.us";
21 const name = `alchemy-acme-lifecycle.${zoneName}`;
22 const resolveZone = Effect.gen(function* () {
23 const { accountId } = yield* yield* CloudflareEnvironment;
24 const zone = yield* findZoneByName({ accountId, name: zoneName });
25 if (!zone) return yield* Effect.fail(new Error(`zone ${zoneName} not found`));
26 return zone.id;
27 });
28
29 test.provider(
30 "keeps an unchanged certificate, renews, persists revocation settings and cleans DNS",
31 (stack) =>
32 Effect.gen(function* () {
33 yield* stack.destroy();
34 const zoneId = yield* resolveZone;
35 const program = (extra: Partial<ACME.CertificateProps> = {}) =>
36 Effect.gen(function* () {
37 const account = yield* ACME.Account("Account", {
38 ca,
39 termsOfServiceAgreed: true,
40 });
41 const cert = yield* ACME.Certificate("Certificate", {
42 account,
43 identifiers: [name],
44 solver: Cloudflare.ACME.ZoneSolver({ zoneId }),
45 ...extra,
46 });
47 return { account, cert };
48 });
49 const first = yield* stack.deploy(program());
50 const parsed = yield* ACME.parseCertificate(first.cert.certificate);
51 expect(parsed.dnsNames).toEqual([name]);
52 expect(first.cert.serial).toBe(parsed.serial);
53 expect(first.cert.issuer).toContain("STAGING");
54 expect(ACME.splitPemChain(first.cert.chain).length).toBeGreaterThan(1);
55 expect(Redacted.isRedacted(first.cert.privateKey)).toBe(true);
56 const unchanged = yield* stack.deploy(program());
57 expect(unchanged.cert.serial).toBe(first.cert.serial);
58 const renewed = yield* stack.deploy(program({ renewBefore: "365 days" }));
59 expect(renewed.cert.serial).not.toBe(first.cert.serial);
60 const configured = yield* stack.deploy(program({ revokeOnDelete: true }));
61 expect(configured.cert.serial).toBe(renewed.cert.serial);
62 const records = yield* dns.listRecords
63 .items({
64 zoneId,
65 name: { exact: `_acme-challenge.${name}` },
66 type: "TXT",
67 })
68 .pipe(Stream.runCollect);
69 expect(records).toEqual([]);
70 yield* stack.destroy();
71 const certificateKey = yield* ACME.privateKeyToJwk(configured.cert.privateKey);
72 const revokedAgain = yield* acme
73 .revokeCertificate({
74 certificate: Jose.base64url(ACME.fromPem(configured.cert.certificate)),
75 })
76 .pipe(Effect.provide(ACME.accountLayer({ ca, accountKey: certificateKey })), Effect.result);
77 expect(Result.isFailure(revokedAgain)).toBe(true);
78 if (Result.isFailure(revokedAgain))
79 expect(revokedAgain.failure._tag).toBe("AcmeAlreadyRevoked");
80 }),
81 {
82 tags: [
83 "provider:acme",
84 "provider:acme:account",
85 "provider:acme:certificate",
86 "provider:cloudflare",
87 "provider:cloudflare:dns",
88 "provider:cloudflare:zone",
89 "live",
90 ],
91 timeout: 180_000,
92 },
93 );
94
95 test.provider(
96 "changing the account replaces the certificate while retaining both accounts",
97 (stack) =>
98 Effect.gen(function* () {
99 yield* stack.destroy();
100 const zoneId = yield* resolveZone;
101 const program = (second: boolean) =>
102 Effect.gen(function* () {
103 const firstAccount = yield* ACME.Account("First", {
104 ca,
105 termsOfServiceAgreed: true,
106 });
107 const secondAccount = yield* ACME.Account("Second", {
108 ca,
109 termsOfServiceAgreed: true,
110 });
111 return yield* ACME.Certificate("Certificate", {
112 account: second ? secondAccount : firstAccount,
113 identifiers: [`alchemy-acme-account-switch.${zoneName}`],
114 solver: Cloudflare.ACME.ZoneSolver({ zoneId }),
115 revokeOnDelete: true,
116 });
117 });
118 const first = yield* stack.deploy(program(false));
119 const second = yield* stack.deploy(program(true));
120 expect(second.serial).not.toBe(first.serial);
121 expect(second.accountUrl).not.toBe(first.accountUrl);
122 yield* stack.destroy();
123 }),
124 {
125 tags: [
126 "provider:acme",
127 "provider:acme:account",
128 "provider:acme:certificate",
129 "provider:cloudflare",
130 "provider:cloudflare:dns",
131 "provider:cloudflare:zone",
132 "live",
133 ],
134 timeout: 180_000,
135 },
136 );
137
138 test.provider(
139 "fails with a typed error when no DNS solver is registered",
140 (stack) =>
141 Effect.gen(function* () {
142 yield* stack.destroy();
143 const result = yield* stack
144 .deploy(
145 Effect.gen(function* () {
146 const account = yield* ACME.Account("Account", {
147 ca,
148 termsOfServiceAgreed: true,
149 });
150 return yield* ACME.Certificate("Certificate", {
151 account,
152 identifiers: [`alchemy-acme-unsolvable.${zoneName}`],
153 solver: { type: "Nope.DNS" },
154 });
155 }),
156 )
157 .pipe(Effect.result);
158 expect(Result.isFailure(result)).toBe(true);
159 expect(JSON.stringify(result)).toContain("ACME.DnsSolverNotRegistered");
160 yield* stack.destroy();
161 }),
162 {
163 tags: [
164 "provider:acme",
165 "provider:acme:account",
166 "provider:acme:certificate",
167 "provider:cloudflare",
168 "live",
169 ],
170 timeout: 60_000,
171 },
172 );