Merge remote-tracking branch 'github/main' into asher/binary-verification

Author: code-asher

CHANGELOG.md

@@ -13,6 +13,14 @@
   and configFile are provided.
 - Add `coder.disableUpdateNotifications` setting to disable workspace template
   update notifications.
+- Coder output panel enhancements: All log entries now include timestamps, and you
+  can filter messages by log level in the panel.
+- Consistently use the same session for each agent. Previously,
+  depending on how you connected, it could be possible to get two
+  different sessions for an agent. Existing connections may still
+  have this problem, only new connections are fixed.
+- Added an agent metadata monitor status bar item, so you can view your active
+  agent metadata at a glance.
 - Add binary signature verification. This can be disabled with
   `coder.disableSignatureVerification` if you purposefully run a binary that is
   not signed by Coder (for example a binary you built yourself).

package.json

@@ -295,8 +295,8 @@
 		"memfs": "^4.17.1",
 		"node-forge": "^1.3.1",
 		"openpgp": "^6.2.0",
-		"pretty-bytes": "^6.1.1",
-		"proxy-agent": "^6.4.0",
+		"pretty-bytes": "^7.0.0",
+		"proxy-agent": "^6.5.0",
 		"semver": "^7.7.1",
 		"ua-parser-js": "1.0.40",
 		"ws": "^8.18.2",
@@ -314,7 +314,7 @@
 		"@typescript-eslint/parser": "^6.21.0",
 		"@vscode/test-cli": "^0.0.10",
 		"@vscode/test-electron": "^2.5.2",
-		"@vscode/vsce": "^2.21.1",
+		"@vscode/vsce": "^3.6.0",
 		"bufferutil": "^4.0.9",
 		"coder": "https://github.com/coder/coder#main",
 		"dayjs": "^1.11.13",
@@ -329,8 +329,7 @@
 		"nyc": "^17.1.0",
 		"prettier": "^3.5.3",
 		"ts-loader": "^9.5.1",
-		"tsc-watch": "^6.2.1",
-		"typescript": "^5.4.5",
+		"typescript": "^5.8.3",
 		"utf-8-validate": "^6.0.5",
 		"vitest": "^0.34.6",
 		"vscode-test": "^1.5.0",

src/agentMetadataHelper.ts

@@ -0,0 +1,81 @@
+import { Api } from "coder/site/src/api/api";
+import { WorkspaceAgent } from "coder/site/src/api/typesGenerated";
+import { EventSource } from "eventsource";
+import * as vscode from "vscode";
+import { createStreamingFetchAdapter } from "./api";
+import {
+	AgentMetadataEvent,
+	AgentMetadataEventSchemaArray,
+	errToStr,
+} from "./api-helper";
+
+export type AgentMetadataWatcher = {
+	onChange: vscode.EventEmitter<null>["event"];
+	dispose: () => void;
+	metadata?: AgentMetadataEvent[];
+	error?: unknown;
+};
+
+/**
+ * Opens an SSE connection to watch metadata for a given workspace agent.
+ * Emits onChange when metadata updates or an error occurs.
+ */
+export function createAgentMetadataWatcher(
+	agentId: WorkspaceAgent["id"],
+	restClient: Api,
+): AgentMetadataWatcher {
+	// TODO: Is there a better way to grab the url and token?
+	const url = restClient.getAxiosInstance().defaults.baseURL;
+	const metadataUrl = new URL(
+		`${url}/api/v2/workspaceagents/${agentId}/watch-metadata`,
+	);
+	const eventSource = new EventSource(metadataUrl.toString(), {
+		fetch: createStreamingFetchAdapter(restClient.getAxiosInstance()),
+	});
+
+	let disposed = false;
+	const onChange = new vscode.EventEmitter<null>();
+	const watcher: AgentMetadataWatcher = {
+		onChange: onChange.event,
+		dispose: () => {
+			if (!disposed) {
+				eventSource.close();
+				disposed = true;
+			}
+		},
+	};
+
+	eventSource.addEventListener("data", (event) => {
+		try {
+			const dataEvent = JSON.parse(event.data);
+			const metadata = AgentMetadataEventSchemaArray.parse(dataEvent);
+
+			// Overwrite metadata if it changed.
+			if (JSON.stringify(watcher.metadata) !== JSON.stringify(metadata)) {
+				watcher.metadata = metadata;
+				onChange.fire(null);
+			}
+		} catch (error) {
+			watcher.error = error;
+			onChange.fire(null);
+		}
+	});
+
+	return watcher;
+}
+
+export function formatMetadataError(error: unknown): string {
+	return "Failed to query metadata: " + errToStr(error, "no error provided");
+}
+
+export function formatEventLabel(metadataEvent: AgentMetadataEvent): string {
+	return getEventName(metadataEvent) + ": " + getEventValue(metadataEvent);
+}
+
+export function getEventName(metadataEvent: AgentMetadataEvent): string {
+	return metadataEvent.description.display_name.trim();
+}
+
+export function getEventValue(metadataEvent: AgentMetadataEvent): string {
+	return metadataEvent.result.value.replace(/\n/g, "").trim();
+}

