lael-labs/t3code

apps/server/src/diagnostics/ProcessDiagnostics.test.ts+76−27

-import { describe, expect, it } from "@effect/vitest";
+import { assert, describe, it } from "@effect/vitest";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
         ].join("\n"),
       );
-      expect(rows).toEqual([
+      assert.deepStrictEqual(rows, [
         {
           pid: 10,
           ppid: 1,
     }),
   );
+  it.effect("parses Windows process JSON through Effect Schema decoding", () =>
+    Effect.sync(() => {
+      const rows = ProcessDiagnostics.parseWindowsProcessRows(
+        [
+          "[",
+          '{"ProcessId":10,"ParentProcessId":1,"Name":"node.exe","CommandLine":"node server.js","Status":"Live","WorkingSetSize":1024,"PercentProcessorTime":1.5},',
+          '{"ProcessId":11,"ParentProcessId":10,"Name":"agent.exe","CommandLine":null,"Status":null,"WorkingSetSize":null,"PercentProcessorTime":null},',
+          '"not-a-process-row"',
+          "]",
+        ].join(""),
+      );
+      assert.deepStrictEqual(rows, [
+        {
+          pid: 10,
+          ppid: 1,
+          pgid: null,
+          status: "Live",
+          cpuPercent: 1.5,
+          rssBytes: 1024,
+          elapsed: "",
+          command: "node server.js",
+        },
+        {
+          pid: 11,
+          ppid: 10,
+          pgid: null,
+          status: "Live",
+          cpuPercent: 0,
+          rssBytes: 0,
+          elapsed: "",
+          command: "agent.exe",
+        },
+      ]);
+      assert.deepStrictEqual(ProcessDiagnostics.parseWindowsProcessRows("not-json"), []);
+    }),
+  );
   it.effect("aggregates only descendants of the server process", () =>
     Effect.sync(() => {
       const diagnostics = ProcessDiagnostics.aggregateProcessDiagnostics({
         ],
       });
-      expect(diagnostics.serverPid).toBe(100);
+      assert.equal(diagnostics.serverPid, 100);
-      expect(DateTime.formatIso(diagnostics.readAt)).toBe("2026-05-05T10:00:00.000Z");
+      assert.equal(DateTime.formatIso(diagnostics.readAt), "2026-05-05T10:00:00.000Z");
-      expect(diagnostics.processCount).toBe(2);
+      assert.equal(diagnostics.processCount, 2);
-      expect(diagnostics.totalRssBytes).toBe(6_000);
+      assert.equal(diagnostics.totalRssBytes, 6_000);
-      expect(diagnostics.totalCpuPercent).toBe(4.75);
+      assert.equal(diagnostics.totalCpuPercent, 4.75);
-      expect(diagnostics.processes.map((process) => process.pid)).toEqual([101, 102]);
+      assert.deepStrictEqual(
-      expect(diagnostics.processes.map((process) => process.depth)).toEqual([0, 1]);
+        diagnostics.processes.map((process) => process.pid),
-      expect(Option.getOrNull(diagnostics.processes[0]!.pgid)).toBe(100);
+        [101, 102],
-      expect(diagnostics.processes[0]?.childPids).toEqual([102]);
+      );
+      assert.deepStrictEqual(
+        diagnostics.processes.map((process) => process.depth),
+        [0, 1],
+      );
+      assert.equal(Option.getOrNull(diagnostics.processes[0]!.pgid), 100);
+      assert.deepStrictEqual(diagnostics.processes[0]?.childPids, [102]);
     }),
   );
         ],
       });
-      expect(diagnostics.processes.map((process) => process.pid)).toEqual([101, 102, 103]);
+      assert.deepStrictEqual(
+        diagnostics.processes.map((process) => process.pid),
+        [101, 102, 103],
+      );
     }),
   );
         Effect.provide(layer),
       );
