support showing symlimk details in terminal suggest (#251296)

Author: meganrogge

extensions/terminal-suggest/src/env/pathExecutableCache.ts

@@ -76,7 +76,7 @@ export class PathExecutableCache implements vscode.Disposable {
 		const promises: Promise<Set<ICompletionResource> | undefined>[] = [];
 		const labels: Set<string> = new Set<string>();
 		for (const path of paths) {
-			promises.push(this._getFilesInPath(path, pathSeparator, labels));
+			promises.push(this._getExecutablesInPath(path, pathSeparator, labels));
 		}
 
 		// Merge all results
@@ -96,7 +96,7 @@ export class PathExecutableCache implements vscode.Disposable {
 		return this._cachedExes;
 	}
 
-	private async _getFilesInPath(path: string, pathSeparator: string, labels: Set<string>): Promise<Set<ICompletionResource> | undefined> {
+	private async _getExecutablesInPath(path: string, pathSeparator: string, labels: Set<string>): Promise<Set<ICompletionResource> | undefined> {
 		try {
 			const dirExists = await fs.stat(path).then(stat => stat.isDirectory()).catch(() => false);
 			if (!dirExists) {
@@ -106,11 +106,53 @@ export class PathExecutableCache implements vscode.Disposable {
 			const fileResource = vscode.Uri.file(path);
 			const files = await vscode.workspace.fs.readDirectory(fileResource);
 			for (const [file, fileType] of files) {
-				const formattedPath = getFriendlyResourcePath(vscode.Uri.joinPath(fileResource, file), pathSeparator);
-				if (!labels.has(file) && fileType !== vscode.FileType.Unknown && fileType !== vscode.FileType.Directory && await isExecutable(formattedPath, this._cachedWindowsExeExtensions)) {
-					result.add({ label: file, documentation: formattedPath, kind: vscode.TerminalCompletionItemKind.Method });
-					labels.add(file);
+				let kind: vscode.TerminalCompletionItemKind | undefined;
+				let formattedPath: string | undefined;
+				const resource = vscode.Uri.joinPath(fileResource, file);
+
+				// Skip unknown or directory file types early
+				if (fileType === vscode.FileType.Unknown || fileType === vscode.FileType.Directory) {
+					continue;
+				}
+
+				try {
+					const lstat = await fs.lstat(resource.fsPath);
+					if (lstat.isSymbolicLink()) {
+						try {
+							const symlinkRealPath = await fs.realpath(resource.fsPath);
+							const isExec = await isExecutable(symlinkRealPath, this._cachedWindowsExeExtensions);
+							if (!isExec) {
+								continue;
+							}
+							kind = vscode.TerminalCompletionItemKind.Method;
+							formattedPath = `${resource.fsPath} -> ${symlinkRealPath}`;
+						} catch {
+							continue;
+						}
+					}
+				} catch {
+					// Ignore errors for unreadable files
+					continue;
+				}
+
+				formattedPath = formattedPath ?? getFriendlyResourcePath(resource, pathSeparator);
+
+				// Check if already added or not executable
+				if (labels.has(file)) {
+					continue;
 				}
+
+				const isExec = kind === vscode.TerminalCompletionItemKind.Method || await isExecutable(formattedPath, this._cachedWindowsExeExtensions);
+				if (!isExec) {
+					continue;
+				}
+
+				result.add({
+					label: file,
+					documentation: formattedPath,
+					kind: kind ?? vscode.TerminalCompletionItemKind.Method
+				});
+				labels.add(file);
 			}
 			return result;
 		} catch (e) {

extensions/terminal-suggest/src/test/env/pathExecutableCache.test.ts

@@ -5,6 +5,7 @@
 
 import 'mocha';
 import { strictEqual } from 'node:assert';
+import type { MarkdownString } from 'vscode';
 import { PathExecutableCache } from '../../env/pathExecutableCache';
 
 suite('PathExecutableCache', () => {
@@ -31,4 +32,39 @@ suite('PathExecutableCache', () => {
 		const result2 = await cache.getExecutablesInPath(env);
 		strictEqual(result !== result2, true);
 	});
+
+	if (process.platform !== 'win32') {
+		test('cache should include executables found via symbolic links', async () => {
+			const path = require('path');
+			// Always use the source fixture directory to ensure symlinks are present
+			const fixtureDir = path.resolve(__dirname.replace(/out[\/].*$/, 'src/test/env'), '../fixtures/symlink-test');
+			const env = { PATH: fixtureDir };
+			const cache = new PathExecutableCache();
+			const result = await cache.getExecutablesInPath(env);
+			cache.refresh();
+			const labels = Array.from(result!.labels!);
+
+			strictEqual(labels.includes('real-executable.sh'), true);
+			strictEqual(labels.includes('symlink-executable.sh'), true);
+			strictEqual(result?.completionResources?.size, 2);
+
+			const completionResources = result!.completionResources!;
+			let realDocRaw: string | MarkdownString | undefined = undefined;
+			let symlinkDocRaw: string | MarkdownString | undefined = undefined;
+			for (const resource of completionResources) {
+				if (resource.label === 'real-executable.sh') {
+					realDocRaw = resource.documentation;
+				} else if (resource.label === 'symlink-executable.sh') {
+					symlinkDocRaw = resource.documentation;
+				}
+			}
+			const realDoc = typeof realDocRaw === 'string' ? realDocRaw : (realDocRaw && 'value' in realDocRaw ? realDocRaw.value : undefined);
+			const symlinkDoc = typeof symlinkDocRaw === 'string' ? symlinkDocRaw : (symlinkDocRaw && 'value' in symlinkDocRaw ? symlinkDocRaw.value : undefined);
+
+			const realPath = path.join(fixtureDir, 'real-executable.sh');
+			const symlinkPath = path.join(fixtureDir, 'symlink-executable.sh');
+			strictEqual(realDoc, realPath);
+			strictEqual(symlinkDoc, `${symlinkPath} -> ${realPath}`);
+		});
+	}
 });

extensions/terminal-suggest/src/test/fixtures/symlink-test/real-executable.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+echo "real executable"

extensions/terminal-suggest/src/test/fixtures/symlink-test/symlink-executable.sh

@@ -0,0 +1 @@
+real-executable.sh