fix: keep a workspace on the host it was last opened on

Reuse was keyed on an exact folder path, which left holes. A multi-root
workspace is recorded by its .code-workspace file and so has no folder URI to
match; a devcontainer authority carries a container payload that only matches
the identical container; and a folder the agent supplies has no entry at all
until it is opened once. Each fell through to a host named after this editor
while the rest of the workspace sat on the legacy one, and since an editor keys
window state by the whole URI, the workspace looked like two.

Decide per workspace instead: whichever of the two hosts a recent entry last
connected over is the one we open on. A compatible entry can only be on this
editor's host or the legacy one, so matching paths was never choosing between
more than those two -- dropping it removes code and closes the holes.

- Read the .code-workspace entries the private recents command returns, and
  tolerate an editor without that command instead of failing the open.
- Look up the same host when guessing an authority for a support bundle, and
  try both hosts against remote.SSH.serverInstallPath, so a bundle for a
  workspace on the legacy host still finds its remote logs.
- Swap an authority's host prefix in one place, so retargetRemoteAuthority and
  its new inverse toLegacyAuthority cannot drift apart.
- List the legacy file in Coder: Open Generated SSH Configuration File, which
  walked only this editor's prefix, so a local window could never open it.

Author: EhabY

CHANGELOG.md

@@ -9,17 +9,26 @@
 
 ### Fixed
 
-- Keep opening a workspace on the SSH host it already uses. v1.16.1 moved
-  existing workspaces onto a host named after your editor, and since an editor
-  identifies a workspace by an address that includes the host name, the
-  workspace looked new: Cursor's chats, your window layout, and anything else
-  kept per workspace appeared to be gone. Nothing was deleted, and a workspace
-  that already moved comes back when you reopen it from **File > Open Recent**.
-- Opening a workspace from the Coder panel reuses the host it was last opened
-  on, so it keeps its history instead of starting over.
+- Reopen a workspace on the SSH host it was last opened on. v1.16.1 moved
+  existing workspaces onto a host named after your editor, and an editor
+  remembers a window by its full address, host included, so the workspace
+  looked new: Cursor's chats, your window layout, and anything else kept per
+  workspace appeared to be gone. Nothing was deleted. The host now follows the
+  workspace wherever you open it from: the Coder panel, a dashboard or
+  devcontainer link, or **File > Open Recent**, and whether it opens as a
+  folder or as a multi-root workspace. Only a workspace you have never opened
+  gets your editor's host.
+- Mark the shared `coder-vscode` host as `(legacy)` in **File > Open Recent**,
+  so a workspace listed on both hosts is no longer two identical lines. The
+  folder picker lists each folder once.
+- Include a workspace's remote editor logs in its support bundle when
+  `remote.SSH.serverInstallPath` is set for the shared host. The bundle looked
+  that setting up under a host named after your editor, found nothing, and fell
+  back to the default location.
 - Serve the shared `coder-vscode` host from one generated SSH config file
-  rather than one per editor, so a connection over it always uses the CLI and
-  credentials of the editor that started it.
+  instead of one per editor, so a connection over it always uses the CLI and
+  credentials of the editor that started it. **Coder: Open Generated SSH
+  Configuration File** can open that file too.
 
 ## [v1.16.1](https://github.com/coder/vscode-coder/releases/tag/v1.16.1) 2026-08-24
 

src/commands.ts

@@ -51,9 +51,13 @@ import {
 } from "./supportBundle/remoteServerDataPath";
 import { runExportTelemetryCommand } from "./telemetry/export/command";
 import {
+	LegacyEditorId,
+	currentEditorId,
 	hostEditorId,
 	isRemoteAuthorityCompatible,
 	parseRemoteAuthority,
+	sshHostOf,
+	toLegacyAuthority,
 	toRemoteAuthority,
 } from "./util/authority";
 import { openInBrowser, toSafeHost } from "./util/uri";
@@ -88,6 +92,12 @@ import type {
 	PongMessage,
 } from "./workspace/duplicateWorkspaceIpc";
 
+/** One entry from the private `_workbench.getRecentlyOpened` command. */
+interface RecentlyOpened {
+	folderUri?: vscode.Uri;
+	workspace?: { configPath?: vscode.Uri };
+}
+
 const NO_SSH_CONFIG_MESSAGE =
 	"No SSH config has been generated yet. It is written when you connect to a workspace.";
 
