feat: Add search filter to sidebar

package.json

@@ -212,6 +212,18 @@
 				"title": "Coder: Open App Status",
 				"icon": "$(robot)",
 				"when": "coder.authenticated"
+			},
+			{
+				"command": "coder.searchWorkspaces",
+				"title": "Coder: Search Workspaces",
+				"icon": "$(search)",
+				"when": "coder.authenticated && coder.isOwner"
+			},
+			{
+				"command": "coder.clearWorkspaceSearch",
+				"title": "Coder: Clear Workspace Search",
+				"icon": "$(clear-all)",
+				"when": "coder.authenticated && coder.isOwner"
 			}
 		],
 		"menus": {
@@ -239,6 +251,21 @@
 					"command": "coder.refreshWorkspaces",
 					"when": "coder.authenticated && view == myWorkspaces",
 					"group": "navigation"
+				},
+				{
+					"command": "coder.searchWorkspaces",
+					"when": "coder.authenticated && coder.isOwner && view == allWorkspaces",
+					"group": "navigation"
+				},
+				{
+					"command": "coder.refreshWorkspaces",
+					"when": "coder.authenticated && coder.isOwner && view == allWorkspaces",
+					"group": "navigation"
+				},
+				{
+					"command": "coder.clearWorkspaceSearch",
+					"when": "coder.authenticated && coder.isOwner && view == allWorkspaces",
+					"group": "navigation"
 				}
 			],
 			"view/item/context": [

src/commands.ts

@@ -684,6 +684,53 @@ export class Commands {
 		});
 	}
 
