fix: reopen a workspace on the host it already used

Opening from the Coder panel matched a recent folder with
isRemoteAuthorityCompatible, which accepts a legacy authority, but then kept
only its path and opened it under a freshly minted per-editor authority. In a
fork that moved the folder to a URI the editor had never seen, orphaning the
window state stored against the old one.

Reuse the matched folder's own authority, so only workspaces with no history
get this editor's prefix.

Author: EhabY

CHANGELOG.md

@@ -13,6 +13,9 @@
   changed the remote authority, and editors key per-workspace state to it —
   Cursor's agent chats among them — so that state looked lost. Workspaces
   opened before v1.16.1 keep the host they already had.
+- Reopen a workspace on the host it already used when you open it from the
+  Coder panel, rather than moving it to this editor's own host and starting its
+  window state over.
 - Serve the historical `coder-vscode` host from a single generated file rather
   than one per editor, so a connection over it always uses the CLI and
   credentials of the editor that is connecting.

src/commands.ts

@@ -1521,7 +1521,7 @@ export class Commands {
 			...options,
 		};
 		let { folderPath } = options;
-		const remoteAuthority = toRemoteAuthority(
+		let remoteAuthority = toRemoteAuthority(
 			baseUrl,
 			workspace.owner_name,
 			workspace.name,
@@ -1551,17 +1551,26 @@ export class Commands {
 			);
 			// openRecent will always use the most recent.  Otherwise, if there are
 			// multiple we ask the user which to use.
+			let recent: (typeof opened)[number] | undefined;
 			if (opened.length === 1 || (opened.length > 1 && openRecent)) {
-				folderPath = opened[0].folderUri.path;
+				recent = opened[0];
 			} else if (opened.length > 1) {
 				const items = opened.map((f) => f.folderUri.path);
-				folderPath = await vscode.window.showQuickPick(items, {
+				const picked = await vscode.window.showQuickPick(items, {
 					title: "Select a recently opened folder",
 				});
-				if (!folderPath) {
+				if (!picked) {
 					// User aborted.
 					return { status: "cancelled", stage: "recent_folder_picker" };
 				}
+				recent = opened.find((f) => f.folderUri.path === picked);
+			}
+			if (recent) {
+				folderPath = recent.folderUri.path;
+				// Reopen on the host the folder already used. A compatible authority
+				// can still be a different string, and the editor stores per-workspace
+				// state under the whole URI.
+				remoteAuthority = recent.folderUri.authority;
 			}
 		}
 

test/unit/commands.openWorkspace.test.ts

@@ -0,0 +1,146 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as vscode from "vscode";
+
+import { Commands } from "@/commands";
+
+import { workspace as createWorkspace } from "@repo/mocks";
+
+import { createTestTelemetryService } from "../mocks/telemetry";
+import {
+	createMockLogger,
+	MockConfigurationProvider,
+	useEditor,
+} from "../mocks/testHelpers";
+
+import type { WorkspaceAgent } from "coder/site/src/api/typesGenerated";
+
+import type { CoderApi } from "@/api/coderApi";
+import type { ServiceContainer } from "@/core/container";
+import type { DeploymentManager } from "@/deployment/deploymentManager";
+
+vi.mock("@/workspace/workspacesProvider", () => ({
+	AgentTreeItem: class {
+		constructor(
+			public agent: unknown,
+			public workspace: unknown,
+		) {}
+	},
+	WorkspaceTreeItem: class {},
+}));
+
+const BASE_URL = "https://dev.coder.com";
+const AGENT = { name: "main", expanded_directory: undefined } as WorkspaceAgent;
+const CURSOR_AUTHORITY = "ssh-remote+coder-cursor.dev.coder.com--foo--bar.main";
+const LEGACY_AUTHORITY = "ssh-remote+coder-vscode.dev.coder.com--foo--bar.main";
+
+/** A recently opened folder, as `_workbench.getRecentlyOpened` reports it. */
+function recent(authority: string, path: string) {
+	return {
+		folderUri: vscode.Uri.from({ scheme: "vscode-remote", authority, path }),
+		remoteAuthority: authority,
+	};
+}
+
+/** Answer the recents query, and capture what openFolder is finally given. */
+function setup(recents: Array<ReturnType<typeof recent>>) {
+	new MockConfigurationProvider();
+	vi.mocked(vscode.commands.executeCommand).mockImplementation(
+		(command: string) =>
+			Promise.resolve(
+				command === "_workbench.getRecentlyOpened"
+					? { workspaces: recents }
+					: undefined,
+			),
+	);
+
+	const serviceContainer = {
+		getTelemetryService: () => createTestTelemetryService(),
+		getLogger: () => createMockLogger(),
+		getMementoManager: () => ({ setStartupMode: vi.fn() }),
+		getDuplicateWorkspaceIpc: () => ({
+			sendPing: vi.fn().mockResolvedValue(undefined),
+		}),
+		getPathResolver: () => ({}),
+		getSecretsManager: () => ({}),
+		getCliManager: () => ({}),
+		getLoginCoordinator: () => ({}),
+		getSpeedtestPanelFactory: () => ({}),
+		getNetcheckPanelFactory: () => ({}),
+	} as unknown as ServiceContainer;
+
+	const client = {
+		getAxiosInstance: () => ({ defaults: { baseURL: BASE_URL } }),
+	} as unknown as CoderApi;
+
+	return new Commands(serviceContainer, client, {} as DeploymentManager);
+}
+
+/** The authority the window was finally handed, by folder or by empty window. */
+function openedAuthority(): string | undefined {
+	for (const [command, arg] of vi.mocked(vscode.commands.executeCommand).mock
+		.calls) {
+		if (command === "vscode.openFolder") {
+			return (arg as vscode.Uri).authority;
+		}
+		if (command === "vscode.newWindow") {
+			return (arg as { remoteAuthority: string }).remoteAuthority;
+		}
+	}
+	return undefined;
+}
+
+describe("openWorkspace", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	/** The sidebar reaches openWorkspace asking for the most recent folder. */
+	async function openFromSidebar(commands: Commands) {
+		const { AgentTreeItem } = await import("@/workspace/workspacesProvider");
+		const item = new AgentTreeItem(
+			AGENT,
+			createWorkspace({ owner_name: "foo", name: "bar" }),
+		);
+		await commands.openFromSidebar(item);
+	}
+
+	it("reopens a folder on the host it already used", async () => {
+		useEditor("cursor");
+		const commands = setup([recent(LEGACY_AUTHORITY, "/home/foo/project")]);
+
+		await openFromSidebar(commands);
+
+		// Not the coder-cursor authority this editor would mint: that URI is a
+		// workspace the editor has never seen, so its stored state is orphaned.
+		expect(openedAuthority()).toBe(LEGACY_AUTHORITY);
+	});
+
+	it("mints this editor's host for a workspace with no history", async () => {
+		useEditor("cursor");
+		const commands = setup([]);
+
+		await openFromSidebar(commands);
+
+		expect(openedAuthority()).toBe(CURSOR_AUTHORITY);
+	});
+
+	it("keeps this editor's host when the recent folder already uses it", async () => {
+		useEditor("cursor");
+		const commands = setup([recent(CURSOR_AUTHORITY, "/home/foo/project")]);
+
+		await openFromSidebar(commands);
+
+		expect(openedAuthority()).toBe(CURSOR_AUTHORITY);
+	});
+
+	it("ignores recent folders from another editor", async () => {
+		useEditor("cursor");
+		const commands = setup([
+			recent("ssh-remote+coder-devin.dev.coder.com--foo--bar.main", "/other"),
+		]);
+
+		await openFromSidebar(commands);
+
+		expect(openedAuthority()).toBe(CURSOR_AUTHORITY);
+	});
+});