@codingame/monaco-vscode-workbench-service-override 37.1.0 → 37.3.0

package/vscode/src/vs/sessions/services/sessions/browser/worktreeTrust.d.ts

@@ -0,0 +1,23 @@
+import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { ISessionWorkspace } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+/**
+ * Auto-trusts every isolated git worktree in `workspace` that VS Code created off
+ * a base repository the user already trusts, granting (and persisting) trust for
+ * the worktree folder so a worktree session opens/sends without tripping the
+ * untrusted-folder prompt.
+ *
+ * A folder is treated as an eligible worktree only when ALL of the following hold:
+ * - it is a worktree (`gitRepository.workTreeUri` is set);
+ * - it is a strict descendant of `getWorktreesRoot(<base repo>)` — a structural
+ *   provenance guard ({@link isWorktreeUnderRepository}). `workTreeUri` alone does
+ *   not prove VS Code created the worktree (its contract permits an arbitrary
+ *   checkout path), so without this guard a session could silently inherit trust
+ *   for an arbitrary working directory whenever its reported base repository
+ *   happens to be trusted. The shared `<repo>.worktrees` container is excluded so
+ *   trusting it can never cascade to every worktree under it;
+ * - its base repository (`gitRepository.uri`) is trusted while the worktree is not.
+ *
+ * Gating on the base repository's trust ensures trust never flows from an
+ * untrusted repository into its worktree.
+ */
+export declare function ensureSessionWorktreesTrusted(workspace: ISessionWorkspace | undefined, workspaceTrustManagementService: IWorkspaceTrustManagementService): Promise<void>;

package/vscode/src/vs/sessions/services/sessions/browser/worktreeTrust.js

@@ -0,0 +1,23 @@
+
+import { isWorktreeUnderRepository } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/worktreePaths';
+
+async function ensureSessionWorktreesTrusted(workspace, workspaceTrustManagementService) {
+    if (!workspace?.requiresWorkspaceTrust) {
+        return;
+    }
+    await Promise.all(workspace.folders.map(async (folder) => {
+        const gitRepository = folder.gitRepository;
+        if (!gitRepository?.workTreeUri || !isWorktreeUnderRepository(folder.workingDirectory, gitRepository.uri)) {
+            return;
+        }
+        const [worktreeTrust, baseRepoTrust] = await Promise.all([
+            workspaceTrustManagementService.getUriTrustInfo(folder.workingDirectory),
+            workspaceTrustManagementService.getUriTrustInfo(gitRepository.uri),
+        ]);
+        if (!worktreeTrust.trusted && baseRepoTrust.trusted) {
+            await workspaceTrustManagementService.setUrisTrust([folder.workingDirectory], true);
+        }
+    }));
+}
+
+export { ensureSessionWorktreesTrusted };

package/vscode/src/vs/sessions/services/sessions/common/sessionContextKeys.d.ts

