sshProcess.test.ts

import find from "find-process";
import { vol } from "memfs";
import * as fsPromises from "node:fs/promises";
import path from "node:path";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import {
	SshProcessMonitor,
	type SshProcessMonitorOptions,
} from "@/remote/sshProcess";

import { createMockLogger, MockStatusBar } from "../../mocks/testHelpers";

import type * as fs from "node:fs";

vi.mock("find-process", () => ({ default: vi.fn() }));

vi.mock("node:fs/promises", async () => {
	const memfs: { fs: typeof fs } = await vi.importActual("memfs");
	return memfs.fs.promises;
});

describe("SshProcessMonitor", () => {
	let activeMonitors: SshProcessMonitor[] = [];
	let statusBar: MockStatusBar;

	beforeEach(() => {
		vi.restoreAllMocks();
		vol.reset();
		activeMonitors = [];
		statusBar = new MockStatusBar();

		// Default: process found immediately
		vi.mocked(find).mockResolvedValue([
			{ pid: 999, ppid: 1, name: "ssh", cmd: "ssh host" },
		]);
	});

	afterEach(() => {
		vi.useRealTimers();
		for (const m of activeMonitors) {
			m.dispose();
		}
		activeMonitors = [];
		vol.reset();
	});

	describe("process discovery", () => {
		it("finds SSH process by port from Remote SSH logs", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
			});

			const monitor = createMonitor({ codeLogDir: "/logs/window1" });
			const pid = await waitForEvent(monitor.onPidChange);

			expect(find).toHaveBeenCalledWith("port", 12345);
			expect(pid).toBe(999);
		});

		it("retries until process is found", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
			});

			// First 2 calls return nothing, third call finds the process
			vi.mocked(find)
				.mockResolvedValueOnce([])
				.mockResolvedValueOnce([])
				.mockResolvedValueOnce([
					{ pid: 888, ppid: 1, name: "ssh", cmd: "ssh host" },
				]);

			const monitor = createMonitor({ codeLogDir: "/logs/window1" });
			const pid = await waitForEvent(monitor.onPidChange);

			expect(vi.mocked(find).mock.calls.length).toBeGreaterThanOrEqual(3);
			expect(pid).toBe(888);
		});

		it("retries when Remote SSH log appears later", async () => {
			// Start with no log file
			vol.fromJSON({});

			vi.mocked(find).mockResolvedValue([
				{ pid: 777, ppid: 1, name: "ssh", cmd: "ssh host" },
			]);

			const monitor = createMonitor({ codeLogDir: "/logs/window1" });

			// Add the log file after a delay
			setTimeout(() => {
				vol.fromJSON({
					"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
						"-> socksPort 55555 ->",
				});
			}, 50);

			const pid = await waitForEvent(monitor.onPidChange);

			expect(find).toHaveBeenCalledWith("port", 55555);
			expect(pid).toBe(777);
		});

		it("uses newest output_logging_ directory when multiple exist", async () => {
			// Reverse alphabetical order means highest number/newest first
			vol.fromJSON({
				"/logs/output_logging_20240101/1-Remote - SSH.log":
					"-> socksPort 11111 ->",
				"/logs/output_logging_20240102/1-Remote - SSH.log":
					"-> socksPort 22222 ->",
				"/logs/output_logging_20240103/1-Remote - SSH.log":
					"-> socksPort 33333 ->",
			});

			// Mock readdir to return directories in unsorted order (simulating Windows fs)
			mockReaddirOrder("/logs", [
				"output_logging_20240103",
				"output_logging_20240101",
				"output_logging_20240102",
				"window1",
			]);

			const monitor = createMonitor({ codeLogDir: "/logs/window1" });
			await waitForEvent(monitor.onPidChange);

			expect(find).toHaveBeenCalledWith("port", 33333);
		});

		it("sorts output_logging_ directories using localeCompare for consistent ordering", async () => {
			// localeCompare differs from default sort() for mixed case
			vol.fromJSON({
				"/logs/output_logging_a/1-Remote - SSH.log": "-> socksPort 11111 ->",
				"/logs/output_logging_Z/1-Remote - SSH.log": "-> socksPort 22222 ->",
			});

			mockReaddirOrder("/logs", [
				"output_logging_a",
				"output_logging_Z",
				"window1",
			]);

			const monitor = createMonitor({ codeLogDir: "/logs/window1" });
			await waitForEvent(monitor.onPidChange);

			// With localeCompare: ["a", "Z"] -> reversed -> "Z" first (port 22222)
			// With plain sort(): ["Z", "a"] -> reversed -> "a" first (port 11111)
			expect(find).toHaveBeenCalledWith("port", 22222);
		});

		it("falls back to output_logging_ when extension folder has no SSH log", async () => {
			// Extension folder exists but doesn't have Remote SSH log
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/some-other-log.log": "",
				"/logs/output_logging_20240101/1-Remote - SSH.log":
					"-> socksPort 55555 ->",
			});

			const monitor = createMonitor({ codeLogDir: "/logs/window1" });
			await waitForEvent(monitor.onPidChange);

			expect(find).toHaveBeenCalledWith("port", 55555);
		});

		it("reconnects when network info becomes stale", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/network/999.json": JSON.stringify({
					p2p: true,
					latency: 10,
					preferred_derp: "",
					derp_latency: {},
					upload_bytes_sec: 0,
					download_bytes_sec: 0,
					using_coder_connect: false,
				}),
			});

			// First search finds PID 999, after reconnect finds PID 888
			vi.mocked(find)
				.mockResolvedValueOnce([{ pid: 999, ppid: 1, name: "ssh", cmd: "ssh" }])
				.mockResolvedValue([{ pid: 888, ppid: 1, name: "ssh", cmd: "ssh" }]);

			const monitor = createMonitor({
				codeLogDir: "/logs/window1",
				networkInfoPath: "/network",
				networkPollInterval: 10,
			});

			// Initial PID
			const firstPid = await waitForEvent(monitor.onPidChange);
			expect(firstPid).toBe(999);

			// Network info will become stale after 50ms (5 * networkPollInterval)
			// Monitor keeps showing last status, only fires when PID actually changes
			const pids: Array<number | undefined> = [];
			monitor.onPidChange((pid) => pids.push(pid));

			// Wait for reconnection to find new PID
			await waitFor(() => pids.includes(888), 200);

			// Should NOT fire undefined - we keep showing last status while searching
			expect(pids).toContain(888);
		});

		it("resets backoff when port changes in log file", async () => {
			vi.useFakeTimers();

			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 11111 ->",
			});
			vi.mocked(find).mockResolvedValue([]);

			const pollInterval = 100;
			const logger = createMockLogger();
			const monitor = createMonitor({
				codeLogDir: "/logs/window1",
				discoveryPollIntervalMs: pollInterval,
				maxDiscoveryBackoffMs: 10_000,
				logger,
			});

			const pids: Array<number | undefined> = [];
			monitor.onPidChange((pid) => pids.push(pid));

			// Backoff doubles each iteration: 100, 200, 400, 800, 1600, ...
			// Total after 5 iterations = pollInterval * (2^5 - 1) = 3100ms
			const fiveIterationsMs = pollInterval * (2 ** 5 - 1);
			await vi.advanceTimersByTimeAsync(fiveIterationsMs - 1);
			expect(logger.debug).toHaveBeenCalledWith(
				"No process found listening on port 11111",
			);

			// Change port, simulates VS Code reconnection after sleep/wake
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 22222 ->",
			});

			// Trigger next iteration: detects port change, resets backoff, no pid
			await vi.advanceTimersByTimeAsync(1);
			expect(logger.debug).toHaveBeenCalledWith(
				"SSH port changed in log file: 11111 -> 22222",
			);

			// Process becomes available
			vi.mocked(find).mockResolvedValue([
				{ pid: 555, ppid: 1, name: "ssh", cmd: "ssh" },
			]);

			// With reset backoff, process found within 2 poll intervals.
			// Without reset, backoff would be pollInterval * 2^5 = 3200ms.
			await vi.advanceTimersByTimeAsync(pollInterval * 2);
			expect(pids).toContain(555);
		});

		it("does not fire event when same process is found after stale check", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/network/999.json": JSON.stringify({
					p2p: true,
					latency: 10,
					preferred_derp: "",
					derp_latency: {},
					upload_bytes_sec: 0,
					download_bytes_sec: 0,
					using_coder_connect: false,
				}),
			});

			// Always returns the same PID
			vi.mocked(find).mockResolvedValue([
				{ pid: 999, ppid: 1, name: "ssh", cmd: "ssh" },
			]);

			const monitor = createMonitor({
				codeLogDir: "/logs/window1",
				networkInfoPath: "/network",
				networkPollInterval: 10,
			});

			// Wait for initial PID
			await waitForEvent(monitor.onPidChange);

			// Track subsequent events
			const pids: Array<number | undefined> = [];
			monitor.onPidChange((pid) => pids.push(pid));

			// Wait long enough for stale check to trigger and re-find same process
			await new Promise((r) => setTimeout(r, 100));

			// No events should fire - same process found, no change
			expect(pids).toEqual([]);
		});
	});

	describe("log file discovery", () => {
		it("finds log file matching PID pattern", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/proxy-logs/999.log": "",
				"/proxy-logs/other.log": "",
			});

			const monitor = createMonitor({
				codeLogDir: "/logs/window1",
				proxyLogDir: "/proxy-logs",
			});
			const logPath = await waitForEvent(monitor.onLogFilePathChange);

			expect(logPath).toBe(path.join("/proxy-logs", "999.log"));
			expect(monitor.getLogFilePath()).toBe(
				path.join("/proxy-logs", "999.log"),
			);
		});

		it("finds log file with prefix pattern", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/proxy-logs/coder-ssh-999.log": "",
			});

			const monitor = createMonitor({
				codeLogDir: "/logs/window1",
				proxyLogDir: "/proxy-logs",
			});
			const logPath = await waitForEvent(monitor.onLogFilePathChange);

			expect(logPath).toBe(path.join("/proxy-logs", "coder-ssh-999.log"));
		});

		it("returns undefined when no proxyLogDir set", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/proxy-logs/coder-ssh-999.log": "", // ignored
			});

			const monitor = createMonitor({
				codeLogDir: "/logs/window1",
				proxyLogDir: undefined,
			});

			// Wait for process to be found
			await waitForEvent(monitor.onPidChange);

			expect(monitor.getLogFilePath()).toBeUndefined();
		});

		it("checks log files in reverse alphabetical order", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/proxy-logs/2024-01-01-999.log": "",
				"/proxy-logs/2024-01-02-999.log": "",
				"/proxy-logs/2024-01-03-999.log": "",
			});

			// Mock readdir to return files in unsorted order (simulating Windows fs)
			mockReaddirOrder("/proxy-logs", [
				"2024-01-03-999.log",
				"2024-01-01-999.log",
				"2024-01-02-999.log",
			]);

			const monitor = createMonitor({
				codeLogDir: "/logs/window1",
				proxyLogDir: "/proxy-logs",
			});
			const logPath = await waitForEvent(monitor.onLogFilePathChange);

			expect(logPath).toBe(path.join("/proxy-logs", "2024-01-03-999.log"));
		});

		it("sorts log files using localeCompare for consistent cross-platform ordering", async () => {
			// localeCompare differs from default sort() for mixed case
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/proxy-logs/a-999.log": "",
				"/proxy-logs/Z-999.log": "",
			});

			mockReaddirOrder("/proxy-logs", ["a-999.log", "Z-999.log"]);

			const monitor = createMonitor({
				codeLogDir: "/logs/window1",
				proxyLogDir: "/proxy-logs",
			});
			const logPath = await waitForEvent(monitor.onLogFilePathChange);

			// With localeCompare: ["a", "Z"] -> reversed -> "Z" first
			// With plain sort(): ["Z", "a"] -> reversed -> "a" first (WRONG)
			expect(logPath).toBe(path.join("/proxy-logs", "Z-999.log"));
		});
	});

	describe("network status", () => {
		it("shows P2P connection in status bar", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/network/999.json": JSON.stringify({
					p2p: true,
					latency: 25.5,
					preferred_derp: "NYC",
					derp_latency: { NYC: 10 },
					upload_bytes_sec: 1024,
					download_bytes_sec: 2048,
					using_coder_connect: false,
				}),
			});

			createMonitor({
				codeLogDir: "/logs/window1",
				networkInfoPath: "/network",
			});
			await waitFor(() => statusBar.text.includes("Direct"));

			expect(statusBar.text).toContain("Direct");
			expect(statusBar.text).toContain("25.50ms");
			expect(statusBar.tooltip).toContain("peer-to-peer");
		});

		it("shows relay connection with DERP region", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/network/999.json": JSON.stringify({
					p2p: false,
					latency: 50,
					preferred_derp: "SFO",
					derp_latency: { SFO: 20, NYC: 40 },
					upload_bytes_sec: 512,
					download_bytes_sec: 1024,
					using_coder_connect: false,
				}),
			});

			createMonitor({
				codeLogDir: "/logs/window1",
				networkInfoPath: "/network",
			});
			await waitFor(() => statusBar.text.includes("SFO"));

			expect(statusBar.text).toContain("SFO");
			expect(statusBar.tooltip).toContain("relay");
		});

		it("shows Coder Connect status", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/network/999.json": JSON.stringify({
					p2p: false,
					latency: 0,
					preferred_derp: "",
					derp_latency: {},
					upload_bytes_sec: 0,
					download_bytes_sec: 0,
					using_coder_connect: true,
				}),
			});

			createMonitor({
				codeLogDir: "/logs/window1",
				networkInfoPath: "/network",
			});
			await waitFor(() => statusBar.text.includes("Coder Connect"));

			expect(statusBar.text).toContain("Coder Connect");
		});
	});

	describe("cleanup old network files", () => {
		// Network cleanup: 1 hour threshold
		const NETWORK_MAX_AGE_MS = 60 * 60 * 1000;

		const setMtimeAgo = (filePath: string, ageMs: number) => {
			const mtime = (Date.now() - ageMs) / 1000;
			vol.utimesSync(filePath, mtime, mtime);
		};

		it("deletes old .json files but preserves recent and non-.json files", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/network/old.json": "{}",
				"/network/recent.json": "{}",
				"/network/old.log": "{}",
			});
			setMtimeAgo("/network/old.json", NETWORK_MAX_AGE_MS * 2);
			setMtimeAgo("/network/old.log", NETWORK_MAX_AGE_MS * 2);

			createMonitor({
				codeLogDir: "/logs/window1",
				networkInfoPath: "/network",
			});

			await vi.waitFor(() => {
				const files = vol.readdirSync("/network");
				expect(files).toHaveLength(2);
				expect(files).toContain("old.log");
				expect(files).toContain("recent.json");
			});
		});

		it("does not throw when network directory is missing or empty", () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
			});
			vol.mkdirSync("/empty-network", { recursive: true });

			expect(() =>
				createMonitor({
					codeLogDir: "/logs/window1",
					networkInfoPath: "/nonexistent",
				}),
			).not.toThrow();

			expect(() =>
				createMonitor({
					codeLogDir: "/logs/window1",
					networkInfoPath: "/empty-network",
				}),
			).not.toThrow();
		});
	});

	describe("cleanup proxy log files", () => {
		// Proxy log cleanup: 7 day threshold, 20 files max
		const LOG_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
		const LOG_MAX_FILES = 20;

		const setMtimeAgo = (filePath: string, ageMs: number) => {
			const mtime = (Date.now() - ageMs) / 1000;
			vol.utimesSync(filePath, mtime, mtime);
		};

		const logFileName = (i: number) =>
			`coder-ssh-${i.toString().padStart(2, "0")}.log`;

		const setupTest = (total: number, stale: number): string[] => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
			});
			vol.mkdirSync("/proxy-logs", { recursive: true });

			const files = Array.from({ length: total }, (_, i) => logFileName(i + 1));
			for (const name of files) {
				vol.writeFileSync(`/proxy-logs/${name}`, "");
			}
			for (let i = 0; i < stale; i++) {
				setMtimeAgo(`/proxy-logs/${files[i]}`, LOG_MAX_AGE_MS * 2);
			}
			return files;
		};

		interface StaleLogTestCase {
			total: number;
			stale: number;
			expected: number;
			desc: string;
		}

		it.each<StaleLogTestCase>([
			{ total: 25, stale: 8, expected: 20, desc: "Deletes until limit" },
			{ total: 25, stale: 3, expected: 22, desc: "Only deletes stale" },
			{ total: 25, stale: 0, expected: 25, desc: "Keeps recent files" },
			{ total: 15, stale: 5, expected: 15, desc: "Keeps under limit" },
		])(
			"$desc: $total files, $stale stale → $expected remaining",
			async ({ total, stale, expected }) => {
				setupTest(total, stale);

				createMonitor({
					codeLogDir: "/logs/window1",
					proxyLogDir: "/proxy-logs",
				});

				await vi.waitFor(() => {
					expect(vol.readdirSync("/proxy-logs")).toHaveLength(expected);
				});
			},
		);

		it("only matches coder-ssh*.log files", async () => {
			const files = setupTest(25, 25);
			// Add non-matching files
			const nonMatchingFiles = [
				"other.log",
				"coder-ssh-config.json",
				"readme.txt",
			];
			for (const f of nonMatchingFiles) {
				const filePath = `/proxy-logs/${f}`;
				vol.writeFileSync(filePath, "");
				setMtimeAgo(filePath, LOG_MAX_AGE_MS * 2);
			}

			createMonitor({
				codeLogDir: "/logs/window1",
				proxyLogDir: "/proxy-logs",
			});

			await vi.waitFor(() => {
				expect(vol.readdirSync("/proxy-logs")).toHaveLength(
					LOG_MAX_FILES + nonMatchingFiles.length,
				);
			});

			const remaining = vol.readdirSync("/proxy-logs") as string[];
			// Non-matching files preserved
			expect(remaining).toContain("other.log");
			expect(remaining).toContain("coder-ssh-config.json");
			expect(remaining).toContain("readme.txt");
			// Oldest matching files deleted
			expect(remaining).not.toContain(files[0]);
			expect(remaining).toContain(files[24]);
		});

		it("does not throw when proxy log directory is missing or empty", () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
			});
			vol.mkdirSync("/empty-proxy-logs", { recursive: true });

			expect(() =>
				createMonitor({
					codeLogDir: "/logs/window1",
					proxyLogDir: "/nonexistent-proxy-logs",
				}),
			).not.toThrow();

			expect(() =>
				createMonitor({
					codeLogDir: "/logs/window1",
					proxyLogDir: "/empty-proxy-logs",
				}),
			).not.toThrow();
		});
	});

	describe("missing file retry logic", () => {
		beforeEach(() => vi.useFakeTimers());
		afterEach(() => vi.useRealTimers());

		it("searches for new process after consecutive file read failures", async () => {
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/network/789.json": "{}",
			});
			// Set mtime far into the future so 789.json is always considered fresh
			const FRESH_MTIME = Date.now() + 1_000_000;
			vol.utimesSync(
				"/network/789.json",
				FRESH_MTIME / 1000,
				FRESH_MTIME / 1000,
			);

			vi.mocked(find)
				.mockResolvedValueOnce([{ pid: 123, ppid: 1, name: "ssh", cmd: "ssh" }])
				.mockResolvedValueOnce([{ pid: 456, ppid: 1, name: "ssh", cmd: "ssh" }])
				.mockResolvedValueOnce([{ pid: 789, ppid: 1, name: "ssh", cmd: "ssh" }])
				// This will not be found since `789.json` is found and is not stale!
				.mockResolvedValue([{ pid: 999, ppid: 1, name: "ssh", cmd: "ssh" }]);

			const pollInterval = 10;
			const monitor = createMonitor({
				codeLogDir: "/logs/window1",
				networkInfoPath: "/network",
				networkPollInterval: pollInterval,
			});

			const pids: Array<number | undefined> = [];
			monitor.onPidChange((pid) => pids.push(pid));

			// Advance enough time for the monitor to cycle through PIDs 123, 456, and find 789
			await vi.advanceTimersByTimeAsync(pollInterval * 100);

			expect(pids).toEqual([123, 456, 789]);
		});
	});

	describe("dispose", () => {
		it("disposes status bar", () => {
			const monitor = createMonitor();
			monitor.dispose();

			expect(statusBar.dispose).toHaveBeenCalled();
		});

		it("stops searching for process after dispose", async () => {
			// Log file exists so port can be found and find() is called
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
			});

			// find() always returns empty - monitor will keep retrying
			vi.mocked(find).mockResolvedValue([]);

			const monitor = createMonitor({ codeLogDir: "/logs/window1" });

			// Let a few poll cycles run
			await new Promise((r) => setTimeout(r, 30));
			const callsBeforeDispose = vi.mocked(find).mock.calls.length;
			expect(callsBeforeDispose).toBeGreaterThan(0);

			monitor.dispose();

			// Wait and verify no new calls
			await new Promise((r) => setTimeout(r, 50));
			expect(vi.mocked(find).mock.calls.length).toBe(callsBeforeDispose);
		});

		it("does not fire log file event after dispose", async () => {
			// Start with SSH log but no proxy log file
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
			});

			const monitor = createMonitor({
				codeLogDir: "/logs/window1",
				proxyLogDir: "/proxy-logs",
			});

			// Wait for PID - this starts the log file search loop
			await waitForEvent(monitor.onPidChange);

			const events: string[] = [];
			monitor.onLogFilePathChange(() => events.push("logPath"));

			monitor.dispose();

			// Now add the log file that WOULD have been found
			vol.fromJSON({
				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
					"-> socksPort 12345 ->",
				"/proxy-logs/999.log": "",
			});

			await new Promise((r) => setTimeout(r, 50));
			expect(events).toEqual([]);
		});

		it("is idempotent - can be called multiple times", () => {
			const monitor = createMonitor();

			monitor.dispose();
			monitor.dispose();
			monitor.dispose();

			// Should not throw, and dispose should only be called once on status bar
			expect(statusBar.dispose).toHaveBeenCalledTimes(1);
		});
	});

	function createMonitor(overrides: Partial<SshProcessMonitorOptions> = {}) {
		const monitor = SshProcessMonitor.start({
			sshHost: "coder-vscode--user--workspace",
			networkInfoPath: "/network",
			codeLogDir: "/logs/window1",
			remoteSshExtensionId: "ms-vscode-remote.remote-ssh",
			logger: createMockLogger(),
			discoveryPollIntervalMs: 10,
			maxDiscoveryBackoffMs: 100,
			networkPollInterval: 10,
			...overrides,
		});
		activeMonitors.push(monitor);
		return monitor;
	}
});