@@ -573,15 +583,12 @@ export class Commands {
 		);
 	}
 
-	/** Open this editor's generated SSH config, picking a deployment when several exist. */
+	/** Open the generated SSH config, picking a file when several exist. */
 	public async openSshConfig(): Promise<void> {
-		let configPath = this.connectedSshConfigPath();
+		const configPath =
+			this.connectedSshConfigPath() ?? (await this.pickSshConfigPath());
 		if (!configPath) {
-			const hostname = await this.pickSshHostname();
-			if (!hostname) {
-				return;
-			}
-			configPath = this.pathResolver.getSshConfigPath(hostname);
+			return;
 		}
 		try {
 			await openFile(configPath);
@@ -613,24 +620,33 @@ export class Commands {
 		}
 	}
 
-	/** Ask which deployment, when this editor has generated more than one config. */
-	private async pickSshHostname(): Promise<string | undefined> {
-		const hostnames = (
-			await readdirOrEmpty(this.pathResolver.getSshConfigDir())
-		)
-			.map((file) => this.pathResolver.parseSshConfigFile(file))
-			.filter((name) => name !== undefined);
-		if (hostnames.length === 0) {
+	/** Ask which config to open, of this editor's prefixes and the legacy one. */
+	private async pickSshConfigPath(): Promise<string | undefined> {
+		const files = await readdirOrEmpty(this.pathResolver.getSshConfigDir());
+		const items = [...new Set([currentEditorId(), LegacyEditorId])].flatMap(
+			(editorId) =>
+				files
+					.map((file) => this.pathResolver.parseSshConfigFile(file, editorId))
+					.filter((safeHostname) => safeHostname !== undefined)
+					.map((safeHostname) => ({
+						label: safeHostname,
+						// Which hosts it serves; two files can share a deployment.
+						description: `coder-${editorId}.${safeHostname}--*`,
+						path: this.pathResolver.getSshConfigPath(safeHostname, editorId),
+					})),
+		);
+		if (items.length === 0) {
 			vscode.window.showInformationMessage(NO_SSH_CONFIG_MESSAGE);
 			return undefined;
 		}
-		if (hostnames.length === 1) {
-			return hostnames[0];
+		if (items.length === 1) {
+			return items[0].path;
 		}
-		return vscode.window.showQuickPick(hostnames, {
+		const picked = await vscode.window.showQuickPick(items, {
 			title: "Open generated SSH configuration",
 			placeHolder: "Select a deployment",
 		});
+		return picked?.path;
 	}
 
 	/**
@@ -1118,6 +1134,39 @@ export class Commands {
 		);
 	}
 
+	/** Recently opened folders, and every entry including workspace files. */
+	private async recentlyOpened(): Promise<{
+		folders: vscode.Uri[];
+		entries: vscode.Uri[];
+	}> {
+		let recents: RecentlyOpened[] = [];
+		try {
+			// Private command; without it there is just no history to reuse.
+			const output: { workspaces?: RecentlyOpened[] } =
+				await vscode.commands.executeCommand("_workbench.getRecentlyOpened");
+			recents = output?.workspaces ?? [];
+		} catch (error) {
+			this.logger.warn("Failed to read recently opened folders", error);
+		}
+		return {
+			folders: recents.flatMap((recent) => recent.folderUri ?? []),
+			entries: recents.flatMap(
+				(recent) => recent.folderUri ?? recent.workspace?.configPath ?? [],
+			),
+		};
+	}
+
+	/** The host this workspace was last opened on, or this editor's own. */
+	private reusableAuthority(recents: vscode.Uri[], target: string): string {
+		const legacyAuthority = toLegacyAuthority(target);
+		const legacyHost = sshHostOf(legacyAuthority);
+		const currentHost = sshHostOf(target);
+		const lastUsed = recents
+			.map((uri) => sshHostOf(uri.authority))
+			.find((host) => host === currentHost || host === legacyHost);
+		return lastUsed === legacyHost ? legacyAuthority : target;
+	}
+
 	private async runOpenDevContainer(
 		workspaceOwner: string,
 		workspaceName: string,
@@ -1155,20 +1204,25 @@ export class Commands {
 		).toString("hex");
 
 		const type = localWorkspaceFolder ? "dev-container" : "attached-container";
-		const devContainerAuthority = `${type}+${devContainer}@${remoteAuthority}`;
+		const target = `${type}+${devContainer}@${remoteAuthority}`;
 
 		let newWindow = true;
 		if (!vscode.workspace.workspaceFolders?.length) {
 			newWindow = false;
 		}
 
+		const { entries } = await this.recentlyOpened();
+		const authority = this.reusableAuthority(entries, target);
+
+		this.logger.info("Opening devcontainer", { remoteAuthority: authority });
+
 		// Only set the memento when opening a new folder
 		await this.mementoManager.setStartupMode("start");
 		await vscode.commands.executeCommand(
 			"vscode.openFolder",
 			vscode.Uri.from({
 				scheme: "vscode-remote",
-				authority: devContainerAuthority,
+				authority,
 				path: devContainerFolder,
 			}),
 			newWindow,
@@ -1263,7 +1317,7 @@ export class Commands {
 				agentName,
 				client: this.extensionClient,
 				workspaceId: createWorkspaceIdentifier(item.workspace),
-				remoteAuthority: this.toWorkspaceAuthority(
+				remoteAuthority: await this.toWorkspaceAuthority(
 					this.extensionClient,
 					item.workspace,
 					agentName,
@@ -1290,7 +1344,7 @@ export class Commands {
 				status: "selected",
 				client: this.extensionClient,
 				workspaceId: createWorkspaceIdentifier(pick.workspace),
-				remoteAuthority: this.toWorkspaceAuthority(
+				remoteAuthority: await this.toWorkspaceAuthority(
 					this.extensionClient,
 					pick.workspace,
 				),
@@ -1303,20 +1357,24 @@ export class Commands {
 	 * Reconstruct the authority Remote-SSH would use, defaulting to the
 	 * first agent like the CLI does.
 	 */
-	private toWorkspaceAuthority(
+	private async toWorkspaceAuthority(
 		client: CoderApi,
 		workspace: Workspace,
 		agentName?: string,
-	): string | undefined {
+	): Promise<string | undefined> {
 		const baseUrl = client.getAxiosInstance().defaults.baseURL;
 		if (!baseUrl) {
 			return undefined;
 		}
-		return toRemoteAuthority(
-			baseUrl,
-			workspace.owner_name,
-			workspace.name,
-			agentName ?? extractAgents(workspace.latest_build.resources)[0]?.name,
+		const { entries } = await this.recentlyOpened();
+		return this.reusableAuthority(
+			entries,
+			toRemoteAuthority(
+				baseUrl,
+				workspace.owner_name,
+				workspace.name,
+				agentName ?? extractAgents(workspace.latest_build.resources)[0]?.name,
+			),
 		);
 	}
 
@@ -1537,38 +1595,35 @@ export class Commands {
 			folderPath = agent.expanded_directory;
 		}
 
+		const { folders, entries } = await this.recentlyOpened();
 		// If the agent had no folder or we have been asked to open the most recent,
 		// we can try to open a recently opened folder/workspace.
 		if (!folderPath || openRecent) {
-			const output: {
-				workspaces: Array<{ folderUri: vscode.Uri; remoteAuthority: string }>;
-			} = await vscode.commands.executeCommand("_workbench.getRecentlyOpened");
-			const opened = output.workspaces.filter((opened) =>
-				isRemoteAuthorityCompatible(
-					opened.folderUri?.authority,
-					remoteAuthority,
+			// One entry per folder: the same path can be in the list once per host.
+			const paths = [
+				...new Set(
+					folders
+						.filter((uri) =>
+							isRemoteAuthorityCompatible(uri.authority, remoteAuthority),
+						)
+						.map((uri) => uri.path),
 				),
-			);
+			];
 			// openRecent will always use the most recent.  Otherwise, if there are
 			// multiple we ask the user which to use.
-			if (opened.length === 1 || (opened.length > 1 && openRecent)) {
-				folderPath = opened[0].folderUri.path;
-			} else if (opened.length > 1) {
-				const items = opened.map((f) => f.folderUri.path);
-				folderPath = await vscode.window.showQuickPick(items, {
+			if (paths.length === 1 || (paths.length > 1 && openRecent)) {
+				folderPath = paths[0];
+			} else if (paths.length > 1) {
+				folderPath = await vscode.window.showQuickPick(paths, {
 					title: "Select a recently opened folder",
 				});
 				if (!folderPath) {
 					// User aborted.
 					return { status: "cancelled", stage: "recent_folder_picker" };
 				}
 			}
-			// A compatible folder can still be on the legacy coder-vscode host.
-			// Reopen it there, since the editor keys window state by the whole URI.
-			remoteAuthority =
-				opened.find((f) => f.folderUri.path === folderPath)?.folderUri
-					.authority ?? remoteAuthority;
 		}
+		remoteAuthority = this.reusableAuthority(entries, remoteAuthority);
 
 		// Only set the memento when opening a new folder/window
 		await this.mementoManager.setStartupMode("start");

src/core/pathResolver.ts

@@ -86,9 +86,12 @@ export class PathResolver {
 		);
 	}
 
-	/** The deployment hostname if this editor generated the file, else undefined. */
-	public parseSshConfigFile(fileName: string): string | undefined {
-		const prefix = `${currentEditorId()}--`;
+	/** The deployment hostname if `editorId` named the file, else undefined. */
+	public parseSshConfigFile(
+		fileName: string,
+		editorId: string = currentEditorId(),
+	): string | undefined {
+		const prefix = `${editorId}--`;
 		return fileName.startsWith(prefix) && fileName.endsWith(SSH_CONFIG_EXT)
 			? fileName.slice(prefix.length, -SSH_CONFIG_EXT.length)
 			: undefined;

src/remote/remote.ts

@@ -40,8 +40,10 @@ import { getHeaderCommand } from "../settings/headers";
 import { escapeCommandArg, expandPath } from "../util";
 import {
 	type AuthorityParts,
+	classifySshHost,
 	hostEditorId,
 	parseRemoteAuthority,
+	sshHostOf,
 } from "../util/authority";
 import { createStatusBarItem } from "../util/statusBar";
 import { vscodeProposed } from "../vscodeProposed";
@@ -106,6 +108,29 @@ interface RemoteSetupContext {
 	disposables: vscode.Disposable[];
 }
 
+/**
+ * What Open Recent shows after the path. VS Code splits the label on the
+ * separator, so "/" would display "/home/kyle [Coder: kyle/workspace]" as
+ * "workspace] /home/kyle [Coder: kyle"; "∕" looks the same in the UI font.
+ */
+export function workspaceLabelSuffix(
+	remoteAuthority: string,
+	owner: string,
+	workspace: string,
+	agent?: string,
+): string {
+	let suffix = `Coder: ${owner}∕${workspace}`;
+	if (agent) {
+		suffix += `∕${agent}`;
+	}
+	// Mark the shared host, so a workspace with an entry on each is not two
+	// identical lines. Only a fork sees it; in VS Code it is the only host.
+	const sshHost = sshHostOf(remoteAuthority);
+	return sshHost && classifySshHost(sshHost) === "legacy"
+		? `${suffix} (legacy)`
+		: suffix;
+}
+
 export class Remote {
 	private readonly logger: Logger;
 	private readonly pathResolver: PathResolver;
@@ -1082,16 +1107,6 @@ export class Remote {
 		workspace: string,
 		agent?: string,
 	): vscode.Disposable {
-		// VS Code splits based on the separator when displaying the label
-		// in a recently opened dialog. If the workspace suffix contains /,
-		// then it'll visually display weird:
-		// "/home/kyle [Coder: kyle/workspace]" displays as "workspace] /home/kyle [Coder: kyle"
-		// For this reason, we use a different / that visually appears the
-		// same on non-monospace fonts "∕".
-		let suffix = `Coder: ${owner}∕${workspace}`;
-		if (agent) {
-			suffix += `∕${agent}`;
-		}
 		// VS Code caches resource label formatters in it's global storage SQLite database
 		// under the key "memento/cachedResourceLabelFormatters2".
 		return vscodeProposed.workspace.registerResourceLabelFormatter({
@@ -1103,7 +1118,12 @@ export class Remote {
 				label: "${path}",
 				separator: "/",
 				tildify: true,
-				workspaceSuffix: suffix,
+				workspaceSuffix: workspaceLabelSuffix(
+					remoteAuthority,
+					owner,
+					workspace,
+					agent,
+				),
 			},
 		});
 	}