@@ -0,0 +1,32 @@
+import { IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { ISessionChangesStatsCache } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionChangesStatsCache.service";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+/**
+ * Sets every context key that can be derived from an {@link ISession} on the
+ * given context key service. The service may be the global/root service (so the
+ * keys reflect the active session) or a scoped service owned by an isolated
+ * component (e.g. a session view), in which case the keys are scoped to that
+ * component's session.
+ *
+ * When invoked from within an `autorun`/`derived`, pass the `reader` so the
+ * observable session properties are tracked and the keys are re-applied on
+ * change. Pass `undefined` for a one-shot read (equivalent to `.get()`).
+ *
+ * Passing `undefined` for `session` resets the keys to their defaults (e.g. for
+ * the empty new-session slot).
+ *
+ * Pass the `changesStatsCache` on surfaces that render the changes pill so it can
+ * be shown optimistically while the session's own changes are still loading.
+ */
+export declare function setSessionContextKeys(session: ISession | undefined, contextKeyService: IContextKeyService, reader: IReader | undefined, changesStatsCache?: ISessionChangesStatsCache): void;
+/**
+ * Sets every context key that can be derived from an {@link IActiveSession} on
+ * the given context key service. This is a superset of
+ * {@link setSessionContextKeys} that also applies the keys which only exist on
+ * an active (visible) session, then delegates to it for the shared keys.
+ *
+ * See {@link setSessionContextKeys} for the `reader` and `undefined` semantics.
+ */
+export declare function setActiveSessionContextKeys(session: IActiveSession | undefined, contextKeyService: IContextKeyService, reader: IReader | undefined, changesStatsCache?: ISessionChangesStatsCache): void;

package/vscode/src/vs/sessions/services/sessions/common/sessionContextKeys.js

@@ -0,0 +1,103 @@
+
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { SessionHasSideChatsContext, SessionActiveChatIsDeletableContext, SessionActiveChatIsClosableContext, SessionHasMultipleOpenChatsContext, SessionShouldShowChatTabsContext, SessionHasMultipleCommittedChatsContext, SessionIsStickyContext, SessionIsCreatedContext, IsQuickChatSessionContext, SessionHasWorkspaceContext, SessionHasIssuesContext, SessionHasPullRequestContext, SessionHasCachedChangesContext, SessionHasChangesContext, SessionHasGitRepositoryContext, SessionWorkspaceIsVirtualContext, SessionSupportsDeleteContext, SessionSupportsRenameContext, SessionSupportsSideChatContext, SessionSupportsForkContext, SessionSupportsMultipleChatsContext, SessionIsReadContext, SessionIsActiveContext, SessionIsArchivedContext, SessionTypeContext, SessionProviderIdContext, SessionIdContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { isActiveSessionStatus, SessionStatus, ChatOriginKind, getChatCapabilities } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { readSessionChangesStats } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionChangesStatsCache';
+
+const boundKeysByService = ( new WeakMap());
+function getBoundKeys(contextKeyService) {
+    let keys = boundKeysByService.get(contextKeyService);
+    if (!keys) {
+        keys = {
+            sessionId: SessionIdContext.bindTo(contextKeyService),
+            providerId: SessionProviderIdContext.bindTo(contextKeyService),
+            type: SessionTypeContext.bindTo(contextKeyService),
+            isArchived: SessionIsArchivedContext.bindTo(contextKeyService),
+            isActive: SessionIsActiveContext.bindTo(contextKeyService),
+            isRead: SessionIsReadContext.bindTo(contextKeyService),
+            supportsMultipleChats: SessionSupportsMultipleChatsContext.bindTo(contextKeyService),
+            supportsFork: SessionSupportsForkContext.bindTo(contextKeyService),
+            supportsSideChat: SessionSupportsSideChatContext.bindTo(contextKeyService),
+            supportsRename: SessionSupportsRenameContext.bindTo(contextKeyService),
+            supportsDelete: SessionSupportsDeleteContext.bindTo(contextKeyService),
+            workspaceIsVirtual: SessionWorkspaceIsVirtualContext.bindTo(contextKeyService),
+            hasGitRepository: SessionHasGitRepositoryContext.bindTo(contextKeyService),
+            hasChanges: SessionHasChangesContext.bindTo(contextKeyService),
+            hasCachedChanges: SessionHasCachedChangesContext.bindTo(contextKeyService),
+            hasPullRequest: SessionHasPullRequestContext.bindTo(contextKeyService),
+            hasIssues: SessionHasIssuesContext.bindTo(contextKeyService),
+            hasWorkspace: SessionHasWorkspaceContext.bindTo(contextKeyService),
+            isQuickChat: IsQuickChatSessionContext.bindTo(contextKeyService),
+            isCreated: SessionIsCreatedContext.bindTo(contextKeyService),
+            sticky: SessionIsStickyContext.bindTo(contextKeyService),
+            hasMultipleCommittedChats: SessionHasMultipleCommittedChatsContext.bindTo(contextKeyService),
+            shouldShowChatTabs: SessionShouldShowChatTabsContext.bindTo(contextKeyService),
+            hasMultipleOpenChats: SessionHasMultipleOpenChatsContext.bindTo(contextKeyService),
+            activeChatIsClosable: SessionActiveChatIsClosableContext.bindTo(contextKeyService),
+            activeChatIsDeletable: SessionActiveChatIsDeletableContext.bindTo(contextKeyService),
+            hasSideChats: SessionHasSideChatsContext.bindTo(contextKeyService)
+        };
+        boundKeysByService.set(contextKeyService, keys);
+    }
+    return keys;
+}
+function setSessionContextKeys(session, contextKeyService, reader, changesStatsCache) {
+    const keys = getBoundKeys(contextKeyService);
+    keys.sessionId.set(session?.sessionId ?? "");
+    keys.providerId.set(session?.providerId ?? "");
+    keys.type.set(session?.sessionType ?? "");
+    keys.isArchived.set(session?.isArchived.read(reader) ?? false);
+    keys.isActive.set(session ? isActiveSessionStatus(session.status.read(reader)) : false);
+    keys.isRead.set(session?.isRead.read(reader) ?? true);
+    const capabilities = session?.capabilities.read(reader);
+    keys.supportsMultipleChats.set(capabilities?.supportsMultipleChats ?? false);
+    keys.supportsFork.set(capabilities?.supportsFork ?? false);
+    keys.supportsSideChat.set(capabilities?.supportsSideChat ?? false);
+    keys.supportsRename.set(capabilities?.supportsRename ?? false);
+    keys.supportsDelete.set(capabilities?.supportsDelete ?? false);
+    const workspace = session?.workspace.read(reader);
+    keys.workspaceIsVirtual.set(workspace?.isVirtualWorkspace ?? true);
+    keys.hasGitRepository.set(
+        session?.hasGitRepository?.read(reader) ?? workspace?.folders.some(folder => folder.gitRepository !== undefined) ?? false
+    );
+    const worktreePending = session?.worktreePending?.read(reader) ?? false;
+    const defaultChangeset = session?.changesets.read(reader)?.find(c => c.isDefault.read(reader));
+    let insertions = 0;
+    let deletions = 0;
+    for (const change of defaultChangeset?.changes.read(reader) ?? session?.changes.read(reader) ?? []) {
+        insertions += change.insertions;
+        deletions += change.deletions;
+    }
+    keys.hasChanges.set(!worktreePending && (insertions > 0 || deletions > 0));
+    const changesReported = session ? readSessionChangesStats(session, reader) !== undefined : true;
+    const cachedFiles = !changesReported && session ? changesStatsCache?.get(session.sessionId, reader)?.files ?? 0 : 0;
+    keys.hasCachedChanges.set(!worktreePending && cachedFiles > 0);
+    const pullRequest = session?.workspace.read(reader)?.folders[0]?.gitRepository?.gitHubInfo.read(reader)?.pullRequest;
+    keys.hasPullRequest.set(!!pullRequest);
+    const issues = session?.workspace.read(reader)?.folders[0]?.gitRepository?.gitHubInfo.read(reader)?.issues;
+    keys.hasIssues.set(!!issues?.length);
+    keys.hasWorkspace.set(!!session?.workspace.read(reader)?.label);
+    keys.isQuickChat.set(!!session && (session.isQuickChat?.read(reader) ?? false));
+}
+function setActiveSessionContextKeys(session, contextKeyService, reader, changesStatsCache) {
+    setSessionContextKeys(session, contextKeyService, reader, changesStatsCache);
+    const keys = getBoundKeys(contextKeyService);
+    keys.isCreated.set(session?.isCreated.read(reader) ?? false);
+    keys.sticky.set(session?.sticky.read(reader) ?? false);
+    const committedChatCount = session?.chats.read(reader).reduce(
+        (count, chat) => chat.status.read(reader) === SessionStatus.Untitled || chat.origin?.kind === ChatOriginKind.Tool ? count : count + 1,
+        0
+    ) ?? 0;
+    keys.hasMultipleCommittedChats.set(committedChatCount > 1);
+    keys.shouldShowChatTabs.set(session?.shouldShowChatTabs.read(reader) ?? false);
+    keys.hasMultipleOpenChats.set((session?.visibleChatTabs.read(reader).length ?? 0) > 1);
+    const activeChat = session?.activeChat.read(reader);
+    const mainResource = session?.mainChat.read(reader).resource;
+    const isNonMainChat = !!activeChat && !!mainResource && !isEqual(activeChat.resource, mainResource);
+    keys.activeChatIsClosable.set(isNonMainChat);
+    keys.activeChatIsDeletable.set(!!activeChat && getChatCapabilities(activeChat, session, reader).canDelete);
+    const allChats = session?.chats.read(reader) ?? [];
+    keys.hasSideChats.set(( allChats.some(chat => chat.origin?.kind === ChatOriginKind.SideChat)));
+}
+
+export { setActiveSessionContextKeys, setSessionContextKeys };

package/vscode/src/vs/sessions/services/workspaceFolderLabel/browser/workspaceFolderLabelService.d.ts

@@ -0,0 +1,16 @@
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IWorkspaceFolderLabelService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workspaces/common/workspaceFolderLabelService.service";
+import { IWorkspaceFolder } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+export declare class SessionsWorkspaceFolderLabelService implements IWorkspaceFolderLabelService {
+    private readonly sessionsService;
+    private readonly sessionsManagementService;
+    private readonly uriIdentityService;
+    private readonly labelService;
+    readonly _serviceBrand: undefined;
+    constructor(sessionsService: ISessionsService, sessionsManagementService: ISessionsManagementService, uriIdentityService: IUriIdentityService, labelService: ILabelService);
+    getWorkspaceFolderLabel(workspaceFolder: IWorkspaceFolder, verbose?: boolean): string;
+    private isWorkspaceFolder;
+}

package/vscode/src/vs/sessions/services/workspaceFolderLabel/browser/workspaceFolderLabelService.js

@@ -0,0 +1,41 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+
+let SessionsWorkspaceFolderLabelService = class SessionsWorkspaceFolderLabelService {
+    constructor(
+        sessionsService,
+        sessionsManagementService,
+        uriIdentityService,
+        labelService
+    ) {
+        this.sessionsService = sessionsService;
+        this.sessionsManagementService = sessionsManagementService;
+        this.uriIdentityService = uriIdentityService;
+        this.labelService = labelService;
+    }
+    getWorkspaceFolderLabel(workspaceFolder, verbose) {
+        const workspace = this.sessionsService.activeSession.get()?.workspace.get();
+        const folder = workspace?.folders.find(folder => this.isWorkspaceFolder(folder, workspaceFolder)) ?? this.sessionsManagementService.getSessions().flatMap(session => session.workspace.get()?.folders ?? []).find(folder => this.isWorkspaceFolder(folder, workspaceFolder));
+        if (folder) {
+            const repositoryName = folder.name;
+            if (verbose && !this.uriIdentityService.extUri.isEqual(folder.root, folder.workingDirectory)) {
+                const branchName = folder.gitRepository?.branchName ?? this.labelService.getUriBasenameLabel(folder.workingDirectory);
+                return `${repositoryName} (${branchName})`;
+            }
+            return repositoryName;
+        }
+        return this.labelService.getUriBasenameLabel(workspaceFolder.uri);
+    }
+    isWorkspaceFolder(folder, workspaceFolder) {
+        return this.uriIdentityService.extUri.isEqual(folder.workingDirectory, workspaceFolder.uri);
+    }
+};
+SessionsWorkspaceFolderLabelService = ( __decorate([( __param(0, ISessionsService)), ( __param(1, ISessionsManagementService)), ( __param(2, IUriIdentityService)), ( __param(3, ILabelService))], SessionsWorkspaceFolderLabelService));
+
+export { SessionsWorkspaceFolderLabelService };

package/vscode/src/vs/workbench/browser/layout.js

@@ -626,7 +626,7 @@ class Layout extends Disposable {
             views
         } = defaultLayout;
         if (views?.length) {
-            return ( views.map(view => view.id));
+            return views.map(view => view.id);
         }
         return undefined;
     }
@@ -773,7 +773,7 @@ class Layout extends Disposable {
                     }
                     editorsByGroup.add(editor.editor);
                 }
