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

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

@@ -0,0 +1,98 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { SessionsBlockedReason, SessionsPolicyBlockedOverlay } from './sessionsPolicyBlocked.js';
+import { AccountPolicyGateState, AccountPolicyGateUnsatisfiedReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/policies/common/accountPolicyService';
+import { IAccountPolicyGateService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/policies/common/accountPolicyService.service';
+import { ManagedSettingsFreshnessState } from '@codingame/monaco-vscode-api/vscode/vs/platform/policy/common/managedSettingsFreshness';
+
+let SessionsPolicyBlockedContribution = class SessionsPolicyBlockedContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessionsPolicyBlocked";
+    }
+    constructor(
+        configurationService,
+        layoutService,
+        instantiationService,
+        gateService,
+        defaultAccountService
+    ) {
+        super();
+        this.configurationService = configurationService;
+        this.layoutService = layoutService;
+        this.instantiationService = instantiationService;
+        this.gateService = gateService;
+        this.defaultAccountService = defaultAccountService;
+        this.overlayRef = this._register(( new MutableDisposable()));
+        this.update();
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.AgentEnabled)) {
+                this.update();
+            }
+        }));
+        this._register(this.gateService.onDidChangeGateInfo(() => this.update()));
+    }
+    update() {
+        const gateInfo = this.gateService.gateInfo;
+        const gateForcesAgentDisabled = gateInfo.state === AccountPolicyGateState.Restricted && gateInfo.reason !== AccountPolicyGateUnsatisfiedReason.PolicyNotResolved;
+        const agentEnabled = this.configurationService.getValue(ChatConfiguration.AgentEnabled);
+        if (agentEnabled === false && !gateForcesAgentDisabled) {
+            this.showOverlay({
+                reason: SessionsBlockedReason.AgentDisabled
+            });
+            return;
+        }
+        if (gateInfo.state === AccountPolicyGateState.Restricted) {
+            if (gateInfo.reason === AccountPolicyGateUnsatisfiedReason.NoAccount || gateInfo.reason === AccountPolicyGateUnsatisfiedReason.WrongProvider) {
+                this.overlayRef.clear();
+                this.currentReason = undefined;
+                return;
+            }
+            if (gateInfo.reason === AccountPolicyGateUnsatisfiedReason.PolicyNotResolved) {
+                this.showOverlay({
+                    reason: SessionsBlockedReason.Loading
+                });
+            } else if (gateInfo.reason === AccountPolicyGateUnsatisfiedReason.ManagedSettingsRefresh) {
+                const freshness = gateInfo.managedSettingsFreshness;
+                this.showOverlay(freshness?.state === ManagedSettingsFreshnessState.Blocked ? {
+                    reason: SessionsBlockedReason.ManagedSettingsRefresh,
+                    freshness
+                } : {
+                    reason: SessionsBlockedReason.Loading
+                });
+            } else {
+                const accountName = this.defaultAccountService.currentDefaultAccount?.accountName;
+                this.showOverlay({
+                    reason: SessionsBlockedReason.AccountPolicyGate,
+                    approvedOrganizations: gateInfo.approvedOrganizations,
+                    accountName
+                });
+            }
+            return;
+        }
+        this.overlayRef.clear();
+        this.currentReason = undefined;
+    }
+    showOverlay(options) {
+        if (this.currentReason === options.reason && options.reason !== SessionsBlockedReason.AccountPolicyGate && options.reason !== SessionsBlockedReason.ManagedSettingsRefresh) {
+            return;
+        }
+        this.overlayRef.clear();
+        this.currentReason = options.reason;
+        this.overlayRef.value = this.instantiationService.createInstance(SessionsPolicyBlockedOverlay, this.layoutService.mainContainer, options);
+    }
+};
+SessionsPolicyBlockedContribution = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IWorkbenchLayoutService)), ( __param(2, IInstantiationService)), ( __param(3, IAccountPolicyGateService)), ( __param(4, IDefaultAccountService))], SessionsPolicyBlockedContribution));
+registerWorkbenchContribution2(
+    SessionsPolicyBlockedContribution.ID,
+    SessionsPolicyBlockedContribution,
+    WorkbenchPhase.BlockRestore
+);
+
+export { SessionsPolicyBlockedContribution };

package/vscode/src/vs/sessions/contrib/policyBlocked/browser/sessionsPolicyBlocked.d.ts