+	/**
+	 * Search/filter workspaces in the All Workspaces view.
+	 * This method will be called from the view title menu.
+	 */
+	public async searchWorkspaces(): Promise<void> {
+		const quickPick = vscode.window.createQuickPick();
+		quickPick.placeholder =
+			"Type to search workspaces by name, owner, template, status, or agent";
+		quickPick.title = "Search All Workspaces";
+		quickPick.value = "";
+
+		// Get current search filter to show in the input
+		const currentFilter = (await vscode.commands.executeCommand(
+			"coder.getWorkspaceSearchFilter",
+		)) as string;
+		if (currentFilter) {
+			quickPick.value = currentFilter;
+		}
+
+		quickPick.ignoreFocusOut = true; // Keep open when clicking elsewhere
+		quickPick.canSelectMany = false; // Don't show selection list
+
+		quickPick.onDidChangeValue((value) => {
+			// Update the search filter in real-time as user types
+			vscode.commands.executeCommand("coder.setWorkspaceSearchFilter", value);
+		});
+
+		quickPick.onDidAccept(() => {
+			// When user presses Enter, close the search
+			quickPick.hide();
+		});
+
+		quickPick.onDidHide(() => {
+			// Don't clear the search when closed - keep the filter active
+			quickPick.dispose();
+		});
+
+		quickPick.show();
+	}
+
+	/**
+	 * Clear the workspace search filter.
+	 */
+	public clearWorkspaceSearch(): void {
+		vscode.commands.executeCommand("coder.setWorkspaceSearchFilter", "");
+	}
+
 	/**
 	 * Return agents from the workspace.
 	 *

src/extension.ts

@@ -290,6 +290,23 @@ export async function activate(ctx: vscode.ExtensionContext): Promise<void> {
 		"coder.viewLogs",
 		commands.viewLogs.bind(commands),
 	);
+	vscode.commands.registerCommand(
+		"coder.searchWorkspaces",
+		commands.searchWorkspaces.bind(commands),
+	);
+	vscode.commands.registerCommand(
+		"coder.setWorkspaceSearchFilter",
+		(searchTerm: string) => {
+			allWorkspacesProvider.setSearchFilter(searchTerm);
+		},
+	);
+	vscode.commands.registerCommand("coder.getWorkspaceSearchFilter", () => {
+		return allWorkspacesProvider.getSearchFilter();
+	});
+	vscode.commands.registerCommand(
+		"coder.clearWorkspaceSearch",
+		commands.clearWorkspaceSearch.bind(commands),
+	);
 
 	// Since the "onResolveRemoteAuthority:ssh-remote" activation event exists
 	// in package.json we're able to perform actions before the authority is

src/workspacesProvider.ts

@@ -42,6 +42,7 @@ export class WorkspaceProvider
 	private timeout: NodeJS.Timeout | undefined;
 	private fetching = false;
 	private visible = false;
+	private searchFilter = "";
 
 	constructor(
 		private readonly getWorkspacesQuery: WorkspaceQuery,
@@ -52,6 +53,15 @@ export class WorkspaceProvider
 		// No initialization.
 	}
 
+	setSearchFilter(filter: string) {
+		this.searchFilter = filter;
+		this.refresh(undefined);
+	}
+
+	getSearchFilter(): string {
+		return this.searchFilter;
+	}
+
 	// fetchAndRefresh fetches new workspaces, re-renders the entire tree, then
 	// keeps refreshing (if a timer length was provided) as long as the user is
 	// still logged in and no errors were encountered fetching workspaces.
@@ -300,7 +310,90 @@ export class WorkspaceProvider
 
 			return Promise.resolve([]);
 		}
-		return Promise.resolve(this.workspaces || []);
+
+		// Filter workspaces based on search term
+		let filteredWorkspaces = this.workspaces || [];
+		const trimmedFilter = this.searchFilter.trim();
+		if (trimmedFilter) {
+			const searchTerm = trimmedFilter.toLowerCase();
+			filteredWorkspaces = filteredWorkspaces.filter((workspace) =>
+				this.matchesSearchTerm(workspace, searchTerm),
+			);
+		}
+
+		return Promise.resolve(filteredWorkspaces);
+	}
+
+	/**
+	 * Check if a workspace matches the given search term using smart search logic.
+	 * Prioritizes exact word matches over substring matches.
+	 */
+	private matchesSearchTerm(
+		workspace: WorkspaceTreeItem,
+		searchTerm: string,
+	): boolean {
+		const workspaceName = workspace.workspace.name.toLowerCase();
+		const ownerName = workspace.workspace.owner_name.toLowerCase();
+		const templateName = (
+			workspace.workspace.template_display_name ||
+			workspace.workspace.template_name ||
+			""
+		).toLowerCase();
+		const status = workspace.workspace.latest_build.status.toLowerCase();
+
+		// Check if any agent names match the search term
+		const agents = extractAgents(workspace.workspace.latest_build.resources);
+		const agentNames = agents.map((agent) => agent.name.toLowerCase());
+		const hasMatchingAgent = agentNames.some((agentName) =>
+			agentName.includes(searchTerm),
+		);
+
+		// Check if any agent metadata contains the search term
+		const hasMatchingMetadata = agents.some((agent) => {
+			const watcher = this.agentWatchers[agent.id];
+			if (watcher?.metadata) {
+				return watcher.metadata.some((metadata) => {
+					const metadataStr = JSON.stringify(metadata).toLowerCase();
+					return metadataStr.includes(searchTerm);
+				});
+			}
+			return false;
+		});
+
+		// Smart search: Try exact word match first, then fall back to substring
+		const searchWords = searchTerm
+			.split(/\s+/)
+			.filter((word) => word.length > 0);
+		const allText = [
+			workspaceName,
+			ownerName,
+			templateName,
+			status,
+			...agentNames,
+		].join(" ");
+
+		// Check for exact word matches (higher priority)
+		const hasExactWordMatch =
+			searchWords.length > 0 &&
+			searchWords.some((word) => {
+				// Escape special regex characters to prevent injection
+				const escapedWord = word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+				const wordBoundaryRegex = new RegExp(`\\b${escapedWord}\\b`, "i");
+				return wordBoundaryRegex.test(allText);
+			});
+
+		// Check for substring matches (lower priority) - only if no exact word match
+		const hasSubstringMatch =
+			!hasExactWordMatch &&
+			(workspaceName.includes(searchTerm) ||
+				ownerName.includes(searchTerm) ||
+				templateName.includes(searchTerm) ||
+				status.includes(searchTerm) ||
+				hasMatchingAgent ||
+				hasMatchingMetadata);
+
+		// Return true if either exact word match or substring match
+		return hasExactWordMatch || hasSubstringMatch;
 	}
 }