@devries-cameron20 / t3code-1 / commits / ef99d3f26f
Fork 0

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