Merge branch 'main' into merogge/stream

Author: meganrogge

build/azure-pipelines/publish-types/update-types.js

@@ -14,22 +14,30 @@ try {
 		.toString()
 		.trim();
 
+	const [major, minor] = tag.split('.');
+	const shorttag = `${major}.${minor}`;
+
 	const dtsUri = `https://raw.githubusercontent.com/microsoft/vscode/${tag}/src/vscode-dts/vscode.d.ts`;
-	const outPath = path.resolve(process.cwd(), 'DefinitelyTyped/types/vscode/index.d.ts');
-	cp.execSync(`curl ${dtsUri} --output ${outPath}`);
+	const outDtsPath = path.resolve(process.cwd(), 'DefinitelyTyped/types/vscode/index.d.ts');
+	cp.execSync(`curl ${dtsUri} --output ${outDtsPath}`);
+
+	updateDTSFile(outDtsPath, shorttag);
 
-	updateDTSFile(outPath, tag);
+	const outPackageJsonPath = path.resolve(process.cwd(), 'DefinitelyTyped/types/vscode/package.json');
+	const packageJson = JSON.parse(fs.readFileSync(outPackageJsonPath, 'utf-8'));
+	packageJson.version = shorttag + '.9999';
+	fs.writeFileSync(outPackageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
 
-	console.log(`Done updating vscode.d.ts at ${outPath}`);
+	console.log(`Done updating vscode.d.ts at ${outDtsPath} and package.json to version ${packageJson.version}`);
 } catch (err) {
 	console.error(err);
 	console.error('Failed to update types');
 	process.exit(1);
 }
 
-function updateDTSFile(outPath: string, tag: string) {
+function updateDTSFile(outPath: string, shorttag: string) {
 	const oldContent = fs.readFileSync(outPath, 'utf-8');
-	const newContent = getNewFileContent(oldContent, tag);
+	const newContent = getNewFileContent(oldContent, shorttag);
 
 	fs.writeFileSync(outPath, newContent);
 }
@@ -46,21 +54,18 @@ function convertTabsToSpaces(str: string): string {
 	return str.replace(/\t/gm, value => repeat('    ', value.length));
 }
 
-function getNewFileContent(content: string, tag: string) {
+function getNewFileContent(content: string, shorttag: string) {
 	const oldheader = [
 		`/*---------------------------------------------------------------------------------------------`,
 		` *  Copyright (c) Microsoft Corporation. All rights reserved.`,
 		` *  Licensed under the MIT License. See License.txt in the project root for license information.`,
 		` *--------------------------------------------------------------------------------------------*/`
 	].join('\n');
 
-	return convertTabsToSpaces(getNewFileHeader(tag) + content.slice(oldheader.length));
+	return convertTabsToSpaces(getNewFileHeader(shorttag) + content.slice(oldheader.length));
 }
 
-function getNewFileHeader(tag: string) {
-	const [major, minor] = tag.split('.');
-	const shorttag = `${major}.${minor}`;
-
+function getNewFileHeader(shorttag: string) {
 	const header = [
 		`// Type definitions for Visual Studio Code ${shorttag}`,
 		`// Project: https://github.com/microsoft/vscode`,

build/azure-pipelines/publish-types/update-types.ts

@@ -1801,42 +1801,48 @@ export class Repository implements Disposable {
 
 	async createWorktree(options?: { path?: string; commitish?: string; branch?: string }): Promise<string> {
 		const defaultWorktreeRoot = this.globalState.get<string>(`${Repository.WORKTREE_ROOT_STORAGE_KEY}:${this.root}`);
-		let { path: worktreePath, commitish, branch } = options || {};
-		let worktreeName: string | undefined;
+		const config = workspace.getConfiguration('git', Uri.file(this.root));
+		const branchPrefix = config.get<string>('branchPrefix', '');
 
 		return await this.run(Operation.Worktree, async () => {
-			// Generate branch name if not provided
-			if (branch === undefined) {
-				const config = workspace.getConfiguration('git', Uri.file(this.root));
-				const branchPrefix = config.get<string>('branchPrefix', '');
+			let worktreeName: string | undefined;
+			let { path: worktreePath, commitish, branch } = options || {};
 
-				let worktreeName = await this.getRandomBranchName();
+			if (branch === undefined) {
+				// Generate branch name if not provided
+				worktreeName = await this.getRandomBranchName();
 				if (!worktreeName) {
 					// Fallback to timestamp-based name if random generation fails
 					const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
 					worktreeName = `worktree-${timestamp}`;
 				}
-
 				branch = `${branchPrefix}${worktreeName}`;
+
+				// Append worktree name to provided path
+				if (worktreePath !== undefined) {
+					worktreePath = path.join(worktreePath, worktreeName);
+				}
+			} else {
+				// Extract worktree name from branch
+				worktreeName = branch.startsWith(branchPrefix)
+					? branch.substring(branchPrefix.length).replace(/\//g, '-')
+					: branch.replace(/\//g, '-');
 			}
 
-			// Generate path if not provided
 			if (worktreePath === undefined) {
 				worktreePath = defaultWorktreeRoot
-					? path.join(defaultWorktreeRoot, worktreeName!)
-					: path.join(path.dirname(this.root), `${path.basename(this.root)}.worktrees`, worktreeName!);
-
-				// Ensure that the worktree path is unique
-				if (this.worktrees.some(worktree => pathEquals(path.normalize(worktree.path), path.normalize(worktreePath!)))) {
-					let counter = 1;
-					let uniqueWorktreePath = `${worktreePath}-${counter}`;
-					while (this.worktrees.some(wt => pathEquals(path.normalize(wt.path), path.normalize(uniqueWorktreePath)))) {
-						counter++;
-						uniqueWorktreePath = `${worktreePath}-${counter}`;
-					}
+					? path.join(defaultWorktreeRoot, worktreeName)
+					: path.join(path.dirname(this.root), `${path.basename(this.root)}.worktrees`, worktreeName);
+			}
 
-					worktreePath = uniqueWorktreePath;
-				}
+			// Ensure that the worktree path is unique
+			if (this.worktrees.some(worktree => pathEquals(path.normalize(worktree.path), path.normalize(worktreePath!)))) {
+				let counter = 0, uniqueWorktreePath: string;
+				do {
+					uniqueWorktreePath = `${worktreePath}-${++counter}`;
+				} while (this.worktrees.some(wt => pathEquals(path.normalize(wt.path), path.normalize(uniqueWorktreePath))));
+
+				worktreePath = uniqueWorktreePath;
 			}
 
 			// Create the worktree
@@ -3047,6 +3053,7 @@ export class Repository implements Disposable {
 		}
 
 		const dictionaries: string[][] = [];
+		const branchPrefix = config.get<string>('branchPrefix', '');
 		const branchWhitespaceChar = config.get<string>('branchWhitespaceChar', '-');
 		const branchRandomNameDictionary = config.get<string[]>('branchRandomName.dictionary', ['adjectives', 'animals']);
 
@@ -3075,7 +3082,7 @@ export class Repository implements Disposable {
 			});
 
 			// Check for local ref conflict
-			const refs = await this.getRefs({ pattern: `refs/heads/${randomName}` });
+			const refs = await this.getRefs({ pattern: `refs/heads/${branchPrefix}${randomName}` });
 			if (refs.length === 0) {
 				return randomName;
 			}

extensions/git/src/repository.ts

@@ -1354,4 +1354,3 @@ function createDOMPurify() {
 var purify = createDOMPurify();
 
 export { purify as default };
-//# sourceMappingURL=purify.es.mjs.map

src/vs/base/browser/dompurify/dompurify.js

@@ -2479,4 +2479,3 @@ const parser = _Parser.parse;
 const lexer = _Lexer.lex;
 
 export { _Hooks as Hooks, _Lexer as Lexer, Marked, _Parser as Parser, _Renderer as Renderer, _TextRenderer as TextRenderer, _Tokenizer as Tokenizer, _defaults as defaults, _getDefaults as getDefaults, lexer, marked, options, parse, parseInline, parser, setOptions, use, walkTokens };
-//# sourceMappingURL=marked.esm.js.map

src/vs/base/common/marked/marked.js

@@ -264,6 +264,9 @@ export class InlineEditsView extends Disposable {
 	} | undefined = undefined;
 
 	private _getLongDistanceHintState(model: ModelPerInlineEdit, reader: IReader): ILongDistanceHint | undefined {
+		if (model.inlineEdit.inlineCompletion.identity.jumpedTo.read(reader)) {
+			return undefined;
+		}
 		if (this._currentInlineEditCache?.inlineSuggestionIdentity !== model.inlineEdit.inlineCompletion.identity) {
 			this._currentInlineEditCache = {
 				inlineSuggestionIdentity: model.inlineEdit.inlineCompletion.identity,

src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/inlineEditsView.ts

@@ -179,6 +179,14 @@ export class MainThreadMcp extends Disposable implements MainThreadMcpShape {
 		this._servers.get(id)?.pushMessage(message);
 	}
 
+	async $getTokenForProviderId(id: number, providerId: string, scopes: string[], options: IMcpAuthenticationOptions = {}): Promise<string | undefined> {
+		const server = this._serverDefinitions.get(id);
+		if (!server) {
+			return undefined;
+		}
+		return this._getSessionForProvider(server, providerId, scopes, undefined, options.errorOnUserInteraction);
+	}
+
 	async $getTokenFromServerMetadata(id: number, authDetails: IMcpAuthenticationDetails, { errorOnUserInteraction, forceNewRegistration }: IMcpAuthenticationOptions = {}): Promise<string | undefined> {
 		const server = this._serverDefinitions.get(id);
 		if (!server) {
@@ -202,7 +210,18 @@ export class MainThreadMcp extends Disposable implements MainThreadMcpShape {
 			}
 			providerId = provider.id;
 		}
-		const sessions = await this._authenticationService.getSessions(providerId, resolvedScopes, { authorizationServer: authorizationServer }, true);
+
+		return this._getSessionForProvider(server, providerId, resolvedScopes, authorizationServer, errorOnUserInteraction);
+	}
+
+	private async _getSessionForProvider(
+		server: McpServerDefinition,
+		providerId: string,
+		scopes: string[],
+		authorizationServer?: URI,
+		errorOnUserInteraction: boolean = false
+	): Promise<string | undefined> {
+		const sessions = await this._authenticationService.getSessions(providerId, scopes, { authorizationServer }, true);
 		const accountNamePreference = this.authenticationMcpServersService.getAccountPreference(server.id, providerId);
 		let matchingAccountPreferenceSession: AuthenticationSession | undefined;
 		if (accountNamePreference) {
@@ -213,12 +232,12 @@ export class MainThreadMcp extends Disposable implements MainThreadMcpShape {
 		if (sessions.length) {
 			// If we have an existing session preference, use that. If not, we'll return any valid session at the end of this function.
 			if (matchingAccountPreferenceSession && this.authenticationMCPServerAccessService.isAccessAllowed(providerId, matchingAccountPreferenceSession.account.label, server.id)) {
-				this.authenticationMCPServerUsageService.addAccountUsage(providerId, matchingAccountPreferenceSession.account.label, resolvedScopes, server.id, server.label);
+				this.authenticationMCPServerUsageService.addAccountUsage(providerId, matchingAccountPreferenceSession.account.label, scopes, server.id, server.label);
 				return matchingAccountPreferenceSession.accessToken;
 			}
 			// If we only have one account for a single auth provider, lets just check if it's allowed and return it if it is.
 			if (!provider.supportsMultipleAccounts && this.authenticationMCPServerAccessService.isAccessAllowed(providerId, sessions[0].account.label, server.id)) {
-				this.authenticationMCPServerUsageService.addAccountUsage(providerId, sessions[0].account.label, resolvedScopes, server.id, server.label);
+				this.authenticationMCPServerUsageService.addAccountUsage(providerId, sessions[0].account.label, scopes, server.id, server.label);
 				return sessions[0].accessToken;
 			}
 		}
@@ -237,7 +256,7 @@ export class MainThreadMcp extends Disposable implements MainThreadMcpShape {
 				throw new UserInteractionRequiredError('authentication');
 			}
 			session = provider.supportsMultipleAccounts
-				? await this.authenticationMcpServersService.selectSession(providerId, server.id, server.label, resolvedScopes, sessions)
+				? await this.authenticationMcpServersService.selectSession(providerId, server.id, server.label, scopes, sessions)
 				: sessions[0];
 		}
 		else {
@@ -248,7 +267,7 @@ export class MainThreadMcp extends Disposable implements MainThreadMcpShape {
 			do {
 				session = await this._authenticationService.createSession(
 					providerId,
-					resolvedScopes,
+					scopes,
 					{
 						activateImmediate: true,
 						account: accountToCreate,
@@ -263,7 +282,7 @@ export class MainThreadMcp extends Disposable implements MainThreadMcpShape {
 
 		this.authenticationMCPServerAccessService.updateAllowedMcpServers(providerId, session.account.label, [{ id: server.id, name: server.label, allowed: true }]);
 		this.authenticationMcpServersService.updateAccountPreference(server.id, providerId, session.account);
-		this.authenticationMCPServerUsageService.addAccountUsage(providerId, session.account.label, resolvedScopes, server.id, server.label);
+		this.authenticationMCPServerUsageService.addAccountUsage(providerId, session.account.label, scopes, server.id, server.label);
 		return session.accessToken;
 	}
 

src/vs/workbench/api/browser/mainThreadMcp.ts

@@ -3125,6 +3125,7 @@ export interface MainThreadMcpShape {
 	$upsertMcpCollection(collection: McpCollectionDefinition.FromExtHost, servers: McpServerDefinition.Serialized[]): void;
 	$deleteMcpCollection(collectionId: string): void;
 	$getTokenFromServerMetadata(id: number, authDetails: IMcpAuthenticationDetails, options?: IMcpAuthenticationOptions): Promise<string | undefined>;
+	$getTokenForProviderId(id: number, providerId: string, scopes: string[], options?: IMcpAuthenticationOptions): Promise<string | undefined>;
 }
 
 export interface MainThreadDataChannelsShape extends IDisposable {

src/vs/workbench/api/common/extHost.protocol.ts

@@ -20,7 +20,7 @@ import product from '../../../platform/product/common/product.js';
 import { StorageScope } from '../../../platform/storage/common/storage.js';
 import { extensionPrefixedIdentifier, McpCollectionDefinition, McpConnectionState, McpServerDefinition, McpServerLaunch, McpServerStaticMetadata, McpServerStaticToolAvailability, McpServerTransportHTTP, McpServerTransportType, UserInteractionRequiredError } from '../../contrib/mcp/common/mcpTypes.js';
 import { MCP } from '../../contrib/mcp/common/modelContextProtocol.js';
-import { isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { ExtHostMcpShape, IMcpAuthenticationDetails, IStartMcpOptions, MainContext, MainThreadMcpShape } from './extHost.protocol.js';
 import { IExtHostInitDataService } from './extHostInitDataService.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
@@ -45,6 +45,10 @@ const serverDataValidation = vObj({
 			availability: vNumber(),
 			definition: vObjAny(),
 		}))),
+	})),
+	authentication: vOptionalProp(vObj({
+		providerId: vString(),
+		scopes: vArray(vString()),
 	}))
 });
 
@@ -165,6 +169,9 @@ export class ExtHostMcpService extends Disposable implements IExtHostMpcService
 				}
 
 				serverDataValidation.validateOrThrow(item);
+				if ((item as vscode.McpHttpServerDefinition2).authentication) {
+					checkProposedApiEnabled(extension, 'mcpToolDefinitions');
+				}
 
 				let staticMetadata: McpServerStaticMetadata | undefined;
 				const castAs2 = item as McpStdioServerDefinition | McpHttpServerDefinition;
@@ -710,6 +717,30 @@ export class McpHTTPHandle extends Disposable {
 				this._log(LogLevel.Warning, `Error getting token from server metadata: ${String(e)}`);
 			}
 		}
+		if (this._launch.authentication) {
+			try {
+				this._log(LogLevel.Debug, `Using provided authentication config: providerId=${this._launch.authentication.providerId}, scopes=${this._launch.authentication.scopes.join(', ')}`);
+				const token = await this._proxy.$getTokenForProviderId(
+					this._id,
+					this._launch.authentication.providerId,
+					this._launch.authentication.scopes,
+					{
+						errorOnUserInteraction: this._errorOnUserInteraction,
+						forceNewRegistration
+					}
+				);
+				if (token) {
+					headers['Authorization'] = `Bearer ${token}`;
+					this._log(LogLevel.Info, 'Successfully obtained token from provided authentication config');
+				}
+			} catch (e) {
+				if (UserInteractionRequiredError.is(e)) {
+					this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Stopped, reason: 'needs-user-interaction' });
+					throw new CancellationError();
+				}
+				this._log(LogLevel.Warning, `Error getting token from provided authentication config: ${String(e)}`);
+			}
+		}
 		return headers;
 	}
 

src/vs/workbench/api/common/extHostMcp.ts

@@ -3825,6 +3825,10 @@ export namespace McpServerDefinition {
 					type: McpServerTransportType.HTTP,
 					uri: item.uri,
 					headers: Object.entries(item.headers),
+					authentication: (item as vscode.McpHttpServerDefinition2).authentication ? {
+						providerId: (item as vscode.McpHttpServerDefinition2).authentication!.providerId,
+						scopes: (item as vscode.McpHttpServerDefinition2).authentication!.scopes
+					} : undefined,
 				}
 				: {
 					type: McpServerTransportType.Stdio,