[pull] main from microsoft:main

.github/dependabot.yml

@@ -15,10 +15,20 @@ updates:
     allow:
       - dependency-name: "@vscode/component-explorer"
       - dependency-name: "@vscode/component-explorer-cli"
+    groups:
+      component-explorer:
+        patterns:
+          - "@vscode/component-explorer"
+          - "@vscode/component-explorer-cli"
   - package-ecosystem: "npm"
     directory: "/build/vite"
     schedule:
       interval: "daily"
     allow:
       - dependency-name: "@vscode/component-explorer"
       - dependency-name: "@vscode/component-explorer-vite-plugin"
+    groups:
+      component-explorer:
+        patterns:
+          - "@vscode/component-explorer"
+          - "@vscode/component-explorer-vite-plugin"

.vscode/extensions/vscode-selfhost-test-provider/src/testOutputScanner.ts

@@ -545,6 +545,9 @@ export class SourceMapStore {
 			}
 		}
 
+		if (/^[a-zA-Z]:/.test(source) || source.startsWith('/')) {
+			return vscode.Uri.file(source);
+		}
 		return vscode.Uri.parse(source);
 	}
 

build/gulpfile.vscode.ts

@@ -100,6 +100,7 @@ const vscodeResourceIncludes = [
 
 	// Sessions
 	'out-build/vs/sessions/contrib/chat/browser/media/*.svg',
+	'out-build/vs/sessions/prompts/*.prompt.md',
 
 	// Extensions
 	'out-build/vs/workbench/contrib/extensions/browser/media/{theme-icon.png,language-icon.svg}',

build/next/index.ts

@@ -273,6 +273,9 @@ const desktopResourcePatterns = [
 	'vs/workbench/services/extensionManagement/common/media/*.png',
 	'vs/workbench/browser/parts/editor/media/*.png',
 	'vs/workbench/contrib/debug/browser/media/*.png',
+
+	// Sessions - built-in prompts
+	'vs/sessions/prompts/*.prompt.md',
 ];
 
 // Resources for server target (minimal - no UI)

extensions/github/src/commands.ts

@@ -90,28 +90,6 @@ function resolveSessionRepo(gitAPI: GitAPI, sessionMetadata: { worktreePath?: st
 	return { repository, remoteInfo, gitRemote: { name: gitRemote.name, fetchUrl: gitRemote.fetchUrl! }, head: head as ResolvedSessionRepo['head'] };
 }
 
-async function checkOpenPullRequest(gitAPI: GitAPI, _sessionResource: vscode.Uri | undefined, sessionMetadata: { worktreePath?: string } | undefined): Promise<void> {
-	const resolved = resolveSessionRepo(gitAPI, sessionMetadata, false);
-	if (!resolved) {
-		vscode.commands.executeCommand('setContext', 'github.hasOpenPullRequest', false);
-		return;
-	}
-
-	try {
-		const octokit = await getOctokit();
-		const { data: openPRs } = await octokit.pulls.list({
-			owner: resolved.remoteInfo.owner,
-			repo: resolved.remoteInfo.repo,
-			head: `${resolved.remoteInfo.owner}:${resolved.head.name}`,
-			state: 'all',
-		});
-
-		vscode.commands.executeCommand('setContext', 'github.hasOpenPullRequest', openPRs.length > 0);
-	} catch {
-		vscode.commands.executeCommand('setContext', 'github.hasOpenPullRequest', false);
-	}
-}
-
 async function createPullRequest(gitAPI: GitAPI, sessionResource: vscode.Uri | undefined, sessionMetadata: { worktreePath?: string } | undefined): Promise<void> {
 	if (!sessionResource) {
 		return;
@@ -263,9 +241,5 @@ export function registerCommands(gitAPI: GitAPI): vscode.Disposable {
 		return openPullRequest(gitAPI, sessionResource, sessionMetadata);
 	}));
 
-	disposables.add(vscode.commands.registerCommand('github.checkOpenPullRequest', async (sessionResource: vscode.Uri | undefined, sessionMetadata: { worktreePath?: string } | undefined) => {
-		return checkOpenPullRequest(gitAPI, sessionResource, sessionMetadata);
-	}));
-
 	return disposables;
 }

extensions/markdown-language-features/package.json

@@ -230,6 +230,14 @@
           "group": "1_markdown"
         }
       ],
