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

main
ts 159 lines 6.11 KB
Raw
1 /// <reference lib="dom" />
2 // The DOM lib types the functions this scenario runs in the page.
3 import { expect } from "e2e";
4 import * as Effect from "effect/Effect";
5 import * as FileSystem from "effect/FileSystem";
6 import * as Path from "effect/Path";
7 import * as Schema from "effect/Schema";
8
9 import { T3_HOME } from "../e2e.config.ts";
10 import { runPromise, test, WEB } from "./t3.ts";
11
12 const SettingsJson = Schema.fromJsonString(Schema.Record(Schema.String, Schema.Unknown));
13 const decodeSettings = Schema.decodeEffect(SettingsJson);
14 const encodeSettings = Schema.encodeEffect(SettingsJson);
15 interface CodexInstance {
16 readonly config?: Readonly<Record<string, unknown>>;
17 }
18
19 interface ConfigHold {
20 active: boolean;
21 readonly held: Array<() => void>;
22 readonly saveReplies: Set<string>;
23 }
24
25 declare global {
26 interface Window {
27 configHold?: ConfigHold;
28 }
29 }
30
31 const settingsFile = Effect.gen(function* () {
32 const fs = yield* FileSystem.FileSystem;
33 const settingsPath = (yield* Path.Path).join(T3_HOME, "userdata/settings.json");
34 const original = yield* fs.readFileString(settingsPath);
35 const settings = yield* decodeSettings(original);
36 const instances = settings.providerInstances as Record<string, CodexInstance>;
37 const codex = instances.codex!;
38 const customModels = [
39 { slug: "model-a", name: "Original A" },
40 { slug: "model-b", name: "Original B" },
41 ];
42 return {
43 seed: fs.writeFileString(
44 settingsPath,
45 yield* encodeSettings({
46 ...settings,
47 providerInstances: {
48 ...instances,
49 codex: { ...codex, config: { ...codex.config, customModels } },
50 },
51 }),
52 ),
53 savedNames: fs.readFileString(settingsPath).pipe(
54 Effect.flatMap(decodeSettings),
55 Effect.map((saved) => {
56 const config = (saved.providerInstances as Record<string, CodexInstance>).codex?.config;
57 const models = (config?.customModels ?? []) as ReadonlyArray<{ readonly name: string }>;
58 return models.map((model) => model.name);
59 }),
60 ),
61 restore: fs.writeFileString(settingsPath, original),
62 };
63 });
64
65 test(
66 "Two custom model edits saved before the first one's settings echo both persist",
67 WEB,
68 async ({ t3, app, browser, screen }) => {
69 // Holds the server config stream while active, so a save's reply arrives before its settings
70 // echo, and records settings save replies by request id.
71 await browser.addInitScript(() => {
72 const hold: ConfigHold = { active: false, held: [], saveReplies: new Set() };
73 window.configHold = hold;
74 const tags = new Map<string, string>();
75 const send = WebSocket.prototype.send;
76 WebSocket.prototype.send = function (data) {
77 if (typeof data === "string") {
78 for (const message of [JSON.parse(data)].flat()) {
79 if (message?._tag === "Request") tags.set(String(message.id), message.tag);
80 }
81 }
82 return send.call(this, data);
83 };
84 const addEventListener = WebSocket.prototype.addEventListener;
85 WebSocket.prototype.addEventListener = function (
86 this: WebSocket,
87 type: string,
88 listener: EventListenerOrEventListenerObject,
89 options?: boolean | AddEventListenerOptions,
90 ) {
91 if (type !== "message" || typeof listener !== "function") {
92 return addEventListener.call(this, type, listener, options);
93 }
94 const wrapped = (event: Event) => {
95 const data = (event as MessageEvent).data;
96 if (typeof data !== "string") return listener.call(this, event);
97 const parsed = JSON.parse(data);
98 const messages = [parsed].flat();
99 const isConfig = (message: { requestId?: unknown }) =>
100 tags.get(String(message.requestId)) === "subscribeServerConfig";
101 for (const message of messages) {
102 if (
103 message?._tag === "Exit" &&
104 tags.get(String(message.requestId)) === "server.updateSettings"
105 ) {
106 hold.saveReplies.add(String(message.requestId));
107 }
108 }
109 const deliver = (part: ReadonlyArray<unknown>) =>
110 listener.call(
111 this,
112 new MessageEvent("message", {
113 data: JSON.stringify(Array.isArray(parsed) ? part : part[0]),
114 }),
115 );
116 const held = hold.active ? messages.filter(isConfig) : [];
117 const passed = messages.filter((message) => !held.includes(message));
118 if (held.length > 0) hold.held.push(() => deliver(held));
119 if (passed.length > 0) deliver(passed);
120 };
121 return addEventListener.call(this, type, wrapped, options);
122 } as typeof WebSocket.prototype.addEventListener;
123 });
124 const hold = (active: boolean) =>
125 browser.evaluate((active) => {
126 const hold = window.configHold!;
127 hold.active = active;
128 if (!active) for (const deliver of hold.held.splice(0)) deliver();
129 return null;
130 }, active);
131 const saveReplies = () => browser.evaluate(() => window.configHold!.saveReplies.size);
132 const rename = async (slug: string, name: string) => {
133 await screen.getByRole("button", `Edit ${slug}`, { exact: true }).tap();
134 await screen.getByRole("textbox", "Display name", { exact: true }).fill(name);
135 await screen.getByRole("button", "Save", { exact: true }).tap();
136 };
137
138 const settings = await runPromise(settingsFile);
139 try {
140 await runPromise(settings.seed);
141 await t3.open("/settings/providers?instanceId=codex");
142 await expect(screen.getByRole("button", "Edit model-a", { exact: true })).toBeVisible();
143
144 const before = await saveReplies();
145 await hold(true);
146 await rename("model-a", "Entered A");
147 await expect.poll(saveReplies).toBe(before + 1);
148 await rename("model-b", "Entered B");
149 await expect.poll(saveReplies).toBe(before + 2);
150 await hold(false);
151
152 await expect.poll(() => runPromise(settings.savedNames)).toContain("Entered B");
153 await app.screenshot("after-both-saves");
154 expect(await runPromise(settings.savedNames)).toEqual(["Entered A", "Entered B"]);
155 } finally {
156 await runPromise(settings.restore);
157 }
158 },
159 );