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

main
ts 436 lines 20.6 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { describe, expect } from "@alchemy.run/test";
3 import * as Test from "@alchemy.run/test/Alchemy";
4 import * as Effect from "effect/Effect";
5 import * as HttpClientRequest from "effect/http/HttpClientRequest";
6 import * as Schedule from "effect/Schedule";
7 import { requestWorker } from "../Utils/WorkerRequest.ts";
8 import type { MigrationProbe, Snapshot } from "./fixtures/alarm-upgrade/types.ts";
9 import AlarmUpgradeWorker from "./fixtures/alarm-upgrade/v2.ts";
10
11 class WorkerVersionPending extends Error {}
12
13 const requestJson = Effect.fn(
14 function* (url: string, action = "snapshot", workerVersion: Snapshot["version"] = "v2") {
15 const fresh = yield* Effect.sync(() => {
16 const fresh = new URL(`${url}/${action}`);
17 fresh.searchParams.set("cb", String(Date.now()));
18 return fresh;
19 });
20 const response = yield* requestWorker(
21 (fresh.pathname === "/snapshot"
22 ? HttpClientRequest.get(fresh.href)
23 : HttpClientRequest.post(fresh.href)
24 ).pipe(
25 // A fresh connection avoids polling an edge still pinned to the old deployment.
26 HttpClientRequest.setHeaders({
27 connection: "close",
28 "cache-control": "no-cache",
29 "x-alarm-worker-version": workerVersion,
30 }),
31 ),
32 ).pipe(Effect.timeout("15 seconds"));
33 if (response.status !== 200) {
34 const body = yield* response.text;
35 const actualVersion = response.headers["x-alarm-worker-version"];
36 if (
37 response.status === 409 &&
38 actualVersion === (workerVersion === "v1" ? "v2" : "v1") &&
39 body === "Alarm worker version mismatch"
40 ) {
41 return yield* Effect.fail(
42 new WorkerVersionPending(`Waiting for Worker ${workerVersion}; got ${actualVersion}`),
43 );
44 }
45 return yield* Effect.fail(
46 new Error(`Upgrade fixture ${action}: HTTP ${response.status}\n${body}`),
47 );
48 }
49 const body: unknown = yield* response.json;
50 return body;
51 },
52 Effect.retry({
53 while: (error) => error instanceof WorkerVersionPending,
54 schedule: Schedule.spaced("1 second"),
55 times: 10,
56 }),
57 );
58
59 const request = (url: string, action = "snapshot", workerVersion: Snapshot["version"] = "v2") =>
60 requestJson(url, action, workerVersion).pipe(Effect.map((body) => body as Snapshot));
61
62 const ready = (url: string, version: Snapshot["version"], name?: string) =>
63 request(
64 url,
65 name === undefined ? "snapshot" : `snapshot?name=${encodeURIComponent(name)}`,
66 version,
67 ).pipe(
68 Effect.flatMap((snapshot) =>
69 snapshot.version === version
70 ? Effect.succeed(snapshot)
71 : Effect.fail(new Error(`Waiting for ${version}; got ${snapshot.version}`)),
72 ),
73 Effect.retry({ schedule: Schedule.spaced("3 seconds"), times: 10 }),
74 );
75
76 /**
77 * Wait for a redeploy to reach the live Durable Object. A Worker deploy that
78 * carries no Durable Object lifecycle change (declarative `exports`, no
79 * migration) does not restart a running object: Cloudflare keeps an
80 * activation that keeps receiving requests on the previous code — measured:
81 * polling every 3s still reached V1 150s after the V2 deploy — and only
82 * starts the new code once the object has been idle (~20s). So the first
83 * probe after the upgrade must come after an idle gap, and so must every
84 * retry. Local restarts are atomic, so dev mode needs no gap.
85 */
86 const readyAfterRollout = (url: string, dev: boolean) =>
87 dev
88 ? ready(url, "v2")
89 : Effect.sleep("25 seconds").pipe(
90 Effect.andThen(
91 request(url).pipe(
92 Effect.flatMap((snapshot) =>
93 snapshot.version === "v2"
94 ? Effect.succeed(snapshot)
95 : Effect.fail(new Error(`Waiting for v2; got ${snapshot.version}`)),
96 ),
97 Effect.retry({ schedule: Schedule.spaced("25 seconds"), times: 2 }),
98 ),
99 ),
100 );
101
102 const delivered = (
103 url: string,
104 until: (snapshot: Snapshot) => boolean,
105 workerVersion: Snapshot["version"] = "v2",
106 ) =>
107 request(url, "snapshot", workerVersion).pipe(
108 Effect.repeat({ schedule: Schedule.spaced("1 second"), times: 10, until }),
109 Effect.tap((snapshot) => Effect.sync(() => expect(until(snapshot)).toBe(true))),
110 );
111
112 const count = (snapshot: Snapshot, channel: "legacy" | "callback", id: string) =>
113 snapshot.deliveries.filter((delivery) => delivery.channel === channel && delivery.id === id)
114 .length;
115
116 for (const dev of [true, false]) {
117 describe(
118 dev ? "local alarm upgrade" : "live alarm upgrade",
119 { tags: ["provider:cloudflare", "provider:cloudflare:worker"] },
120 () => {
121 const { test } = Test.make({ providers: Cloudflare.providers(), dev });
122
123 test.provider(
124 `${dev ? "local" : "live"} V1 to V2 deployment preserves legacy schema, jobs and object identity`,
125 (stack) =>
126 Effect.gen(function* () {
127 yield* stack.destroy();
128 const main = yield* Effect.sync(
129 () => new URL("./fixtures/alarm-upgrade/v1.ts", import.meta.url).pathname,
130 );
131 const originalDeployment = yield* stack.deploy(
132 Effect.gen(function* () {
133 const host = yield* Cloudflare.Worker("AlarmUpgradeWorker", {
134 main,
135 env: { UpgradeObject: Cloudflare.DurableObject("UpgradeObject") },
136 });
137 const reader = dev
138 ? undefined
139 : yield* Cloudflare.Worker("AlarmUpgradeV1Reader", {
140 main,
141 env: {
142 UpgradeObject: Cloudflare.DurableObject("UpgradeObject", {
143 scriptName: host.workerName,
144 }),
145 },
146 });
147 return { host, reader };
148 }),
149 );
150 const original = originalDeployment.host;
151 expect(original.url).toBeDefined();
152 expect(original.durableObjectNamespaces.UpgradeObject).toBeDefined();
153 if (dev) {
154 expect(original.url).toMatch(/^http:\/\/localhost:\d+$/);
155 } else {
156 expect(original.url).toMatch(/^https:\/\//);
157 }
158 const initial = yield* ready(original.url!, "v1");
159 expect(initial.marker).toBeNull();
160 yield* request(original.url!, "seed", "v1");
161 yield* ready(original.url!, "v1", "future-version");
162 const futureOriginal = yield* request(original.url!, "seed?name=future-version", "v1");
163 yield* ready(original.url!, "v1", "atomic-migration");
164 const rollbackOriginal = yield* request(
165 original.url!,
166 "seed?name=atomic-migration",
167 "v1",
168 );
169 for (const seeded of [futureOriginal, rollbackOriginal]) {
170 expect(seeded.tables).toEqual(["alchemy_scheduled_events"]);
171 expect(seeded.schemaVersion).toBeNull();
172 expect(seeded.schemaRows).toEqual([]);
173 expect(seeded.legacyRows).toHaveLength(3);
174 }
175 const before = yield* delivered(
176 original.url!,
177 (snapshot) =>
178 count(snapshot, "legacy", "v1-proof") === 1 &&
179 snapshot.legacyRows.length === 3 &&
180 snapshot.alarm === Math.min(...snapshot.legacyRows.map((row) => row.run_at)),
181 "v1",
182 );
183 expect(before.version).toBe("v1");
184 expect(before.marker).toBe("written-by-v1");
185 expect(before.tables).toEqual(["alchemy_scheduled_events"]);
186 expect(before.schemaVersion).toBeNull();
187 expect(before.schemaRows).toEqual([]);
188 expect(before.legacyRows.map((row) => row.id)).toEqual([
189 "legacy-cancel",
190 "legacy-one",
191 "legacy-repeat",
192 ]);
193 expect(before.legacyColumns).toEqual([
194 { name: "id", type: "TEXT", notnull: 0, pk: 1 },
195 { name: "run_at", type: "INTEGER", notnull: 1, pk: 0 },
196 { name: "repeat_ms", type: "INTEGER", notnull: 0, pk: 0 },
197 { name: "payload", type: "TEXT", notnull: 1, pk: 0 },
198 ]);
199 expect(before.alarm).toBe(Math.min(...before.legacyRows.map((row) => row.run_at)));
200 expect(before.deliveries).toEqual([
201 {
202 version: "v1",
203 channel: "legacy",
204 id: "v1-proof",
205 payload: { callback: "archive", value: "v1-proof" },
206 },
207 ]);
208
209 // This is an update of the existing resource, not a fresh namespace or a schema-only fixture.
210 const upgradedDeployment = yield* stack.deploy(
211 Effect.gen(function* () {
212 const host = yield* AlarmUpgradeWorker;
213 const reader = dev
214 ? undefined
215 : yield* Cloudflare.Worker("AlarmUpgradeV1Reader", {
216 main,
217 env: {
218 UpgradeObject: Cloudflare.DurableObject("UpgradeObject", {
219 scriptName: host.workerName,
220 }),
221 },
222 });
223 return { host, reader };
224 }),
225 );
226 const upgraded = upgradedDeployment.host;
227 expect(upgraded.workerName).toBe(original.workerName);
228 expect(upgraded.workerId).toBe(original.workerId);
229 expect(upgraded.durableObjectNamespaces.UpgradeObject).toBe(
230 original.durableObjectNamespaces.UpgradeObject,
231 );
232 const after = yield* readyAfterRollout(upgraded.url!, dev);
233 expect(after.id).toBe(before.id);
234 expect(after.marker).toBe(before.marker);
235 expect(after.constructors).toContain("v1");
236 expect(after.constructors).toContain("v2");
237 expect(after.legacyColumns).toEqual(before.legacyColumns);
238 expect(after.legacyRows).toEqual(before.legacyRows);
239 expect(after.deliveries).toEqual(before.deliveries);
240 expect(after.alarm).toBe(before.alarm);
241 expect(after.tables).toContain("alchemy_scheduled_events");
242 expect(after.tables).toContain("alchemy_alarm_callbacks");
243 expect(after.tables).toContain("alchemy_alarm_schema");
244 expect(after.schemaVersion).toBe(2);
245 expect(after.schemaRows).toEqual([{ id: 1, version: 2 }]);
246 expect(after.callbacks).toEqual([]);
247 if (upgradedDeployment.reader) {
248 // Local restarts are atomic; live edges can still run V1 against the V2 object.
249 const viaV1 = yield* request(upgradedDeployment.reader.url!, "snapshot", "v1");
250 expect(viaV1).toEqual(after);
251 const rejected = yield* requestWorker(
252 HttpClientRequest.post(`${upgradedDeployment.reader.url!}/callback-first`).pipe(
253 HttpClientRequest.setHeader("x-alarm-worker-version", "v2"),
254 ),
255 );
256 expect(rejected.status).toBe(409);
257 expect(rejected.headers["x-alarm-worker-version"]).toBe("v1");
258 expect(yield* rejected.text).toBe("Alarm worker version mismatch");
259 expect(yield* request(upgraded.url!)).toEqual(after);
260 }
261
262 const callbackFirst = yield* request(upgraded.url!, "callback-first");
263 expect(callbackFirst.callbacks).toHaveLength(1);
264 expect(callbackFirst.alarm).toBe(callbackFirst.callbacks[0].run_at);
265 expect(callbackFirst.alarm!).toBeLessThan(before.alarm!);
266 const reset = (yield* requestJson(upgraded.url!, "reconstruct")) as {
267 aborted: boolean;
268 };
269 expect(reset.aborted).toBe(true);
270 const reconstructed = yield* ready(upgraded.url!, "v2");
271 expect(reconstructed.constructors.length).toBeGreaterThan(
272 callbackFirst.constructors.length,
273 );
274 expect(reconstructed.id).toBe(before.id);
275 expect(reconstructed.marker).toBe(before.marker);
276 expect(reconstructed.schemaVersion).toBe(2);
277 expect(reconstructed.schemaRows).toEqual([{ id: 1, version: 2 }]);
278 expect(reconstructed.schema).toEqual(callbackFirst.schema);
279 expect(reconstructed.legacyRows).toEqual(callbackFirst.legacyRows);
280 expect(reconstructed.callbacks).toEqual(callbackFirst.callbacks);
281 expect(reconstructed.alarm).toBe(callbackFirst.alarm);
282 const repeated = yield* request(upgraded.url!);
283 expect(repeated.schemaVersion).toBe(2);
284 expect(repeated.schemaRows).toEqual(reconstructed.schemaRows);
285 expect(repeated.schema).toEqual(reconstructed.schema);
286 expect(repeated.legacyRows).toEqual(reconstructed.legacyRows);
287 expect(repeated.callbacks).toEqual(reconstructed.callbacks);
288 expect(repeated.alarm).toBe(reconstructed.alarm);
289 const legacyCanceled = yield* request(upgraded.url!, "cancel-legacy");
290 expect(legacyCanceled.legacyRows.map((row) => row.id)).toEqual([
291 "legacy-one",
292 "legacy-repeat",
293 ]);
294 expect(legacyCanceled.callbacks).toEqual(callbackFirst.callbacks);
295 expect(legacyCanceled.alarm).toBe(callbackFirst.alarm);
296 const callbackCanceled = yield* request(upgraded.url!, "cancel-callback");
297 expect(callbackCanceled.callbacks).toEqual([]);
298 expect(callbackCanceled.legacyRows).toEqual(legacyCanceled.legacyRows);
299 expect(callbackCanceled.alarm).toBe(before.alarm);
300
301 // Pending jobs start five minutes ahead so deployment latency cannot consume them in V1.
302 // Moving only their due times forward keeps the native-alarm assertion bounded.
303 const released = yield* request(upgraded.url!, "release");
304 expect(released.callbacks).toHaveLength(1);
305 expect(released.alarm).toBe(released.callbacks[0].run_at);
306 for (const row of released.legacyRows) {
307 const old = before.legacyRows.find((event) => event.id === row.id)!;
308 expect(row.payload).toBe(old.payload);
309 expect(row.repeat_ms).toBe(old.repeat_ms);
310 expect(row.run_at).toBe(released.callbacks[0].run_at);
311 }
312 const fired = yield* delivered(
313 upgraded.url!,
314 (snapshot) =>
315 count(snapshot, "legacy", "legacy-one") === 1 &&
316 count(snapshot, "legacy", "legacy-repeat") >= 2 &&
317 count(snapshot, "callback", "new-callback") === 1 &&
318 snapshot.callbacks.length === 0 &&
319 snapshot.legacyRows.length === 1 &&
320 snapshot.alarm === snapshot.legacyRows[0].run_at,
321 );
322 expect(fired.legacyRows).toHaveLength(1);
323 expect(fired.legacyRows[0].id).toBe("legacy-repeat");
324 expect(fired.legacyRows[0].repeat_ms).toBe(2_000);
325 expect(fired.legacyRows[0].run_at).toBeGreaterThan(
326 released.legacyRows.find((row) => row.id === "legacy-repeat")!.run_at,
327 );
328 expect(fired.callbacks).toEqual([]);
329 expect(fired.alarm).toBe(fired.legacyRows[0].run_at);
330 for (const delivery of fired.deliveries.filter((event) => event.id !== "v1-proof")) {
331 expect(delivery.version).toBe("v2");
332 if (delivery.channel === "legacy") {
333 expect(delivery.payload).toEqual({ callback: "archive", value: delivery.id });
334 }
335 }
336 expect(count(fired, "legacy", "legacy-cancel")).toBe(0);
337 expect(fired.deliveries.filter((event) => event.channel === "callback")).toEqual([
338 {
339 version: "v2",
340 channel: "callback",
341 id: "new-callback",
342 payload: { value: "new-callback" },
343 },
344 ]);
345
346 const onlyCallback = yield* request(upgraded.url!, "only-callback");
347 expect(onlyCallback.legacyRows).toEqual([]);
348 expect(onlyCallback.callbacks).toHaveLength(1);
349 expect(onlyCallback.alarm).toBe(onlyCallback.callbacks[0].run_at);
350 const callbackSurvived = yield* delivered(
351 upgraded.url!,
352 (snapshot) =>
353 count(snapshot, "callback", "callback-survivor") === 1 &&
354 snapshot.callbacks.length === 0 &&
355 snapshot.alarm === null,
356 );
357 expect(callbackSurvived.callbacks).toEqual([]);
358 expect(callbackSurvived.alarm).toBeNull();
359
360 const onlyLegacy = yield* request(upgraded.url!, "only-legacy");
361 expect(onlyLegacy.callbacks).toEqual([]);
362 expect(onlyLegacy.legacyRows).toHaveLength(1);
363 expect(onlyLegacy.alarm).toBe(onlyLegacy.legacyRows[0].run_at);
364 const legacySurvived = yield* delivered(
365 upgraded.url!,
366 (snapshot) =>
367 count(snapshot, "legacy", "legacy-survivor") === 1 &&
368 snapshot.legacyRows.length === 0 &&
369 snapshot.alarm === null,
370 );
371 expect(count(legacySurvived, "callback", "must-not-fire")).toBe(0);
372 expect(count(legacySurvived, "callback", "canceled-callback")).toBe(0);
373 expect(count(legacySurvived, "legacy", "legacy-cancel")).toBe(0);
374 expect(legacySurvived.legacyRows).toEqual([]);
375 expect(legacySurvived.callbacks).toEqual([]);
376 expect(legacySurvived.alarm).toBeNull();
377 expect(legacySurvived.id).toBe(before.id);
378 expect(legacySurvived.marker).toBe("written-by-v1");
379
380 const future = (yield* requestJson(
381 upgraded.url!,
382 "migration-future?name=future-version",
383 )) as MigrationProbe;
384 expect(future.before.id).toBe(futureOriginal.id);
385 expect(future.before.legacyRows).toEqual(futureOriginal.legacyRows);
386 expect(future.before.schemaVersion).toBe(3);
387 expect(future.before.schemaRows).toEqual([{ id: 1, version: 3 }]);
388 expect(future.before.callbacks).toHaveLength(1);
389 expect(future.before.alarm).toBe(futureOriginal.alarm);
390 expect(future.failure?.tag).toBe("UnsupportedAlarmSchemaVersion");
391 expect(future.failure?.version).toBe(3);
392 expect(future.failure?.supportedVersion).toBe(2);
393 expect(future.after).toEqual(future.before);
394 expect(future.recovered).toBeNull();
395
396 const rollback = (yield* requestJson(
397 upgraded.url!,
398 "migration-rollback?name=atomic-migration",
399 )) as MigrationProbe;
400 expect(rollback.before.id).toBe(rollbackOriginal.id);
401 expect(rollback.before.legacyRows).toEqual(rollbackOriginal.legacyRows);
402 expect(rollback.before.schemaVersion).toBeNull();
403 expect(rollback.before.schemaRows).toEqual([]);
404 expect(rollback.before.tables).not.toContain("alchemy_alarm_callbacks");
405 expect(rollback.before.tables).not.toContain("alchemy_alarm_schema");
406 expect(
407 rollback.before.schema.some(
408 (row) => row.name === "idx_alchemy_scheduled_events_run_at",
409 ),
410 ).toBe(false);
411 expect(rollback.failure).not.toBeNull();
412 expect(rollback.failure!.message).toContain("idx_alchemy_alarm_callbacks_run_at");
413 expect(rollback.after).toEqual(rollback.before);
414 expect(rollback.after.alarm).toBe(rollbackOriginal.alarm);
415 expect(rollback.retryBefore?.schemaVersion).toBe(0);
416 expect(rollback.retryBefore?.schemaRows).toEqual([{ id: 1, version: 0 }]);
417 expect(rollback.retryBefore?.legacyRows).toEqual(rollbackOriginal.legacyRows);
418 expect(rollback.recovered?.schemaVersion).toBe(2);
419 expect(rollback.recovered?.schemaRows).toEqual([{ id: 1, version: 2 }]);
420 expect(rollback.recovered?.legacyRows).toEqual(rollbackOriginal.legacyRows);
421 expect(rollback.recovered?.callbacks).toEqual([]);
422 expect(rollback.recovered?.tables).toContain("alchemy_alarm_callbacks");
423 expect(
424 rollback.recovered?.schema.some(
425 (row) => row.name === "idx_alchemy_scheduled_events_run_at" && row.type === "index",
426 ),
427 ).toBe(true);
428 expect(rollback.recovered?.alarm).toBe(rollbackOriginal.alarm);
429 yield* stack.destroy();
430 }),
431 // Live: up to ~75s of idle-gap waiting for the DO rollout (readyAfterRollout).
432 { tags: [...(dev ? ["local"] : ["live"])], timeout: 180_000 },
433 );
434 },
435 );
436 }