Merge branch 'main' into copilot/fix-258895

Author: Tyriar

build/lib/stylelint/vscode-known-variables.json

@@ -52,17 +52,17 @@
 		"--vscode-charts-yellow",
 		"--vscode-chat-avatarBackground",
 		"--vscode-chat-avatarForeground",
+		"--vscode-chat-checkpointSeparator",
 		"--vscode-chat-editedFileForeground",
+		"--vscode-chat-linesAddedForeground",
+		"--vscode-chat-linesRemovedForeground",
 		"--vscode-chat-requestBackground",
 		"--vscode-chat-requestBorder",
 		"--vscode-chat-requestBubbleBackground",
 		"--vscode-chat-requestBubbleHoverBackground",
-		"--vscode-chat-checkpointSeparator",
 		"--vscode-chat-requestCodeBorder",
 		"--vscode-chat-slashCommandBackground",
 		"--vscode-chat-slashCommandForeground",
-		"--vscode-chat-linesAddedForeground",
-		"--vscode-chat-linesRemovedForeground",
 		"--vscode-checkbox-background",
 		"--vscode-checkbox-border",
 		"--vscode-checkbox-disabled-background",
@@ -322,9 +322,9 @@
 		"--vscode-editorPane-background",
 		"--vscode-editorRuler-foreground",
 		"--vscode-editorStickyScroll-background",
-		"--vscode-editorStickyScrollGutter-background",
 		"--vscode-editorStickyScroll-border",
 		"--vscode-editorStickyScroll-shadow",
+		"--vscode-editorStickyScrollGutter-background",
 		"--vscode-editorStickyScrollHover-background",
 		"--vscode-editorSuggestWidget-background",
 		"--vscode-editorSuggestWidget-border",
@@ -807,6 +807,8 @@
 		"--vscode-terminalSymbolIcon-methodForeground",
 		"--vscode-terminalSymbolIcon-optionForeground",
 		"--vscode-terminalSymbolIcon-optionValueForeground",
+		"--vscode-terminalSymbolIcon-symbolicLinkFileForeground",
+		"--vscode-terminalSymbolIcon-symbolicLinkFolderForeground",
 		"--vscode-testing-coverCountBadgeBackground",
 		"--vscode-testing-coverCountBadgeForeground",
 		"--vscode-testing-coveredBackground",
@@ -963,4 +965,4 @@
 		"--animation-opacity",
 		"--chat-setup-dialog-glow-angle"
 	]
-}
+}

cli/src/commands/serve_web.rs

@@ -91,6 +91,12 @@ pub async fn serve_web(ctx: CommandContext, mut args: ServeWebArgs) -> Result<i3
 	if args.commit_id.is_none() {
 		cm.clone()
 			.start_update_checker(Duration::from_secs(update_check_interval));
+	} else {
+		// If a commit was provided, invoke get_latest_release() once to ensure we're using that exact version;
+		// get_latest_release() will short-circuit to args.commit_id.
+		if let Err(e) = cm.get_latest_release().await {
+			warning!(cm.log, "error getting latest version: {}", e);
+		}
 	}
 
 	let key = get_server_key_half(&ctx.paths);

extensions/git/src/api/git.d.ts

@@ -442,5 +442,6 @@ export const enum GitErrorCodes {
 	CherryPickEmpty = 'CherryPickEmpty',
 	CherryPickConflict = 'CherryPickConflict',
 	WorktreeContainsChanges = 'WorktreeContainsChanges',
-	WorktreeAlreadyExists = 'WorktreeAlreadyExists'
+	WorktreeAlreadyExists = 'WorktreeAlreadyExists',
+	WorktreeBranchAlreadyUsed = 'WorktreeBranchAlreadyUsed'
 }

extensions/git/src/commands.ts

@@ -110,6 +110,16 @@ class RefItem implements QuickPickItem {
 		return undefined;
 	}
 
+	get refId(): string {
+		switch (this.ref.type) {
+			case RefType.Head:
+				return `refs/heads/${this.ref.name}`;
+			case RefType.RemoteHead:
+				return `refs/remotes/${this.ref.remote}/${this.ref.name}`;
+			case RefType.Tag:
+				return `refs/tags/${this.ref.name}`;
+		}
+	}
 	get refName(): string | undefined { return this.ref.name; }
 	get refRemote(): string | undefined { return this.ref.remote; }
 	get shortCommit(): string { return (this.ref.commit || '').substring(0, this.shortCommitLength); }
