@codingame/monaco-vscode-api 37.3.2 → 37.3.4

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

@@ -0,0 +1,586 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
+import { Codicon } from '../../../../../base/common/codicons.js';
+import { isCancellationError, CancellationError } from '../../../../../base/common/errors.js';
+import { Event } from '../../../../../base/common/event.js';
+import { Disposable, DisposableMap, MutableDisposable, DisposableStore, toDisposable } from '../../../../../base/common/lifecycle.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { localize } from '../../../../../nls.js';
+import { Registry } from '../../../../../platform/registry/common/platform.js';
+import { CLOUD_SANDBOX_SESSION_SCHEME, CLOUD_SANDBOX_AGENT_PROVIDER, CloudSandboxEnabledSettingId, cloudSandboxAddress, isCloudSandboxEnabled } from '../../../../../platform/agentHost/common/cloudSandboxAgentHost.js';
+import { ICloudSandboxAgentHostService, ICloudSandboxApiService } from '../../../../../platform/agentHost/common/cloudSandboxAgentHost.service.js';
+import { AgentSession } from '../../../../../platform/agentHost/common/agent.js';
+import { ChangesetKind } from '../../../../../platform/agentHost/common/changesetUri.js';
+import { agentHostAuthority } from '../../../../../platform/agentHost/common/agentHostUri.js';
+import { findRemoteAgentHostSessionTypeAuthority, remoteAgentHostSessionTypeId } from '../../../../../platform/agentHost/common/agentHostSessionType.js';
+import { RemoteAgentHostConnectionStatus, RemoteAgentHostsEnabledSettingId } from '../../../../../platform/agentHost/common/remoteAgentHostService.js';
+import { IRemoteAgentHostService } from '../../../../../platform/agentHost/common/remoteAgentHostService.service.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { IAuthenticationService } from '../../../../../workbench/services/authentication/common/authentication.service.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../../platform/log/common/log.service.js';
+import { INotificationService } from '../../../../../platform/notification/common/notification.service.js';
+import { ChatSessionsExtensions } from '../../../../../workbench/contrib/chat/common/chatSessionsService.js';
+import { IChatSessionsService } from '../../../../../workbench/contrib/chat/common/chatSessionsService.service.js';
+import { CloudSandboxReadOnlySessionHandler } from './cloudSandboxReadOnlySessionHandler.js';
+import { IAgentHostFilterService } from '../../../../services/agentHostFilter/common/agentHostFilter.service.js';
+import { ISessionsProvidersService } from '../../../../services/sessions/browser/sessionsProvidersService.service.js';
+import { CloudSandboxSessionsProvider } from './cloudSandboxSessionsProvider.js';
+import { IRemoteAgentHostConnectionCustomizationService } from './remoteAgentHostConnectionCustomization.service.js';
+import { isCloudSandboxConnectionAddress, createCloudSandboxConnectionCustomization } from './cloudSandboxConnectionCustomization.js';
+import { watchForIncompatibleNotifications } from './remoteHostOptions.js';
+
+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(4372, "GitHub Sandboxes")),
+    order: 1,
+    connectable: false
+};
+const CLOUD_SANDBOX_CONNECTION_LABELS = {
+    unavailableTitle: ( localize(4373, "Environment Offline")),
+    unavailable: ( localize(4374, "Environment offline.")),
+    connectingTitle: ( localize(4375, "Connecting to the Environment")),
+    connecting: ( localize(4376, "Connecting...")),
+    reconnecting: ( localize(4377, "Reconnecting...")),
+    reconnectingIn: seconds => ( localize(4378, "Reconnecting in {0}s", seconds)),
+    incompatibleTitle: ( localize(4379, "Cannot Connect to the Environment")),
+    incompatible: ( localize(
+        4380,
+        "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

@@ -0,0 +1,15 @@
+import { ICloudSandboxAgentHostService } from "../../../../../platform/agentHost/common/cloudSandboxAgentHost.service.js";
+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

@@ -0,0 +1,47 @@
+
+import { cloudSandboxEnvironmentId, CLOUD_SANDBOX_SESSION_SCHEME, CLOUD_SANDBOX_AGENT_PROVIDER, isCloudSandboxSealedToken, CLOUD_SANDBOX_ADDRESS_PREFIX } from '../../../../../platform/agentHost/common/cloudSandboxAgentHost.js';
+
+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 };