-      expect(diagnostics.processes.map((process) => process.pid)).toEqual([4242]);
+      assert.deepStrictEqual(
-      expect(commands).toEqual([
+        diagnostics.processes.map((process) => process.pid),
+        [4242],
+      );
+      assert.deepStrictEqual(commands, [
         {
           command: "ps",
           args: ["-axo", "pid=,ppid=,pgid=,stat=,pcpu=,rss=,etime=,command="],
         Effect.flip,
       );
-      expect(error).toMatchObject({
+      assert.equal(error._tag, "ProcessDiagnosticsQueryFailedError");
-        _tag: "ProcessDiagnosticsQueryFailedError",
+      assert.equal(error.command, "ps");
-        command: "ps",
+      assert.equal(error.argCount, 2);
-        argCount: 2,
+      assert.equal(error.cwd, process.cwd());
-        cwd: process.cwd(),
+      assert.equal(error.exitCode, 17);
-        exitCode: 17,
+      assert.equal(error.stdoutBytes, 22);
-        stdoutBytes: 22,
+      assert.equal(error.stderrBytes, 21);
-        stderrBytes: 21,
+      assert.equal(error.stdoutTruncated, false);
-        stdoutTruncated: false,
+      assert.equal(error.stderrTruncated, false);
-        stderrTruncated: false,
+      assert.equal(
-      });
+        error.message,
-      expect(error.message).toBe(
         `Process diagnostics query 'ps' failed with exit code 17 in '${process.cwd()}'.`,
       );
     }),
         Effect.provide(layer),
       );
-      expect(result).toEqual({
+      assert.deepStrictEqual(result, {
         pid: 4242,
         signal: "SIGINT",
         signaled: false,

apps/server/src/diagnostics/ProcessDiagnostics.ts+23−13

 type ProcessDiagnosticsError = typeof ProcessDiagnosticsError.Type;
 const isProcessDiagnosticsError = Schema.is(ProcessDiagnosticsError);
+const WindowsProcessRecord = Schema.Struct({
+  ProcessId: Schema.optionalKey(Schema.NullOr(Schema.Number)),
+  ParentProcessId: Schema.optionalKey(Schema.NullOr(Schema.Number)),
+  CommandLine: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  Name: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  Status: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  WorkingSetSize: Schema.optionalKey(Schema.NullOr(Schema.Number)),
+  PercentProcessorTime: Schema.optionalKey(Schema.NullOr(Schema.Number)),
+});
+const decodeWindowsProcessJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString);
+const decodeWindowsProcessRecord = Schema.decodeUnknownOption(WindowsProcessRecord);
 function parsePositiveInt(value: string): number | null {
   const parsed = Number.parseInt(value, 10);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
 }
 function normalizeWindowsProcessRow(value: unknown): ProcessRow | null {
-  if (typeof value !== "object" || value === null) return null;
+  const recordOption = decodeWindowsProcessRecord(value);
-  const record = value as Record<string, unknown>;
+  if (Option.isNone(recordOption)) return null;
+  const record = recordOption.value;
   const pid = typeof record.ProcessId === "number" ? record.ProcessId : null;
   const ppid = typeof record.ParentProcessId === "number" ? record.ParentProcessId : null;
   const commandLine =
   };
 }
-function parseWindowsProcessRows(output: string): ReadonlyArray<ProcessRow> {
+export function parseWindowsProcessRows(output: string): ReadonlyArray<ProcessRow> {
   if (output.trim().length === 0) return [];
-  try {
+  const parsedOption = decodeWindowsProcessJson(output);
-    const parsed = JSON.parse(output) as unknown;
+  if (Option.isNone(parsedOption)) return [];
-    const records = Array.isArray(parsed) ? parsed : [parsed];
+  const records = Array.isArray(parsedOption.value) ? parsedOption.value : [parsedOption.value];
-    return records.flatMap((record) => {
+  return records.flatMap((record) => {
-      const row = normalizeWindowsProcessRow(record);
+    const row = normalizeWindowsProcessRow(record);
-      return row ? [row] : [];
+    return row ? [row] : [];
-    });
+  });
-  } catch {
-    return [];
-  }
 }
 export function buildDescendantEntries(

apps/server/src/diagnostics/TraceDiagnostics.test.ts+2−1

                 durationMs: 50,
               }),
               "not-json",
+              "42",
             ].join("\n"),
           },
           {
         }),
         "1970-01-01T00:00:05.025Z",
       );
