The best way to control Claude Code, Codex and more from any computer or phone
fix(server): WSL servers avoid ports already used by Windows (#22962)
Co-authored-by: maria-rcks <maria@kuuro.net>
Tyler Jennings committed
Nov 3, 2026 at 18:06 UTC
ef99d3f26ffbbe5561a17294163eb1f5073919e4
7 files changed
+355
-76
apps/server/src/cli/automaticPort.test.ts
new
+165
@@ -0,0 +1,165 @@
1
+import { describe, expect, it } from "@effect/vitest";
2
+import * as NetService from "@t3tools/shared/Net";
3
+import * as Effect from "effect/Effect";
4
+import * as CliError from "effect/cli/CliError";
5
+import * as FileSystem from "effect/FileSystem";
6
+import * as Layer from "effect/Layer";
7
+import * as PlatformError from "effect/PlatformError";
8
+import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
9
+
10
+import * as ProcessRunner from "../processRunner.ts";
11
+import * as AutomaticPort from "./automaticPort.ts";
12
+
13
+const WSL_KERNEL = "6.6.87.2-microsoft-standard-WSL2\n";
14
+const NETSTAT_PATH = "/windows/c/Windows/System32/netstat.exe";
15
+
16
+const output = (stdout: string, code: number | null = null): ProcessRunner.ProcessRunOutput => ({
17
+ stdout,
18
+ stderr: "",
19
+ code: code === null ? null : ChildProcessSpawner.ExitCode(code),
20
+ timedOut: false,
21
+ stdoutTruncated: false,
22
+ stderrTruncated: false,
23
+ stdoutInvalidUtf8: false,
24
+ stderrInvalidUtf8: false,
25
+});
26
+
27
+const listening = (ports: ReadonlyArray<number>, host = "127.0.0.1", foreign = "0.0.0.0:0") =>
28
+ ports.map((port) => ` TCP ${host}:${port} ${foreign} ABHÖREN 4242`).join("\r\n");
29
+
30
+interface Scenario {
31
+ readonly kernelRelease?: string;
32
+ readonly windowsPorts?: ReadonlyArray<number>;
33
+ readonly windowsPortsV6?: ReadonlyArray<number>;
34
+ readonly tcpv6ExitCode?: number;
35
+ readonly wslpathMissing?: boolean;
36
+ readonly reservedPorts?: ReadonlyArray<number>;
37
+}
38
+
39
+const select = (scenario: Scenario) => {
40
+ const commands: string[] = [];
41
+ const reserved = [...(scenario.reservedPorts ?? [50_001])];
42
+ const net: NetService.NetServiceShape = {
43
+ canListenOnHost: () => Effect.succeed(true),
44
+ hasListenerOnHost: () => Effect.succeed(false),
45
+ isPortAvailableOnLoopback: () => Effect.succeed(true),
46
+ reserveLoopbackPort: () => Effect.sync(() => reserved.shift() ?? 60_000),
47
+ findAvailablePort: Effect.succeed,
48
+ };
49
+ const run: ProcessRunner.ProcessRunner["Service"]["run"] = (input) => {
50
+ commands.push(input.command);
51
+ if (input.command === "wslpath") {
52
+ if (scenario.wslpathMissing) {
53
+ return Effect.fail(
54
+ new ProcessRunner.ProcessSpawnError({
55
+ command: input.command,
56
+ argumentCount: input.args.length,
57
+ cause: PlatformError.systemError({
58
+ _tag: "NotFound",
59
+ module: "ChildProcess",
60
+ method: "spawn",
61
+ }),
62
+ }),
63
+ );
64
+ }
65
+ return Effect.succeed(output(`${NETSTAT_PATH}\n`));
66
+ }
67
+ if (input.args.includes("tcpv6")) {
68
+ return Effect.succeed(
69
+ output(
70
+ listening(scenario.windowsPortsV6 ?? [], "[::1]", "[::]:0"),
71
+ scenario.tcpv6ExitCode ?? null,
72
+ ),
73
+ );
74
+ }
75
+ return Effect.succeed(output(listening(scenario.windowsPorts ?? [])));
76
+ };
77
+ const layer = Layer.mergeAll(
78
+ Layer.succeed(NetService.NetService, net),
79
+ Layer.succeed(ProcessRunner.ProcessRunner, { run }),
80
+ FileSystem.layerNoop({
81
+ readFileString: (path) =>
82
+ path === "/proc/sys/kernel/osrelease" && scenario.kernelRelease !== undefined
83
+ ? Effect.succeed(scenario.kernelRelease)
84
+ : Effect.fail(
85
+ PlatformError.systemError({
86
+ _tag: "NotFound",
87
+ module: "FileSystem",
88
+ method: "readFileString",
89
+ }),
90
+ ),
91
+ }),
92
+ );
93
+ return Effect.gen(function* () {
94
+ const selectAutomaticPort = yield* AutomaticPort.make;
95
+ const port = yield* selectAutomaticPort(3773);
96
+ return { port, commands };
97
+ }).pipe(Effect.provide(layer));
98
+};
99
+
100
+describe("automatic port selection", () => {
101
+ it.effect("moves off the default port only when Windows already listens on it", () =>
102
+ Effect.gen(function* () {
103
+ const free = yield* select({ kernelRelease: WSL_KERNEL, windowsPorts: [8080] });
104
+ expect(free.port).toBe(3773);
105
+ expect(free.commands).toEqual(["wslpath", NETSTAT_PATH, NETSTAT_PATH]);
106
+
107
+ const owned = yield* select({ kernelRelease: WSL_KERNEL, windowsPorts: [3773] });
108
+ expect(owned.port).toBe(50_001);
109
+ }),
110
+ );
111
+
112
+ it.effect("retries a fallback port that Windows already listens on", () =>
113
+ Effect.gen(function* () {
114
+ const result = yield* select({
115
+ kernelRelease: WSL_KERNEL,
116
+ windowsPorts: [3773],
117
+ windowsPortsV6: [50_001],
118
+ reservedPorts: [50_001, 50_002],
119
+ });
120
+ expect(result.port).toBe(50_002);
121
+ }),
122
+ );
123
+
124
+ it.effect("fails with an actionable error when every fallback belongs to Windows", () =>
125
+ Effect.gen(function* () {
126
+ const ports = Array.from({ length: 8 }, (_, index) => 50_001 + index);
127
+ const error = yield* select({
128
+ kernelRelease: WSL_KERNEL,
129
+ windowsPorts: [3773],
130
+ windowsPortsV6: ports,
131
+ reservedPorts: ports,
132
+ }).pipe(Effect.flip);
133
+ expect(error).toBeInstanceOf(CliError.UserError);
134
+ expect(error.cause).toContain("--port");
135
+ }),
136
+ );
137
+
138
+ it.effect("keeps the local choice when the Windows snapshot is unavailable", () =>
139
+ Effect.gen(function* () {
140
+ const partial = yield* select({
141
+ kernelRelease: WSL_KERNEL,
142
+ windowsPorts: [3773],
143
+ tcpv6ExitCode: 1,
144
+ });
145
+ expect(partial.port).toBe(3773);
146
+
147
+ const noInterop = yield* select({ kernelRelease: WSL_KERNEL, wslpathMissing: true });
148
+ expect(noInterop.port).toBe(3773);
149
+ }),
150
+ );
151
+
152
+ it.effect("never queries Windows outside WSL", () =>
153
+ Effect.gen(function* () {
154
+ for (const scenario of [
155
+ { kernelRelease: "6.8.0-45-generic\n" },
156
+ // macOS and Windows have no kernel release file.
157
+ {},
158
+ ] satisfies ReadonlyArray<Scenario>) {
159
+ const result = yield* select(scenario);
160
+ expect(result.port).toBe(3773);
161
+ expect(result.commands).toEqual([]);
162
+ }
163
+ }),
164
+ );
165
+});
apps/server/src/cli/automaticPort.ts
new
+69
@@ -0,0 +1,69 @@
1
+import * as NetService from "@t3tools/shared/Net";
2
+import * as Duration from "effect/Duration";
3
+import * as Effect from "effect/Effect";
4
+import * as FileSystem from "effect/FileSystem";
5
+import * as CliError from "effect/cli/CliError";
6
+
7
+import { queryWindowsTcpListeners } from "../process/windowsTcpListeners.ts";
8
+import * as ProcessRunner from "../processRunner.ts";
9
+
10
+const KERNEL_RELEASE_PATH = "/proc/sys/kernel/osrelease";
11
+const WINDOWS_NETSTAT_PATH = String.raw`C:\Windows\System32\netstat.exe`;
12
+const FALLBACK_ATTEMPTS = 8;
13
+
14
+/**
15
+ * Picks the startup port when none was configured. Under WSL's default NAT networking, Windows
16
+ * reaches the server through localhost forwarding, which fails for a port a Windows process
17
+ * already listens on even though WSL can bind it.
18
+ */
19
+export const make = Effect.gen(function* () {
20
+ const net = yield* NetService.NetService;
21
+ const fs = yield* FileSystem.FileSystem;
22
+ const processRunner = yield* ProcessRunner.ProcessRunner;
23
+
24
+ // Services started by systemd lack WSL_DISTRO_NAME and WSL_INTEROP; the kernel release does not.
25
+ // Hosts without this file (macOS, Windows) are not WSL.
26
+ const isWsl = fs.readFileString(KERNEL_RELEASE_PATH).pipe(
27
+ Effect.map((release) => release.toLowerCase().includes("microsoft")),
28
+ Effect.orElseSucceed(() => false),
29
+ );
30
+
31
+ const readWindowsHostListeners = Effect.gen(function* () {
32
+ // The automount root is configurable, so `/mnt/c` is not guaranteed.
33
+ const netstat = yield* processRunner.run({
34
+ command: "wslpath",
35
+ args: ["-u", WINDOWS_NETSTAT_PATH],
36
+ timeout: Duration.seconds(5),
37
+ });
38
+ const netstatPath = netstat.stdout.trim();
39
+ if ((netstat.code !== null && netstat.code !== 0) || netstatPath.length === 0) {
40
+ return null;
41
+ }
42
+ const listeners = yield* queryWindowsTcpListeners(processRunner, netstatPath);
43
+ if (listeners === null) return null;
44
+ return new Set(listeners.map((listener) => listener.port));
45
+ }).pipe(Effect.orElseSucceed(() => null));
46
+
47
+ return Effect.fn("automaticPort.select")(function* (preferred: number) {
48
+ if (!(yield* isWsl)) return yield* net.findAvailablePort(preferred);
49
+ const windows = yield* readWindowsHostListeners;
50
+ if (windows === null) {
51
+ yield* Effect.logWarning(
52
+ "Could not list Windows TCP listeners from WSL; Windows may be unable to reach the selected port. Pass --port to choose one.",
53
+ );
54
+ return yield* net.findAvailablePort(preferred);
55
+ }
56
+ if (!windows.has(preferred) && (yield* net.isPortAvailableOnLoopback(preferred))) {
57
+ return preferred;
58
+ }
59
+ // Linux and Windows ephemeral ranges overlap, so fallback ports can collide too.
60
+ for (let attempt = 0; attempt < FALLBACK_ATTEMPTS; attempt += 1) {
61
+ const port = yield* net.reserveLoopbackPort();
62
+ if (!windows.has(port)) return port;
63
+ }
64
+ return yield* new CliError.UserError({
65
+ cause:
66
+ "Windows is already using every port T3 Code tried. Pass --port or set T3CODE_PORT to a port Windows is not using.",
67
+ });
68
+ });
69
+});
apps/server/src/cli/config.test.ts
+37
@@ -754,6 +754,43 @@ it.layer(NodeServices.layer)("cli config resolution", (it) => {
754
lan: Option.none<boolean>(),
755
});
756
757
+ it.effect("uses the automatic port selector only when no port is configured", () =>
758
+ Effect.gen(function* () {
759
+ const baseDir = yield* FileSystem.FileSystem.pipe(
760
+ Effect.flatMap((fs) => fs.makeTempDirectoryScoped({ prefix: "t3-cli-auto-port-" })),
761
+ );
762
+ const selected: number[] = [];
763
+ const selectAutomaticPort = (preferred: number) =>
764
+ Effect.sync(() => {
765
+ selected.push(preferred);
766
+ return 50_123;
767
+ });
768
+ const resolvePort = (flags: {
769
+ readonly mode?: Option.Option<"web" | "desktop">;
770
+ readonly port: Option.Option<number>;
771
+ }) =>
772
+ resolveServerConfig({ ...minimalWebFlags(baseDir), ...flags }, Option.none(), {
773
+ selectAutomaticPort,
774
+ }).pipe(
775
+ Effect.map((config) => config.port),
776
+ Effect.provide(
777
+ Layer.merge(
778
+ NetService.layer,
779
+ ConfigProvider.layer(ConfigProvider.fromEnv({ env: {} })),
780
+ ),
781
+ ),
782
+ );
783
+
784
+ expect(yield* resolvePort({ port: Option.none() })).toBe(50_123);
785
+ expect(selected).toEqual([3773]);
786
+ expect(yield* resolvePort({ port: Option.some(8788) })).toBe(8788);
787
+ expect(
788
+ yield* resolvePort({ mode: Option.some("desktop" as const), port: Option.none() }),
789
+ ).toBe(3773);
790
+ expect(selected).toEqual([3773]);
791
+ }),
792
+ );
793
+
794
it.effect(
795
"resolves each signal's endpoint through T3CODE_OTLP_*_URL, an OTEL endpoint, the bootstrap envelope, and persisted Settings, in that order",
796
() =>
apps/server/src/cli/config.ts
+5
-1
@@ -267,9 +267,13 @@ export const resolveServerConfig = Effect.fn("config.resolveServerConfig")(funct
267
readonly startupPresentation?: ServerConfig.StartupPresentation;
268
readonly forceAutoBootstrapProjectFromCwd?: boolean;
269
readonly rejectRunningServer?: boolean;
270
+ readonly selectAutomaticPort?: (
271
+ preferred: number,
272
+ ) => Effect.Effect<number, NetService.NetError | CliError.UserError>;
273
},
274
) {
275
const { findAvailablePort } = yield* NetService.NetService;
276
+ const selectAutomaticPort = options?.selectAutomaticPort ?? findAvailablePort;
277
const path = yield* Path.Path;
278
const fs = yield* FileSystem.FileSystem;
279
const env = yield* EnvServerConfig;
@@ -316,7 +320,7 @@ export const resolveServerConfig = Effect.fn("config.resolveServerConfig")(funct
320
if (mode === "desktop") {
321
return Effect.succeed(ServerConfig.DEFAULT_PORT);
322
}
319
- return findAvailablePort(ServerConfig.DEFAULT_PORT);
323
+ return selectAutomaticPort(ServerConfig.DEFAULT_PORT);
324
},
325
},
326
);
apps/server/src/cli/server.ts
+4
-1
@@ -8,6 +8,8 @@ import * as CliError from "effect/cli/CliError";
8
9
import * as ServerConfig from "../config.ts";
10
import { awaitLauncherLoss } from "../launcherWatch.ts";
11
+import * as ProcessRunner from "../processRunner.ts";
12
+import * as AutomaticPort from "./automaticPort.ts";
13
import { type CliServerFlags, resolveServerConfig, sharedServerCommandFlags } from "./config.ts";
14
15
const encodeCommand = Schema.encodeEffect(Schema.fromJsonString(Schema.String));
@@ -30,7 +32,8 @@ const runServerCommand = Effect.fn("server.runServerCommand")(function* (
32
// Before config resolution, which claims a port and creates directories.
33
const { runServer } = yield* Effect.promise(() => import("../server.ts"));
34
const logLevel = yield* GlobalFlag.LogLevel;
33
- const config = yield* resolveServerConfig(flags, logLevel, options);
35
+ const selectAutomaticPort = yield* AutomaticPort.make.pipe(Effect.provide(ProcessRunner.layer));
36
+ const config = yield* resolveServerConfig(flags, logLevel, { ...options, selectAutomaticPort });
37
const run = runServer.pipe(Effect.provideService(ServerConfig.ServerConfig, config));
38
if (config.mode !== "desktop" || config.desktopBootstrapToken === undefined) return yield* run;
39
yield* Effect.sync(() => {
apps/server/src/preview/PortScanner.ts
+14
-74
@@ -24,6 +24,7 @@ import * as Scope from "effect/Scope";
24
import * as Semaphore from "effect/Semaphore";
25
import { FetchHttpClient, HttpClient } from "effect/http";
26
27
+import * as WindowsTcpListeners from "../process/windowsTcpListeners.ts";
28
import * as ProcessRunner from "../processRunner.ts";
29
30
export class PortDiscovery extends Context.Service<
@@ -76,8 +77,6 @@ const LSOF_TIMEOUT_MS = 5_000;
77
const PROC_FD_WALK_LIMIT = 50_000;
78
const SOCKET_OWNER_ATTEMPTS = 3;
79
const WINDOWS_LISTENER_TIMEOUT_MS = 5_000;
79
-/** `netstat -ano` lists every connection, not just listeners; ~80 bytes per row, sized for ~200k rows. */
80
-const WINDOWS_NETSTAT_MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
80
const WEB_PROBE_TIMEOUT = Duration.seconds(1);
81
const WEB_PROBE_CACHE_TTL_MS = Duration.toMillis(Duration.seconds(15));
82
/** Bounds how long a cached Windows image name can outlive its process if Windows reuses the PID. */
@@ -272,53 +271,6 @@ const parsePortFromLsofName = (name: string): number | null => {
271
return port;
272
};
273
275
-const parseWindowsListenerLine = (
276
- line: string,
277
-): {
278
- readonly host: string;
279
- readonly port: number;
280
- readonly pid: number | null;
281
- readonly processName: string | null;
282
-} | null => {
283
- const trimmed = line.trim();
284
- if (trimmed.length === 0) return null;
285
-
286
- if (trimmed.includes("|")) {
287
- const [hostRaw, portRaw, pidRaw, processNameRaw] = trimmed.split("|", 4);
288
- const host = hostRaw?.trim() ?? "";
289
- if (!LSOF_LOCAL_HOST_TOKENS.has(host) && host !== "::") return null;
290
- const port = Number(portRaw);
291
- const pid = Number(pidRaw);
292
- if (!Number.isInteger(port) || port <= 0 || port >= 65536) return null;
293
- return {
294
- host,
295
- port,
296
- pid: Number.isInteger(pid) && pid > 0 ? pid : null,
297
- processName: processNameRaw?.trim() || null,
298
- };
299
- }
300
-
301
- // Foreign port `:0` identifies a listening TCP socket regardless of Windows locale.
302
- const fields = trimmed.split(/\s+/);
303
- if (fields.length < 4 || fields[0]?.toUpperCase() !== "TCP") return null;
304
- const localEndpoint = fields[1] ?? "";
305
- const foreignEndpoint = fields[2] ?? "";
306
- if (!foreignEndpoint.endsWith(":0")) return null;
307
- const lastColon = localEndpoint.lastIndexOf(":");
308
- if (lastColon <= 0) return null;
309
- const host = localEndpoint.slice(0, lastColon);
310
- if (!LSOF_LOCAL_HOST_TOKENS.has(host) && host !== "::") return null;
311
- const port = Number(localEndpoint.slice(lastColon + 1));
312
- if (!Number.isInteger(port) || port <= 0 || port >= 65536) return null;
313
- const pid = Number(fields.at(-1));
314
- return {
315
- host,
316
- port,
317
- pid: Number.isInteger(pid) && pid > 0 ? pid : null,
318
- processName: null,
319
- };
320
-};
321
-
274
const exitedWithError = (result: ProcessRunner.ProcessRunOutput): boolean =>
275
result.code !== null && result.code !== 0;
276
@@ -330,16 +282,13 @@ const parseTasklistProcessName = (raw: string, pid: number): string | null => {
282
return null;
283
};
284
333
-const parseWindowsListenerOutput = (
334
- raw: string,
335
- owners: ReadonlyMap<number, ServerOwner> = new Map(),
285
+const discoveredWindowsListeners = (
286
+ listeners: ReadonlyArray<WindowsTcpListeners.WindowsTcpListener>,
287
+ owners: ReadonlyMap<number, ServerOwner>,
288
): ReadonlyArray<DiscoveredLocalServer> => {
289
const seen = new Map<number, DiscoveredLocalServer>();
338
- for (const line of raw.split(/\r?\n/g)) {
339
- const parsed = parseWindowsListenerLine(line);
340
- if (!parsed) continue;
341
- const { port, pid: normalizedPid, processName } = parsed;
342
- const owner = normalizedPid === null ? undefined : owners.get(normalizedPid);
290
+ for (const { port, pid } of listeners) {
291
+ const owner = pid === null ? undefined : owners.get(pid);
292
const existing = seen.get(port);
293
if (existing) {
294
if (owner === undefined) seen.set(port, { ...existing, ...UNOWNED });
@@ -349,8 +298,8 @@ const parseWindowsListenerOutput = (
298
host: "localhost",
299
port,
300
url: `http://localhost:${port}`,
352
- processName,
353
- pid: normalizedPid,
301
+ processName: null,
302
+ pid,
303
...(owner ?? UNOWNED),
304
});
305
}
@@ -857,21 +806,12 @@ export const make = Effect.gen(function* PortDiscoveryMake() {
806
agentsPossible ? withAgentOwners(terminalOwners, pids) : Effect.succeed(terminalOwners);
807
if (hostPlatform === "win32") {
808
const recoverWindowsProbeFailure = recoverProcessProbeFailure("windows-listeners");
860
- const runNetstat = (protocol: "tcp" | "tcpv6") =>
861
- processRunner.run({
862
- command: "netstat.exe",
863
- args: ["-ano", "-p", protocol],
864
- timeout: Duration.millis(WINDOWS_LISTENER_TIMEOUT_MS),
865
- maxOutputBytes: WINDOWS_NETSTAT_MAX_OUTPUT_BYTES,
866
- });
867
- const listeners = yield* Effect.all([runNetstat("tcp"), runNetstat("tcpv6")], {
868
- concurrency: 2,
869
- }).pipe(
870
- // Failed queries can hide other IPv4/IPv6 listeners on the port; fall back to configured URLs.
871
- Effect.map(([tcp4, tcp6]) =>
872
- exitedWithError(tcp4) || exitedWithError(tcp6)
873
- ? null
874
- : parseWindowsListenerOutput(`${tcp4.stdout}\n${tcp6.stdout}`, terminalOwners),
809
+ const listeners = yield* WindowsTcpListeners.queryWindowsTcpListeners(
810
+ processRunner,
811
+ "netstat.exe",
812
+ ).pipe(
813
+ Effect.map((snapshot) =>
814
+ snapshot === null ? null : discoveredWindowsListeners(snapshot, terminalOwners),
815
),
816
Effect.catchTags({
817
ProcessSpawnError: recoverWindowsProbeFailure,
apps/server/src/process/windowsTcpListeners.ts
new
+61
@@ -0,0 +1,61 @@
1
+import { LSOF_LOCAL_HOST_TOKENS } from "@t3tools/shared/preview";
2
+import * as Duration from "effect/Duration";
3
+import * as Effect from "effect/Effect";
4
+
5
+import type * as ProcessRunner from "../processRunner.ts";
6
+
7
+const NETSTAT_TIMEOUT = Duration.seconds(5);
8
+/** `netstat -ano` lists every connection, not just listeners; ~80 bytes per row, sized for ~200k rows. */
9
+const NETSTAT_MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
10
+
11
+export interface WindowsTcpListener {
12
+ readonly port: number;
13
+ readonly pid: number | null;
14
+}
15
+
16
+const parseWindowsTcpListenerLine = (line: string): WindowsTcpListener | null => {
17
+ // Foreign port `:0` identifies a listening TCP socket regardless of Windows locale.
18
+ const fields = line.trim().split(/\s+/);
19
+ if (fields.length < 4 || fields[0]?.toUpperCase() !== "TCP") return null;
20
+ const localEndpoint = fields[1] ?? "";
21
+ const foreignEndpoint = fields[2] ?? "";
22
+ if (!foreignEndpoint.endsWith(":0")) return null;
23
+ const lastColon = localEndpoint.lastIndexOf(":");
24
+ if (lastColon <= 0) return null;
25
+ const host = localEndpoint.slice(0, lastColon);
26
+ if (!LSOF_LOCAL_HOST_TOKENS.has(host) && host !== "::") return null;
27
+ const port = Number(localEndpoint.slice(lastColon + 1));
28
+ if (!Number.isInteger(port) || port <= 0 || port >= 65536) return null;
29
+ const pid = Number(fields.at(-1));
30
+ return { port, pid: Number.isInteger(pid) && pid > 0 ? pid : null };
31
+};
32
+
33
+const parseWindowsTcpListeners = (raw: string): ReadonlyArray<WindowsTcpListener> =>
34
+ raw.split(/\r?\n/g).flatMap((line) => {
35
+ const listener = parseWindowsTcpListenerLine(line);
36
+ return listener === null ? [] : [listener];
37
+ });
38
+
39
+const exitedWithError = (result: ProcessRunner.ProcessRunOutput): boolean =>
40
+ result.code !== null && result.code !== 0;
41
+
42
+/** Resolves to `null` when either query exits nonzero. */
43
+export const queryWindowsTcpListeners = Effect.fn("windowsTcpListeners.query")(function* (
44
+ processRunner: ProcessRunner.ProcessRunner["Service"],
45
+ netstatCommand: string,
46
+) {
47
+ const runNetstat = (protocol: "tcp" | "tcpv6") =>
48
+ processRunner.run({
49
+ command: netstatCommand,
50
+ args: ["-ano", "-p", protocol],
51
+ timeout: NETSTAT_TIMEOUT,
52
+ maxOutputBytes: NETSTAT_MAX_OUTPUT_BYTES,
53
+ });
54
+ const [tcp4, tcp6] = yield* Effect.all([runNetstat("tcp"), runNetstat("tcpv6")], {
55
+ concurrency: 2,
56
+ });
57
+ // One failed query leaves a partial snapshot that could hide another process sharing a
58
+ // port across IPv4/IPv6.
59
+ if (exitedWithError(tcp4) || exitedWithError(tcp6)) return null;
60
+ return parseWindowsTcpListeners(`${tcp4.stdout}\n${tcp6.stdout}`);
61
+});