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

package/vscode/src/vs/sessions/contrib/automations/common/isolationGroupModel.js

@@ -0,0 +1,123 @@
+
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+const GENERATED_WORKTREE_BRANCH_MARKER = "copilot-worktree-";
+function isSelectableAutomationBranch(name) {
+    return !!name && !name.includes(GENERATED_WORKTREE_BRANCH_MARKER);
+}
+function normalizeAutomationBranchNames(names) {
+    return [...( new Set([...names].filter(isSelectableAutomationBranch)))].sort((a, b) => a.localeCompare(b));
+}
+class AutomationIsolationModel {
+    constructor(_state) {
+        this._state = _state;
+        this._supportsWorktreeConfiguration = false;
+        if (_state.isQuickChat) {
+            _state.folderUri = undefined;
+            _state.isolationMode = undefined;
+            _state.branch = undefined;
+        }
+        const branch = _state.isolationMode === "worktree" ? _state.branch : undefined;
+        this._selectedBranch = isSelectableAutomationBranch(branch) ? branch : undefined;
+        this._state.branch = this._selectedBranch;
+        this._isQuickChat = observableValue(this, _state.isQuickChat);
+        this.isQuickChatObs = this._isQuickChat;
+        this._folderUri = observableValue(this, _state.folderUri);
+        this.folderUriObs = this._folderUri;
+    }
+    get isQuickChat() {
+        return this._state.isQuickChat;
+    }
+    get folderUri() {
+        return this._state.folderUri;
+    }
+    get isolationMode() {
+        return this._state.isolationMode ?? "workspace";
+    }
+    get selectedBranch() {
+        return this._selectedBranch;
+    }
+    get headBranch() {
+        return this._headBranch;
+    }
+    get displayBranch() {
+        return this.isolationMode === "worktree" ? this._selectedBranch ?? this._headBranch : this._headBranch;
+    }
+    get persistedBranch() {
+        if (!this._state.folderUri || this.isolationMode !== "worktree" || !this._supportsWorktreeConfiguration) {
+            return undefined;
+        }
+        return this._selectedBranch ?? this._headBranch;
+    }
+    get supportsWorktreeConfiguration() {
+        return this._supportsWorktreeConfiguration;
+    }
+    get branchPickerAvailable() {
+        return !!this._state.folderUri && this.isolationMode === "worktree" && this._supportsWorktreeConfiguration;
+    }
+    setSupportsWorktreeConfiguration(supported) {
+        this._supportsWorktreeConfiguration = supported;
+    }
+    selectIsolationMode(mode) {
+        if (this._state.isQuickChat || (mode === "worktree" && (!this._state.folderUri || !this._supportsWorktreeConfiguration))) {
+            return false;
+        }
+        this._state.isolationMode = mode;
+        return true;
+    }
+    setQuickChat(isQuickChat, workspaceFolderUri) {
+        if (this._state.isQuickChat === isQuickChat) {
+            if (!isQuickChat) {
+                this.setWorkspace(workspaceFolderUri);
+            }
+            return;
+        }
+        this._state.isQuickChat = isQuickChat;
+        if (isQuickChat) {
+            this._state.folderUri = undefined;
+            this._state.isolationMode = undefined;
+            this._headBranch = undefined;
+            this._selectedBranch = undefined;
+            this._state.branch = undefined;
+        } else {
+            this._state.isolationMode = "workspace";
+            this._state.folderUri = workspaceFolderUri;
+        }
+        transaction(tx => {
+            this._isQuickChat.set(isQuickChat, tx);
+            this._folderUri.set(this._state.folderUri, tx);
+        });
+    }
+    setWorkspace(folderUri) {
+        if (this._state.isQuickChat) {
+            return false;
+        }
+        if (isEqual(this._state.folderUri, folderUri)) {
+            return true;
+        }
+        this._state.folderUri = folderUri;
+        this._headBranch = undefined;
+        this._selectedBranch = undefined;
+        this._state.branch = undefined;
+        if (!folderUri) {
+            this._state.isolationMode = "workspace";
+        }
+        this._folderUri.set(folderUri, undefined);
+        return true;
+    }
+    setHeadBranch(branch) {
+        this._headBranch = isSelectableAutomationBranch(branch) ? branch : undefined;
+    }
+    selectBranch(branch) {
+        if (!isSelectableAutomationBranch(branch)) {
+            return;
+        }
+        this._selectedBranch = branch;
+        this._state.branch = branch;
+    }
+}
+
+export { AutomationIsolationModel, normalizeAutomationBranchNames };