-      assert.equal(diagnostics.parseErrorCount, 1);
+      assert.equal(diagnostics.parseErrorCount, 2);
       assert.equal(diagnostics.failureCount, 2);
       assert.equal(diagnostics.interruptionCount, 1);
       assert.equal(diagnostics.slowSpanCount, 1);

apps/server/src/diagnostics/TraceDiagnostics.ts+27−16

   readonly attributes?: unknown;
 }
+const TraceEventRecord = Schema.Struct({
+  name: Schema.optionalKey(Schema.Unknown),
+  timeUnixNano: Schema.optionalKey(Schema.Unknown),
+  attributes: Schema.optionalKey(Schema.Unknown),
+});
+const TraceRecord = Schema.Struct({
+  name: Schema.optionalKey(Schema.Unknown),
+  traceId: Schema.optionalKey(Schema.Unknown),
+  spanId: Schema.optionalKey(Schema.Unknown),
+  startTimeUnixNano: Schema.optionalKey(Schema.Unknown),
+  endTimeUnixNano: Schema.optionalKey(Schema.Unknown),
+  durationMs: Schema.optionalKey(Schema.Unknown),
+  exit: Schema.optionalKey(Schema.Unknown),
+  events: Schema.optionalKey(Schema.Unknown),
+});
+const decodeTraceRecordLine = Schema.decodeUnknownOption(Schema.fromJsonString(TraceRecord));
+const decodeTraceEventRecord = Schema.decodeUnknownOption(TraceEventRecord);
 export interface TraceDiagnosticsOptions {
   readonly traceFilePath: string;
   readonly maxFiles: number;
   return toStringValue(exit.cause)?.trim() ?? "Failure";
 }
-function isTraceEvent(value: unknown): value is TraceEventLike {
-  return typeof value === "object" && value !== null;
-}
 function readEventAttributes(event: TraceEventLike): Readonly<Record<string, unknown>> {
   return typeof event.attributes === "object" && event.attributes !== null
     ? (event.attributes as Readonly<Record<string, unknown>>)
     for (const line of lines) {
       if (line.trim().length === 0) continue;
-      let parsed: unknown;
+      const parsedOption = decodeTraceRecordLine(line);
-      try {
+      if (Option.isNone(parsedOption)) {
-        parsed = JSON.parse(line);
-      } catch {
         parseErrorCount += 1;
         continue;
       }
-      if (!isRecordObject(parsed)) {
+      const parsed = parsedOption.value;
-        parseErrorCount += 1;
-        continue;
-      }
       const name = toStringValue(parsed.name);
       const traceId = toStringValue(parsed.traceId);
       if (Array.isArray(parsed.events)) {
         for (const rawEvent of parsed.events) {
-          if (!isTraceEvent(rawEvent)) continue;
+          const eventOption = decodeTraceEventRecord(rawEvent);
-          const attributes = readEventAttributes(rawEvent);
+          if (Option.isNone(eventOption)) continue;
+          const event = eventOption.value;
+          const attributes = readEventAttributes(event);
           const level = toStringValue(attributes["effect.logLevel"]);
           if (!level) continue;
             continue;
           }
-          const seenAt = unixNanoToDateTime(rawEvent.timeUnixNano) ?? endedAt;
+          const seenAt = unixNanoToDateTime(event.timeUnixNano) ?? endedAt;
-          const message = toStringValue(rawEvent.name)?.trim() ?? "Log event";
+          const message = toStringValue(event.name)?.trim() ?? "Log event";
           latestWarningAndErrorLogs.push({
             spanName: name,
             level,