+      "modalEditor/editorTitle": [
+        {
+          "command": "markdown.showPreviewToSide",
+          "when": "editorLangId =~ /^(markdown|prompt|instructions|chatagent|skill)$/ && !notebookEditorFocused && !hasCustomMarkdownPreview",
+          "alt": "markdown.showPreview",
+          "group": "navigation"
+        }
+      ],
       "explorer/context": [
         {
           "command": "markdown.showPreview",

extensions/terminal-suggest/package.json

@@ -6,7 +6,7 @@
   "version": "1.0.1",
   "private": true,
   "license": "MIT",
-  "icon": "./src/media/icon.png",
+  "icon": "./media/icon.png",
   "engines": {
     "vscode": "^1.95.0"
   },

extensions/typescript-language-features/package.nls.json

@@ -64,7 +64,7 @@
 	"format.semicolons.remove": "Remove unnecessary semicolons.",
 	"format.indentSwitchCase": "Indent case clauses in switch statements. Requires using TypeScript 5.1+ in the workspace.",
 	"format.enable": "Enable/disable the default JavaScript and TypeScript formatter.",
-	"configuration.format.enable.unifiedDeprecationMessage": "This setting is deprecated. Use `#js/ts.format.enable#` instead.",
+	"configuration.format.enable.unifiedDeprecationMessage": "This setting is deprecated. Use `#js/ts.format.enabled#` instead.",
 	"configuration.format.insertSpaceAfterCommaDelimiter.unifiedDeprecationMessage": "This setting is deprecated. Use `#js/ts.format.insertSpaceAfterCommaDelimiter#` instead.",
 	"configuration.format.insertSpaceAfterConstructor.unifiedDeprecationMessage": "This setting is deprecated. Use `#js/ts.format.insertSpaceAfterConstructor#` instead.",
 	"configuration.format.insertSpaceAfterSemicolonInForStatements.unifiedDeprecationMessage": "This setting is deprecated. Use `#js/ts.format.insertSpaceAfterSemicolonInForStatements#` instead.",

src/vs/base/common/htmlContent.ts

@@ -210,9 +210,9 @@ export function createMarkdownLink(text: string, href: string, title?: string, e
 	return `[${escapeTokens ? escapeMarkdownSyntaxTokens(text) : text}](${href}${title ? ` "${escapeMarkdownSyntaxTokens(title)}"` : ''})`;
 }
 
-export function createMarkdownCommandLink(command: { title: string; id: string; arguments?: unknown[]; tooltip?: string }, escapeTokens = true): string {
+export function createMarkdownCommandLink(command: { text: string; id: string; arguments?: unknown[]; tooltip: string }, escapeTokens = true): string {
 	const uri = createCommandUri(command.id, ...(command.arguments || [])).toString();
-	return createMarkdownLink(command.title, uri, command.tooltip, escapeTokens);
+	return createMarkdownLink(command.text, uri, command.tooltip, escapeTokens);
 }
 
 export function createCommandUri(commandId: string, ...commandArgs: unknown[]): URI {

src/vs/editor/common/config/editorOptions.ts

@@ -1744,6 +1744,10 @@ export interface IEditorFindOptions {
 	 * Controls whether the search result and diff result automatically restarts from the beginning (or the end) when no further matches can be found
 	 */
 	loop?: boolean;
+	/**
+	 * Controls whether to close the Find Widget after an explicit find navigation command lands on a match.
+	 */
+	closeOnResult?: boolean;
 	/**
 	 * @internal
 	 * Controls how the find widget search history should be stored
@@ -1772,6 +1776,7 @@ class EditorFind extends BaseEditorOption<EditorOption.find, IEditorFindOptions,
 			globalFindClipboard: false,
 			addExtraSpaceOnTop: true,
 			loop: true,
+			closeOnResult: false,
 			history: 'workspace',
 			replaceHistory: 'workspace',
 		};
@@ -1821,6 +1826,11 @@ class EditorFind extends BaseEditorOption<EditorOption.find, IEditorFindOptions,
 					default: defaults.loop,
 					description: nls.localize('find.loop', "Controls whether the search automatically restarts from the beginning (or the end) when no further matches can be found.")
 				},
+				'editor.find.closeOnResult': {
+					type: 'boolean',
+					default: defaults.closeOnResult,
+					description: nls.localize('find.closeOnResult', "Controls whether the Find Widget closes after an explicit find navigation command lands on a result.")
+				},
 				'editor.find.history': {
 					type: 'string',
 					enum: ['never', 'workspace'],
@@ -1867,6 +1877,7 @@ class EditorFind extends BaseEditorOption<EditorOption.find, IEditorFindOptions,
 			globalFindClipboard: boolean(input.globalFindClipboard, this.defaultValue.globalFindClipboard),
 			addExtraSpaceOnTop: boolean(input.addExtraSpaceOnTop, this.defaultValue.addExtraSpaceOnTop),
 			loop: boolean(input.loop, this.defaultValue.loop),
+			closeOnResult: boolean(input.closeOnResult, this.defaultValue.closeOnResult),
 			history: stringSet<'never' | 'workspace'>(input.history, this.defaultValue.history, ['never', 'workspace']),
 			replaceHistory: stringSet<'never' | 'workspace'>(input.replaceHistory, this.defaultValue.replaceHistory, ['never', 'workspace']),
 		};

src/vs/editor/common/viewModel/minimapTokensColorTracker.ts

@@ -38,7 +38,10 @@ export class MinimapTokensColorTracker extends Disposable {
 	private _updateColorMap(): void {
 		const colorMap = TokenizationRegistry.getColorMap();
 		if (!colorMap) {
-			this._colors = [RGBA8.Empty];
+			this._colors = [];
+			for (let i = 0; i <= ColorId.DefaultBackground; i++) {
+				this._colors[i] = RGBA8.Empty;
+			}
 			this._backgroundIsLight = true;
 			return;
 		}

src/vs/editor/contrib/find/browser/findController.ts

@@ -725,11 +725,28 @@ async function matchFindAction(editor: ICodeEditor, next: boolean): Promise<void
 	if (!controller) {
 		return;
 	}
+	const shouldCloseOnResult = editor.getOption(EditorOption.find).closeOnResult;
+	const wasFindWidgetVisible = controller.getState().isRevealed;
 
 	const runMatch = (): boolean => {
+		const previousSelection = controller.editor.getSelection();
 		const result = next ? controller.moveToNextMatch() : controller.moveToPrevMatch();
+
+		let landedOnMatch = false;
 		if (result) {
+			const currentSelection = controller.editor.getSelection();
+			if (!previousSelection && currentSelection) {
+				landedOnMatch = true;
+			} else if (previousSelection && currentSelection && !previousSelection.equalsSelection(currentSelection)) {
+				landedOnMatch = true;
+			}
+		}
+
+		if (landedOnMatch) {
 			controller.editor.pushUndoStop();
+			if (shouldCloseOnResult && wasFindWidgetVisible && controller.isFindInputFocused()) {
+				controller.closeFindWidget();
+			}
 			return true;
 		}
 		return false;

src/vs/editor/contrib/find/test/browser/findController.test.ts

@@ -292,6 +292,67 @@ suite('FindController', () => {
 		});
 	});
 
+	test('editor.find.closeOnResult: closes find widget when a match is found from explicit navigation', async () => {
+		await withAsyncTestCodeEditor([
+			'ABC',
+			'ABC',
+			'XYZ',
+		], { serviceCollection: serviceCollection, find: { closeOnResult: true } }, async (editor, _, instantiationService) => {
+			const findController = editor.registerAndInstantiateContribution(TestFindController.ID, TestFindController);
+			const findState = findController.getState();
+
+			await executeAction(instantiationService, editor, StartFindAction);
+			assert.strictEqual(findState.isRevealed, true);
+
+			findState.change({ searchString: 'ABC' }, true);
+			await editor.runAction(NextMatchFindAction);
+
+			assert.strictEqual(findState.isRevealed, false);
+			findController.dispose();
+		});
+	});
+
+	test('editor.find.closeOnResult: keeps find widget open when no match is found', async () => {
+		await withAsyncTestCodeEditor([
+			'ABC',
+			'DEF',
+			'XYZ',
+		], { serviceCollection: serviceCollection, find: { closeOnResult: true } }, async (editor, _, instantiationService) => {
+			const findController = editor.registerAndInstantiateContribution(TestFindController.ID, TestFindController);
+			const findState = findController.getState();
+
+			await executeAction(instantiationService, editor, StartFindAction);
+			assert.strictEqual(findState.isRevealed, true);
+
+			findState.change({ searchString: 'NO_MATCH' }, true);
+			await editor.runAction(NextMatchFindAction);
+
+			assert.strictEqual(findState.matchesCount, 0);
+			assert.strictEqual(findState.isRevealed, true);
+			findController.dispose();
+		});
+	});
+
+	test('editor.find.closeOnResult: disabled keeps find widget open after navigation', async () => {
+		await withAsyncTestCodeEditor([
+			'ABC',
+			'ABC',
+			'XYZ',
+		], { serviceCollection: serviceCollection, find: { closeOnResult: false } }, async (editor, _, instantiationService) => {
+			const findController = editor.registerAndInstantiateContribution(TestFindController.ID, TestFindController);
+			const findState = findController.getState();
+
+			await executeAction(instantiationService, editor, StartFindAction);
+			assert.strictEqual(findState.isRevealed, true);
+
+			findState.change({ searchString: 'ABC' }, true);
+			await editor.runAction(NextMatchFindAction);
+
+			assert.strictEqual(findState.isRevealed, true);
+			findController.dispose();
+		});
+	});
+
 	test('issue #9043: Clear search scope when find widget is hidden', async () => {
 		await withAsyncTestCodeEditor([
 			'var x = (3 * 5)',

src/vs/monaco.d.ts

@@ -4255,6 +4255,10 @@ declare namespace monaco.editor {
 		 * Controls whether the search result and diff result automatically restarts from the beginning (or the end) when no further matches can be found
 		 */
 		loop?: boolean;
+		/**
+		 * Controls whether to close the Find Widget after an explicit find navigation command lands on a match.
+		 */
+		closeOnResult?: boolean;
 	}
 
 	export type GoToLocationValues = 'peek' | 'gotoAndPeek' | 'goto';

src/vs/platform/actions/common/actions.ts

@@ -89,6 +89,7 @@ export class MenuId {
 	static readonly EditorContextShare = new MenuId('EditorContextShare');
 	static readonly EditorTitle = new MenuId('EditorTitle');
 	static readonly ModalEditorTitle = new MenuId('ModalEditorTitle');
+	static readonly ModalEditorEditorTitle = new MenuId('ModalEditorEditorTitle');
 	static readonly CompactWindowEditorTitle = new MenuId('CompactWindowEditorTitle');
 	static readonly EditorTitleRun = new MenuId('EditorTitleRun');
 	static readonly EditorTitleContext = new MenuId('EditorTitleContext');

src/vs/platform/update/common/update.ts

@@ -62,14 +62,13 @@ export const enum DisablementReason {
 	MissingConfiguration,
 	InvalidConfiguration,
 	RunningAsAdmin,
-	EmbeddedApp,
 }
 
 export type Uninitialized = { type: StateType.Uninitialized };
 export type Disabled = { type: StateType.Disabled; reason: DisablementReason };
 export type Idle = { type: StateType.Idle; updateType: UpdateType; error?: string };
 export type CheckingForUpdates = { type: StateType.CheckingForUpdates; explicit: boolean };
-export type AvailableForDownload = { type: StateType.AvailableForDownload; update: IUpdate };
+export type AvailableForDownload = { type: StateType.AvailableForDownload; update: IUpdate; canInstall?: boolean };
 export type Downloading = { type: StateType.Downloading; update?: IUpdate; explicit: boolean; overwrite: boolean; downloadedBytes?: number; totalBytes?: number; startTime?: number };
 export type Downloaded = { type: StateType.Downloaded; update: IUpdate; explicit: boolean; overwrite: boolean };
 export type Updating = { type: StateType.Updating; update: IUpdate; currentProgress?: number; maxProgress?: number };
@@ -83,7 +82,7 @@ export const State = {
 	Disabled: (reason: DisablementReason): Disabled => ({ type: StateType.Disabled, reason }),
 	Idle: (updateType: UpdateType, error?: string): Idle => ({ type: StateType.Idle, updateType, error }),
 	CheckingForUpdates: (explicit: boolean): CheckingForUpdates => ({ type: StateType.CheckingForUpdates, explicit }),
-	AvailableForDownload: (update: IUpdate): AvailableForDownload => ({ type: StateType.AvailableForDownload, update }),
+	AvailableForDownload: (update: IUpdate, canInstall?: boolean): AvailableForDownload => ({ type: StateType.AvailableForDownload, update, canInstall }),
 	Downloading: (update: IUpdate | undefined, explicit: boolean, overwrite: boolean, downloadedBytes?: number, totalBytes?: number, startTime?: number): Downloading => ({ type: StateType.Downloading, update, explicit, overwrite, downloadedBytes, totalBytes, startTime }),
 	Downloaded: (update: IUpdate, explicit: boolean, overwrite: boolean): Downloaded => ({ type: StateType.Downloaded, update, explicit, overwrite }),
 	Updating: (update: IUpdate, currentProgress?: number, maxProgress?: number): Updating => ({ type: StateType.Updating, update, currentProgress, maxProgress }),

src/vs/platform/update/electron-main/updateService.darwin.ts

@@ -16,7 +16,7 @@ import { ILogService } from '../../log/common/log.js';
 import { IProductService } from '../../product/common/productService.js';
 import { asJson, IRequestService } from '../../request/common/request.js';
 import { ITelemetryService } from '../../telemetry/common/telemetry.js';
-import { AvailableForDownload, DisablementReason, IUpdate, State, StateType, UpdateType } from '../common/update.js';
+import { AvailableForDownload, IUpdate, State, StateType, UpdateType } from '../common/update.js';
 import { IMeteredConnectionService } from '../../meteredConnection/common/meteredConnection.js';
 import { AbstractUpdateService, createUpdateURL, getUpdateRequestHeaders, IUpdateURLOptions, UpdateErrorClassification } from './abstractUpdateService.js';
 import { INodeProcess } from '../../../base/common/platform.js';
@@ -68,13 +68,15 @@ export class DarwinUpdateService extends AbstractUpdateService implements IRelau
 	}
 
 	protected override async initialize(): Promise<void> {
+		await super.initialize();
+
+		// In the embedded app we still want to detect available updates via HTTP,
+		// but we must not wire up Electron's autoUpdater (which auto-downloads).
 		if ((process as INodeProcess).isEmbeddedApp) {
-			this.setState(State.Disabled(DisablementReason.EmbeddedApp));
-			this.logService.info('update#ctor - updates are disabled from embedded app');
+			this.logService.info('update#ctor - embedded app: checking for updates without auto-download');
 			return;
 		}
 
-		await super.initialize();
 		this.onRawError(this.onError, this, this.disposables);
 		this.onRawCheckingForUpdate(this.onCheckingForUpdate, this, this.disposables);
 		this.onRawUpdateAvailable(this.onUpdateAvailable, this, this.disposables);
@@ -135,6 +137,13 @@ export class DarwinUpdateService extends AbstractUpdateService implements IRelau
 			return;
 		}
 
+		// In the embedded app, always check without triggering Electron's auto-download.
+		if ((process as INodeProcess).isEmbeddedApp) {
+			this.logService.info('update#doCheckForUpdates - embedded app: checking for update without auto-download');
+			this.checkForUpdateNoDownload(url, /* canInstall */ false);
+			return;
+		}
+
 		// When connection is metered and this is not an explicit check, avoid electron call as to not to trigger auto-download.
 		if (!explicit && this.meteredConnectionService.isConnectionMetered) {
 			this.logService.info('update#doCheckForUpdates - checking for update without auto-download because connection is metered');
@@ -148,9 +157,10 @@ export class DarwinUpdateService extends AbstractUpdateService implements IRelau
 
 	/**
 	 * Manually check the update feed URL without triggering Electron's auto-download.
-	 * Used when connection is metered to show update availability without downloading.
+	 * Used when connection is metered or in the embedded app.
+	 * @param canInstall When false, signals that the update cannot be installed from this app.
 	 */
-	private async checkForUpdateNoDownload(url: string): Promise<void> {
+	private async checkForUpdateNoDownload(url: string, canInstall?: boolean): Promise<void> {
 		const headers = getUpdateRequestHeaders(this.productService.version);
 		this.logService.trace('update#checkForUpdateNoDownload - checking update server', { url, headers });
 
@@ -165,7 +175,7 @@ export class DarwinUpdateService extends AbstractUpdateService implements IRelau
 				this.setState(State.Idle(UpdateType.Archive));
 			} else {
 				this.logService.trace('update#checkForUpdateNoDownload - update available', { version: update.version, productVersion: update.productVersion });
-				this.setState(State.AvailableForDownload(update));
+				this.setState(State.AvailableForDownload(update, canInstall));
 			}
 		} catch (err) {
 			this.logService.error('update#checkForUpdateNoDownload - failed to check for update', err);