feat: collect remote editor logs in support bundles (#1042)

Support bundles now include the remote editor server's logs alongside the
local Remote-SSH and Coder proxy logs. Remote files are passed through the
CLI's repeatable `--workspace-file` flag, gated to Coder 2.36.0+.

- Resolve the server data directory from `remote.SSH.serverInstallPath` for
  the workspace's SSH host, falling back to `~/{serverDataFolderName}` from
  the editor's `product.json`. No remote connection needed.
- Handle each Remote-SSH fork's convention: parent directory for Microsoft
  and Cursor, final data directory for Open Remote SSH (with exact >
  wildcard > `*` precedence), home default for Windsurf and Antigravity.
- Collect three known layouts: `data/logs/**/*.log`, `.*.log`, and
  `cli/servers/*/log.txt`. Both startup layouts are included rather than
  gated on `remote.SSH.useExecServer`, which can change after connection.
- Omit remote logs rather than scan broad paths or pass unresolved
  environment variables.
- Pass the selected agent to `coder support bundle`, reconstructing the SSH
  authority from workspace metadata when not connected so sidebar, picker,
  and palette flows resolve identically.
- Add `raceWithAbort` to keep glob resolution cancellable, since the VS Code
  resolution APIs take no signal.

Author: EhabY

src/commands.ts

@@ -12,7 +12,7 @@ import {
 import { runDiagnosticCli } from "./command/diagnosticFlow";
 import * as cliExec from "./core/cliExec";
 import { CertificateError } from "./error/certificateError";
-import { toError } from "./error/errorUtils";
+import { raceWithAbort, toError } from "./error/errorUtils";
 import { type FeatureSet, featureSetForVersion } from "./featureSet";
 import {
 	AuthTelemetry,
@@ -45,6 +45,10 @@ import {
 } from "./remote/sshOverrides";
 import { resolveCliAuth } from "./settings/cli";
 import { appendVsCodeLogs } from "./supportBundle/appendVsCodeLogs";
+import {
+	getRemoteServerDataPath,
+	toRemoteLogGlobs,
+} from "./supportBundle/remoteServerDataPath";
 import { runExportTelemetryCommand } from "./telemetry/export/command";
 import { toRemoteAuthority } from "./util/authority";
 import { openInBrowser, toSafeHost } from "./util/uri";
@@ -99,8 +103,11 @@ interface LoginArgs {
 type WorkspaceResolution =
 	| {
 			readonly status: "selected";
+			readonly agentName?: string;
 			readonly client: CoderApi;
 			readonly workspaceId: string;
+			/** Authority for the workspace, live or reconstructed from metadata. */
+			readonly remoteAuthority?: string;
 	  }
 	| { readonly status: "cancelled" }
 	| {
@@ -150,6 +157,7 @@ export class Commands {
 	// are logged into (for convenience; otherwise the recents menu can be a pain
 	// if you use multiple deployments).
 	public workspace?: Workspace;
+	public agent?: WorkspaceAgent;
 	public workspaceLogPath?: string;
 	public remoteWorkspaceClient?: CoderApi;
 
@@ -424,7 +432,7 @@ export class Commands {
 			return;
 		}
 
-		const { client, workspaceId } = resolved;
+		const { agentName, client, workspaceId, remoteAuthority } = resolved;
 
 		const outputUri = await this.promptSupportBundlePath();
 		if (!outputUri) {
@@ -435,13 +443,30 @@ export class Commands {
 		const result = await withCancellableProgress(
 			async ({ signal, progress }) => {
 				progress.report({ message: "Resolving CLI..." });
+				// Independent of the CLI and never rejects, so resolve the globs
+				// concurrently and discard them when the CLI lacks support.
+				const remoteLogGlobs = getRemoteServerDataPath({
+					appRoot: vscode.env.appRoot,
+					remoteAuthority,
+					logger: this.logger,
+				}).then(toRemoteLogGlobs);
 				const env = await this.resolveCliEnv(client);
 				if (!env.featureSet.supportBundle) {
 					throw new SupportBundleUnsupportedCliError();
 				}
 
+				// The resolution APIs take no signal, so race to keep cancel honest.
+				const workspaceFiles = env.featureSet.supportBundleWorkspaceFiles
+					? await raceWithAbort(remoteLogGlobs, signal)
+					: [];
+
 				progress.report({ message: "Collecting diagnostics..." });
-				await cliExec.supportBundle(env, workspaceId, outputUri.fsPath, signal);
+				await cliExec.supportBundle(env, workspaceId, {
+					outputPath: outputUri.fsPath,
+					agentName,
+					workspaceFiles,
+					signal,
+				});
 
 				progress.report({ message: "Adding VS Code logs..." });
 				await appendVsCodeLogs(
@@ -1131,17 +1156,27 @@ export class Commands {
 		item?: OpenableTreeItem,
 	): Promise<WorkspaceResolution> {
 		if (item) {
+			const agentName =
+				item instanceof AgentTreeItem ? item.agent.name : undefined;
 			return {
 				status: "selected",
+				agentName,
 				client: this.extensionClient,
 				workspaceId: createWorkspaceIdentifier(item.workspace),
+				remoteAuthority: this.toWorkspaceAuthority(
+					this.extensionClient,
+					item.workspace,
+					agentName,
+				),
 			};
 		}
 		if (this.workspace && this.remoteWorkspaceClient) {
 			return {
 				status: "selected",
+				agentName: this.agent?.name,
 				client: this.remoteWorkspaceClient,
 				workspaceId: createWorkspaceIdentifier(this.workspace),
+				remoteAuthority: vscodeProposed.env.remoteAuthority,
 			};
 		}
 		const pick = await this.pickWorkspace("diagnostic", {
@@ -1155,11 +1190,36 @@ export class Commands {
 				status: "selected",
 				client: this.extensionClient,
 				workspaceId: createWorkspaceIdentifier(pick.workspace),
+				remoteAuthority: this.toWorkspaceAuthority(
+					this.extensionClient,
+					pick.workspace,
+				),
 			};
 		}
 		return pick;
 	}
 
+	/**
+	 * Reconstruct the authority Remote-SSH would use, defaulting to the
+	 * first agent like the CLI does.
+	 */
+	private toWorkspaceAuthority(
+		client: CoderApi,
+		workspace: Workspace,
+		agentName?: string,
+	): 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,
+		);
+	}
+
 	/** Resolve a CliEnv, preferring a locally cached binary over a network fetch. */
 	private async resolveCliEnv(
 		client: CoderApi,

src/core/cliExec.ts

@@ -105,18 +105,25 @@ export async function netcheck(
 export async function supportBundle(
 	env: CliEnv,
 	workspaceName: string,
-	outputPath: string,
-	signal?: AbortSignal,
+	options: {
+		outputPath: string;
+		agentName?: string;
+		workspaceFiles?: readonly string[];
+		signal?: AbortSignal;
+	},
 ): Promise<void> {
+	const { outputPath, agentName, workspaceFiles = [], signal } = options;
 	const globalFlags = getGlobalFlags(env.configs, env.auth);
 	const args = [
 		...globalFlags,
 		"support",
 		"bundle",
 		workspaceName,
+		...(agentName ? [agentName] : []),
 		"--output-file",
 		outputPath,
 		"--yes",
+		...workspaceFiles.flatMap((file) => ["--workspace-file", file]),
 	];
 	try {
 		await execFileAsync(env.binary, args, { signal });

src/error/errorUtils.ts

@@ -14,12 +14,37 @@ export function isAbortError(error: unknown): error is Error {
  */
 export function throwIfAborted(signal: AbortSignal | undefined): void {
 	if (!signal?.aborted) return;
-	const reason: unknown = signal.reason;
-	throw reason instanceof Error
+	throw toAbortError(signal.reason);
+}
+
+function toAbortError(reason: unknown): Error {
+	return reason instanceof Error
 		? reason
 		: Object.assign(new Error("Aborted"), { name: "AbortError" });
 }
 
+/**
+ * Await `promise`, rejecting with an AbortError as soon as `signal` aborts.
+ * The underlying work is abandoned, not stopped; use for operations that
+ * cannot take a signal themselves.
+ */
+export async function raceWithAbort<T>(
+	promise: Promise<T>,
+	signal: AbortSignal,
+): Promise<T> {
+	throwIfAborted(signal);
+	let onAbort!: () => void;
+	const aborted = new Promise<never>((_, reject) => {
+		onAbort = () => reject(toAbortError(signal.reason));
+	});
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		return await Promise.race([promise, aborted]);
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+
 // getErrorDetail is copied from coder/site, but changes the default return.
 export const getErrorDetail = (error: unknown): string | undefined | null => {
 	if (isApiError(error)) {

src/featureSet.ts

@@ -9,6 +9,7 @@ export interface FeatureSet {
 	keyringAuth: boolean;
 	tokenRead: boolean;
 	supportBundle: boolean;
+	supportBundleWorkspaceFiles: boolean;
 }
 
 /**
@@ -49,5 +50,7 @@ export function featureSetForVersion(
 		tokenRead: versionAtLeast(version, "2.31.0"),
 		// `coder support bundle` (officially released/unhidden in 2.10.0)
 		supportBundle: versionAtLeast(version, "2.10.0"),
+		// --workspace-file flag for `coder support bundle`
+		supportBundleWorkspaceFiles: versionAtLeast(version, "2.36.0"),
 	};
 }

src/remote/remote.ts

@@ -638,6 +638,7 @@ export class Remote {
 		});
 
 		this.commands.workspace = workspace;
+		this.commands.agent = agent;
 		return agent;
 	}