Merge branch 'main' into osortega/chat-sessions-view

Author: osortega

.devcontainer/Dockerfile

@@ -1,4 +1,4 @@
-FROM mcr.microsoft.com/devcontainers/typescript-node:20-bookworm
+FROM mcr.microsoft.com/devcontainers/typescript-node:22-bookworm
 
 ADD install-vscode.sh /root/
 RUN /root/install-vscode.sh

cli/src/commands/serve_web.rs

@@ -127,7 +127,9 @@ pub async fn serve_web(ctx: CommandContext, mut args: ServeWebArgs) -> Result<i3
 		};
 		let builder = Server::try_bind(&addr).map_err(CodeError::CouldNotListenOnInterface)?;
 
-		let mut listening = format!("Web UI available at http://{addr}");
+		// Get the actual bound address (important when port 0 is used for random port assignment)
+		let bound_addr = builder.local_addr();
+		let mut listening = format!("Web UI available at http://{bound_addr}");
 		if let Some(base) = args.server_base_path {
 			if !base.starts_with('/') {
 				listening.push('/');

extensions/git/package.json

@@ -1335,6 +1335,14 @@
           "command": "git.deleteWorktree",
           "when": "false"
         },
+        {
+          "command": "git.openWorktree",
+          "when": "false"
+        },
+        {
+          "command": "git.openWorktreeInNewWindow",
+          "when": "false"
+        },
         {
           "command": "git.deleteWorktreeFromPalette",
           "when": "config.git.enabled && !git.missing && gitOpenRepositoryCount > 1"
@@ -1690,13 +1698,13 @@
         },
         {
           "command": "git.openWorktree",
-          "group": "worktree@1",
-          "when": "scmProvider == git && gitOpenRepositoryCount > 1"
+          "group": "1_worktree@1",
+          "when": "scmProvider == git && scmProviderContext == worktree"
         },
         {
           "command": "git.openWorktreeInNewWindow",
-          "group": "worktree@2",
-          "when": "scmProvider == git && gitOpenRepositoryCount > 1"
+          "group": "1_worktree@2",
+          "when": "scmProvider == git && scmProviderContext == worktree"
         }
       ],
       "scm/resourceGroup/context": [
@@ -3071,7 +3079,7 @@
         "git.detectWorktrees": {
           "type": "boolean",
           "scope": "resource",
-          "default": false,
+          "default": true,
           "description": "%config.detectWorktrees%"
         },
         "git.detectWorktreesLimit": {

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

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

extensions/git/src/askpass.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { window, InputBoxOptions, Uri, Disposable, workspace, QuickPickOptions, l10n, LogOutputChannel } from 'vscode';
-import { IDisposable, EmptyDisposable, toDisposable } from './util';
+import { IDisposable, EmptyDisposable, toDisposable, extractFilePathFromArgs } from './util';
 import * as path from 'path';
 import { IIPCHandler, IIPCServer } from './ipc/ipcServer';
 import { CredentialsProvider, Credentials } from './api/git';
@@ -108,7 +108,7 @@ export class Askpass implements IIPCHandler, ITerminalEnvironmentProvider {
 		if (/passphrase/i.test(request)) {
 			// Commit signing - Enter passphrase:
 			// Git operation  - Enter passphrase for key '/c/Users/<username>/.ssh/id_ed25519':
-			const file = argv[6]?.replace(/^["']+|["':]+$/g, '');
+			const file = extractFilePathFromArgs(argv, 6);
 
 			this.logger.trace(`[Askpass][handleSSHAskpass] request: ${request}, file: ${file}`);
 

extensions/git/src/commands.ts

@@ -340,6 +340,7 @@ class StashItem implements QuickPickItem {
 
 interface ScmCommandOptions {
 	repository?: boolean;
+	repositoryFilter?: ('repository' | 'submodule' | 'worktree')[];
 }
 
 interface ScmCommand {
@@ -1681,7 +1682,11 @@ export class CommandCenter {
 
 	@command('git.diff.stageHunk')
 	async diffStageHunk(changes: DiffEditorSelectionHunkToolbarContext | undefined): Promise<void> {
-		this.diffStageHunkOrSelection(changes);
+		if (changes) {
+			this.diffStageHunkOrSelection(changes);
+		} else {
+			await this.stageHunkAtCursor();
+		}
 	}
 
 	@command('git.diff.stageSelection')
@@ -1719,6 +1724,36 @@ export class CommandCenter {
 			await repository.stage(resource, result, modifiedDocument.encoding));
 	}
 
+	private async stageHunkAtCursor(): Promise<void> {
+		const textEditor = window.activeTextEditor;
+
+		if (!textEditor) {
+			return;
+		}
+
+		const workingTreeDiffInformation = getWorkingTreeDiffInformation(textEditor);
+		if (!workingTreeDiffInformation) {
+			return;
+		}
+
+		const workingTreeLineChanges = toLineChanges(workingTreeDiffInformation);
+		const modifiedDocument = textEditor.document;
+		const cursorPosition = textEditor.selection.active;
+
+		// Find the hunk that contains the cursor position
+		const hunkAtCursor = workingTreeLineChanges.find(change => {
+			const hunkRange = getModifiedRange(modifiedDocument, change);
+			return hunkRange.contains(cursorPosition);
+		});
+
+		if (!hunkAtCursor) {
+			window.showInformationMessage(l10n.t('No hunk found at cursor position.'));
+			return;
+		}
+
+		await this._stageChanges(textEditor, [hunkAtCursor]);
+	}
+
 	@command('git.stageSelectedRanges')
 	async stageSelectedChanges(): Promise<void> {
 		const textEditor = window.activeTextEditor;
@@ -2882,10 +2917,15 @@ export class CommandCenter {
 			try {
 				await item.run(repository, opts);
 			} catch (err) {
-				if (err.gitErrorCode !== GitErrorCodes.DirtyWorkTree) {
+				if (err.gitErrorCode !== GitErrorCodes.DirtyWorkTree && err.gitErrorCode !== GitErrorCodes.WorktreeAlreadyExists) {
 					throw err;
 				}
 
+				if (err.gitErrorCode === GitErrorCodes.WorktreeAlreadyExists) {
+					this.handleWorktreeError(err);
+					return false;
+				}
+
 				const stash = l10n.t('Stash & Checkout');
 				const migrate = l10n.t('Migrate Changes');
 				const force = l10n.t('Force Checkout');
@@ -3351,33 +3391,45 @@ export class CommandCenter {
 		}
 	}
 
-	@command('git.createWorktree', { repository: true })
+	@command('git.createWorktree', { repository: true, repositoryFilter: ['repository', 'submodule'] })
 	async createWorktree(repository: Repository): Promise<void> {
-		await this._createWorktree(repository, undefined, undefined);
+		await this._createWorktree(repository);
 	}
 
-	private async _createWorktree(repository: Repository, worktreePath?: string, name?: string): Promise<void> {
+	private async _createWorktree(repository: Repository, worktreePath?: string, name?: string, newBranch?: boolean): Promise<void> {
 		const config = workspace.getConfiguration('git');
 		const showRefDetails = config.get<boolean>('showReferenceDetails') === true;
 
 		if (!name) {
+			const createBranch = new CreateBranchItem();
 			const getBranchPicks = async () => {
-				const refs = await repository.getRefs({
-					pattern: 'refs/heads',
-					includeCommitDetails: showRefDetails
-				});
-				const processors = [new RefProcessor(RefType.Head, BranchItem)];
-				const itemsProcessor = new RefItemsProcessor(repository, processors);
-				return itemsProcessor.processRefs(refs);
+				const refs = await repository.getRefs({ includeCommitDetails: showRefDetails });
+				const itemsProcessor = new RefItemsProcessor(repository, [
+					new RefProcessor(RefType.Head),
+					new RefProcessor(RefType.RemoteHead),
+					new RefProcessor(RefType.Tag)
+				]);
+				const branchItems = itemsProcessor.processRefs(refs);
+				return [createBranch, { label: '', kind: QuickPickItemKind.Separator }, ...branchItems];
 			};
 
 			const placeHolder = l10n.t('Select a branch to create the new worktree from');
 			const choice = await this.pickRef(getBranchPicks(), placeHolder);
 
-			if (!(choice instanceof BranchItem) || !choice.refName) {
+			if (choice === createBranch) {
+				const branchName = await this.promptForBranchName(repository);
+
+				if (!branchName) {
+					return;
+				}
+
+				newBranch = true;
+				name = branchName;
+			} else if (choice instanceof BranchItem && choice.refName) {
+				name = choice.refName;
+			} else {
 				return;
 			}
-			name = choice.refName;
 		}
 
 		const disposables: Disposable[] = [];
@@ -3395,6 +3447,10 @@ export class CommandCenter {
 		dispose(disposables);
 		inputBox.dispose();
 
+		if (!worktreeName) {
+			return;
+		}
+
 		// Default to view parent directory of repository root
 		const defaultUri = Uri.file(path.dirname(repository.root));
 
@@ -3416,10 +3472,48 @@ export class CommandCenter {
 
 		worktreePath = path.join(uris[0].fsPath, worktreeName);
 
-		await repository.worktree({
-			name: name,
-			path: worktreePath,
-		});
+		try {
+			await repository.worktree({ name: name, path: worktreePath, newBranch: newBranch });
+		} catch (err) {
+			if (err.gitErrorCode !== GitErrorCodes.WorktreeAlreadyExists) {
+				throw err;
+			}
+
+			this.handleWorktreeError(err);
+			return;
+
+		}
+	}
+
+	private async handleWorktreeError(err: any): Promise<void> {
+		const errorMessage = err.stderr;
+		const match = errorMessage.match(/worktree at '([^']+)'/) || errorMessage.match(/'([^']+)'/);
+		const path = match ? match[1] : undefined;
+
+		if (!path) {
+			return;
+		}
+
+		const worktreeRepository = this.model.getRepository(path) || this.model.getRepository(Uri.file(path));
+
+		if (!worktreeRepository) {
+			return;
+		}
+
+		const openWorktree = l10n.t('Open in current window');
+		const openWorktreeInNewWindow = l10n.t('Open in new window');
+		const message = l10n.t(errorMessage);
+		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 })
@@ -3456,18 +3550,10 @@ export class CommandCenter {
 		}
 	}
 
-	@command('git.deleteWorktreeFromPalette')
-	async deleteWorktreeFromPalette(): Promise<void> {
-		const mainRepository = this.model.repositories.find(repo =>
-			!repo.dotGit.commonPath
-		);
-
-		if (!mainRepository) {
-			return;
-		}
-
+	@command('git.deleteWorktreeFromPalette', { repository: true, repositoryFilter: ['repository', 'submodule'] })
+	async deleteWorktreeFromPalette(repository: Repository): Promise<void> {
 		const worktreePicks = async (): Promise<WorktreeDeleteItem[] | QuickPickItem[]> => {
-			const worktrees = await mainRepository.getWorktrees();
+			const worktrees = await repository.getWorktrees();
 			return worktrees.length === 0
 				? [{ label: l10n.t('$(info) This repository has no worktrees.') }]
 				: worktrees.map(worktree => new WorktreeDeleteItem(worktree));
@@ -3477,14 +3563,13 @@ export class CommandCenter {
 		const choice = await this.pickRef<WorktreeDeleteItem | QuickPickItem>(worktreePicks(), placeHolder);
 
 		if (choice instanceof WorktreeDeleteItem) {
-			await choice.run(mainRepository);
+			await choice.run(repository);
 		}
 	}
 
 	@command('git.openWorktree', { repository: true })
-	async openWorktreeInCurrentWindow(repository: Repository, ...args: SourceControl[]): Promise<void> {
-		// If multiple repositories are selected, no action is taken
-		if (args.length > 0) {
+	async openWorktreeInCurrentWindow(repository: Repository): Promise<void> {
+		if (!repository) {
 			return;
 		}
 
@@ -3493,9 +3578,8 @@ export class CommandCenter {
 	}
 
 	@command('git.openWorktreeInNewWindow', { repository: true })
-	async openWorktreeInNewWindow(repository: Repository, ...args: SourceControl[]): Promise<void> {
-		// If multiple repositories are selected, no action is taken
-		if (args.length > 0) {
+	async openWorktreeInNewWindow(repository: Repository): Promise<void> {
+		if (!repository) {
 			return;
 		}
 
@@ -4863,10 +4947,8 @@ export class CommandCenter {
 
 				if (repository) {
 					repositoryPromise = Promise.resolve(repository);
-				} else if (this.model.repositories.length === 1) {
-					repositoryPromise = Promise.resolve(this.model.repositories[0]);
 				} else {
-					repositoryPromise = this.model.pickRepository();
+					repositoryPromise = this.model.pickRepository(options.repositoryFilter);
 				}
 
 				result = repositoryPromise.then(repository => {

extensions/git/src/git.ts

@@ -351,6 +351,8 @@ 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)) {
+		return GitErrorCodes.WorktreeAlreadyExists;
 	}
 
 	return undefined;
@@ -2035,8 +2037,19 @@ export class Repository {
 		await this.exec(args);
 	}
 
-	async worktree(options: { path: string; name: string }): Promise<void> {
-		const args = ['worktree', 'add', options.path, options.name];
+	async worktree(options: { path: string; name: string; newBranch?: boolean }): Promise<void> {
+		const args = ['worktree', 'add'];
+
+		if (options?.newBranch) {
+			args.push('-b', options.name);
+		}
+
+		args.push(options.path);
+
+		if (!options.newBranch) {
+			args.push(options.name);
+		}
+
 		await this.exec(args);
 	}