feat: detect SSH port changes, reconnect WebSockets on PID change

Add port-change detection to SshProcessMonitor so backoff resets when
VS Code writes a new port after reconnection. Extract label formatter
re-registration into a shared helper and trigger it (along with
WebSocket reconnection) when the SSH process PID changes.

Also makes the CLI version mismatch prompt modal.

Author: EhabY

src/api/coderApi.ts

@@ -154,6 +154,25 @@ export class CoderApi extends Api implements vscode.Disposable {
 		this.setCredentials(host, this.getSessionToken());
 	};
 
+	/**
+	 * Force-reconnect all sockets in CONNECTED state, which may be in a TCP
+	 * half-open state after sleep/wake. Sockets in other states (AWAITING_RETRY,
+	 * DISCONNECTED) are left alone as they already have their own retry logic.
+	 */
+	reconnectAllConnected(reason: string): void {
+		const stale = [...this.reconnectingSockets].filter(
+			(s) => s.state === ConnectionState.CONNECTED,
+		);
+		if (stale.length > 0) {
+			this.output.info(
+				`Reconnecting ${stale.length} WebSocket(s): ${reason}`,
+			);
+			for (const socket of stale) {
+				socket.reconnect();
+			}
+		}
+	}
+
 	/**
 	 * Permanently dispose all WebSocket connections.
 	 * This clears handlers and prevents reconnection.

src/core/cliManager.ts

@@ -232,6 +232,7 @@ export class CliManager {
 	): Promise<boolean> {
 		const choice = await vscodeProposed.window.showErrorMessage(
 			`${reason}. Run version ${version} anyway?`,
+			{ modal: true, useCustom: true },
 			"Run",
 		);
 		return choice === "Run";

src/remote/remote.ts

@@ -512,20 +512,29 @@ export class Remote {
 
 			this.commands.workspaceLogPath = sshMonitor.getLogFilePath();
 
+			const reregisterLabelFormatter = () => {
+				labelFormatterDisposable.dispose();
+				labelFormatterDisposable = this.registerLabelFormatter(
+					remoteAuthority,
+					workspace.owner_name,
+					workspace.name,
+					agent.name,
+				);
+			};
+
 			disposables.push(
 				sshMonitor.onLogFilePathChange((newPath) => {
 					this.commands.workspaceLogPath = newPath;
 				}),
+				// Re-register label formatter when SSH process reconnects after sleep/wake
+				sshMonitor.onPidChange(() => {
+					reregisterLabelFormatter();
+					// Reconnect WebSockets that may be in TCP half-open state
+					workspaceClient.reconnectAllConnected("SSH process changed");
+				}),
 				// Register the label formatter again because SSH overrides it!
 				vscode.extensions.onDidChange(() => {
-					// Dispose previous label formatter
-					labelFormatterDisposable.dispose();
-					labelFormatterDisposable = this.registerLabelFormatter(
-						remoteAuthority,
-						workspace.owner_name,
-						workspace.name,
-						agent.name,
-					);
+					reregisterLabelFormatter();
 				}),
 				...(await this.createAgentMetadataStatusBar(agent, workspaceClient)),
 			);

src/remote/sshProcess.ts

@@ -279,6 +279,7 @@ export class SshProcessMonitor implements vscode.Disposable {
 			this.options;
 		let attempt = 0;
 		let currentBackoff = discoveryPollIntervalMs;
+		let lastFoundPort: number | undefined;
 
 		while (!this.disposed) {
 			attempt++;
@@ -289,9 +290,25 @@ export class SshProcessMonitor implements vscode.Disposable {
 				);
 			}
 
-			const pidByPort = await this.findSshProcessByPort();
-			if (pidByPort !== undefined) {
-				this.setCurrentPid(pidByPort);
+			const { pid, port } = await this.findSshProcessByPort();
+
+			// Track port changes to reset backoff after VS Code reconnection
+			const portChanged =
+				lastFoundPort !== undefined &&
+				port !== undefined &&
+				port !== lastFoundPort;
+			if (portChanged) {
+				logger.debug(
+					`SSH port changed in log file: ${lastFoundPort} -> ${port}`,
+				);
+				currentBackoff = discoveryPollIntervalMs;
+			}
+			if (port !== undefined) {
+				lastFoundPort = port;
+			}
+
+			if (pid !== undefined) {
+				this.setCurrentPid(pid);
 				this.startMonitoring();
 				return;
 			}
@@ -305,7 +322,10 @@ export class SshProcessMonitor implements vscode.Disposable {
 	 * Finds SSH process by parsing the Remote SSH extension's log to get the port.
 	 * This is more accurate as each VS Code window has a unique port.
 	 */