package/vscode/src/vs/sessions/contrib/blockedSessions/browser/blockedSessions.d.ts

@@ -0,0 +1,45 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { IGitHubService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/githubService.service";
+/**
+ * Why a session is surfaced as "blocked" (i.e. needs the user's attention).
+ */
+export declare enum BlockedSessionReason {
+    /** The session is waiting for the user to provide input or approve an action. */
+    NeedsInput = "needsInput",
+    /** The session's pull request has failing CI checks. */
+    FailingCI = "failingCI"
+}
+/** A blocked session paired with the reason it needs attention. */
+export interface IBlockedSession {
+    readonly session: ISession;
+    readonly reason: BlockedSessionReason;
+    /** Identifies this occurrence so a later block can be surfaced again. */
+    readonly occurrenceId: string;
+}
+/**
+ * Surfaces the set of "blocked" sessions — sessions that require the user's
+ * attention. A session is considered blocked when it:
+ *
+ * - needs input (`SessionStatus.NeedsInput`), or
+ * - has failing CI checks while not in progress.
+ *
+ * Archived (done) sessions are never reported as blocked.
+ */
+export declare class BlockedSessions extends Disposable {
+    private readonly _sessionsManagementService;
+    private readonly _gitHubService;
+    private readonly _logService;
+    private readonly _allSessions;
+    /** The blocked sessions, most-recently-updated first. */
+    readonly blockedSessions: IObservable<readonly ISession[]>;
+    /** The blocked sessions paired with their reason, most-recently-updated first. */
+    readonly blockedSessionsWithReasons: IObservable<readonly IBlockedSession[]>;
+    constructor(_sessionsManagementService: ISessionsManagementService, _gitHubService: IGitHubService, _logService: ILogService);
+    private _getBlockedSession;
+}
+/** Compact, log-friendly rendering of blocked sessions: `sessionId=occurrenceId`. */
+export declare function describeBlockedSessions(blocked: readonly IBlockedSession[]): string;

package/vscode/src/vs/sessions/contrib/blockedSessions/browser/blockedSessions.js

@@ -0,0 +1,110 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { LogLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { IGitHubService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/githubService.service';
+import { GitHubPullRequestState, GitHubCIOverallStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/common/types';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { derivedOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+const LOG_PREFIX = "[BlockedSessions]";
+var BlockedSessionReason;
+(function(BlockedSessionReason) {
+    BlockedSessionReason["NeedsInput"] = "needsInput";
+    BlockedSessionReason["FailingCI"] = "failingCI";
+})(BlockedSessionReason || (BlockedSessionReason = {}));
+let BlockedSessions = class BlockedSessions extends Disposable {
+    constructor(_sessionsManagementService, _gitHubService, _logService) {
+        super();
+        this._sessionsManagementService = _sessionsManagementService;
+        this._gitHubService = _gitHubService;
+        this._logService = _logService;
+        this._allSessions = observableFromEvent(
+            this,
+            this._sessionsManagementService.onDidChangeSessions,
+            () => this._sessionsManagementService.getSessions()
+        );
+        this.blockedSessionsWithReasons = derivedOpts({
+            owner: this,
+            equalsFn: (a, b) => equals(
+                a,
+                b,
+                (x, y) => x.session.sessionId === y.session.sessionId && x.reason === y.reason && x.occurrenceId === y.occurrenceId
+            )
+        }, reader => {
+            const sessions = this._allSessions.read(reader);
+            const blocked = [];
+            for (const session of sessions) {
+                const blockedSession = this._getBlockedSession(reader, session);
+                if (blockedSession !== undefined) {
+                    blocked.push(blockedSession);
+                }
+            }
+            blocked.sort(
+                (a, b) => b.session.updatedAt.read(reader).getTime() - a.session.updatedAt.read(reader).getTime()
+            );
+            if (this._logService.getLevel() === LogLevel.Trace) {
+                this._logService.trace(
+                    `${LOG_PREFIX} computed blocked sessions (${blocked.length} of ${sessions.length}): ${describeBlockedSessions(blocked)}`
+                );
+            }
+            return blocked;
+        });
+        this.blockedSessions = derivedOpts({
+            owner: this,
+            equalsFn: (a, b) => equals(a, b, (x, y) => x.sessionId === y.sessionId)
+        }, reader => this.blockedSessionsWithReasons.read(reader).map(blocked => blocked.session));
+    }
+    _getBlockedSession(reader, session) {
+        if (session.isArchived.read(reader)) {
+            return undefined;
+        }
+        const status = session.status.read(reader);
+        if (status === SessionStatus.NeedsInput) {
+            return {
+                session,
+                reason: BlockedSessionReason.NeedsInput,
+                occurrenceId: BlockedSessionReason.NeedsInput
+            };
+        }
+        if (status === SessionStatus.InProgress) {
+            return undefined;
+        }
+        const gitHubInfo = session.workspace.read(reader)?.folders[0]?.gitRepository?.gitHubInfo.read(reader);
+        if (!gitHubInfo?.pullRequest) {
+            return undefined;
+        }
+        const prRef = reader.delayedStore.add(
+            this._gitHubService.createPullRequestModelReference(gitHubInfo.owner, gitHubInfo.repo, gitHubInfo.pullRequest.number)
+        );
+        const livePR = prRef.object.pullRequest.read(reader);
+        if (!livePR) {
+            return undefined;
+        }
+        if (livePR.isDraft || livePR.state !== GitHubPullRequestState.Open) {
+            return undefined;
+        }
+        const ciRef = reader.delayedStore.add(
+            this._gitHubService.createPullRequestCIModelReference(gitHubInfo.owner, gitHubInfo.repo, livePR.number, livePR.headSha)
+        );
+        if (ciRef.object.overallStatus.read(reader) === GitHubCIOverallStatus.Failure) {
+            return {
+                session,
+                reason: BlockedSessionReason.FailingCI,
+                occurrenceId: `${BlockedSessionReason.FailingCI}:${livePR.headSha}`
+            };
+        }
+        return undefined;
+    }
+};
+BlockedSessions = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, IGitHubService)), ( __param(2, ILogService))], BlockedSessions));
+function describeBlockedSessions(blocked) {
+    return `[${blocked.map(entry => `${entry.session.sessionId}=${entry.occurrenceId}`).join(", ")}]`;
+}
+
+export { BlockedSessionReason, BlockedSessions, describeBlockedSessions };

