@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 426 lines 17.6 KB
Raw
1 import * as NodeServices from "@effect/platform-node/NodeServices";
2 import { assert, describe, it } from "@effect/vitest";
3 import * as Deferred from "effect/Deferred";
4 import * as Context from "effect/Context";
5 import * as Option from "effect/Option";
6 import * as Duration from "effect/Duration";
7 import * as Effect from "effect/Effect";
8 import * as Exit from "effect/Exit";
9 import * as FileSystem from "effect/FileSystem";
10 import * as Layer from "effect/Layer";
11 import * as Schema from "effect/Schema";
12 import * as Scope from "effect/Scope";
13 import * as Stream from "effect/Stream";
14 import * as TestClock from "effect/testing/TestClock";
15
16 import type * as Electron from "electron";
17 import * as NodeEvents from "node:events";
18
19 import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
20 import * as ElectronApp from "../electron/ElectronApp.ts";
21 import * as ElectronPowerMonitor from "../electron/ElectronPowerMonitor.ts";
22 import * as DesktopTelemetryPublisher from "./DesktopTelemetryPublisher.ts";
23 import * as DesktopRendererHistory from "./DesktopRendererHistory.ts";
24 import * as DesktopShellEnvironment from "../shell/DesktopShellEnvironment.ts";
25
26 const layerHistory = Layer.succeed(DesktopRendererHistory.DesktopRendererHistory, {
27 register: () => Effect.void,
28 recordMetrics: () => Effect.void,
29 shutdown: Effect.void,
30 });
31
32 function layerElectronApp(
33 metrics: ReadonlyArray<Electron.ProcessMetric>,
34 onMetricsRead: () => void = () => undefined,
35 ) {
36 return Layer.succeed(ElectronApp.ElectronApp, {
37 metadata: Effect.die("unexpected metadata read"),
38 name: Effect.succeed("T3 Code"),
39 systemLocale: Effect.succeed("en-US"),
40 preferredSystemLanguages: Effect.succeed(["en-US"]),
41 whenReady: Effect.void,
42 requestSingleInstanceLock: Effect.succeed(true),
43 quit: Effect.void,
44 exit: () => Effect.void,
45 relaunch: () => Effect.void,
46 setPath: () => Effect.void,
47 setName: () => Effect.void,
48 setAboutPanelOptions: () => Effect.void,
49 setAppUserModelId: () => Effect.void,
50 getAppMetrics: Effect.sync(() => {
51 onMetricsRead();
52 return metrics;
53 }),
54 setAsDefaultProtocolClient: () => Effect.succeed(true),
55 setDesktopName: () => Effect.void,
56 setDockIcon: () => Effect.void,
57 appendCommandLineSwitch: () => Effect.void,
58 removeCommandLineSwitch: () => Effect.void,
59 onBeforeQuitForUpdate: () => Effect.void,
60 on: () => Effect.void,
61 } satisfies ElectronApp.ElectronApp["Service"]);
62 }
63
64 describe("DesktopTelemetryPublisher", () => {
65 it.effect(
66 "forwards shell discovery while a telemetry sample is pending and stops on scope close",
67 () =>
68 Effect.gen(function* () {
69 const pollStarted = yield* Deferred.make<void>();
70 const blockPoll = yield* Deferred.make<void>();
71 const layerPower = Layer.succeed(
72 ElectronPowerMonitor.ElectronPowerMonitor,
73 ElectronPowerMonitor.ElectronPowerMonitor.of({
74 isOnBatteryPower: Effect.succeed(false),
75 getSystemIdleTime: Deferred.succeed(pollStarted, undefined).pipe(
76 Effect.andThen(Deferred.await(blockPoll)),
77 Effect.as(0),
78 ),
79 getSystemIdleState: () => Effect.succeed("active"),
80 getCurrentThermalState: Effect.succeed("nominal"),
81 onSimpleEvent: () => Effect.void,
82 onThermalStateChange: () => Effect.void,
83 onSpeedLimitChange: () => Effect.void,
84 }),
85 );
86 const layer = DesktopTelemetryPublisher.layer.pipe(
87 Layer.provide(
88 Layer.mergeAll(
89 layerElectronApp([]),
90 layerPower,
91 layerHistory,
92 Layer.succeed(DesktopShellEnvironment.DesktopShellEnvironment, {
93 installIntoProcess: Effect.succeed(true),
94 awaitDiscovery: Effect.succeed(true),
95 awaitUserShellDiscovery: Effect.succeed(true),
96 discoveryFinished: Effect.succeed(true),
97 updates: Stream.make({
98 version: 1,
99 type: "shellEnvironment",
100 discovered: true,
101 platform: "darwin",
102 environment: { PATH: "/discovered/bin" },
103 }),
104 }),
105 ),
106 ),
107 );
108 const scope = yield* Scope.make();
109
110 const context = yield* Layer.buildWithScope(layer, scope);
111 const publisher = Context.get(context, DesktopTelemetryPublisher.DesktopTelemetryPublisher);
112 const update = yield* publisher.encoded.pipe(
113 Stream.filter((bytes) => new TextDecoder().decode(bytes).includes("shellEnvironment")),
114 Stream.runHead,
115 );
116 assert.isTrue(Option.isSome(update));
117 if (Option.isSome(update))
118 assert.include(new TextDecoder().decode(update.value), "/discovered/bin");
119 yield* Deferred.await(pollStarted);
120
121 const closeFiber = yield* Scope.close(scope, Exit.void).pipe(Effect.forkDetach);
122 yield* Effect.yieldNow;
123 yield* Effect.yieldNow;
124
125 assert.isDefined(closeFiber.pollUnsafe());
126 }),
127 );
128 });
129
130 describe("DesktopRendererHistory", () => {
131 it.effect(
132 "persists surface identity and memory through renderer replacement and destruction",
133 () =>
134 Effect.gen(function* () {
135 const fileSystem = yield* FileSystem.FileSystem;
136 const directory = yield* fileSystem.makeTempDirectoryScoped({
137 prefix: "t3-renderer-history-",
138 });
139 let previewPid = 7_002;
140 let previewDestroyed = false;
141 let urlReads = 0;
142 const main = Object.assign(new NodeEvents.EventEmitter(), {
143 id: 1,
144 getOSProcessId: () => 7_001,
145 isDestroyed: () => false,
146 getURL: () => {
147 urlReads += 1;
148 return "https://private.invalid/main?secret=private";
149 },
150 });
151 const preview = Object.assign(new NodeEvents.EventEmitter(), {
152 id: 2,
153 getOSProcessId: () => previewPid,
154 isDestroyed: () => previewDestroyed,
155 getURL: () => {
156 urlReads += 1;
157 return "https://private.invalid/preview?secret=private";
158 },
159 });
160 const metrics = [7_001, 7_002].map(
161 (pid) =>
162 ({
163 pid,
164 type: "Tab",
165 creationTime: pid * 100,
166 memory: { workingSetSize: 2_048, peakWorkingSetSize: 4_096 },
167 cpu: { percentCPUUsage: 0, cumulativeCPUUsage: 0, idleWakeupsPerSecond: 0 },
168 }) satisfies Electron.ProcessMetric,
169 );
170 const recordSchema = Schema.fromJsonString(
171 Schema.Struct({
172 event: Schema.String,
173 mainPid: Schema.Number,
174 mainSessionStartedAtUnixMs: Schema.Number,
175 timestampUnixMs: Schema.Number,
176 webContentsId: Schema.Number,
177 surface: Schema.String,
178 tabId: Schema.optional(Schema.String),
179 rendererPid: Schema.NullOr(Schema.Number),
180 rendererPidSource: Schema.String,
181 rendererCreationTimeMs: Schema.NullOr(Schema.Number),
182 memory: Schema.NullOr(
183 Schema.Struct({
184 kind: Schema.String,
185 sampledAtUnixMs: Schema.Number,
186 workingSetBytes: Schema.Number,
187 peakWorkingSetBytes: Schema.Number,
188 }),
189 ),
190 reason: Schema.optional(Schema.String),
191 exitCode: Schema.optional(Schema.Number),
192 }),
193 );
194 const decodeRecord = Schema.decodeUnknownEffect(recordSchema);
195 type Record = typeof recordSchema.Type;
196 const persisted: Record[] = [];
197 let milestone:
198 | {
199 readonly matches: (record: Record) => boolean;
200 readonly written: Deferred.Deferred<Record>;
201 }
202 | undefined;
203 const layerFile = Layer.succeed(FileSystem.FileSystem, {
204 ...fileSystem,
205 writeFile: (filePath, bytes, options) =>
206 fileSystem.writeFile(filePath, bytes, options).pipe(
207 Effect.tap(() =>
208 decodeRecord(new TextDecoder().decode(bytes).trim()).pipe(
209 Effect.orDie,
210 Effect.flatMap((record) =>
211 Effect.sync(() => {
212 persisted.push(record);
213 if (milestone?.matches(record)) {
214 Deferred.doneUnsafe(milestone.written, Effect.succeed(record));
215 }
216 }),
217 ),
218 ),
219 ),
220 ),
221 });
222 const layer = DesktopRendererHistory.layer.pipe(
223 Layer.provide(
224 Layer.mergeAll(
225 Layer.succeed(
226 DesktopEnvironment.DesktopEnvironment,
227 DesktopEnvironment.DesktopEnvironment.of({
228 logDir: directory,
229 } as DesktopEnvironment.DesktopEnvironment["Service"]),
230 ),
231 layerFile,
232 ),
233 ),
234 );
235
236 yield* Effect.gen(function* () {
237 const history = yield* DesktopRendererHistory.DesktopRendererHistory;
238 yield* history.register(main as unknown as Electron.WebContents, { surface: "main" });
239 yield* history.register(preview as unknown as Electron.WebContents, {
240 surface: "preview",
241 });
242 yield* history.register(preview as unknown as Electron.WebContents, {
243 surface: "preview",
244 tabId: "preview-tab",
245 });
246 const sampled = yield* Deferred.make<Record>();
247 milestone = {
248 matches: (row) => row.event === "sample" && row.webContentsId === 2,
249 written: sampled,
250 };
251 yield* TestClock.adjust(Duration.seconds(30));
252 yield* history.recordMetrics(metrics);
253 const sample = yield* Deferred.await(sampled);
254 assert.equal(sample.rendererPid, 7_002);
255 assert.equal(sample.rendererCreationTimeMs, 700_200);
256 assert.equal(sample.tabId, "preview-tab");
257 assert.equal(sample.mainPid, process.pid);
258 assert.equal(sample.memory?.kind, "electron-process-working-set");
259 assert.equal(sample.memory?.workingSetBytes, 2_048 * 1_024);
260 assert.equal(sample.memory?.peakWorkingSetBytes, 4_096 * 1_024);
261 assert.equal(sample.memory?.sampledAtUnixMs, sample.timestampUnixMs);
262 assert.isTrue(
263 persisted.some(
264 (row) =>
265 row.event === "created" && row.surface === "main" && row.rendererPid === 7_001,
266 ),
267 );
268 assert.isTrue(
269 persisted.some((row) => row.event === "identified" && row.tabId === "preview-tab"),
270 );
271
272 const replaced = yield* Deferred.make<Record>();
273 milestone = { matches: (row) => row.event === "dom-ready", written: replaced };
274 previewPid = 7_003;
275 preview.emit("dom-ready");
276 const replacement = yield* Deferred.await(replaced);
277 assert.equal(replacement.rendererPid, 7_003);
278 assert.isNull(replacement.rendererCreationTimeMs);
279 assert.isNull(replacement.memory);
280 metrics[1] = { ...metrics[1]!, pid: 7_003, creationTime: 700_300 };
281 const replacementSampled = yield* Deferred.make<Record>();
282 milestone = {
283 matches: (row) => row.event === "sample" && row.webContentsId === 2,
284 written: replacementSampled,
285 };
286 yield* TestClock.adjust(Duration.seconds(30));
287 yield* history.recordMetrics(metrics);
288 assert.equal((yield* Deferred.await(replacementSampled)).rendererCreationTimeMs, 700_300);
289
290 const crashed = yield* Deferred.make<Record>();
291 milestone = { matches: (row) => row.event === "render-process-gone", written: crashed };
292 previewPid = 0;
293 preview.emit("render-process-gone", {}, { reason: "oom", exitCode: -7 });
294 const crash = yield* Deferred.await(crashed);
295 assert.equal(crash.rendererPid, 7_003);
296 assert.equal(crash.rendererPidSource, "last-known");
297 assert.equal(crash.reason, "oom");
298 assert.equal(crash.exitCode, -7);
299 const restarted = yield* Deferred.make<Record>();
300 milestone = { matches: (row) => row.event === "dom-ready", written: restarted };
301 previewPid = 7_003;
302 preview.emit("dom-ready");
303 const restart = yield* Deferred.await(restarted);
304 assert.equal(restart.rendererPid, 7_003);
305 assert.equal(restart.rendererPidSource, "current");
306 assert.isNull(restart.rendererCreationTimeMs);
307 assert.isNull(restart.memory);
308 const destroyed = yield* Deferred.make<Record>();
309 milestone = { matches: (row) => row.event === "destroyed", written: destroyed };
310 previewDestroyed = true;
311 preview.emit("destroyed");
312 const destruction = yield* Deferred.await(destroyed);
313 assert.equal(destruction.rendererPid, 7_003);
314 assert.isNull(destruction.rendererCreationTimeMs);
315 assert.equal(destruction.tabId, "preview-tab");
316 assert.equal(preview.eventNames().length, 0);
317 const afterDestroy = yield* Deferred.make<Record>();
318 milestone = { matches: (row) => row.event === "sample", written: afterDestroy };
319 const previousCount = persisted.length;
320 yield* TestClock.adjust(Duration.seconds(30));
321 yield* history.recordMetrics(metrics);
322 assert.equal((yield* Deferred.await(afterDestroy)).webContentsId, 1);
323 assert.isFalse(persisted.slice(previousCount).some((row) => row.webContentsId === 2));
324 for (let index = 0; index < 12; index++) main.emit("dom-ready");
325 yield* history.shutdown;
326 assert.equal(
327 persisted.filter((row) => row.webContentsId === 1 && row.event === "dom-ready").length,
328 12,
329 );
330 const afterShutdown = persisted.length;
331 yield* history.register(main as unknown as Electron.WebContents, { surface: "main" });
332 yield* history.recordMetrics(metrics);
333 assert.equal(persisted.length, afterShutdown);
334 assert.equal(main.eventNames().length, 0);
335 yield* history.shutdown;
336 }).pipe(Effect.provide(layer));
337
338 assert.equal(main.eventNames().length, 0);
339 assert.equal(
340 persisted.filter((row) => row.webContentsId === 1 && row.event === "dom-ready").length,
341 12,
342 );
343 assert.equal(urlReads, 0);
344 const contents = yield* fileSystem.readFileString(`${directory}/renderer-history.ndjson`);
345 assert.isFalse(contents.includes("private.invalid"));
346 assert.isFalse(contents.includes("secret"));
347 }).pipe(Effect.provide(NodeServices.layer)),
348 );
349
350 it.effect("rotates retained incident history within three 256 kib files", () =>
351 Effect.gen(function* () {
352 const fileSystem = yield* FileSystem.FileSystem;
353 const directory = yield* fileSystem.makeTempDirectoryScoped({
354 prefix: "t3-renderer-rotation-",
355 });
356 const filePath = `${directory}/renderer-history.ndjson`;
357 const maxBytes = 256 * 1_024;
358 const encodeSeed = Schema.encodeEffect(
359 Schema.fromJsonString(Schema.Struct({ seed: Schema.String })),
360 );
361 for (const [suffix, seed] of [
362 ["", "current"],
363 [".1", "previous"],
364 [".2", "expired"],
365 [".3", "overflow"],
366 ] as const) {
367 const encodedSeed = yield* encodeSeed({ seed });
368 yield* fileSystem.writeFileString(
369 `${filePath}${suffix}`,
370 `${encodedSeed.padEnd(maxBytes - 1, " ")}\n`,
371 );
372 }
373 const written = yield* Deferred.make<void>();
374 const layerFile = Layer.succeed(FileSystem.FileSystem, {
375 ...fileSystem,
376 writeFile: (target, bytes, options) =>
377 fileSystem
378 .writeFile(target, bytes, options)
379 .pipe(Effect.tap(() => Deferred.succeed(written, undefined))),
380 });
381 const layer = DesktopRendererHistory.layer.pipe(
382 Layer.provide(
383 Layer.mergeAll(
384 Layer.succeed(
385 DesktopEnvironment.DesktopEnvironment,
386 DesktopEnvironment.DesktopEnvironment.of({
387 logDir: directory,
388 } as DesktopEnvironment.DesktopEnvironment["Service"]),
389 ),
390 layerFile,
391 ),
392 ),
393 );
394 const renderer = Object.assign(new NodeEvents.EventEmitter(), {
395 id: 7,
396 getOSProcessId: () => 9_001,
397 isDestroyed: () => false,
398 });
399 yield* Effect.gen(function* () {
400 const history = yield* DesktopRendererHistory.DesktopRendererHistory;
401 yield* history.register(renderer as unknown as Electron.WebContents, {
402 surface: "preview",
403 tabId: "t".repeat(1_000),
404 });
405 yield* Deferred.await(written);
406 }).pipe(Effect.provide(layer));
407 assert.deepEqual((yield* fileSystem.readDirectory(directory)).sort(), [
408 "renderer-history.ndjson",
409 "renderer-history.ndjson.1",
410 "renderer-history.ndjson.2",
411 ]);
412 let totalBytes = 0;
413 for (const suffix of ["", ".1", ".2"]) {
414 const size = Number((yield* fileSystem.stat(`${filePath}${suffix}`)).size);
415 assert.isAtMost(size, maxBytes);
416 totalBytes += size;
417 }
418 assert.isAtMost(totalBytes, 3 * maxBytes);
419 assert.include(yield* fileSystem.readFileString(`${filePath}.1`), '"seed":"current"');
420 assert.include(yield* fileSystem.readFileString(`${filePath}.2`), '"seed":"previous"');
421 const current = yield* fileSystem.readFileString(filePath);
422 assert.include(current, `"tabId":"${"t".repeat(128)}"`);
423 assert.notInclude(current, "t".repeat(129));
424 }).pipe(Effect.provide(NodeServices.layer)),
425 );
426 });