Merge branch 'main' into tyriar/update_cursor_still__suggest__2

Author: Tyriar

package.json

@@ -1,7 +1,7 @@
 {
   "name": "code-oss-dev",
   "version": "1.89.0",
-  "distro": "853f475a6e8e85ad811a2f8e49c3032bdb660558",
+  "distro": "a6c3333a909e54cb5353b27766ec4388e5f50cd8",
   "author": {
     "name": "Microsoft Corporation"
   },

src/vs/base/common/product.ts

@@ -190,6 +190,7 @@ export interface IProductConfiguration {
 	readonly aiGeneratedWorkspaceTrust?: IAiGeneratedWorkspaceTrust;
 	readonly gitHubEntitlement?: IGitHubEntitlement;
 	readonly chatWelcomeView?: IChatWelcomeView;
+	readonly chatParticipantRegistry?: string;
 }
 
 export interface ITunnelApplicationConfig {

src/vs/platform/files/common/watcher.ts

@@ -135,14 +135,14 @@ export interface IRecursiveWatcherWithSubscribe extends IRecursiveWatcher {
 
 	/**
 	 * Subscribe to file events for the given path. The callback is called
-	 * whenever a file event occurs for the path. I fthe watcher failed,
+	 * whenever a file event occurs for the path. If the watcher failed,
 	 * the error parameter is set to `true`.
 	 *
 	 * @returns an `IDisposable` to stop listening to events or `undefined`
 	 * if no events can be watched for the path given the current set of
 	 * recursive watch requests.
 	 */
-	subscribe(path: string, callback: (error: boolean, change?: IFileChange) => void): IDisposable | undefined;
+	subscribe(path: string, callback: (error: true | null, change?: IFileChange) => void): IDisposable | undefined;
 }
 
 export interface IRecursiveWatcherOptions {

src/vs/platform/files/node/watcher/nodejs/nodejsWatcherLib.ts

@@ -147,7 +147,12 @@ export class NodeJSFileWatcherLibrary extends Disposable {
 
 	private doWatchWithExistingWatcher(realPath: string, isDirectory: boolean, disposables: DisposableStore): boolean {
 		if (isDirectory) {
-			return false; // only supported for files where we have the full path known upfront
+			// TODO@bpasero recursive watcher re-use is currently not enabled
+			// for when folders are watched. this is because the dispatching
+			// in the recursive watcher for non-recurive requests is optimized
+			// for file changes  where we really only match on the exact path
+			// and not child paths.
+			return false;
 		}
 
 		const resource = URI.file(this.request.path);

src/vs/platform/files/node/watcher/parcel/parcelWatcher.ts

@@ -782,7 +782,7 @@ export class ParcelWatcher extends BaseWatcher implements IRecursiveWatcherWithS
 		return true;
 	}
 
-	subscribe(path: string, callback: (error: boolean, change?: IFileChange) => void): IDisposable | undefined {
+	subscribe(path: string, callback: (error: true | null, change?: IFileChange) => void): IDisposable | undefined {
 		for (const watcher of this.watchers) {
 			if (watcher.failed) {
 				continue; // watcher has already failed
@@ -810,7 +810,7 @@ export class ParcelWatcher extends BaseWatcher implements IRecursiveWatcherWithS
 				callback(true /* error */);
 			}));
 			disposables.add(Event.once(watcher.onDidFail)(() => callback(true /* error */)));
-			disposables.add(watcher.subscribe(path, change => callback(false, change)));
+			disposables.add(watcher.subscribe(path, change => callback(null, change)));
 
 			return disposables;
 		}

src/vs/platform/files/node/watcher/watcherStats.ts

@@ -38,19 +38,31 @@ export function computeStats(
 	lines.push(`- I/O Handles Impact:     total: ${recursiveRequestsStatus.polling + nonRecursiveRequestsStatus.polling + recursiveWatcherStatus.active + nonRecursiveWatcherStatus.active}`);
 
 	lines.push(`\n[Recursive Requests (${allRecursiveRequests.length}, suspended: ${recursiveRequestsStatus.suspended}, polling: ${recursiveRequestsStatus.polling})]:`);
+	const recursiveRequestLines: string[] = [];
 	for (const request of [nonSuspendedRecursiveRequests, suspendedPollingRecursiveRequests, suspendedNonPollingRecursiveRequests].flat()) {
-		fillRequestStats(lines, request, recursiveWatcher);
+		fillRequestStats(recursiveRequestLines, request, recursiveWatcher);
 	}
+	lines.push(...alignTextColumns(recursiveRequestLines));
 
-	fillRecursiveWatcherStats(lines, recursiveWatcher);
+	const recursiveWatcheLines: string[] = [];
+	fillRecursiveWatcherStats(recursiveWatcheLines, recursiveWatcher);
+	lines.push(...alignTextColumns(recursiveWatcheLines));
 
 	lines.push(`\n[Non-Recursive Requests (${allNonRecursiveRequests.length}, suspended: ${nonRecursiveRequestsStatus.suspended}, polling: ${nonRecursiveRequestsStatus.polling})]:`);
+	const nonRecursiveRequestLines: string[] = [];
 	for (const request of [nonSuspendedNonRecursiveRequests, suspendedPollingNonRecursiveRequests, suspendedNonPollingNonRecursiveRequests].flat()) {
-		fillRequestStats(lines, request, nonRecursiveWatcher);
+		fillRequestStats(nonRecursiveRequestLines, request, nonRecursiveWatcher);
 	}
+	lines.push(...alignTextColumns(nonRecursiveRequestLines));
 
-	fillNonRecursiveWatcherStats(lines, nonRecursiveWatcher);
+	const nonRecursiveWatcheLines: string[] = [];
+	fillNonRecursiveWatcherStats(nonRecursiveWatcheLines, nonRecursiveWatcher);
+	lines.push(...alignTextColumns(nonRecursiveWatcheLines));
 
+	return `\n\n[File Watcher] request stats:\n\n${lines.join('\n')}\n\n`;
+}
+
+function alignTextColumns(lines: string[]) {
 	let maxLength = 0;
 	for (const line of lines) {
 		maxLength = Math.max(maxLength, line.split('\t')[0].length);
@@ -65,7 +77,7 @@ export function computeStats(
 		}
 	}
 
-	return `\n\n[File Watcher] request stats:\n\n${lines.join('\n')}\n\n`;
+	return lines;
 }
 
 function computeRequestStatus(requests: IUniversalWatchRequest[], watcher: ParcelWatcher | NodeJSWatcher): { suspended: number; polling: number } {

src/vs/platform/utilityProcess/electron-main/utilityProcess.ts

@@ -168,6 +168,7 @@ export class UtilityProcess extends Disposable {
 	private process: ElectronUtilityProcess | undefined = undefined;
 	private processPid: number | undefined = undefined;
 	private configuration: IUtilityProcessConfiguration | undefined = undefined;
+	private killed = false;
 
 	constructor(
 		@ILogService private readonly logService: ILogService,
@@ -314,18 +315,19 @@ export class UtilityProcess extends Disposable {
 
 		// Exit
 		this._register(Event.fromNodeEventEmitter<number>(process, 'exit')(code => {
-			this.log(`received exit event with code ${code}`, Severity.Info);
+			const normalizedCode = this.isNormalExit(code) ? 0 : code;
+			this.log(`received exit event with code ${normalizedCode}`, Severity.Info);
 
 			// Event
-			this._onExit.fire({ pid: this.processPid!, code, signal: 'unknown' });
+			this._onExit.fire({ pid: this.processPid!, code: normalizedCode, signal: 'unknown' });
 
 			// Cleanup
 			this.onDidExitOrCrashOrKill();
 		}));
 
 		// Child process gone
 		this._register(Event.fromNodeEventEmitter<{ details: Details }>(app, 'child-process-gone', (event, details) => ({ event, details }))(({ details }) => {
-			if (details.type === 'Utility' && details.name === serviceName) {
+			if (details.type === 'Utility' && details.name === serviceName && !this.isNormalExit(details.exitCode)) {
 				this.log(`crashed with code ${details.exitCode} and reason '${details.reason}'`, Severity.Error);
 
 				// Telemetry
@@ -415,12 +417,24 @@ export class UtilityProcess extends Disposable {
 		const killed = this.process.kill();
 		if (killed) {
 			this.log('successfully killed the process', Severity.Info);
+			this.killed = true;
 			this.onDidExitOrCrashOrKill();
 		} else {
 			this.log('unable to kill the process', Severity.Warning);
 		}
 	}
 
+	private isNormalExit(exitCode: number): boolean {
+		if (exitCode === 0) {
+			return true;
+		}
+
+		// Treat an exit code of 15 (SIGTERM) as a normal exit
+		// if we triggered the termination from process.kill()
+
+		return this.killed && exitCode === 15 /* SIGTERM */;
+	}
+
 	private onDidExitOrCrashOrKill(): void {
 		if (typeof this.processPid === 'number') {
 			UtilityProcess.all.delete(this.processPid);

src/vs/workbench/contrib/chat/browser/chat.contribution.ts

@@ -42,7 +42,7 @@ import { ChatWidgetService } from 'vs/workbench/contrib/chat/browser/chatWidget'
 import { ChatCodeBlockContextProviderService } from 'vs/workbench/contrib/chat/browser/codeBlockContextProviderService';
 import 'vs/workbench/contrib/chat/browser/contrib/chatHistoryVariables';
 import 'vs/workbench/contrib/chat/browser/contrib/chatInputEditorContrib';
-import { ChatAgentLocation, ChatAgentService, IChatAgentService } from 'vs/workbench/contrib/chat/common/chatAgents';
+import { ChatAgentLocation, ChatAgentService, IChatAgentService, IChatAgentNameService, ChatAgentNameService } from 'vs/workbench/contrib/chat/common/chatAgents';
 import { CONTEXT_IN_CHAT_SESSION } from 'vs/workbench/contrib/chat/common/chatContextKeys';
 import { ChatWelcomeMessageModel } from 'vs/workbench/contrib/chat/common/chatModel';
 import { chatAgentLeader, chatSubcommandLeader, chatVariableLeader } from 'vs/workbench/contrib/chat/common/chatParserTypes';
@@ -342,6 +342,7 @@ registerSingleton(IChatWidgetHistoryService, ChatWidgetHistoryService, Instantia
 registerSingleton(ILanguageModelsService, LanguageModelsService, InstantiationType.Delayed);
 registerSingleton(IChatSlashCommandService, ChatSlashCommandService, InstantiationType.Delayed);
 registerSingleton(IChatAgentService, ChatAgentService, InstantiationType.Delayed);
+registerSingleton(IChatAgentNameService, ChatAgentNameService, InstantiationType.Delayed);
 registerSingleton(IChatVariablesService, ChatVariablesService, InstantiationType.Delayed);
 registerSingleton(IVoiceChatService, VoiceChatService, InstantiationType.Delayed);
 registerSingleton(IChatCodeBlockContextProviderService, ChatCodeBlockContextProviderService, InstantiationType.Delayed);

src/vs/workbench/contrib/chat/browser/chatListRenderer.ts

@@ -54,7 +54,7 @@ import { ChatFollowups } from 'vs/workbench/contrib/chat/browser/chatFollowups';
 import { ChatMarkdownDecorationsRenderer } from 'vs/workbench/contrib/chat/browser/chatMarkdownDecorationsRenderer';
 import { ChatEditorOptions } from 'vs/workbench/contrib/chat/browser/chatOptions';
 import { ChatCodeBlockContentProvider, CodeBlockPart, CodeCompareBlockPart, ICodeBlockData, localFileLanguageId, parseLocalFileData } from 'vs/workbench/contrib/chat/browser/codeBlockPart';
-import { ChatAgentLocation, IChatAgentMetadata } from 'vs/workbench/contrib/chat/common/chatAgents';
+import { ChatAgentLocation, IChatAgentMetadata, IChatAgentNameService } from 'vs/workbench/contrib/chat/common/chatAgents';
 import { CONTEXT_CHAT_RESPONSE_SUPPORT_ISSUE_REPORTING, CONTEXT_REQUEST, CONTEXT_RESPONSE, CONTEXT_RESPONSE_DETECTED_AGENT_COMMAND, CONTEXT_RESPONSE_FILTERED, CONTEXT_RESPONSE_VOTE } from 'vs/workbench/contrib/chat/common/chatContextKeys';
 import { IChatProgressRenderableResponseContent } from 'vs/workbench/contrib/chat/common/chatModel';
 import { chatAgentLeader, chatSubcommandLeader } from 'vs/workbench/contrib/chat/common/chatParserTypes';
@@ -71,6 +71,8 @@ import { createTextBufferFactoryFromSnapshot } from 'vs/editor/common/model/text
 import { TextEdit } from 'vs/editor/common/languages';
 import { IChatListItemRendererOptions } from './chat';
 import { CancellationTokenSource } from 'vs/base/common/cancellation';
+import { autorun, constObservable, IObservable } from 'vs/base/common/observable';
+import { isUndefined } from 'vs/base/common/types';
 
 const $ = dom.$;
 
@@ -146,6 +148,7 @@ export class ChatListItemRenderer extends Disposable implements ITreeRenderer<Ch
 		@ICommandService private readonly commandService: ICommandService,
 		@ITextModelService private readonly textModelService: ITextModelService,
 		@IModelService private readonly modelService: IModelService,
+		@IChatAgentNameService private readonly chatAgentNameService: IChatAgentNameService,
 	) {
 		super();
 
@@ -367,9 +370,23 @@ export class ChatListItemRenderer extends Disposable implements ITreeRenderer<Ch
 	}
 
 	private renderDetail(element: IChatResponseViewModel, templateData: IChatListItemTemplate): void {
-		let progressMsg: string = '';
+		let agentName: IObservable<string | undefined> = constObservable(undefined);
+
 		if (element.agent && !element.agent.isDefault) {
-			let usingMsg = chatAgentLeader + element.agent.name;
+			const name = element.agent.name;
+			agentName = this.chatAgentNameService.getAgentNameRestriction(element.agent)
+				.map(allowed => allowed ? name : name); // TODO
+		}
+
+		templateData.elementDisposables.add(autorun(reader => {
+			this._renderDetail(element, agentName.read(reader), templateData);
+		}));
+	}
+
+	private _renderDetail(element: IChatResponseViewModel, agentName: string | undefined, templateData: IChatListItemTemplate): void {
+		let progressMsg: string = '';
+		if (!isUndefined(agentName)) {
+			let usingMsg = chatAgentLeader + agentName;
 			if (element.slashCommand) {
 				usingMsg += ` ${chatSubcommandLeader}${element.slashCommand.name}`;
 			}
@@ -381,8 +398,8 @@ export class ChatListItemRenderer extends Disposable implements ITreeRenderer<Ch
 			}
 		} else if (element.agentOrSlashCommandDetected) {
 			const usingMsg: string[] = [];
-			if (element.agent && !element.agent.isDefault) {
-				usingMsg.push(chatAgentLeader + element.agent.name);
+			if (!isUndefined(agentName)) {
+				usingMsg.push(chatAgentLeader + agentName);
 			}
 			if (element.slashCommand) {
 				usingMsg.push(chatSubcommandLeader + element.slashCommand.name);

src/vs/workbench/contrib/chat/common/chatAgents.ts

@@ -3,17 +3,25 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { timeout } from 'vs/base/common/async';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { Emitter, Event } from 'vs/base/common/event';
 import { IMarkdownString } from 'vs/base/common/htmlContent';
 import { Iterable } from 'vs/base/common/iterator';
 import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { IObservable } from 'vs/base/common/observable';
+import { observableValue } from 'vs/base/common/observableInternal/base';
+import { equalsIgnoreCase } from 'vs/base/common/strings';
 import { ThemeIcon } from 'vs/base/common/themables';
 import { URI } from 'vs/base/common/uri';
 import { ProviderResult } from 'vs/editor/common/languages';
 import { ContextKeyExpr, IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IProductService } from 'vs/platform/product/common/productService';
+import { asJson, IRequestService } from 'vs/platform/request/common/request';
+import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
 import { CONTEXT_CHAT_ENABLED } from 'vs/workbench/contrib/chat/common/chatContextKeys';
 import { IChatProgressResponseContent, IChatRequestVariableData } from 'vs/workbench/contrib/chat/common/chatModel';
 import { IRawChatCommandContribution, RawChatParticipantLocation } from 'vs/workbench/contrib/chat/common/chatParticipantContribTypes';
@@ -351,3 +359,95 @@ export class MergedChatAgent implements IChatAgent {
 		return undefined;
 	}
 }
+
+export const IChatAgentNameService = createDecorator<IChatAgentNameService>('chatAgentNameService');
+
+type IChatParticipantRegistry = { [name: string]: string[] };
+
+interface IChatParticipantRegistryResponse {
+	readonly version: number;
+	readonly restrictedChatParticipants: IChatParticipantRegistry;
+}
+
+export interface IChatAgentNameService {
+	_serviceBrand: undefined;
+	getAgentNameRestriction(chatAgentData: IChatAgentData): IObservable<boolean>;
+}
+
+export class ChatAgentNameService implements IChatAgentNameService {
+
+	private static readonly StorageKey = 'chat.participantNameRegistry';
+
+	declare _serviceBrand: undefined;
+
+	private readonly url!: string;
+	private registry = observableValue<IChatParticipantRegistry>(this, Object.create(null));
+	private disposed = false;
+
+	constructor(
+		@IProductService productService: IProductService,
+		@IRequestService private readonly requestService: IRequestService,
+		@ILogService private readonly logService: ILogService,
+		@IStorageService private readonly storageService: IStorageService
+	) {
+		if (!productService.chatParticipantRegistry) {
+			return;
+		}
+
+		this.url = productService.chatParticipantRegistry;
+
+		const raw = storageService.get(ChatAgentNameService.StorageKey, StorageScope.APPLICATION);
+
+		try {
+			this.registry.set(JSON.parse(raw ?? '{}'), undefined);
+		} catch (err) {
+			storageService.remove(ChatAgentNameService.StorageKey, StorageScope.APPLICATION);
+		}
+
+		this.refresh();
+	}
+
+	private refresh(): void {
+		if (this.disposed) {
+			return;
+		}
+
+		this.update()
+			.catch(err => this.logService.warn('Failed to fetch chat participant registry', err))
+			.then(() => timeout(5 * 60 * 1000)) // every 5 minutes
+			.then(() => this.refresh());
+	}
+
+	private async update(): Promise<void> {
+		const context = await this.requestService.request({ type: 'GET', url: this.url }, CancellationToken.None);
+
+		if (context.res.statusCode !== 200) {
+			throw new Error('Could not get extensions report.');
+		}
+
+		const result = await asJson<IChatParticipantRegistryResponse>(context);
+
+		if (!result || result.version !== 1) {
+			throw new Error('Unexpected chat participant registry response.');
+		}
+
+		const registry = result.restrictedChatParticipants;
+		this.registry.set(registry, undefined);
+		this.storageService.store(ChatAgentNameService.StorageKey, JSON.stringify(registry), StorageScope.APPLICATION, StorageTarget.MACHINE);
+	}
+
+	getAgentNameRestriction(chatAgentData: IChatAgentData): IObservable<boolean> {
+		const allowList = this.registry.map<string[] | undefined>(registry => registry[chatAgentData.name.toLowerCase()]);
+		return allowList.map(allowList => {
+			if (!allowList) {
+				return true;
+			}
+
+			return allowList.some(id => equalsIgnoreCase(id, id.includes('.') ? chatAgentData.extensionId.value : chatAgentData.extensionPublisher));
+		});
+	}
+
+	dispose() {
+		this.disposed = true;
+	}
+}