package/vscode/src/vs/sessions/contrib/browserView/browser/sessionBrowserView.contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/browserView/browser/sessionBrowserView.contribution.js

@@ -0,0 +1,5 @@
+
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { SessionBrowserViewController } from './sessionBrowserView.js';
+
+registerWorkbenchContribution2(SessionBrowserViewController.ID, SessionBrowserViewController, WorkbenchPhase.AfterRestored);

package/vscode/src/vs/sessions/contrib/browserView/browser/sessionBrowserView.d.ts

@@ -0,0 +1,31 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IBrowserViewWorkbenchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/browserView/common/browserView.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+export declare class SessionBrowserViewController extends Disposable implements IWorkbenchContribution {
+    private readonly _sessionManagementService;
+    private readonly _sessionsService;
+    private readonly _browserViewService;
+    private readonly _editorService;
+    private readonly _editorGroupsService;
+    static readonly ID = "workbench.contrib.sessionBrowserViewController";
+    /**
+     * Tracks browser view inputs with their owning session. The
+     * DisposableMap cleans up lifecycle listeners on deletion/disposal.
+     */
+    private readonly _trackedInputs;
+    constructor(_sessionManagementService: ISessionsManagementService, _sessionsService: ISessionsService, _browserViewService: IBrowserViewWorkbenchService, _editorService: IEditorService, _editorGroupsService: IEditorGroupsService);
+    /**
+     * Resolves a browser view owner id (the *chat* resource string the
+     * browser tools stamp onto `IBrowserViewOwner.sessionId`) to the
+     * `ISession` that owns it. A session's browsers can be opened from any
+     * of its chats (main, peer, or subagent), so this looks up the owning
+     * session across all chats rather than comparing against the session's
+     * own resource directly.
+     */
+    private _resolveOwningSession;
+    private _attachLifecycle;
+}