@@ -2923,12 +2933,12 @@ export class CommandCenter {
 			try {
 				await item.run(repository, opts);
 			} catch (err) {
-				if (err.gitErrorCode !== GitErrorCodes.DirtyWorkTree && err.gitErrorCode !== GitErrorCodes.WorktreeAlreadyExists) {
+				if (err.gitErrorCode !== GitErrorCodes.DirtyWorkTree && err.gitErrorCode !== GitErrorCodes.WorktreeBranchAlreadyUsed) {
 					throw err;
 				}
 
-				if (err.gitErrorCode === GitErrorCodes.WorktreeAlreadyExists) {
-					this.handleWorktreeError(err);
+				if (err.gitErrorCode === GitErrorCodes.WorktreeBranchAlreadyUsed) {
+					this.handleWorktreeBranchAlreadyUsed(err);
 					return false;
 				}
 
@@ -3397,8 +3407,36 @@ export class CommandCenter {
 		}
 	}
 
-	@command('git.createWorktree', { repository: true, repositoryFilter: ['repository', 'submodule'] })
-	async createWorktree(repository: Repository): Promise<void> {
+	@command('git.createWorktree')
+	async createWorktree(repository: any): Promise<void> {
+		repository = this.model.getRepository(repository);
+
+		if (!repository) {
+			// Single repository/submodule/worktree
+			if (this.model.repositories.length === 1) {
+				repository = this.model.repositories[0];
+			}
+		}
+
+		if (!repository) {
+			// Single repository/submodule
+			const repositories = this.model.repositories
+				.filter(r => r.kind === 'repository' || r.kind === 'submodule');
+
+			if (repositories.length === 1) {
+				repository = repositories[0];
+			}
+		}
+
+		if (!repository) {
+			// Multiple repositories/submodules
+			repository = await this.model.pickRepository(['repository', 'submodule']);
+		}
+
+		if (!repository) {
+			return;
+		}
+
 		await this._createWorktree(repository);
 	}
 
@@ -3442,16 +3480,14 @@ export class CommandCenter {
 				return;
 			}
 
-			// If the worktree is locked, we prompt to create a new branch
-			// otherwise we can use the existing selected branch or tag
-			const isWorktreeLocked = await this.isWorktreeLocked(repository, choice);
-			if (isWorktreeLocked) {
-				branch = await this.promptForBranchName(repository);
-
-				if (!branch) {
-					return;
-				}
+			// Check whether the selected branch is checked out in an existing worktree
+			const worktree = repository.worktrees.find(worktree => worktree.ref === choice.refId);
+			if (worktree) {
+				const message = l10n.t('Branch "{0}" is already checked out in the worktree at "{1}".', choice.refName, worktree.path);
+				await this.handleWorktreeConflict(worktree.path, message);
+				return;
 			}
+
 			commitish = choice.refName;
 		}
 
@@ -3488,6 +3524,14 @@ export class CommandCenter {
 			return [start, value.length];
 		};
 
+		const getValidationMessage = (value: string): InputBoxValidationMessage | undefined => {
+			const worktree = repository.worktrees.find(worktree => pathEquals(path.normalize(worktree.path), path.normalize(value)));
+			return worktree ? {
+				message: l10n.t('A worktree already exists at "{0}".', value),
+				severity: InputBoxValidationSeverity.Warning
+			} : undefined;
+		};
+
 		// Default worktree path is based on the last worktree location or a worktree folder for the repository
 		const defaultWorktreeRoot = this.globalState.get<string>(`${CommandCenter.WORKTREE_ROOT_KEY}:${repository.root}`);
 		const defaultWorktreePath = defaultWorktreeRoot
@@ -3502,6 +3546,7 @@ export class CommandCenter {
 		inputBox.prompt = l10n.t('Please provide a worktree path');
 		inputBox.value = defaultWorktreePath;
 		inputBox.valueSelection = getValueSelection(inputBox.value);
+		inputBox.validationMessage = getValidationMessage(inputBox.value);
 		inputBox.ignoreFocusOut = true;
 		inputBox.buttons = [
 			{
@@ -3516,6 +3561,9 @@ export class CommandCenter {
 		const worktreePath = await new Promise<string | undefined>((resolve) => {
 			disposables.push(inputBox.onDidHide(() => resolve(undefined)));
 			disposables.push(inputBox.onDidAccept(() => resolve(inputBox.value)));
+			disposables.push(inputBox.onDidChangeValue(value => {
+				inputBox.validationMessage = getValidationMessage(value);
+			}));
 			disposables.push(inputBox.onDidTriggerButton(async () => {
 				inputBox.value = await getWorktreePath() ?? '';
 				inputBox.valueSelection = getValueSelection(inputBox.value);
@@ -3537,57 +3585,64 @@ export class CommandCenter {
 				this.globalState.update(`${CommandCenter.WORKTREE_ROOT_KEY}:${repository.root}`, worktreeRoot);
 			}
 		} catch (err) {
-			if (err.gitErrorCode !== GitErrorCodes.WorktreeAlreadyExists) {
+			if (err.gitErrorCode === GitErrorCodes.WorktreeAlreadyExists) {
+				await this.handleWorktreeAlreadyExists(err);
+			} else if (err.gitErrorCode === GitErrorCodes.WorktreeBranchAlreadyUsed) {
+				await this.handleWorktreeBranchAlreadyUsed(err);
+			} else {
 				throw err;
 			}
 
-			this.handleWorktreeError(err);
 			return;
 		}
 	}
 
-	// If the user picks a branch that is present in any of the worktrees or the current branch, return true
-	// Otherwise, return false.
-	private async isWorktreeLocked(repository: Repository, choice: RefItem): Promise<boolean> {
-		if (!choice.refName) {
-			return false;
-		}
-
-		const worktrees = await repository.getWorktrees();
+	private async handleWorktreeBranchAlreadyUsed(err: any): Promise<void> {
+		const match = err.stderr.match(/fatal: '([^']+)' is already used by worktree at '([^']+)'/);
 
-		const isInWorktree = worktrees.some(worktree => worktree.ref === `refs/heads/${choice.refName}`);
-		const isCurrentBranch = repository.HEAD?.name === choice.refName;
+		if (!match) {
+			return;
+		}
 
-		return isInWorktree || isCurrentBranch;
+		const [, branch, path] = match;
+		const message = l10n.t('Branch "{0}" is already checked out in the worktree at "{1}".', branch, path);
+		await this.handleWorktreeConflict(path, message);
 	}
 
-	private async handleWorktreeError(err: any): Promise<void> {
-		const match = err.stderr.match(/^fatal: '([^']+)' is already used by worktree at '([^']+)'/);
+	private async handleWorktreeAlreadyExists(err: any): Promise<void> {
+		const match = err.stderr.match(/fatal: '([^']+)'/);
+
 		if (!match) {
 			return;
 		}
 
-		const [, branch, path] = match;
+		const [, path] = match;
+		const message = l10n.t('A worktree already exists at "{0}".', path);
+		await this.handleWorktreeConflict(path, message);
+	}
+
+	private async handleWorktreeConflict(path: string, message: string): Promise<void> {
+		await this.model.openRepository(path, true);
+
 		const worktreeRepository = this.model.getRepository(path);
 
 		if (!worktreeRepository) {
 			return;
 		}
 
-		const openWorktree = l10n.t('Open in Current Window');
-		const openWorktreeInNewWindow = l10n.t('Open in New Window');
-		const message = l10n.t('Branch \'{0}\' is already checked out in the worktree at \'{1}\'.', branch, path);
+		const openWorktree = l10n.t('Open Worktree in Current Window');
+		const openWorktreeInNewWindow = l10n.t('Open Worktree in New Window');
 		const choice = await window.showWarningMessage(message, { modal: true }, openWorktree, openWorktreeInNewWindow);
 
 		if (choice === openWorktree) {
 			await this.openWorktreeInCurrentWindow(worktreeRepository);
 		} else if (choice === openWorktreeInNewWindow) {
 			await this.openWorktreeInNewWindow(worktreeRepository);
 		}
-
 		return;
 	}
 
+
 	@command('git.deleteWorktree', { repository: true, repositoryFilter: ['worktree'] })
 	async deleteWorktree(repository: Repository): Promise<void> {
 		if (!repository.dotGit.commonPath) {
@@ -3640,7 +3695,7 @@ export class CommandCenter {
 		}
 	}
 
-	@command('git.openWorktree', { repository: true, repositoryFilter: ['worktree'] })
+	@command('git.openWorktree', { repository: true })
 	async openWorktreeInCurrentWindow(repository: Repository): Promise<void> {
 		if (!repository) {
 			return;
@@ -3650,7 +3705,7 @@ export class CommandCenter {
 		await commands.executeCommand('vscode.openFolder', uri, { forceReuseWindow: true });
 	}
 
-	@command('git.openWorktreeInNewWindow', { repository: true, repositoryFilter: ['worktree'] })
+	@command('git.openWorktreeInNewWindow', { repository: true })
 	async openWorktreeInNewWindow(repository: Repository): Promise<void> {
 		if (!repository) {
 			return;

extensions/git/src/git.ts

@@ -351,10 +351,11 @@ function getGitErrorCode(stderr: string): string | undefined {
 		return GitErrorCodes.NotASafeGitRepository;
 	} else if (/contains modified or untracked files|use --force to delete it/.test(stderr)) {
 		return GitErrorCodes.WorktreeContainsChanges;
-	} else if (/is already used by worktree at|already exists/.test(stderr)) {
+	} else if (/fatal: '[^']+' already exists/.test(stderr)) {
 		return GitErrorCodes.WorktreeAlreadyExists;
+	} else if (/is already used by worktree at/.test(stderr)) {
+		return GitErrorCodes.WorktreeBranchAlreadyUsed;
 	}
-
 	return undefined;
 }
 
@@ -2786,14 +2787,9 @@ export class Repository {
 			return [];
 		}
 
-		if (this.kind !== 'repository') {
-			this.logger.info('[Git][getWorktreesFS] Either a submodule or a worktree, skipping worktree detection');
-			return [];
-		}
-
 		try {
 			// List all worktree folder names
-			const worktreesPath = path.join(this.repositoryRoot, '.git', 'worktrees');
+			const worktreesPath = path.join(this.dotGit.commonPath ?? this.dotGit.path, 'worktrees');
 			const dirents = await fs.readdir(worktreesPath, { withFileTypes: true });
 			const result: Worktree[] = [];
 
@@ -2812,7 +2808,7 @@ export class Repository {
 					result.push({
 						name: dirent.name,
 						// Remove '/.git' suffix
-						path: gitdirContent.replace(/\.git.*$/, ''),
+						path: gitdirContent.replace(/\/.git.*$/, ''),
 						// Remove 'ref: ' prefix
 						ref: headContent.replace(/^ref: /, ''),
 					});

extensions/git/src/model.ts

@@ -647,19 +647,6 @@ export class Model implements IRepositoryResolver, IBranchProtectionProviderRegi
 			// Open repository
 			const [dotGit, repositoryRootRealPath] = await Promise.all([this.git.getRepositoryDotGit(repositoryRoot), this.getRepositoryRootRealPath(repositoryRoot)]);
 			const gitRepository = this.git.open(repositoryRoot, repositoryRootRealPath, dotGit, this.logger);
-
-			// Check if the repository is a submodule/worktree and if they should be detected
-			const detectSubmodules = config.get<boolean>('detectSubmodules', true) === true;
-			const detectWorktrees = config.get<boolean>('detectWorktrees', true) === true;
-			if ((gitRepository.kind === 'submodule' && !detectSubmodules) ||
-				(gitRepository.kind === 'worktree' && !detectWorktrees)) {
-				this.logger.info(`[Model][openRepository] Skip opening repository (path): ${repositoryRoot}`);
-				this.logger.info(`[Model][openRepository] Skip opening repository (real path): ${repositoryRootRealPath ?? repositoryRoot}`);
-				this.logger.info(`[Model][openRepository] Skip opening repository (kind): ${gitRepository.kind}`);
-
-				return;
-			}
-
 			const repository = new Repository(gitRepository, this, this, this, this, this, this, this.globalState, this.logger, this.telemetryReporter);
 
 			this.open(repository);
@@ -783,6 +770,11 @@ export class Model implements IRepositoryResolver, IBranchProtectionProviderRegi
 				return;
 			}
 
+			if (repository.kind === 'worktree') {
+				this.logger.trace('[Model][open] Automatic detection of git worktrees is not skipped.');
+				return;
+			}
+
 			if (repository.worktrees.length > worktreesLimit) {
 				window.showWarningMessage(l10n.t('The "{0}" repository has {1} worktrees which won\'t be opened automatically. You can still open each one individually by opening a file within.', path.basename(repository.root), repository.worktrees.length));
 				statusListener.dispose();