-                openEditorsPromise = Promise.all(( Array.from(mapEditorsToGroup).map(async ([groupId, editors]) => {
+                openEditorsPromise = Promise.all(Array.from(mapEditorsToGroup).map(async ([groupId, editors]) => {
                     try {
                         await this.editorService.openEditors(Array.from(editors), groupId, {
                             validateTrust: true
@@ -781,7 +781,7 @@ class Layout extends Disposable {
                     } catch (error) {
                         this.logService.error(error);
                     }
-                })));
+                }));
             }
             const customEditorRestorePromise = instantiationService.invokeFunction(
                 this.layoutOptions?.customEditorRestore ?? (async () => {}),
@@ -818,10 +818,10 @@ class Layout extends Disposable {
                     }
                     return false;
                 };
-                const defaultViews = ( [...this.state.initialization.views.defaults].reverse().map((v, index) => ({
+                const defaultViews = [...this.state.initialization.views.defaults].reverse().map((v, index) => ({
                     id: v,
                     order: index
-                })));
+                }));
                 let i = defaultViews.length;
                 while (i) {
                     i--;
@@ -1378,7 +1378,7 @@ class Layout extends Disposable {
     }
     centerMainEditorLayout(active, skipLayout) {
         this.stateModel.setRuntimeValue(LayoutStateKeys.MAIN_EDITOR_CENTERED, active);
-        const mainVisibleEditors = coalesce(( this.editorGroupService.mainPart.groups.map(group => group.activeEditor)));
+        const mainVisibleEditors = coalesce(this.editorGroupService.mainPart.groups.map(group => group.activeEditor));
         const isEditorComplex = ( mainVisibleEditors.some(editor => {
             if (editor instanceof DiffEditorInput) {
                 return this.configurationService.getValue("diffEditor.renderSideBySide");
@@ -1841,7 +1841,7 @@ class Layout extends Disposable {
     toggleSecondarySideBar() {
         const visible = !this.isSecondarySideBarVisible();
         this.setPartHidden(!visible, Parts.AUXILIARYBAR_PART);
-        alert(visible ? ( localize(3503, "Secondary Side Bar shown")) : ( localize(3504, "Secondary Side Bar hidden")));
+        alert(visible ? ( localize(5474, "Secondary Side Bar shown")) : ( localize(5475, "Secondary Side Bar hidden")));
     }
     isSecondarySideBarVisible() {
         return this.isVisible(Parts.AUXILIARYBAR_PART);

package/vscode/src/vs/workbench/browser/workbench.js

@@ -185,7 +185,7 @@ class Workbench extends Layout {
         }
         this.fontAliasing = aliasing;
         const fontAliasingValues = ["antialiased", "none", "auto"];
-        this.mainContainer.classList.remove(...( fontAliasingValues.map(value => `monaco-font-aliasing-${value}`)));
+        this.mainContainer.classList.remove(...fontAliasingValues.map(value => `monaco-font-aliasing-${value}`));
         if (( fontAliasingValues.some(option => option === aliasing))) {
             this.mainContainer.classList.add(`monaco-font-aliasing-${aliasing}`);
         }
@@ -327,10 +327,10 @@ class Workbench extends Layout {
         registerNotificationCommands(notificationsCenter, notificationsToasts, notificationService.model);
         AccessibleViewRegistry.register(( new NotificationAccessibleView()));
         this.registerNotifications({
-            onDidChangeNotificationsVisibility: ( Event.map(Event.any(
+            onDidChangeNotificationsVisibility: Event.map(Event.any(
                 notificationsToasts.onDidChangeVisibility,
                 notificationsCenter.onDidChangeVisibility
-            ), () => notificationsToasts.isVisible || notificationsCenter.isVisible))
+            ), () => notificationsToasts.isVisible || notificationsCenter.isVisible)
         });
     }
     restore(instantiationService, lifecycleService) {