-	private async findSshProcessByPort(): Promise<number | undefined> {
+	private async findSshProcessByPort(): Promise<{
+		pid?: number;
+		port?: number;
+	}> {
 		const { codeLogDir, remoteSshExtensionId, logger } = this.options;
 
 		try {
@@ -315,27 +335,31 @@ export class SshProcessMonitor implements vscode.Disposable {
 				logger,
 			);
 			if (!logPath) {
-				return undefined;
+				logger.debug("No Remote SSH log file found");
+				return {};
 			}
 
 			const logContent = await fs.readFile(logPath, "utf8");
-			this.options.logger.debug(`Read Remote SSH log file:`, logPath);
+			logger.debug(`Read Remote SSH log file:`, logPath);
 
 			const port = findPort(logContent);
 			if (!port) {
-				return undefined;
+				logger.debug(`No SSH port found in log file: ${logPath}`);
+				return {};
 			}
-			this.options.logger.debug(`Found SSH port ${port} in log file`);
+
+			logger.debug(`Found SSH port ${port} in log file`);
 
 			const processes = await find("port", port);
 			if (processes.length === 0) {
-				return undefined;
+				logger.debug(`No process found listening on port ${port}`);
+				return { port };
 			}
 
-			return processes[0].pid;
+			return { pid: processes[0].pid, port };
 		} catch (error) {
 			logger.debug("SSH process search failed", error);
-			return undefined;
+			return {};
 		}
 	}
 
@@ -579,6 +603,7 @@ async function findRemoteSshLogPath(
 
 		if (outputDirs.length > 0) {
 			const outputPath = path.join(logsParentDir, outputDirs[0]);
+			logger.debug(`Using Remote SSH log directory: ${outputPath}`);
 			const remoteSshLog = await findSshLogInDir(outputPath);
 			if (remoteSshLog) {
 				return remoteSshLog;

test/unit/remote/sshProcess.test.ts

@@ -204,6 +204,109 @@ describe("SshProcessMonitor", () => {
 			expect(pids).toContain(888);
 		});
 
+		it("resets backoff when port changes in log file", async () => {
+			// Start with port 11111, no process on it
+			vol.fromJSON({
+				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
+					"-> socksPort 11111 ->",
+			});
+
+			// No process found initially, then process found after port change
+			vi.mocked(find).mockResolvedValue([]);
+
+			const logger = createMockLogger();
+			const monitor = createMonitor({
+				codeLogDir: "/logs/window1",
+				discoveryPollIntervalMs: 10,
+				maxDiscoveryBackoffMs: 5000,
+				logger,
+			});
+
+			// Wait for several search attempts with backoff growing
+			await new Promise((r) => setTimeout(r, 80));
+
+			// Now change the port in the log — simulates VS Code reconnection
+			vol.fromJSON({
+				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
+					"-> socksPort 22222 ->",
+			});
+
+			// After port change, make find return a process
+			vi.mocked(find).mockResolvedValue([
+				{ pid: 555, ppid: 1, name: "ssh", cmd: "ssh" },
+			]);
+
+			// The process should be found quickly since backoff resets on port change
+			const pid = await waitForEvent(monitor.onPidChange, 2000);
+			expect(pid).toBe(555);
+
+			// Verify port change was logged
+			expect(logger.debug).toHaveBeenCalledWith(
+				"SSH port changed in log file: 11111 -> 22222",
+			);
+		});
+
+		it("logs when port found but no process listening", async () => {
+			vol.fromJSON({
+				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
+					"-> socksPort 12345 ->",
+			});
+
+			vi.mocked(find).mockResolvedValue([]);
+
+			const logger = createMockLogger();
+			const monitor = createMonitor({
+				codeLogDir: "/logs/window1",
+				logger,
+			});
+
+			// Wait for at least one search attempt
+			await new Promise((r) => setTimeout(r, 30));
+			monitor.dispose();
+
+			expect(logger.debug).toHaveBeenCalledWith(
+				"No process found listening on port 12345",
+			);
+		});
+
+		it("detects port change across search attempts", async () => {
+			vol.fromJSON({
+				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
+					"-> socksPort 11111 ->",
+			});
+
+			// First attempt: port 11111 with no process
+			// After port changes: port 22222 with process
+			let callCount = 0;
+			vi.mocked(find).mockImplementation(() => {
+				callCount++;
+				if (callCount >= 3) {
+					return Promise.resolve([
+						{ pid: 777, ppid: 1, name: "ssh", cmd: "ssh" },
+					]);
+				}
+				return Promise.resolve([]);
+			});
+
+			const logger = createMockLogger();
+			const monitor = createMonitor({
+				codeLogDir: "/logs/window1",
+				logger,
+			});
+
+			// Wait for first attempts with port 11111
+			await new Promise((r) => setTimeout(r, 30));
+
+			// Change port
+			vol.fromJSON({
+				"/logs/ms-vscode-remote.remote-ssh/1-Remote - SSH.log":
+					"-> socksPort 22222 ->",
+			});
+
+			const pid = await waitForEvent(monitor.onPidChange, 2000);
+			expect(pid).toBe(777);
+		});
+
 		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":