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

main
ts 159 lines 5.17 KB
Raw
1 import * as Hetzner from "@alchemy.run/hetzner";
2 import { expect } from "@alchemy.run/test";
3 import * as Test from "@alchemy.run/test/Alchemy";
4 import * as zoneRrsets from "@distilled.cloud/hetzner/zone_rrsets";
5 import * as zones from "@distilled.cloud/hetzner/zones";
6 import { Action } from "alchemy/Action";
7 import * as Effect from "effect/Effect";
8 import { MinimumLogLevel } from "effect/References";
9 import * as Schedule from "effect/Schedule";
10
11 const { test } = Test.make({ providers: Hetzner.providers() });
12
13 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
14
15 const hasHetznerCreds = !!process.env.HCLOUD_TOKEN;
16
17 const waitUntilGone = (zoneId: number, name: string, type: string) =>
18 zoneRrsets
19 .getZoneRrset({
20 id_or_name: String(zoneId),
21 rr_name: name,
22 rr_type: type,
23 })
24 .pipe(
25 Effect.as("found" as const),
26 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
27 Effect.repeat({
28 schedule: Schedule.spaced("1 second"),
29 until: (status) => status === "gone",
30 times: 10,
31 }),
32 );
33
34 const waitUntilZoneGone = (zoneId: number) =>
35 zones.getZone({ id_or_name: String(zoneId) }).pipe(
36 Effect.as("found" as const),
37 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
38 Effect.repeat({
39 schedule: Schedule.spaced("1 second"),
40 until: (status) => status === "gone",
41 times: 10,
42 }),
43 );
44
45 test.provider.skipIf(!hasHetznerCreds)(
46 "ReadWriteDns: get, list, create, update and delete a record set",
47 (stack) =>
48 Effect.gen(function* () {
49 yield* stack.destroy();
50
51 const out = yield* stack.deploy(
52 Effect.gen(function* () {
53 const zone = yield* Hetzner.Zone("DnsBindingZone", {
54 ttl: 3600,
55 });
56 const recordSet = yield* Hetzner.RecordSet("Www", {
57 zone,
58 name: "www",
59 type: "A",
60 records: [{ value: "192.0.2.1" }],
61 ttl: 300,
62 });
63
64 const Probe = Action(
65 "Probe",
66 Effect.gen(function* () {
67 // Capture the record-set Output so Probe waits for Www.
68 yield* recordSet.id;
69 const dns = yield* Hetzner.ReadWriteDns(zone);
70 return Effect.fn(function* () {
71 const listed = yield* dns.listRecordSets({
72 name: "www",
73 type: ["A"],
74 });
75 const got = yield* dns.getRecordSet("www", "A");
76
77 const created = yield* dns.createRecordSet({
78 name: "api",
79 type: "A",
80 records: [{ value: "192.0.2.50" }],
81 ttl: 300,
82 });
83 yield* Hetzner.waitForZoneAction(created.action);
84
85 const set = yield* dns.setRecordSetRecords("api", "A", {
86 records: [{ value: "192.0.2.51" }],
87 });
88 yield* Hetzner.waitForZoneAction(set.action);
89 const updated = yield* dns.getRecordSet("api", "A");
90
91 const deleted = yield* dns.deleteRecordSet("api", "A");
92 yield* Hetzner.waitForZoneAction(deleted.action);
93
94 return {
95 listedCount: listed.rrsets.length,
96 listedValue: listed.rrsets[0]?.records[0]?.value,
97 gotId: got.rrset.id,
98 gotValue: got.rrset.records[0]?.value,
99 createdId: created.rrset.id,
100 updatedValue: updated.rrset.records[0]?.value,
101 };
102 });
103 }),
104 );
105
106 return {
107 zone,
108 recordSet,
109 probe: yield* Probe({}),
110 };
111 }),
112 );
113
114 expect(out.recordSet.id).toEqual("www/A");
115 expect(out.probe.gotId).toEqual("www/A");
116 expect(out.probe.gotValue).toEqual("192.0.2.1");
117 expect(out.probe.listedCount).toBeGreaterThan(0);
118 expect(out.probe.listedValue).toEqual("192.0.2.1");
119 expect(out.probe.createdId).toEqual("api/A");
120 expect(out.probe.updatedValue).toEqual("192.0.2.51");
121
122 const fetched = yield* zoneRrsets.getZoneRrset({
123 id_or_name: String(out.zone.zoneId),
124 rr_name: "www",
125 rr_type: "A",
126 });
127 expect(fetched.rrset.id).toEqual("www/A");
128 expect(fetched.rrset.records.map((record) => record.value)).toEqual(["192.0.2.1"]);
129
130 const apiGone = yield* zoneRrsets
131 .getZoneRrset({
132 id_or_name: String(out.zone.zoneId),
133 rr_name: "api",
134 rr_type: "A",
135 })
136 .pipe(
137 Effect.as("found" as const),
138 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
139 );
140 expect(apiGone).toEqual("gone");
141
142 yield* stack.destroy();
143
144 const gone = yield* waitUntilGone(out.zone.zoneId, "www", "A");
145 expect(gone).toEqual("gone");
146 const zoneGone = yield* waitUntilZoneGone(out.zone.zoneId);
147 expect(zoneGone).toEqual("gone");
148 }).pipe(logLevel),
149 {
150 tags: [
151 "provider:hetzner",
152 "provider:hetzner:recordset",
153 "provider:hetzner:service",
154 "provider:hetzner:zone",
155 "live",
156 ],
157 timeout: 120_000,
158 },
159 );