@@ -0,0 +1,39 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service";
+import { IDefaultAccountService } from "@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service";
+import { IManagedSettingsFreshness, ManagedSettingsFreshnessState } from "@codingame/monaco-vscode-api/vscode/vs/platform/policy/common/managedSettingsFreshness";
+export declare enum SessionsBlockedReason {
+    AgentDisabled = "agentDisabled",
+    /** Transient loading state — blocks UI but shows only a progress bar. */
+    Loading = "loading",
+    /** Signed in but not in an approved org — must switch accounts. */
+    AccountPolicyGate = "accountPolicyGate",
+    ManagedSettingsRefresh = "managedSettingsRefresh"
+}
+export interface ISessionsBlockedOverlayOptions {
+    readonly reason: SessionsBlockedReason;
+    readonly approvedOrganizations?: readonly string[];
+    readonly accountName?: string;
+    readonly freshness?: Extract<IManagedSettingsFreshness, {
+        state: ManagedSettingsFreshnessState.Blocked;
+    }>;
+}
+/**
+ * Full-window impassable overlay shown when the Agents app is blocked.
+ */
+export declare class SessionsPolicyBlockedOverlay extends Disposable {
+    private readonly commandService;
+    private readonly openerService;
+    private readonly productService;
+    private readonly defaultAccountService;
+    private readonly overlay;
+    constructor(container: HTMLElement, options: ISessionsBlockedOverlayOptions, commandService: ICommandService, openerService: IOpenerService, productService: IProductService, defaultAccountService: IDefaultAccountService, layoutService: IWorkbenchLayoutService);
+    private _renderAgentDisabled;
+    private _renderLoading;
+    private _renderAccountPolicyGate;
+    private _renderManagedSettingsRefresh;
+    private _openVSCode;
+}

package/vscode/src/vs/sessions/contrib/policyBlocked/browser/sessionsPolicyBlocked.js