package/vscode/src/vs/sessions/contrib/browserView/browser/sessionBrowserView.js

@@ -0,0 +1,137 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IBrowserViewWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/browserView/common/browserView.service';
+import { BrowserEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/browserView/common/browserEditorInput';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
+
+let SessionBrowserViewController = class SessionBrowserViewController extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessionBrowserViewController";
+    }
+    constructor(
+        _sessionManagementService,
+        _sessionsService,
+        _browserViewService,
+        _editorService,
+        _editorGroupsService
+    ) {
+        super();
+        this._sessionManagementService = _sessionManagementService;
+        this._sessionsService = _sessionsService;
+        this._browserViewService = _browserViewService;
+        this._editorService = _editorService;
+        this._editorGroupsService = _editorGroupsService;
+        this._trackedInputs = this._register(( new DisposableMap()));
+        this._register(this._editorService.onWillOpenEditor(e => {
+            if (e.editor instanceof BrowserEditorInput) {
+                this._attachLifecycle(e.editor);
+            }
+        }));
+        this._register(this._editorGroupsService.onDidAddGroup(group => {
+            for (const editor of group.editors) {
+                if (editor instanceof BrowserEditorInput) {
+                    this._attachLifecycle(editor);
+                }
+            }
+        }));
+        const onDidChangeActiveSession = this._register(( new Emitter()));
+        this._register(
+            runOnChange(this._sessionsService.activeSession, () => onDidChangeActiveSession.fire())
+        );
+        this._register(this._browserViewService.registerContextualFilter({
+            include: (input, context) => {
+                const tracked = this._trackedInputs.get(input.id);
+                const ownerId = input.model?.owner.type === "agent" ? input.model.owner.sessionId : tracked?.session.resource.toString();
+                if (!ownerId) {
+                    return true;
+                }
+                const owningSession = this._resolveOwningSession(ownerId) ?? tracked?.session;
+                if (!owningSession) {
+                    return true;
+                }
+                const activeSession = context.activeSessionId ? this._resolveOwningSession(context.activeSessionId) : this._sessionsService.activeSession.read(undefined);
+                return activeSession?.sessionId === owningSession.sessionId;
+            },
+            onDidChange: onDidChangeActiveSession.event
+        }));
+        this._register(this._browserViewService.registerOpenHandler({
+            shouldOpenEditor: (_input, owner) => {
+                if (owner.type !== "agent") {
+                    return true;
+                }
+                const owningSession = this._resolveOwningSession(owner.sessionId);
+                if (!owningSession) {
+                    return true;
+                }
+                const activeSession = this._sessionsService.activeSession.read(undefined);
+                return owningSession.sessionId === activeSession?.sessionId;
+            }
+        }));
+        this._register(this._sessionManagementService.onDidChangeSessions(e => {
+            if (e.removed.length === 0 || this._trackedInputs.size === 0) {
+                return;
+            }
+            const removedSessionIds = ( new Set(e.removed.map(s => ( s.resource.toString()))));
+            const known = this._browserViewService.getKnownBrowserViews();
+            for (const [id, {
+                session
+            }] of this._trackedInputs) {
+                if (( removedSessionIds.has(( session.resource.toString())))) {
+                    const existingInput = known.get(id);
+                    if (existingInput instanceof BrowserEditorInput) {
+                        existingInput.dispose(true);
+                    }
+                }
+            }
+        }));
+    }
+    _resolveOwningSession(ownerId) {
+        let resource;
+        try {
+            resource = ( URI.parse(ownerId));
+        } catch {
+            return undefined;
+        }
+        return this._sessionManagementService.getSessionForChatResource(resource)?.session ?? this._sessionManagementService.getSession(resource);
+    }
+    _attachLifecycle(input) {
+        if (( this._trackedInputs.has(input.id))) {
+            return;
+        }
+        const session = this._sessionsService.activeSession.read(undefined);
+        if (!session) {
+            return;
+        }
+        const store = ( new DisposableStore());
+        this._trackedInputs.set(input.id, {
+            session,
+            dispose: () => store.dispose()
+        });
+        store.add(runOnChange(session.isArchived, isArchived => {
+            if (isArchived) {
+                input.dispose(true);
+            }
+        }));
+        store.add(input.onBeforeDispose(e => {
+            const activeSession = this._sessionsService.activeSession.read(undefined);
+            if (session.sessionId !== activeSession?.sessionId) {
+                e.veto();
+            }
+        }));
+        store.add(input.onWillDispose(() => {
+            store.dispose();
+            this._trackedInputs.deleteAndDispose(input.id);
+        }));
+    }
+};
+SessionBrowserViewController = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, ISessionsService)), ( __param(2, IBrowserViewWorkbenchService)), ( __param(3, IEditorService)), ( __param(4, IEditorGroupsService))], SessionBrowserViewController));
+
+export { SessionBrowserViewController };

