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
| 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 | }); |