src/api.ts

@@ -12,6 +12,7 @@ import * as vscode from "vscode";
 import * as ws from "ws";
 import { errToStr } from "./api-helper";
 import { CertificateError } from "./error";
+import { FeatureSet } from "./featureSet";
 import { getHeaderArgs } from "./headers";
 import { getProxyForUrl } from "./proxy";
 import { Storage } from "./storage";
@@ -174,6 +175,7 @@ export async function startWorkspaceIfStoppedOrFailed(
 	binPath: string,
 	workspace: Workspace,
 	writeEmitter: vscode.EventEmitter<string>,
+	featureSet: FeatureSet,
 ): Promise<Workspace> {
 	// Before we start a workspace, we make an initial request to check it's not already started
 	const updatedWorkspace = await restClient.getWorkspace(workspace.id);
@@ -191,6 +193,10 @@ export async function startWorkspaceIfStoppedOrFailed(
 			"--yes",
 			workspace.owner_name + "/" + workspace.name,
 		];
+		if (featureSet.buildReason) {
+			startArgs.push(...["--reason", "vscode_connection"]);
+		}
+
 		const startProcess = spawn(binPath, startArgs);
 
 		startProcess.stdout.on("data", (data: Buffer) => {

src/commands.ts

@@ -437,12 +437,15 @@ export class Commands {
 			if (!baseUrl) {
 				throw new Error("You are not logged in");
 			}
+			if (treeItem.primaryAgentName === undefined) {
+				return;
+			}
 			await openWorkspace(
 				baseUrl,
 				treeItem.workspaceOwner,
 				treeItem.workspaceName,
-				treeItem.workspaceAgent,
-				treeItem.workspaceFolderPath,
+				treeItem.primaryAgentName,
+				treeItem.primaryAgentFolderPath,
 				true,
 			);
 		} else {
@@ -525,6 +528,8 @@ export class Commands {
 		let folderPath: string | undefined;
 		let openRecent: boolean | undefined;
 
+		let workspace: Workspace | undefined;
+
 		const baseUrl = this.restClient.getAxiosInstance().defaults.baseURL;
 		if (!baseUrl) {
 			throw new Error("You are not logged in");
@@ -571,7 +576,7 @@ export class Commands {
 					});
 			});
 			quickPick.show();
-			const workspace = await new Promise<Workspace | undefined>((resolve) => {
+			workspace = await new Promise<Workspace | undefined>((resolve) => {
 				quickPick.onDidHide(() => {
 					resolve(undefined);
 				});
@@ -590,20 +595,31 @@ export class Commands {
 			}
 			workspaceOwner = workspace.owner_name;
 			workspaceName = workspace.name;
+		} else {
+			workspaceOwner = args[0] as string;
+			workspaceName = args[1] as string;
+			workspaceAgent = args[2] as string | undefined;
+			folderPath = args[3] as string | undefined;
+			openRecent = args[4] as boolean | undefined;
+		}
+
+		if (!workspaceAgent) {
+			if (workspace === undefined) {
+				workspace = await this.restClient.getWorkspaceByOwnerAndName(
+					workspaceOwner,
+					workspaceName,
+				);
+			}
 
 			const agent = await this.maybeAskAgent(workspace);
 			if (!agent) {
 				// User declined to pick an agent.
 				return;
 			}
-			folderPath = agent.expanded_directory;
+			if (!folderPath) {
+				folderPath = agent.expanded_directory;
+			}
 			workspaceAgent = agent.name;
-		} else {
-			workspaceOwner = args[0] as string;
-			workspaceName = args[1] as string;
-			workspaceAgent = args[2] as string | undefined;
-			folderPath = args[3] as string | undefined;
-			openRecent = args[4] as boolean | undefined;
 		}
 
 		await openWorkspace(
@@ -655,14 +671,15 @@ export class Commands {
 		if (!this.workspace || !this.workspaceRestClient) {
 			return;
 		}
-		const action = await this.vscodeProposed.window.showInformationMessage(
+		const action = await this.vscodeProposed.window.showWarningMessage(
 			"Update Workspace",
 			{
 				useCustom: true,
 				modal: true,
-				detail: `Update ${this.workspace.owner_name}/${this.workspace.name} to the latest version?`,
+				detail: `Update ${this.workspace.owner_name}/${this.workspace.name} to the latest version?\n\nUpdating will restart your workspace which stops any running processes and may result in the loss of unsaved work.`,
 			},
 			"Update",
+			"Cancel",
 		);
 		if (action === "Update") {
 			await this.workspaceRestClient.updateWorkspaceVersion(this.workspace);
@@ -678,7 +695,7 @@ async function openWorkspace(
 	baseUrl: string,
 	workspaceOwner: string,
 	workspaceName: string,
-	workspaceAgent: string | undefined,
+	workspaceAgent: string,
 	folderPath: string | undefined,
 	openRecent: boolean | undefined,
 ) {

src/featureSet.ts

@@ -4,6 +4,7 @@ export type FeatureSet = {
 	vscodessh: boolean;
 	proxyLogDirectory: boolean;
 	wildcardSSH: boolean;
+	buildReason: boolean;
 };
 
 /**
@@ -29,5 +30,10 @@ export function featureSetForVersion(
 		wildcardSSH:
 			(version ? version.compare("2.19.0") : -1) >= 0 ||
 			version?.prerelease[0] === "devel",
+
+		// The --reason flag was added to `coder start` in 2.25.0
+		buildReason:
+			(version?.compare("2.25.0") || 0) >= 0 ||
+			version?.prerelease[0] === "devel",
 	};
 }

src/remote.ts

@@ -1,6 +1,6 @@
 import { isAxiosError } from "axios";
 import { Api } from "coder/site/src/api/api";
-import { Workspace } from "coder/site/src/api/typesGenerated";
+import { Workspace, WorkspaceAgent } from "coder/site/src/api/typesGenerated";
 import find from "find-process";
 import * as fs from "fs/promises";
 import * as jsonc from "jsonc-parser";
@@ -9,6 +9,12 @@ import * as path from "path";
 import prettyBytes from "pretty-bytes";
 import * as semver from "semver";
 import * as vscode from "vscode";
+import {
+	createAgentMetadataWatcher,
+	getEventValue,
+	formatEventLabel,
+	formatMetadataError,
+} from "./agentMetadataHelper";
 import {
 	createHttpAgent,
 	makeCoderSdk,
@@ -68,6 +74,7 @@ export class Remote {
 		workspace: Workspace,
 		label: string,
 		binPath: string,
+		featureSet: FeatureSet,
 	): Promise<Workspace | undefined> {
 		const workspaceName = `${workspace.owner_name}/${workspace.name}`;
 
@@ -136,6 +143,7 @@ export class Remote {
 									binPath,
 									workspace,
 									writeEmitter,
+									featureSet,
 								);
 								break;
 							case "failed":
@@ -153,6 +161,7 @@ export class Remote {
 										binPath,
 										workspace,
 										writeEmitter,
+										featureSet,
 									);
 									break;
 								}
@@ -383,6 +392,7 @@ export class Remote {
 				workspace,
 				parts.label,
 				binaryPath,
+				featureSet,
 			);
 			if (!updatedWorkspace) {
 				// User declined to start the workspace.
@@ -620,6 +630,10 @@ export class Remote {
 			}),
 		);
 
+		disposables.push(
+			...this.createAgentMetadataStatusBar(agent, workspaceRestClient),
+		);
+
 		this.storage.output.info("Remote setup complete");
 
 		// Returning the URL and token allows the plugin to authenticate its own
@@ -962,6 +976,56 @@ export class Remote {
 		return loop();
 	}
 
+	/**
+	 * Creates and manages a status bar item that displays metadata information for a given workspace agent.
+	 * The status bar item updates dynamically based on changes to the agent's metadata,
+	 * and hides itself if no metadata is available or an error occurs.
+	 */
+	private createAgentMetadataStatusBar(
+		agent: WorkspaceAgent,
+		restClient: Api,
+	): vscode.Disposable[] {
+		const statusBarItem = vscode.window.createStatusBarItem(
+			"agentMetadata",
+			vscode.StatusBarAlignment.Left,
+		);
+
+		const agentWatcher = createAgentMetadataWatcher(agent.id, restClient);
+
+		const onChangeDisposable = agentWatcher.onChange(() => {
+			if (agentWatcher.error) {
+				const errMessage = formatMetadataError(agentWatcher.error);
+				this.storage.output.warn(errMessage);
+
+				statusBarItem.text = "$(warning) Agent Status Unavailable";
+				statusBarItem.tooltip = errMessage;
+				statusBarItem.color = new vscode.ThemeColor(
+					"statusBarItem.warningForeground",
+				);
+				statusBarItem.backgroundColor = new vscode.ThemeColor(
+					"statusBarItem.warningBackground",
+				);
+				statusBarItem.show();
+				return;
+			}
+
+			if (agentWatcher.metadata && agentWatcher.metadata.length > 0) {
+				statusBarItem.text =
+					"$(dashboard) " + getEventValue(agentWatcher.metadata[0]);
+				statusBarItem.tooltip = agentWatcher.metadata
+					.map((metadata) => formatEventLabel(metadata))
+					.join("\n");
+				statusBarItem.color = undefined;
+				statusBarItem.backgroundColor = undefined;
+				statusBarItem.show();
+			} else {
+				statusBarItem.hide();
+			}
+		});
+
+		return [statusBarItem, agentWatcher, onChangeDisposable];
+	}
+
 	// closeRemote ends the current remote session.
 	public async closeRemote() {
 		await vscode.commands.executeCommand("workbench.action.remote.close");