Use Effect Schema for Windows process diagnostics

Cursor Agent committed 4 months ago

Commit f3da91a1 parent a9b11902 files · +151 −44Browse files

Unified · Split

2 files

apps/server/src/diagnostics/ProcessDiagnostics.test.ts +93 −1
apps/server/src/diagnostics/ProcessDiagnostics.ts +58 −43

apps/server/src/diagnostics/ProcessDiagnostics.test.ts+93−1

@@ -1,4 +1,4 @@
1	import { describe, expect, it } from "@effect/vitest";	1	import { assert, describe, expect, it } from "@effect/vitest";
2	import * as DateTime from "effect/DateTime";	2	import * as DateTime from "effect/DateTime";
3	import * as Effect from "effect/Effect";	3	import * as Effect from "effect/Effect";
4	import * as Layer from "effect/Layer";	4	import * as Layer from "effect/Layer";
@@ -67,6 +67,98 @@ describe("ProcessDiagnostics", () => { · 62 unmodified lines
67	}),	67	}),
68	);	68	);
69		69
		70	it.effect("parses Windows CIM JSON process rows", () =>
		71	Effect.sync(() => {
		72	const rows = ProcessDiagnostics.parseWindowsProcessRows(`[
		73	{
		74	"ProcessId": 10,
		75	"ParentProcessId": 1,
		76	"Name": "node.exe",
		77	"CommandLine": "node server.js",
		78	"Status": "Running",
		79	"WorkingSetSize": 4096,
		80	"PercentProcessorTime": 12.5
		81	},
		82	{
		83	"ProcessId": "invalid",
		84	"ParentProcessId": 10,
		85	"Name": "ignored.exe"
		86	},
		87	{
		88	"ProcessId": 11,
		89	"ParentProcessId": 10,
		90	"Name": "agent.exe",
		91	"CommandLine": null,
		92	"Status": null,
		93	"WorkingSetSize": -128,
		94	"PercentProcessorTime": -1
		95	}
		96	]`);
		97
		98	assert.deepStrictEqual(rows, [
		99	{
		100	pid: 10,
		101	ppid: 1,
		102	pgid: null,
		103	status: "Running",
		104	cpuPercent: 12.5,
		105	rssBytes: 4096,
		106	elapsed: "",
		107	command: "node server.js",
		108	},
		109	{
		110	pid: 11,
		111	ppid: 10,
		112	pgid: null,
		113	status: "Live",
		114	cpuPercent: 0,
		115	rssBytes: 0,
		116	elapsed: "",
		117	command: "agent.exe",
		118	},
		119	]);
		120	}),
		121	);
		122
		123	it.effect("parses single Windows CIM JSON process objects", () =>
		124	Effect.sync(() => {
		125	const rows = ProcessDiagnostics.parseWindowsProcessRows(`{
		126	"ProcessId": 42,
		127	"ParentProcessId": 10,
		128	"Name": "agent.exe",
		129	"CommandLine": "",
		130	"WorkingSetSize": 2048,
		131	"PercentProcessorTime": 5
		132	}`);
		133
		134	assert.deepStrictEqual(rows, [
		135	{
		136	pid: 42,
		137	ppid: 10,
		138	pgid: null,
		139	status: "Live",
		140	cpuPercent: 5,
		141	rssBytes: 2048,
		142	elapsed: "",
		143	command: "agent.exe",
		144	},
		145	]);
		146	}),
		147	);
		148
		149	it.effect("ignores malformed Windows CIM JSON output", () =>
		150	Effect.sync(() => {
		151	assert.deepStrictEqual(ProcessDiagnostics.parseWindowsProcessRows("{not json"), []);
		152	assert.deepStrictEqual(
		153	ProcessDiagnostics.parseWindowsProcessRows(`{
		154	"ProcessId": 42,
		155	"Name": "missing-parent.exe"
		156	}`),
		157	[],
		158	);
		159	}),
		160	);
		161