/**
 * Helper to mock readdir returning files in a specific unsorted order.
 * This is needed because memfs returns files in sorted order, which masks
 * bugs in sorting logic.
 */
function mockReaddirOrder(dirPath: string, files: string[]): void {
	const originalReaddir = fsPromises.readdir;
	const mockImpl = (path: fs.PathLike): Promise<string[]> => {
		if (path === dirPath) {
			return Promise.resolve(files);
		}
		return originalReaddir(path);
	};
	vi.spyOn(fsPromises, "readdir").mockImplementation(
		mockImpl as typeof fsPromises.readdir,
	);
}

/** Wait for a VS Code event to fire once */
function waitForEvent<T>(
	event: (listener: (e: T) => void) => { dispose(): void },
	timeout = 1000,
): Promise<T> {
	return new Promise((resolve, reject) => {
		const timer = setTimeout(() => {
			disposable.dispose();
			reject(new Error(`waitForEvent timed out after ${timeout}ms`));
		}, timeout);

		const disposable = event((value) => {
			clearTimeout(timer);
			disposable.dispose();
			resolve(value);
		});
	});
}

/** Poll for a condition to become true */
async function waitFor(
	condition: () => boolean,
	timeout = 1000,
	interval = 5,
): Promise<void> {
	const start = Date.now();
	while (!condition()) {
		if (Date.now() - start > timeout) {
			throw new Error(`waitFor timed out after ${timeout}ms`);
		}
		await new Promise((r) => setTimeout(r, interval));
	}
}