@@ -0,0 +1,218 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as sessionsPolicyBlocked from './media/sessionsPolicyBlocked.css';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { append, $, addDisposableListener, getWindow, EventType, addDisposableGenericMouseDownListener, createTextNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
+import { ManagedSettingsFreshnessFailure } from '@codingame/monaco-vscode-api/vscode/vs/platform/policy/common/managedSettingsFreshness';
+
+registerCss(sessionsPolicyBlocked, 1);
+var SessionsBlockedReason;
+(function(SessionsBlockedReason) {
+    SessionsBlockedReason["AgentDisabled"] = "agentDisabled";
+    SessionsBlockedReason["Loading"] = "loading";
+    SessionsBlockedReason["AccountPolicyGate"] = "accountPolicyGate";
+    SessionsBlockedReason["ManagedSettingsRefresh"] = "managedSettingsRefresh";
+})(SessionsBlockedReason || (SessionsBlockedReason = {}));
+let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Disposable {
+    constructor(
+        container,
+        options,
+        commandService,
+        openerService,
+        productService,
+        defaultAccountService,
+        layoutService
+    ) {
+        super();
+        this.commandService = commandService;
+        this.openerService = openerService;
+        this.productService = productService;
+        this.defaultAccountService = defaultAccountService;
+        this.overlay = append(container, $(".sessions-policy-blocked-overlay"));
+        this.overlay.setAttribute("role", "dialog");
+        this.overlay.setAttribute("aria-modal", "true");
+        this.overlay.tabIndex = -1;
+        this.overlay.focus();
+        this._register(toDisposable(() => this.overlay.remove()));
+        const workbenchRoot = layoutService.mainContainer;
+        workbenchRoot.classList.add("sessions-policy-blocked");
+        this._register(
+            toDisposable(() => workbenchRoot.classList.remove("sessions-policy-blocked"))
+        );
+        const card = append(this.overlay, $(".sessions-policy-blocked-card"));
+        this._register(addDisposableListener(getWindow(this.overlay), EventType.KEY_DOWN, e => {
+            if (card.contains(e.target)) {
+                return;
+            }
+            e.preventDefault();
+            e.stopPropagation();
+        }, true));
+        this._register(addDisposableGenericMouseDownListener(this.overlay, e => {
+            if (e.target === this.overlay) {
+                e.preventDefault();
+                e.stopPropagation();
+            }
+        }));
+        append(card, $("div.sessions-policy-blocked-logo"));
+        switch (options.reason) {
+        case SessionsBlockedReason.AgentDisabled:
+            this._renderAgentDisabled(card);
+            break;
+        case SessionsBlockedReason.Loading:
+            this._renderLoading(card);
+            break;
+        case SessionsBlockedReason.AccountPolicyGate:
+            this._renderAccountPolicyGate(card, options);
+            break;
+        case SessionsBlockedReason.ManagedSettingsRefresh:
+            this._renderManagedSettingsRefresh(card, options.freshness);
+            break;
+        }
+    }
+    _renderAgentDisabled(card) {
+        this.overlay.setAttribute("aria-label", ( localize(4138, "Agents disabled by organization policy")));
+        append(card, $("h2", undefined, ( localize(4139, "Agents Disabled"))));
+        const description = append(card, $("p"));
+        append(description, createTextNode(( localize(4140, "Your organization has disabled Agents via policy."))));
+        append(description, createTextNode(" "));
+        const learnMore = append(description, $("a.sessions-policy-blocked-link"));
+        learnMore.textContent = ( localize(4141, "Learn more"));
+        learnMore.href = "https://aka.ms/VSCode/Agents/docs";
+        this._register(addDisposableListener(learnMore, EventType.CLICK, e => {
+            e.preventDefault();
+            this.openerService.open(( URI.parse("https://aka.ms/VSCode/Agents/docs")));
+        }));
+        const button = this._register(( new Button(card, {
+            ...defaultButtonStyles,
+            secondary: true
+        })));
+        button.label = ( localize(4142, "Open VS Code"));
+        this._register(button.onDidClick(() => this._openVSCode()));
+    }
+    _renderLoading(card) {
+        this.overlay.setAttribute("aria-label", ( localize(4143, "Loading")));
+        append(card, $(
+            "div.sessions-policy-blocked-progress-bar",
+            undefined,
+            $("div.sessions-policy-blocked-progress-bar-fill")
+        ));
+    }
+    _renderAccountPolicyGate(card, options) {
+        this.overlay.setAttribute("aria-label", ( localize(4144, "Sign-in required by your administrator")));
+        append(card, $("h2", undefined, ( localize(4145, "Sign-In Required"))));
+        const description = append(card, $("p"));
+        if (options.accountName) {
+            append(description, createTextNode(( localize(
+                4146,
+                "The account \"{0}\" is not a member of an organization that your administrator allows for Agents.",
+                options.accountName
+            ))));
+        } else {
+            append(description, createTextNode(( localize(
+                4147,
+                "Your administrator restricts Agents to members of the organizations below."
+            ))));
+        }
+        const approvedOrgs = options.approvedOrganizations ?? [];
+        const hasConcreteOrgs = approvedOrgs.length > 0 && !approvedOrgs.includes("*");
+        if (hasConcreteOrgs) {
+            const orgSection = append(card, $("div.sessions-policy-blocked-orgs"));
+            append(
+                orgSection,
+                $("p.sessions-policy-blocked-orgs-label", undefined, ( localize(4148, "Allowed organizations:")))
+            );
+            const orgList = append(orgSection, $("ul"));
+            for (const org of approvedOrgs) {
+                append(orgList, $("li", undefined, org));
+            }
+        }
+        const footer = append(card, $("p.sessions-policy-blocked-footer"));
+        append(footer, createTextNode(( localize(4149, "Contact your administrator for more information."))));
+        append(footer, createTextNode(" "));
+        const learnMore = append(footer, $("a.sessions-policy-blocked-link"));
+        learnMore.textContent = ( localize(4150, "Learn more"));
+        learnMore.href = "https://code.visualstudio.com/docs/enterprise/overview";
+        this._register(addDisposableListener(learnMore, EventType.CLICK, e => {
+            e.preventDefault();
+            this.openerService.open(( URI.parse("https://code.visualstudio.com/docs/enterprise/overview")));
+        }));
+        const signInButton = this._register(( new Button(card, {
+            ...defaultButtonStyles
+        })));
+        signInButton.label = ( localize(4151, "Sign In"));
+        this._register(signInButton.onDidClick(() => {
+            this.commandService.executeCommand("workbench.action.agenticSignIn");
+        }));
+    }
+    _renderManagedSettingsRefresh(card, freshness) {
+        this.overlay.setAttribute("aria-label", ( localize(4152, "Managed settings refresh required")));
+        append(card, $("h2", undefined, ( localize(4153, "Managed Settings Unavailable"))));
+        const message = freshness?.failure === ManagedSettingsFreshnessFailure.NoToken ? ( localize(
+            4154,
+            "Sign in so {0} can refresh your organization's managed settings before starting an agent.",
+            this.productService.nameShort
+        )) : freshness?.failure === ManagedSettingsFreshnessFailure.RateLimited ? ( localize(
+            4155,
+            "Your organization's managed settings service is rate limiting requests. Try again later."
+        )) : freshness?.failure === ManagedSettingsFreshnessFailure.NoUrl ? ( localize(
+            4156,
+            "{0} cannot locate your organization's managed settings service. Contact your administrator.",
+            this.productService.nameShort
+        )) : freshness?.failure === ManagedSettingsFreshnessFailure.UpdateRequired ? ( localize(
+            4157,
+            "Update {0} to a version that supports your organization's managed settings before starting an agent.",
+            this.productService.nameShort
+        )) : ( localize(
+            4158,
+            "Your organization requires {0} to refresh managed settings whenever it starts or reloads. An error prevented the required policy from being retrieved, so agents are unavailable. Retry, or contact your organization's administrator if the issue persists.",
+            this.productService.nameShort
+        ));
+        append(card, $("p", undefined, message));
+        if (freshness?.failure === ManagedSettingsFreshnessFailure.NoToken) {
+            const signInButton = this._register(( new Button(card, {
+                ...defaultButtonStyles
+            })));
+            signInButton.label = ( localize(4159, "Sign In"));
+            this._register(
+                signInButton.onDidClick(() => this.commandService.executeCommand("workbench.action.agenticSignIn"))
+            );
+        } else if (freshness?.failure !== ManagedSettingsFreshnessFailure.NoUrl && freshness?.failure !== ManagedSettingsFreshnessFailure.UpdateRequired) {
+            const retryButton = this._register(( new Button(card, {
+                ...defaultButtonStyles
+            })));
+            retryButton.label = ( localize(4160, "Retry"));
+            this._register(retryButton.onDidClick(() => this.defaultAccountService.refresh({
+                forceRefresh: true,
+                retryManagedSettings: true
+            })));
+        }
+        const openVSCodeButton = this._register(( new Button(card, {
+            ...defaultButtonStyles,
+            secondary: true
+        })));
+        openVSCodeButton.label = ( localize(4161, "Open VS Code"));
+        this._register(openVSCodeButton.onDidClick(() => this._openVSCode()));
+    }
+    _openVSCode() {
+        const scheme = this.productService.parentPolicyConfig?.urlProtocol ?? this.productService.urlProtocol;
+        this.openerService.open(( URI.from({
+            scheme,
+            query: "windowId=_blank"
+        })), {
+            openExternal: true
+        });
+    }
+};
+SessionsPolicyBlockedOverlay = ( __decorate([( __param(2, ICommandService)), ( __param(3, IOpenerService)), ( __param(4, IProductService)), ( __param(5, IDefaultAccountService)), ( __param(6, IWorkbenchLayoutService))], SessionsPolicyBlockedOverlay));
+
+export { SessionsBlockedReason, SessionsPolicyBlockedOverlay };

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/devContainerAgentHostService.d.ts

@@ -0,0 +1,53 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IDevContainerAgentHostConnector, IDevContainerAgentHostTarget } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/devContainerAgentHostService";
+import { IDevContainerAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/devContainerAgentHostService.service";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { RemoteAgentHostSessionsProvider } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider";
+/** Registers Dev Container Agent Hosts as persistent remote Sessions providers. */
+export declare class DevContainerAgentHostService extends Disposable implements IDevContainerAgentHostService {
+    private readonly _instantiationService;
+    private readonly _remoteAgentHostService;
+    private readonly _sessionsProvidersService;
+    private readonly _storageService;
+    readonly _serviceBrand: undefined;
+    private readonly _providerStores;
+    private readonly _providers;
+    private readonly _activeConnections;
+    private readonly _pendingConnections;
+    private readonly _storedConnections;
+    private readonly _connectionFactory;
+    private readonly _onDidRegisterConnector;
+    private readonly _onDidChangeAvailability;
+    readonly onDidChangeAvailability: Event<void>;
+    private _connector;
+    constructor(_instantiationService: IInstantiationService, _remoteAgentHostService: IRemoteAgentHostService, _sessionsProvidersService: ISessionsProvidersService, _storageService: IStorageService);
+    registerConnector(connector: IDevContainerAgentHostConnector): IDisposable;
+    isAvailable(workspaceUri: URI): Promise<boolean>;
+    connect(workspaceUri: URI, token: CancellationToken): Promise<IDevContainerAgentHostTarget>;
+    private _ensureConnection;
+    private _completePendingConnection;
+    private _replaceConnectionAndConnect;
+    private _waitForConnector;
+    private _connect;
+    private _acquireConnection;
+    private _ensureProvider;
+    protected _createProvider(config: ConstructorParameters<typeof RemoteAgentHostSessionsProvider>[0]): RemoteAgentHostSessionsProvider;
+    protected _waitForSessionTypes(provider: RemoteAgentHostSessionsProvider, token: CancellationToken): Promise<void>;
+    disconnect(workspaceUri: URI): Promise<void>;
+    private _disconnectActiveConnection;
+    private _isConnectedOrReconnecting;
+    private _reconcileConnections;
+    private _restoreProviders;
+    private _readStoredConnections;
+    private _storeConnection;
+    private _removeStoredConnection;
+    private _writeStoredConnections;
+    private _removeProvider;
+    dispose(): void;
+}