@codingame/monaco-vscode-chat-service-override 37.3.2 → 37.3.4

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxAgentHostContribution.js

@@ -1,586 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { isCancellationError, CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable, DisposableMap, MutableDisposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
-import { CLOUD_SANDBOX_SESSION_SCHEME, CLOUD_SANDBOX_AGENT_PROVIDER, CloudSandboxEnabledSettingId, cloudSandboxAddress, isCloudSandboxEnabled } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost';
-import { ICloudSandboxAgentHostService, ICloudSandboxApiService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost.service';
-import { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
-import { ChangesetKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/changesetUri';
-import { agentHostAuthority } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
-import { findRemoteAgentHostSessionTypeAuthority, remoteAgentHostSessionTypeId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSessionType';
-import { RemoteAgentHostConnectionStatus, RemoteAgentHostsEnabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
-import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
-import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
-import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
-import { ChatSessionsExtensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
-import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
-import { CloudSandboxReadOnlySessionHandler } from './cloudSandboxReadOnlySessionHandler.js';
-import { IAgentHostFilterService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter.service';
-import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
-import { CloudSandboxSessionsProvider } from './cloudSandboxSessionsProvider.js';
-import { IRemoteAgentHostConnectionCustomizationService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostConnectionCustomization.service';
-import { isCloudSandboxConnectionAddress, createCloudSandboxConnectionCustomization } from './cloudSandboxConnectionCustomization.js';
-import { watchForIncompatibleNotifications } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteHostOptions';
-
-const LOG_PREFIX = "[CloudSandboxAgentHost]";
-const SANDBOX_SESSION_SCHEME_ALIAS = {
-    ui: CLOUD_SANDBOX_AGENT_PROVIDER,
-    backend: CLOUD_SANDBOX_SESSION_SCHEME
-};
-const CLOUD_SANDBOX_HOST_GROUP = {
-    id: "githubsandbox",
-    label: ( localize(4256, "GitHub Sandboxes")),
-    order: 1,
-    connectable: false
-};
-const CLOUD_SANDBOX_CONNECTION_LABELS = {
-    unavailableTitle: ( localize(4257, "Environment Offline")),
-    unavailable: ( localize(4258, "Environment offline.")),
-    connectingTitle: ( localize(4259, "Connecting to the Environment")),
-    connecting: ( localize(4260, "Connecting...")),
-    reconnecting: ( localize(4261, "Reconnecting...")),
-    reconnectingIn: seconds => ( localize(4262, "Reconnecting in {0}s", seconds)),
-    incompatibleTitle: ( localize(4263, "Cannot Connect to the Environment")),
-    incompatible: ( localize(
-        4264,
-        "This environment is incompatible with this version of Visual Studio Code."
-    ))
-};
-function discoveredSessionProject(repoName) {
-    if (!repoName) {
-        return undefined;
-    }
-    return {
-        uri: ( URI.parse(`https://github.com/${repoName}`)),
-        displayName: repoName
-    };
-}
-let CloudSandboxAgentHostContribution = class CloudSandboxAgentHostContribution extends Disposable {
-    static {
-        this.ID = "workbench.contrib.cloudSandboxAgentHost";
-    }
-    constructor(
-        _cloudSandboxService,
-        _apiService,
-        _remoteAgentHostService,
-        _connectionCustomizations,
-        _sessionsProvidersService,
-        _agentHostFilterService,
-        _configurationService,
-        _authenticationService,
-        _instantiationService,
-        _notificationService,
-        _chatSessionsService,
-        _logService
-    ) {
-        super();
-        this._cloudSandboxService = _cloudSandboxService;
-        this._apiService = _apiService;
-        this._remoteAgentHostService = _remoteAgentHostService;
-        this._connectionCustomizations = _connectionCustomizations;
-        this._sessionsProvidersService = _sessionsProvidersService;
-        this._agentHostFilterService = _agentHostFilterService;
-        this._configurationService = _configurationService;
-        this._authenticationService = _authenticationService;
-        this._instantiationService = _instantiationService;
-        this._notificationService = _notificationService;
-        this._chatSessionsService = _chatSessionsService;
-        this._logService = _logService;
-        this._providerInstances = ( new Map());
-        this._providerStores = this._register(( new DisposableMap()));
-        this._environments = ( new Map());
-        this._pendingConnects = ( new Map());
-        this._provisioning = ( new Set());
-        this._readOnlyHandlers = this._register(( new DisposableMap()));
-        this._enabledCts = ( new CancellationTokenSource());
-        this._hasDiscovered = false;
-        this._hostGroupRegistration = this._register(( new MutableDisposable()));
-        this._register(this._connectionCustomizations.register(
-            isCloudSandboxConnectionAddress,
-            address => createCloudSandboxConnectionCustomization(address, this._cloudSandboxService)
-        ));
-        this._register(this._remoteAgentHostService.onDidChangeConnections(() => {
-            for (const connection of this._remoteAgentHostService.connections) {
-                if (RemoteAgentHostConnectionStatus.isConnected(connection.status)) {
-                    this._clearReadOnly(connection.address);
-                }
-            }
-            this._wireConnections();
-            this._updateConnectionStatuses();
-        }));
-        this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(CloudSandboxEnabledSettingId) || e.affectsConfiguration(RemoteAgentHostsEnabledSettingId)) {
-                this._updateHostGroupRegistration();
-                if (this._isEnabled()) {
-                    void this._discoverAndSeed();
-                } else {
-                    this._teardownAll();
-                }
-            }
-        }));
-        this._updateHostGroupRegistration();
-        this._register(
-            this._agentHostFilterService.registerDiscoveryHandler(() => this._discoverAndSeed())
-        );
-        void this._discoverAndSeed();
-        const retryUntilFirstSuccess = this._register(( new DisposableStore()));
-        const retry = () => {
-            if (this._hasDiscovered) {
-                retryUntilFirstSuccess.clear();
-                return;
-            }
-            void this._discoverAndSeed();
-        };
-        retryUntilFirstSuccess.add(this._authenticationService.onDidChangeSessions(retry));
-        retryUntilFirstSuccess.add(this._authenticationService.onDidRegisterAuthenticationProvider(retry));
-        this._register(toDisposable(() => {
-            this._enabledCts.cancel();
-            this._enabledCts.dispose();
-        }));
-        this._register(( Registry.as(ChatSessionsExtensions.AsyncActivation)).register({
-            matchSessionType: sessionType => this._findAddressForSessionType(sessionType) !== undefined,
-            waitForActivation: (_accessor, sessionType) => this._waitForActivation(sessionType)
-        }));
-    }
-    _discoverAndSeed() {
-        if (this._discoveryInFlight) {
-            this._discoveryQueued ??= this._discoveryInFlight.then(() => {
-                this._discoveryQueued = undefined;
-                return this._discoverAndSeed();
-            });
-            return this._discoveryQueued;
-        }
-        this._discoveryInFlight = this._doDiscoverAndSeed().finally(() => {
-            this._discoveryInFlight = undefined;
-        });
-        return this._discoveryInFlight;
-    }
-    async _doDiscoverAndSeed() {
-        if (!this._isEnabled()) {
-            return;
-        }
-        const token = this._enabledCts.token;
-        let result;
-        try {
-            result = await this._apiService.listSessions(token);
-        } catch (error) {
-            if (token.isCancellationRequested || isCancellationError(error) || !this._isEnabled()) {
-                return;
-            }
-            result = {
-                kind: "failed",
-                reason: error instanceof Error ? error.message : String(error)
-            };
-        }
-        if (result.kind === "failed") {
-            this._logService.warn(`${LOG_PREFIX} Discovery failed: ${result.reason}`);
-            return;
-        }
-        if (token.isCancellationRequested || !this._isEnabled()) {
-            return;
-        }
-        this._hasDiscovered = true;
-        const present = ( new Set());
-        for (const session of result.sessions) {
-            if (!session.environmentId || !session.sessionId) {
-                continue;
-            }
-            const address = cloudSandboxAddress(session.environmentId);
-            present.add(address);
-            this._ensureProvider({
-                environmentId: session.environmentId,
-                sessionId: session.sessionId,
-                taskId: session.taskId,
-                name: session.name
-            });
-            const provider = this._providerInstances.get(address);
-            const parsed = session.updatedAt ? Date.parse(session.updatedAt) : Number.NaN;
-            const modifiedTime = Number.isNaN(parsed) ? Date.now() : parsed;
-            const project = discoveredSessionProject(session.repoName);
-            const meta = {
-                session: AgentSession.uri(CLOUD_SANDBOX_AGENT_PROVIDER, session.sessionId),
-                startTime: modifiedTime,
-                modifiedTime,
-                summary: session.name,
-                ...(project ? {
-                    project
-                } : {})
-            };
-            provider?.seedSessions([meta]);
-        }
-        if (result.kind === "complete") {
-            for (const address of [...( this._environments.keys())]) {
-                if (( present.has(address)) || ( this._provisioning.has(address))) {
-                    continue;
-                }
-                const connected = ( this._remoteAgentHostService.connections.some(
-                    c => c.address === address && RemoteAgentHostConnectionStatus.isConnected(c.status)
-                ));
-                if (!connected) {
-                    this._teardownEnvironment(address);
-                }
-            }
-        }
-        this._logService.info(
-            `${LOG_PREFIX} Seeded ${present.size} discovered sandbox environment(s)${result.kind === "partial" ? " (partial scan; kept existing entries)" : ""}.`
-        );
-    }
-    async _disconnectEnvironment(address) {
-        try {
-            await this._remoteAgentHostService.removeRemoteAgentHost(address);
-        } catch (error) {
-            this._logService.warn(
-                `${LOG_PREFIX} Failed to disconnect ${address}: ${error instanceof Error ? error.message : String(error)}`
-            );
-        }
-    }
-    async provisionSession(request, token) {
-        if (!this._isEnabled()) {
-            throw ( new Error("Copilot cloud sandbox connections are not enabled."));
-        }
-        const created = await this._apiService.createSession(request, token);
-        const name = request.repoNwo ?? created.taskId;
-        const address = cloudSandboxAddress(created.environmentId);
-        if (!this._isEnabled() || token.isCancellationRequested) {
-            throw ( new CancellationError());
-        }
-        this._provisioning.add(address);
-        let seededProvider;
-        try {
-            this._ensureProvider({
-                environmentId: created.environmentId,
-                sessionId: created.sessionId,
-                taskId: created.taskId,
-                name
-            });
-            const provider = this._providerInstances.get(address);
-            if (!provider) {
-                throw ( new Error(
-                    `No sessions provider was registered for sandbox environment ${created.environmentId}`
-                ));
-            }
-            const now = Date.now();
-            const project = discoveredSessionProject(request.repoNwo);
-            provider.seedProvisionalSession({
-                session: AgentSession.uri(CLOUD_SANDBOX_AGENT_PROVIDER, created.sessionId),
-                startTime: now,
-                modifiedTime: now,
-                summary: name,
-                ...(project ? {
-                    project
-                } : {})
-            });
-            seededProvider = provider;
-            await this.connect({
-                environmentId: created.environmentId,
-                sessionId: created.sessionId,
-                name
-            });
-            if (!this._isEnabled() || this._providerInstances.get(address) !== provider) {
-                throw ( new CancellationError());
-            }
-            const session = provider.getCachedSession(created.sessionId);
-            if (!session) {
-                throw ( new Error(
-                    `Provisioned sandbox session ${created.sessionId} did not surface on its provider`
-                ));
-            }
-            return {
-                ...created,
-                provider,
-                session
-            };
-        } catch (error) {
-            if (seededProvider && this._providerInstances.get(address) === seededProvider) {
-                seededProvider.publishWithheldSession(created.sessionId);
-            }
-            throw error;
-        } finally {
-            this._provisioning.delete(address);
-        }
-    }
-    _teardownEnvironment(address) {
-        this._environments.delete(address);
-        this._pendingConnects.delete(address);
-        this._providerStores.deleteAndDispose(address);
-        this._clearReadOnly(address);
-        void this._disconnectEnvironment(address);
-    }
-    _teardownAll() {
-        this._enabledCts.cancel();
-        this._enabledCts.dispose();
-        this._enabledCts = ( new CancellationTokenSource());
-        for (const address of [...( this._environments.keys())]) {
-            this._teardownEnvironment(address);
-        }
-    }
-    _authoritiesByAddress() {
-        const byAuthority = ( new Map());
-        for (const address of ( this._environments.keys())) {
-            byAuthority.set(agentHostAuthority(address), address);
-        }
-        return byAuthority;
-    }
-    _findAddressForSessionType(sessionType) {
-        const byAuthority = this._authoritiesByAddress();
-        const authority = findRemoteAgentHostSessionTypeAuthority(sessionType, ( byAuthority.keys()));
-        return authority ? byAuthority.get(authority) : undefined;
-    }
-    async _waitForActivation(sessionType) {
-        const address = this._findAddressForSessionType(sessionType);
-        const env = address ? this._environments.get(address) : undefined;
-        const provider = address ? this._providerInstances.get(address) : undefined;
-        if (!address || !env || !provider) {
-            return false;
-        }
-        const token = this._enabledCts.token;
-        const isCurrentActivation = () => {
-            const current = !token.isCancellationRequested && this._isEnabled() && ( this._environments.has(address)) && this._providerInstances.get(address) === provider;
-            if (!current) {
-                this._logService.trace(`${LOG_PREFIX} Abandoning activation for ${address} after teardown.`);
-            }
-            return current;
-        };
-        const shouldConnect = !env.taskId || (await this._isEnvironmentOnline(env, token));
-        if (!isCurrentActivation()) {
-            return false;
-        }
-        if (!shouldConnect) {
-            this._logService.info(
-                `${LOG_PREFIX} Environment for ${address} is not online; serving history and leaving the connect to the user.`
-            );
-            return this._activateReadOnly(sessionType, address, env, this._fetchTaskHistory(env, token));
-        }
-        const connectError = await this.connect({
-            environmentId: env.environmentId,
-            sessionId: env.sessionId,
-            name: env.name
-        }).then(() => undefined, error => error ?? ( new Error("connect failed")));
-        if (!isCurrentActivation()) {
-            return false;
-        }
-        if (connectError !== undefined) {
-            this._logService.warn(
-                `${LOG_PREFIX} connect-on-open failed for ${address}: ${connectError instanceof Error ? connectError.message : String(connectError)}`
-            );
-            return this._activateReadOnly(sessionType, address, env, this._fetchTaskHistory(env, token));
-        }
-        const authority = agentHostAuthority(address);
-        while (true) {
-            const connection = this._remoteAgentHostService.getConnection(address);
-            if (!connection) {
-                return false;
-            }
-            const rootState = connection.rootState.value;
-            if (rootState instanceof Error) {
-                return false;
-            }
-            if (rootState) {
-                return ( rootState.agents.some(
-                    agent => remoteAgentHostSessionTypeId(authority, agent.provider) === sessionType
-                ));
-            }
-            await Event.toPromise(connection.rootState.onDidChange);
-        }
-    }
-    async _isEnvironmentOnline(env, token) {
-        try {
-            const record = await this._apiService.getEnvironment(env.environmentId, token);
-            return record.status === "online";
-        } catch (error) {
-            this._logService.trace(
-                `${LOG_PREFIX} Could not read the state of ${env.environmentId}; treating it as not online: ${error instanceof Error ? error.message : String(error)}`
-            );
-            return false;
-        }
-    }
-    _fetchTaskHistory(env, token) {
-        const taskId = env.taskId;
-        if (!taskId) {
-            return undefined;
-        }
-        return this._apiService.getSessionHistory(taskId, token).catch(error => {
-            this._logService.trace(
-                `${LOG_PREFIX} History read for ${env.environmentId} did not complete: ${error instanceof Error ? error.message : String(error)}`
-            );
-            return undefined;
-        });
-    }
-    _activateReadOnly(sessionType, address, env, prefetchedHistory) {
-        if (( this._readOnlyHandlers.has(sessionType))) {
-            return true;
-        }
-        if (this._chatSessionsService.getContentProviderSchemes().includes(sessionType)) {
-            this._logService.trace(
-                `${LOG_PREFIX} ${sessionType} already has a content provider; leaving it to serve the session.`
-            );
-            return true;
-        }
-        if (!env.taskId) {
-            this._logService.warn(`${LOG_PREFIX} No task id for ${address}; cannot serve history read-only.`);
-            return false;
-        }
-        const store = ( new DisposableStore());
-        const handler = store.add(
-            this._instantiationService.createInstance(CloudSandboxReadOnlySessionHandler, {
-                taskId: env.taskId,
-                agentId: sessionType,
-                connectionAuthority: agentHostAuthority(address),
-                prefetchedHistory
-            })
-        );
-        handler.markReadOnly();
-        store.add(
-            this._chatSessionsService.registerChatSessionContentProvider(sessionType, handler)
-        );
-        this._readOnlyHandlers.set(sessionType, store);
-        this._logService.info(`${LOG_PREFIX} Serving ${sessionType} from Mission Control history.`);
-        return true;
-    }
-    _clearReadOnly(address) {
-        const authority = agentHostAuthority(address);
-        for (const sessionType of [...( this._readOnlyHandlers.keys())]) {
-            if (findRemoteAgentHostSessionTypeAuthority(sessionType, [authority]) === authority) {
-                this._readOnlyHandlers.deleteAndDispose(sessionType);
-                this._logService.info(
-                    `${LOG_PREFIX} Dropped read-only stand-in for ${sessionType}; the environment is reachable again.`
-                );
-            }
-        }
-    }
-    async connect(options) {
-        if (!this._isEnabled()) {
-            throw ( new Error("Copilot cloud sandbox connections are not enabled."));
-        }
-        const address = cloudSandboxAddress(options.environmentId);
-        this._ensureProvider({
-            environmentId: options.environmentId,
-            sessionId: options.sessionId,
-            name: options.name
-        });
-        const pending = this._pendingConnects.get(address);
-        if (pending) {
-            return pending;
-        }
-        const token = this._enabledCts.token;
-        const attempt = (async () => {
-            try {
-                this._providerInstances.get(address)?.setConnectionStatus(RemoteAgentHostConnectionStatus.connecting);
-                this._clearReadOnly(address);
-                const result = await this._cloudSandboxService.connect(options, token);
-                if (token.isCancellationRequested || !this._isEnabled()) {
-                    void this._disconnectEnvironment(address);
-                    throw ( new CancellationError());
-                }
-                return result;
-            } catch (error) {
-                this._settleFailedConnect(address);
-                throw error;
-            } finally {
-                this._pendingConnects.delete(address);
-            }
-        })();
-        this._pendingConnects.set(address, attempt);
-        return attempt;
-    }
-    _settleFailedConnect(address) {
-        const provider = this._providerInstances.get(address);
-        if (!provider) {
-            return;
-        }
-        const connectionInfo = this._remoteAgentHostService.connections.find(c => c.address === address);
-        if (connectionInfo) {
-            provider.setConnectionStatus(connectionInfo.status);
-        } else if (!RemoteAgentHostConnectionStatus.isIncompatible(provider.connectionStatus.get())) {
-            provider.setConnectionStatus(RemoteAgentHostConnectionStatus.disconnected);
-        }
-    }
-    _isEnabled() {
-        return isCloudSandboxEnabled(this._configurationService);
-    }
-    _updateHostGroupRegistration() {
-        if (!this._isEnabled()) {
-            this._hostGroupRegistration.clear();
-        } else if (!this._hostGroupRegistration.value) {
-            this._hostGroupRegistration.value = this._agentHostFilterService.registerHostGroup(CLOUD_SANDBOX_HOST_GROUP);
-        }
-    }
-    _ensureProvider(env) {
-        const address = cloudSandboxAddress(env.environmentId);
-        const known = this._environments.get(address);
-        this._environments.set(address, {
-            ...known,
-            ...env,
-            taskId: env.taskId ?? known?.taskId
-        });
-        if (( this._providerStores.has(address))) {
-            return;
-        }
-        const store = ( new DisposableStore());
-        const provider = this._instantiateProvider({
-            address,
-            name: env.name,
-            connectOnDemand: () => this.connect({
-                environmentId: env.environmentId,
-                sessionId: env.sessionId,
-                name: env.name
-            }).then(() => {}),
-            sessionSchemeAlias: SANDBOX_SESSION_SCHEME_ALIAS,
-            defaultChangesetKind: ChangesetKind.Session,
-            omitHostFromWorkspaceLabel: true,
-            workspaceTypeIcon: Codicon.package,
-            readOnlyWhenDisconnected: true,
-            connectionLabels: CLOUD_SANDBOX_CONNECTION_LABELS,
-            hostGroup: CLOUD_SANDBOX_HOST_GROUP
-        });
-        store.add(provider);
-        store.add(this._sessionsProvidersService.registerProvider(provider));
-        store.add(
-            watchForIncompatibleNotifications(provider, this._instantiationService, this._notificationService)
-        );
-        this._providerInstances.set(address, provider);
-        store.add(toDisposable(() => this._providerInstances.delete(address)));
-        this._providerStores.set(address, store);
-        this._logService.info(`${LOG_PREFIX} Registered sessions provider for ${address}`);
-    }
-    _instantiateProvider(config) {
-        return this._instantiationService.createInstance(CloudSandboxSessionsProvider, config);
-    }
-    _wireConnections() {
-        for (const [address, provider] of this._providerInstances) {
-            const connectionInfo = this._remoteAgentHostService.connections.find(
-                c => c.address === address && RemoteAgentHostConnectionStatus.isConnected(c.status)
-            );
-            if (connectionInfo) {
-                const connection = this._remoteAgentHostService.getConnection(address);
-                if (connection) {
-                    provider.setConnection(connection, connectionInfo.defaultDirectory);
-                }
-            }
-        }
-    }
-    _updateConnectionStatuses() {
-        for (const [address, provider] of this._providerInstances) {
-            const connectionInfo = this._remoteAgentHostService.connections.find(c => c.address === address);
-            if (connectionInfo) {
-                provider.setConnectionStatus(connectionInfo.status);
-            } else if (( this._pendingConnects.has(address))) {
-                continue;
-            } else if (!RemoteAgentHostConnectionStatus.isIncompatible(provider.connectionStatus.get())) {
-                provider.setConnectionStatus(RemoteAgentHostConnectionStatus.disconnected);
-            }
-        }
-    }
-};
-CloudSandboxAgentHostContribution = ( __decorate([( __param(0, ICloudSandboxAgentHostService)), ( __param(1, ICloudSandboxApiService)), ( __param(2, IRemoteAgentHostService)), ( __param(3, IRemoteAgentHostConnectionCustomizationService)), ( __param(4, ISessionsProvidersService)), ( __param(5, IAgentHostFilterService)), ( __param(6, IConfigurationService)), ( __param(7, IAuthenticationService)), ( __param(8, IInstantiationService)), ( __param(9, INotificationService)), ( __param(10, IChatSessionsService)), ( __param(11, ILogService))], CloudSandboxAgentHostContribution));
-
-export { CloudSandboxAgentHostContribution };

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

@@ -1,15 +0,0 @@
-import { ICloudSandboxAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost.service";
-import { IRemoteAgentHostConnectionCustomization } from "@codingame/monaco-vscode-workbench-service-override/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostConnectionCustomization";
-/**
- * The {@link IRemoteAgentHostConnectionCustomization} for a cloud sandbox address, supplying the two
- * ways the sandbox host deviates from the generic path:
- *
- *  - **Auth**: the host only accepts a sealed envelope, so the connection's `encrypted_github_token`
- *    is presented instead of the resolved bearer. Fails closed if no sealed token is available.
- *  - **Scheme**: the host advertises provider `copilot` but addresses sessions as `ahp-session`.
- *
- * Returns `undefined` for non-sandbox addresses.
- */
-export declare function createCloudSandboxConnectionCustomization(address: string, sandboxService: ICloudSandboxAgentHostService): IRemoteAgentHostConnectionCustomization | undefined;
-/** Whether a remote-agent-host connection address identifies a cloud sandbox environment. */
-export declare function isCloudSandboxConnectionAddress(address: string): boolean;

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxConnectionCustomization.js

@@ -1,47 +0,0 @@
-
-import { cloudSandboxEnvironmentId, CLOUD_SANDBOX_SESSION_SCHEME, CLOUD_SANDBOX_AGENT_PROVIDER, isCloudSandboxSealedToken, CLOUD_SANDBOX_ADDRESS_PREFIX } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost';
-
-function isGitHubResource(resource) {
-    let host;
-    try {
-        host = ( new URL(resource)).hostname.toLowerCase();
-    } catch {
-        return false;
-    }
-    return host === "github.com" || host.endsWith(".github.com") || host === "githubcopilot.com" || host.endsWith(".githubcopilot.com") || host.endsWith(".ghe.com");
-}
-function createCloudSandboxConnectionCustomization(address, sandboxService) {
-    const environmentId = cloudSandboxEnvironmentId(address);
-    if (environmentId === undefined) {
-        return undefined;
-    }
-    return {
-        authenticate: async request => {
-            if (isCloudSandboxSealedToken(request.token)) {
-                return request;
-            }
-            if (!isGitHubResource(request.resource)) {
-                throw ( new Error(
-                    `Cloud sandbox cannot authenticate the non-GitHub resource '${request.resource}'.`
-                ));
-            }
-            const sealed = sandboxService.getSealedGitHubToken(environmentId);
-            if (!sealed || !isCloudSandboxSealedToken(sealed)) {
-                throw ( new Error(
-                    `No sealed GitHub token is available for cloud sandbox ${address}; refusing to forward a plaintext bearer.`
-                ));
-            }
-            return {
-                resource: request.resource,
-                scopes: request.scopes,
-                token: sealed
-            };
-        },
-        backendSessionScheme: provider => provider === CLOUD_SANDBOX_AGENT_PROVIDER ? CLOUD_SANDBOX_SESSION_SCHEME : undefined
-    };
-}
-function isCloudSandboxConnectionAddress(address) {
-    return address.startsWith(CLOUD_SANDBOX_ADDRESS_PREFIX);
-}
-
-export { createCloudSandboxConnectionCustomization, isCloudSandboxConnectionAddress };