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

main
ts 200 lines 7.52 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as alerting from "@distilled.cloud/cloudflare/alerting";
6 import * as Provider from "alchemy/Provider";
7 import * as Clock from "effect/Clock";
8 import * as Effect from "effect/Effect";
9 import { MinimumLogLevel } from "effect/References";
10 import * as Schedule from "effect/Schedule";
11
12 const { test } = Test.make({ providers: Cloudflare.providers() });
13
14 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
15
16 const EMAIL = "test@alchemy.run";
17
18 const DAY_MS = 86_400_000;
19
20 // Cloudflare rejects silence windows starting more than 90 days out, so the
21 // window cannot be a fixed far-future constant. Derive it from the Effect
22 // Clock, truncated to the UTC day boundary: deterministic within a test run
23 // (and across reruns on the same day), always inside the 90-day limit.
24 const silenceWindow = Effect.gen(function* () {
25 const now = yield* Clock.currentTimeMillis;
26 return yield* Effect.sync(() => {
27 const base = Math.floor(now / DAY_MS) * DAY_MS;
28 return {
29 start: new Date(base + 30 * DAY_MS).toISOString(),
30 end: new Date(base + 31 * DAY_MS).toISOString(),
31 extendedEnd: new Date(base + 32 * DAY_MS).toISOString(),
32 };
33 });
34 });
35
36 const sameInstant = (a: string | undefined | null, b: string) =>
37 a != null && Date.parse(a) === Date.parse(b);
38
39 test.provider(
40 "create, update window in place, delete silence",
41 (stack) =>
42 Effect.gen(function* () {
43 const { accountId } = yield* yield* CloudflareEnvironment;
44 const { start, end, extendedEnd } = yield* silenceWindow;
45
46 yield* stack.destroy();
47
48 const initial = yield* stack.deploy(
49 Effect.gen(function* () {
50 const policy = yield* Cloudflare.Alerting.NotificationPolicy("SilencedPolicy", {
51 alertType: "universal_ssl_event_type",
52 mechanisms: { email: [{ id: EMAIL }] },
53 });
54 return yield* Cloudflare.Alerting.Silence("Maintenance", {
55 policyId: policy.policyId,
56 startTime: start,
57 endTime: end,
58 });
59 }),
60 );
61
62 expect(initial.silenceId).toBeDefined();
63 expect(initial.accountId).toEqual(accountId);
64 expect(initial.policyId).toBeDefined();
65 expect(sameInstant(initial.startTime, start)).toBe(true);
66 expect(sameInstant(initial.endTime, end)).toBe(true);
67
68 // Verify out-of-band via the API.
69 const actual = yield* alerting.getSilence({ accountId, silenceId: initial.silenceId });
70 expect(actual.policyId).toEqual(initial.policyId);
71 expect(sameInstant(actual.startTime, start)).toBe(true);
72 expect(sameInstant(actual.endTime, end)).toBe(true);
73
74 // Extend the window in place — same silence id.
75 const updated = yield* stack.deploy(
76 Effect.gen(function* () {
77 const policy = yield* Cloudflare.Alerting.NotificationPolicy("SilencedPolicy", {
78 alertType: "universal_ssl_event_type",
79 mechanisms: { email: [{ id: EMAIL }] },
80 });
81 return yield* Cloudflare.Alerting.Silence("Maintenance", {
82 policyId: policy.policyId,
83 startTime: start,
84 endTime: extendedEnd,
85 });
86 }),
87 );
88
89 expect(updated.silenceId).toEqual(initial.silenceId);
90 expect(sameInstant(updated.endTime, extendedEnd)).toBe(true);
91
92 const afterUpdate = yield* alerting.getSilence({ accountId, silenceId: initial.silenceId });
93 expect(sameInstant(afterUpdate.endTime, extendedEnd)).toBe(true);
94
95 yield* stack.destroy();
96
97 yield* waitForSilenceDeleted(accountId, initial.silenceId);
98 }).pipe(logLevel),
99 { tags: ["provider:cloudflare", "provider:cloudflare:alerting", "live"] },
100 );
101
102 test.provider(
103 "replaces silence when the policy changes",
104 (stack) =>
105 Effect.gen(function* () {
106 const { accountId } = yield* yield* CloudflareEnvironment;
107 const { start, end } = yield* silenceWindow;
108
109 yield* stack.destroy();
110
111 const deploySilence = (policyResourceId: "PolicyA" | "PolicyB") =>
112 stack.deploy(
113 Effect.gen(function* () {
114 const policyA = yield* Cloudflare.Alerting.NotificationPolicy("PolicyA", {
115 alertType: "universal_ssl_event_type",
116 mechanisms: { email: [{ id: EMAIL }] },
117 });
118 const policyB = yield* Cloudflare.Alerting.NotificationPolicy("PolicyB", {
119 alertType: "universal_ssl_event_type",
120 mechanisms: { email: [{ id: EMAIL }] },
121 });
122 const target = policyResourceId === "PolicyA" ? policyA : policyB;
123 const silence = yield* Cloudflare.Alerting.Silence("ReplaceMe", {
124 policyId: target.policyId,
125 startTime: start,
126 endTime: end,
127 });
128 return { policyA, policyB, silence };
129 }),
130 );
131
132 const initial = yield* deploySilence("PolicyA");
133 expect(initial.silence.policyId).toEqual(initial.policyA.policyId);
134
135 // Pointing the silence at a different policy is a replacement — the
136 // silence update API cannot move a silence between policies.
137 const replaced = yield* deploySilence("PolicyB");
138 expect(replaced.silence.policyId).toEqual(replaced.policyB.policyId);
139 expect(replaced.silence.silenceId).not.toEqual(initial.silence.silenceId);
140
141 // The replaced (old) silence must be gone.
142 yield* waitForSilenceDeleted(accountId, initial.silence.silenceId);
143
144 const actual = yield* alerting.getSilence({
145 accountId,
146 silenceId: replaced.silence.silenceId,
147 });
148 expect(actual.policyId).toEqual(replaced.policyB.policyId);
149
150 yield* stack.destroy();
151
152 yield* waitForSilenceDeleted(accountId, replaced.silence.silenceId);
153 }).pipe(logLevel),
154 { tags: ["provider:cloudflare", "provider:cloudflare:alerting", "live"] },
155 );
156
157 test.provider(
158 "list enumerates the deployed silence",
159 (stack) =>
160 Effect.gen(function* () {
161 const { accountId } = yield* yield* CloudflareEnvironment;
162 const { start, end } = yield* silenceWindow;
163
164 yield* stack.destroy();
165
166 const deployed = yield* stack.deploy(
167 Effect.gen(function* () {
168 const policy = yield* Cloudflare.Alerting.NotificationPolicy("ListedPolicy", {
169 alertType: "universal_ssl_event_type",
170 mechanisms: { email: [{ id: EMAIL }] },
171 });
172 return yield* Cloudflare.Alerting.Silence("ListedSilence", {
173 policyId: policy.policyId,
174 startTime: start,
175 endTime: end,
176 });
177 }),
178 );
179
180 const provider = yield* Provider.findProvider(Cloudflare.Alerting.Silence);
181 const all = yield* provider.list();
182
183 expect(all.some((s) => s.silenceId === deployed.silenceId)).toBe(true);
184
185 yield* stack.destroy();
186
187 yield* waitForSilenceDeleted(accountId, deployed.silenceId);
188 }).pipe(logLevel),
189 { tags: ["provider:cloudflare", "provider:cloudflare:alerting", "live"] },
190 );
191
192 const waitForSilenceDeleted = (accountId: string, silenceId: string) =>
193 alerting.getSilence({ accountId, silenceId }).pipe(
194 Effect.flatMap(() => Effect.fail({ _tag: "SilenceNotDeleted" } as const)),
195 Effect.catchTag("SilenceNotFound", () => Effect.void),
196 Effect.retry({
197 while: (e) => e._tag === "SilenceNotDeleted",
198 schedule: Schedule.max([Schedule.exponential("500 millis"), Schedule.recurs(10)]),
199 }),
200 );