fix: drop throughput-based slowness detection, polish tooltip

The download_bytes_sec/upload_bytes_sec fields from the Coder CLI
measure actual tunnel traffic during the poll window, not link
capacity. Idle SSH sessions always dipped below the 5 Mbps default
even on fast networks, producing spurious warnings.

Keep latency as the only slowness signal. Display throughput in the
tooltip as informational data only. Replace the warning-icon-mid-line
layout with a bold header, tight metric rows, and an action row
containing explicit Ping workspace and Configure threshold links.

Author: EhabY

package.json

@@ -172,16 +172,6 @@
 					"type": "number",
 					"default": 200
 				},
-				"coder.networkThreshold.downloadMbps": {
-					"markdownDescription": "Download speed threshold in Mbps. A warning indicator appears in the status bar when download speed drops below this value. Set to `0` to disable.",
-					"type": "number",
-					"default": 5
-				},
-				"coder.networkThreshold.uploadMbps": {
-					"markdownDescription": "Upload speed threshold in Mbps. A warning indicator appears in the status bar when upload speed drops below this value. Set to `0` to disable.",
-					"type": "number",
-					"default": 0
-				},
 				"coder.httpClientLogLevel": {
 					"markdownDescription": "Controls the verbosity of HTTP client logging. This affects what details are logged for each HTTP request and response.",
 					"type": "string",

src/remote/networkStatus.ts

@@ -3,152 +3,88 @@ import * as vscode from "vscode";
 
 import type { NetworkInfo } from "./sshProcess";
 
-/** Bytes per second in 1 Mbps */
-const BYTES_PER_MBPS = 125_000;
-
 /** Number of consecutive polls required to trigger or clear a warning */
 const WARNING_DEBOUNCE_THRESHOLD = 3;
 
-export interface ThresholdViolations {
-	latency: boolean;
-	download: boolean;
-	upload: boolean;
-}
-
-const NO_VIOLATIONS: ThresholdViolations = {
-	latency: false,
-	download: false,
-	upload: false,
-};
+const WARNING_BACKGROUND = new vscode.ThemeColor(
+	"statusBarItem.warningBackground",
+);
 
-export function getThresholdConfig(): {
+export interface NetworkThresholds {
 	latencyMs: number;
-	downloadMbps: number;
-	uploadMbps: number;
-} {
+}
+
+function getThresholdConfig(): NetworkThresholds {
 	const cfg = vscode.workspace.getConfiguration("coder");
 	return {
 		latencyMs: cfg.get<number>("networkThreshold.latencyMs", 200),
-		downloadMbps: cfg.get<number>("networkThreshold.downloadMbps", 5),
-		uploadMbps: cfg.get<number>("networkThreshold.uploadMbps", 0),
 	};
 }
 
-export function checkThresholdViolations(
+export function isLatencySlow(
 	network: NetworkInfo,
-	thresholds: { latencyMs: number; downloadMbps: number; uploadMbps: number },
-): ThresholdViolations {
-	return {
-		latency: thresholds.latencyMs > 0 && network.latency > thresholds.latencyMs,
-		download:
-			thresholds.downloadMbps > 0 &&
-			network.download_bytes_sec / BYTES_PER_MBPS < thresholds.downloadMbps,
-		upload:
-			thresholds.uploadMbps > 0 &&
-			network.upload_bytes_sec / BYTES_PER_MBPS < thresholds.uploadMbps,
-	};
-}
-
-export function hasAnyViolation(violations: ThresholdViolations): boolean {
-	return violations.latency || violations.download || violations.upload;
-}
-
-export function getWarningCommand(violations: ThresholdViolations): string {
-	const latencyOnly =
-		violations.latency && !violations.download && !violations.upload;
-	const throughputOnly =
-		!violations.latency && (violations.download || violations.upload);
-
-	if (latencyOnly) {
-		return "coder.pingWorkspace";
-	}
-	if (throughputOnly) {
-		return "coder.speedTest";
-	}
-	// Multiple types of violations — let the user choose
-	return "coder.showNetworkDiagnostics";
+	thresholds: NetworkThresholds,
+): boolean {
+	return thresholds.latencyMs > 0 && network.latency > thresholds.latencyMs;
 }
 
 export function buildNetworkTooltip(
 	network: NetworkInfo,
-	violations: ThresholdViolations,
-	thresholds: { latencyMs: number; downloadMbps: number; uploadMbps: number },
+	latencySlow: boolean,
+	thresholds: NetworkThresholds,
 ): vscode.MarkdownString {
 	const fmt = (bytesPerSec: number) =>
 		prettyBytes(bytesPerSec * 8, { bits: true }) + "/s";
 
-	const lines: string[] = [];
-
-	let latencyLine = `Latency: ${network.latency.toFixed(2)}ms`;
-	if (violations.latency) {
-		latencyLine += ` $(warning) (threshold: ${thresholds.latencyMs}ms)`;
-	}
-	lines.push(latencyLine);
+	const sections: string[] = [];
 
-	let downloadLine = `Download: ${fmt(network.download_bytes_sec)}`;
-	if (violations.download) {
-		downloadLine += ` $(warning) (threshold: ${thresholds.downloadMbps} Mbit/s)`;
+	if (latencySlow) {
+		sections.push("$(warning) **Slow connection detected**");
 	}
-	lines.push(downloadLine);
 
-	let uploadLine = `Upload: ${fmt(network.upload_bytes_sec)}`;
-	if (violations.upload) {
-		uploadLine += ` $(warning) (threshold: ${thresholds.uploadMbps} Mbit/s)`;
-	}
-	lines.push(uploadLine);
+	const metrics: string[] = [];
+	metrics.push(
+		latencySlow
+			? `Latency: ${network.latency.toFixed(2)}ms (threshold: ${thresholds.latencyMs}ms)`
+			: `Latency: ${network.latency.toFixed(2)}ms`,
+	);
+	metrics.push(`Download: ${fmt(network.download_bytes_sec)}`);
+	metrics.push(`Upload: ${fmt(network.upload_bytes_sec)}`);
 
 	if (network.using_coder_connect) {
-		lines.push("Connection: Coder Connect");
+		metrics.push("Connection: Coder Connect");
 	} else if (network.p2p) {
-		lines.push("Connection: Direct (P2P)");
+		metrics.push("Connection: Direct (P2P)");
 	} else {
-		lines.push(`Connection: ${network.preferred_derp} (relay)`);
+		metrics.push(`Connection: ${network.preferred_derp} (relay)`);
 	}
 
-	if (hasAnyViolation(violations)) {
-		lines.push("");
-		lines.push(
-			"_Click for diagnostics_ | [Configure thresholds](command:workbench.action.openSettings?%22coder.networkThreshold%22)",
+	// Two trailing spaces + \n = hard line break (tight rows within a section).
+	sections.push(metrics.join("  \n"));
+
+	if (latencySlow) {
+		sections.push(
+			"[$(pulse) Ping workspace](command:coder.pingWorkspace) · " +
+				"[$(gear) Configure threshold](command:workbench.action.openSettings?%22coder.networkThreshold%22)",
 		);
 	}
 
-	const md = new vscode.MarkdownString(lines.join("\n\n"));
+	// Blank line between sections = paragraph break.
+	const md = new vscode.MarkdownString(sections.join("\n\n"));
 	md.isTrusted = true;
 	md.supportThemeIcons = true;
 	return md;
 }
 
 /**
  * Manages network status bar presentation and slowness warning state.
- * Owns the warning debounce logic, status bar updates, and the
- * diagnostics command registration.
+ * Owns the warning debounce logic and status bar updates.
  */
-export class NetworkStatusReporter implements vscode.Disposable {
+export class NetworkStatusReporter {
 	private warningCounter = 0;
 	private isWarningActive = false;
-	private readonly diagnosticsCommand: vscode.Disposable;
-
-	constructor(private readonly statusBarItem: vscode.StatusBarItem) {
-		this.diagnosticsCommand = vscode.commands.registerCommand(
-			"coder.showNetworkDiagnostics",
-			async () => {
-				const pick = await vscode.window.showQuickPick(
-					[
-						{ label: "Run Ping", commandId: "coder.pingWorkspace" },
-						{ label: "Run Speed Test", commandId: "coder.speedTest" },
-						{
-							label: "Create Support Bundle",
-							commandId: "coder.supportBundle",
-						},
-					],
-					{ placeHolder: "Select a diagnostic to run" },
-				);
-				if (pick) {
-					await vscode.commands.executeCommand(pick.commandId);
-				}
-			},
-		);
-	}
+
+	constructor(private readonly statusBarItem: vscode.StatusBarItem) {}
 
 	update(network: NetworkInfo, isStale: boolean): void {
 		let statusText = "$(globe) ";
@@ -166,8 +102,8 @@ export class NetworkStatusReporter implements vscode.Disposable {
 		}
 
 		const thresholds = getThresholdConfig();
-		const violations = checkThresholdViolations(network, thresholds);
-		const activeViolations = this.updateWarningState(violations);
+		const latencySlow = isLatencySlow(network, thresholds);
+		this.updateWarningState(latencySlow);
 
 		if (network.p2p) {
 			statusText += "Direct ";
@@ -182,32 +118,24 @@ export class NetworkStatusReporter implements vscode.Disposable {
 		this.statusBarItem.text = statusText;
 
 		if (this.isWarningActive) {
-			this.statusBarItem.backgroundColor = new vscode.ThemeColor(
-				"statusBarItem.warningBackground",
-			);
-			this.statusBarItem.command = getWarningCommand(activeViolations);
+			this.statusBarItem.backgroundColor = WARNING_BACKGROUND;
+			this.statusBarItem.command = "coder.pingWorkspace";
 		} else {
 			this.statusBarItem.backgroundColor = undefined;
 			this.statusBarItem.command = undefined;
 		}
 
 		this.statusBarItem.tooltip = buildNetworkTooltip(
 			network,
-			activeViolations,
+			this.isWarningActive,
 			thresholds,
 		);
 
 		this.statusBarItem.show();
 	}
 
-	/**
-	 * Updates the debounce counter and returns the effective violations
-	 * (current violations when warning is active, all-clear otherwise).
-	 */
-	private updateWarningState(
-		violations: ThresholdViolations,
-	): ThresholdViolations {
-		if (hasAnyViolation(violations)) {
+	private updateWarningState(latencySlow: boolean): void {
+		if (latencySlow) {
 			this.warningCounter = Math.min(
 				this.warningCounter + 1,
 				WARNING_DEBOUNCE_THRESHOLD,
@@ -221,11 +149,5 @@ export class NetworkStatusReporter implements vscode.Disposable {
 		} else if (this.warningCounter === 0) {
 			this.isWarningActive = false;
 		}
-
-		return this.isWarningActive ? violations : NO_VIOLATIONS;
-	}
-
-	dispose(): void {
-		this.diagnosticsCommand.dispose();
 	}
 }

src/remote/sshProcess.ts

@@ -255,7 +255,6 @@ export class SshProcessMonitor implements vscode.Disposable {
 			this.pendingTimeout = undefined;
 		}
 		this.statusBarItem.dispose();
-		this.reporter.dispose();
 		this._onLogFilePathChange.dispose();
 		this._onPidChange.dispose();
 	}
@@ -462,20 +461,15 @@ export class SshProcessMonitor implements vscode.Disposable {
 
 		while (!this.disposed && this.currentPid !== undefined) {
 			const filePath = path.join(networkInfoPath, `${this.currentPid}.json`);
-			let search: { needed: true; reason: string } | { needed: false } = {
-				needed: false,
-			};
+			let searchReason: string | undefined;
 
 			try {
 				const stats = await fs.stat(filePath);
 				const ageMs = Date.now() - stats.mtime.getTime();
 				readFailures = 0;
 
 				if (ageMs > staleThreshold) {
-					search = {
-						needed: true,
-						reason: `Network info stale (${Math.round(ageMs / 1000)}s old)`,
-					};
+					searchReason = `Network info stale (${Math.round(ageMs / 1000)}s old)`;
 				} else {
 					const content = await fs.readFile(filePath, "utf8");
 					const network = JSON.parse(content) as NetworkInfo;
@@ -488,22 +482,18 @@ export class SshProcessMonitor implements vscode.Disposable {
 					`Failed to read network info (attempt ${readFailures}): ${(error as Error).message}`,
 				);
 				if (readFailures >= maxReadFailures) {
-					search = {
-						needed: true,
-						reason: `Network info missing for ${readFailures} attempts`,
-					};
+					searchReason = `Network info missing for ${readFailures} attempts`;
 				}
 			}
 
-			// Search for new process if needed (with throttling)
-			if (search.needed) {
+			if (searchReason !== undefined) {
 				const timeSinceLastSearch = Date.now() - this.lastStaleSearchTime;
 				if (timeSinceLastSearch < staleThreshold) {
 					await this.delay(staleThreshold - timeSinceLastSearch);
 					continue;
 				}
 
-				logger.debug(`${search.reason}, searching for new SSH process`);
+				logger.debug(`${searchReason}, searching for new SSH process`);
 				// searchForProcess will update PID if a different process is found
 				this.lastStaleSearchTime = Date.now();
 				await this.searchForProcess();