70	it.effect("aggregates only descendants of the server process", () =>	162	it.effect("aggregates only descendants of the server process", () =>
71	Effect.sync(() => {	163	Effect.sync(() => {
72	const diagnostics = ProcessDiagnostics.aggregateProcessDiagnostics({	164	const diagnostics = ProcessDiagnostics.aggregateProcessDiagnostics({

apps/server/src/diagnostics/ProcessDiagnostics.ts+58−43

   readonly command: string;
 }
-const PROCESS_QUERY_TIMEOUT_MS = 1_000;
+const PROCESS_QUERY_TIMEOUT = Duration.seconds(1);
 const POSIX_PROCESS_QUERY_COMMAND = "pid=,ppid=,pgid=,stat=,pcpu=,rss=,etime=,command=";
 const PROCESS_QUERY_MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
 type ProcessDiagnosticsError = typeof ProcessDiagnosticsError.Type;
 const isProcessDiagnosticsError = Schema.is(ProcessDiagnosticsError);
+const WindowsCimProcessRecord = Schema.Struct({
+  ProcessId: Schema.Number,
+  ParentProcessId: Schema.Number,
+  Name: Schema.optional(Schema.NullOr(Schema.String)),
+  CommandLine: Schema.optional(Schema.NullOr(Schema.String)),
+  Status: Schema.optional(Schema.NullOr(Schema.String)),
+  WorkingSetSize: Schema.optional(Schema.Number),
+  PercentProcessorTime: Schema.optional(Schema.Number),
+});
+type WindowsCimProcessRecord = typeof WindowsCimProcessRecord.Type;
+const decodeWindowsProcessJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Json));
+const decodeWindowsProcessRecord = Schema.decodeUnknownOption(WindowsCimProcessRecord);
 function parsePositiveInt(value: string): number | null {
   const parsed = Number.parseInt(value, 10);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
   return rows;
 }
-function normalizeWindowsProcessRow(value: unknown): ProcessRow | null {
+function nonEmptyStringOption(value: string | null | undefined): Option.Option<string> {
-  if (typeof value !== "object" || value === null) return null;
+  return typeof value === "string" && value.trim().length > 0 ? Option.some(value) : Option.none();
-  const record = value as Record<string, unknown>;
-  const pid = typeof record.ProcessId === "number" ? record.ProcessId : null;
-  const ppid = typeof record.ParentProcessId === "number" ? record.ParentProcessId : null;
-  const commandLine =
-    typeof record.CommandLine === "string" && record.CommandLine.trim().length > 0
-      ? record.CommandLine
-      : typeof record.Name === "string"
-        ? record.Name
-        : null;
-  const workingSet =
-    typeof record.WorkingSetSize === "number" && Number.isFinite(record.WorkingSetSize)
-      ? Math.max(0, Math.round(record.WorkingSetSize))
-      : 0;
-  const cpuPercent =
-    typeof record.PercentProcessorTime === "number" && Number.isFinite(record.PercentProcessorTime)
-      ? Math.max(0, record.PercentProcessorTime)
-      : 0;
-  if (!pid || pid <= 0 || ppid === null || ppid < 0 || !commandLine) return null;
-  return {
-    pid,
-    ppid,
-    pgid: null,
-    status: typeof record.Status === "string" && record.Status.length > 0 ? record.Status : "Live",
-    cpuPercent,
-    rssBytes: workingSet,
-    elapsed: "",
-    command: commandLine,
-  };
 }
-function parseWindowsProcessRows(output: string): ReadonlyArray<ProcessRow> {
+function normalizeWindowsProcessRow(value: unknown): Option.Option<ProcessRow> {
+  return Option.flatMap(decodeWindowsProcessRecord(value), (record: WindowsCimProcessRecord) => {
+    const pid = record.ProcessId;
+    const ppid = record.ParentProcessId;
+    if (!Number.isInteger(pid) || pid <= 0 || !Number.isInteger(ppid) || ppid < 0) {
+      return Option.none();
+    }
+    const commandLine = nonEmptyStringOption(record.CommandLine).pipe(
+      Option.orElse(() => nonEmptyStringOption(record.Name)),
+    );
+    return Option.map(commandLine, (command) => ({
+      pid,
+      ppid,
+      pgid: null,
+      status: Option.getOrElse(nonEmptyStringOption(record.Status), () => "Live"),
+      cpuPercent:
+        typeof record.PercentProcessorTime === "number" && Number.isFinite(record.PercentProcessorTime)
+          ? Math.max(0, record.PercentProcessorTime)
+          : 0,
+      rssBytes:
+        typeof record.WorkingSetSize === "number" && Number.isFinite(record.WorkingSetSize)
+          ? Math.max(0, Math.round(record.WorkingSetSize))
+          : 0,
+      elapsed: "",
+      command,
+    }));
+  });
+}
+export function parseWindowsProcessRows(output: string): ReadonlyArray<ProcessRow> {
   if (output.trim().length === 0) return [];
-  try {
+  const parsed = decodeWindowsProcessJson(output);
-    const parsed = JSON.parse(output) as unknown;
+  if (Option.isNone(parsed)) {
-    const records = Array.isArray(parsed) ? parsed : [parsed];
-    return records.flatMap((record) => {
-      const row = normalizeWindowsProcessRow(record);
-      return row ? [row] : [];
-    });
-  } catch {
     return [];
   }
+  const records = Array.isArray(parsed.value) ? parsed.value : [parsed.value];
+  return records.flatMap((record) =>
+    Option.match(normalizeWindowsProcessRow(record), {
+      onNone: () => [],
+      onSome: (row) => [row],
+    }),
+  );
 }
 export function buildDescendantEntries(
     } satisfies ProcessOutput;
   }).pipe(
     Effect.scoped,
-    Effect.timeoutOption(Duration.millis(PROCESS_QUERY_TIMEOUT_MS)),
+    Effect.timeoutOption(PROCESS_QUERY_TIMEOUT),
     Effect.flatMap((result) =>
       Option.match(result, {
         onNone: () =>
               command: input.command,
               argCount: input.args.length,
               cwd,
-              timeoutMillis: PROCESS_QUERY_TIMEOUT_MS,
+              timeoutMillis: Duration.toMillis(PROCESS_QUERY_TIMEOUT),
             }),
           ),
         onSome: Effect.succeed,