package/vscode/src/vs/sessions/contrib/changes/browser/changes.contribution.d.ts

@@ -0,0 +1 @@
+export declare const changesViewWhen: import("@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey").ContextKeyExpression | undefined;

package/vscode/src/vs/sessions/contrib/changes/browser/changes.contribution.js

@@ -0,0 +1,130 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+import { Extensions, WindowEnablement, ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
+import { EditorPaneDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/editor';
+import { EditorExtensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { CHANGES_VIEW_CONTAINER_ID, CHANGES_VIEW_ID, SESSIONS_CHANGES_OPEN_SINGLE_FILE_DIFF_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changes';
+import { ChangesViewPaneContainer, SinglePaneChangesViewPane, ChangesViewPane } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/changesView';
+import { SessionChangesEditor } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesEditor';
+import { SessionChangesEditorInput, SessionChangesEditorSerializer } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesEditorInput';
+import { IsPhoneLayoutContext, SessionHasWorkspaceContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService';
+import './changesActions.js';
+import './changesViewActions.js';
+import './changesetReviewActions.js';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/checksActions';
+import './sessionSyncChanges.js';
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Extensions as Extensions$1 } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/changesViewService';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { AccessibleViewRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleViewRegistry';
+import { SessionsChangesAccessibilityHelp } from './sessionsChangesAccessibilityHelp.js';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+
+let SinglePaneChangesEditorContribution = class SinglePaneChangesEditorContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessions.singlePaneChangesEditor";
+    }
+    constructor(layoutService) {
+        super();
+        if (!layoutService.isSinglePaneLayoutEnabled) {
+            return;
+        }
+        this._register(( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(
+            EditorPaneDescriptor.create(SessionChangesEditor, SessionChangesEditor.ID, ( localize(3386, "Changes"))),
+            [( new SyncDescriptor(SessionChangesEditorInput))]
+        ));
+        this._register(( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(SessionChangesEditorInput.ID, SessionChangesEditorSerializer));
+    }
+};
+SinglePaneChangesEditorContribution = ( __decorate([( __param(0, IAgentWorkbenchLayoutService))], SinglePaneChangesEditorContribution));
+registerWorkbenchContribution2(
+    SinglePaneChangesEditorContribution.ID,
+    SinglePaneChangesEditorContribution,
+    WorkbenchPhase.BlockStartup
+);
+AccessibleViewRegistry.register(( new SessionsChangesAccessibilityHelp()));
+const changesViewIcon = registerIcon("changes-view-icon", Codicon.gitCompare, ( localize2(3387, "View icon for the Changes view.")).value);
+const viewContainersRegistry = ( Registry.as(Extensions.ViewContainersRegistry));
+const changesViewContainer = viewContainersRegistry.registerViewContainer({
+    id: CHANGES_VIEW_CONTAINER_ID,
+    title: ( localize2(3388, "Changes")),
+    icon: changesViewIcon,
+    order: 10,
+    ctorDescriptor: ( new SyncDescriptor(ChangesViewPaneContainer)),
+    storageId: CHANGES_VIEW_CONTAINER_ID,
+    hideIfEmpty: true,
+    openCommandActionDescriptor: {
+        id: CHANGES_VIEW_CONTAINER_ID,
+        mnemonicTitle: ( localize(3389, "Chan&&ges")),
+        keybindings: {
+            primary: 0,
+            win: {
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyG
+            },
+            linux: {
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyG
+            },
+            mac: {
+                primary: KeyMod.WinCtrl | KeyMod.Shift | KeyCode.KeyG
+            }
+        },
+        order: 1
+    },
+    windowEnablement: WindowEnablement.Sessions
+}, ViewContainerLocation.AuxiliaryBar);
+const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+const changesViewWhen = ( ContextKeyExpr.and(( IsPhoneLayoutContext.negate()), SessionHasWorkspaceContext));
+let ChangesViewContribution = class ChangesViewContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessions.changesView";
+    }
+    constructor(layoutService) {
+        super();
+        const ctor = layoutService.isSinglePaneLayoutEnabled ? SinglePaneChangesViewPane : ChangesViewPane;
+        viewsRegistry.registerViews([{
+            id: CHANGES_VIEW_ID,
+            name: ( localize2(3388, "Changes")),
+            containerIcon: changesViewIcon,
+            ctorDescriptor: ( new SyncDescriptor(ctor)),
+            canToggleVisibility: false,
+            canMoveView: false,
+            weight: 100,
+            order: 1,
+            when: changesViewWhen,
+            windowEnablement: WindowEnablement.Sessions
+        }], changesViewContainer);
+    }
+};
+ChangesViewContribution = ( __decorate([( __param(0, IAgentWorkbenchLayoutService))], ChangesViewContribution));
+registerWorkbenchContribution2(
+    ChangesViewContribution.ID,
+    ChangesViewContribution,
+    WorkbenchPhase.BlockStartup
+);
+( Registry.as(Extensions$1.Configuration)).registerConfiguration({
+    id: "sessions",
+    properties: {
+        [SESSIONS_CHANGES_OPEN_SINGLE_FILE_DIFF_SETTING]: {
+            type: "boolean",
+            tags: ["preview"],
+            description: ( localize(
+                3390,
+                "Controls whether clicking a file in the Changes view opens a single file diff editor instead of the multi file diff editor."
+            )),
+            default: false
+        }
+    }
+});
+
+export { changesViewWhen };

package/vscode/src/vs/sessions/contrib/changes/browser/changesActions.d.ts

@@ -0,0 +1,8 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IActionViewItemService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+export declare class NewSessionUncommittedChangesetOperationsActionContribution extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "workbench.contrib.sessions.newSessionUncommittedChangesetOperationsAction";
+    constructor(sessionsService: ISessionsService, actionViewItemService: IActionViewItemService);
+}