@codingame/monaco-vscode-chat-cloud-service-override 0.0.0-stage → 38.0.7

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

@@ -0,0 +1,321 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { equalsIgnoreCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { ChangesetKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/changesetUri';
+import { cloudSandboxAddress, CLOUD_SANDBOX_SESSION_SCHEME, CLOUD_SANDBOX_AGENT_PROVIDER, CloudSandboxAuthenticationRequiredError } 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 { readCloudSandboxProjects } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/meta/copilotd/cloudSandboxProjectMeta';
+import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
+import { withSessionWorkspaceless } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.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 { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { CloudSandboxSessionContribution, discoveredSessionProject } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/remoteAgentHost/cloudSandboxSessionContribution';
+import { IRemoteAgentHostConnectionCustomizationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/remoteAgentHost/remoteAgentHostConnectionCustomization.service';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { getGitHubRepositoryFromRemoteUrl } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/git/common/utils';
+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';
+
+const CLOUD_SANDBOX_CREATION_PROVIDER_ID = "cloud-sandbox-creation";
+const CLOUD_SANDBOX_HOST_GROUP = {
+    id: "githubsandbox",
+    label: ( localize(5127, "GitHub Sandboxes")),
+    order: 1,
+    connectable: false,
+    sessionCreationProviderId: isWeb ? CLOUD_SANDBOX_CREATION_PROVIDER_ID : undefined
+};
+const CLOUD_SANDBOX_CONNECTION_LABELS = {
+    unavailableTitle: ( localize(5128, "Environment Offline")),
+    unavailable: ( localize(5129, "Environment offline.")),
+    connectingTitle: ( localize(5130, "Connecting to the Environment")),
+    connecting: ( localize(5131, "Connecting...")),
+    reconnecting: ( localize(5132, "Reconnecting...")),
+    reconnectingIn: seconds => ( localize(5133, "Reconnecting in {0}s", seconds)),
+    incompatibleTitle: ( localize(5134, "Cannot Connect to the Environment")),
+    incompatible: ( localize(
+        5135,
+        "This environment is incompatible with this version of Visual Studio Code."
+    ))
+};
+let CloudSandboxAgentHostContribution = class CloudSandboxAgentHostContribution extends CloudSandboxSessionContribution {
+    static {
+        this.ID = "workbench.contrib.cloudSandboxAgentHost";
+    }
+    get supportsBackgroundConnection() {
+        return true;
+    }
+    constructor(
+        cloudSandboxService,
+        apiService,
+        _remoteService,
+        _sandboxConnectionCustomizations,
+        _sessionsProvidersService,
+        _agentHostFilterService,
+        configurationService,
+        instantiationService,
+        chatSessionsService,
+        logService,
+        chatEntitlementService,
+        hostService,
+        storageService,
+        workspaceTrustManagementService,
+        localAgentHostService
+    ) {
+        super(
+            cloudSandboxService,
+            apiService,
+            _remoteService,
+            _sandboxConnectionCustomizations,
+            configurationService,
+            instantiationService,
+            chatSessionsService,
+            logService,
+            chatEntitlementService,
+            hostService,
+            storageService,
+            workspaceTrustManagementService,
+            localAgentHostService
+        );
+        this._remoteService = _remoteService;
+        this._sandboxConnectionCustomizations = _sandboxConnectionCustomizations;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._agentHostFilterService = _agentHostFilterService;
+        this._hostGroupRegistration = this._register(( new MutableDisposable()));
+        this._updateRegistration();
+        this._register(
+            this._agentHostFilterService.registerDiscoveryHandler(() => this._discoverAndSeed())
+        );
+        this._register(this._agentHostFilterService.onDidChange(() => {
+            if (this._agentHostFilterService.selectedHostId === CLOUD_SANDBOX_HOST_GROUP.id) {
+                void this._refreshIfStale();
+            }
+        }));
+    }
+    async prepareSession(environmentId, repoNwo, token) {
+        const address = cloudSandboxAddress(environmentId);
+        const connection = this._remoteService.getConnection(address);
+        if (!connection) {
+            throw ( new Error(( localize(5136, "The cloud sandbox connection is no longer available."))));
+        }
+        const store = ( new DisposableStore());
+        try {
+            const prepare = this._sandboxConnectionCustomizations.get(address)?.createSessionPreparation?.(connection, store);
+            if (!prepare) {
+                throw ( new Error(( localize(5137, "Cloud sandbox repository preparation is not registered."))));
+            }
+            await prepare(( URI.from({
+                scheme: Schemas.https,
+                authority: "github.com",
+                path: `/${repoNwo}`
+            })), token);
+        } finally {
+            store.dispose();
+        }
+    }
+    _updateRegistration() {
+        if (!this._isEnabled()) {
+            this._hostGroupRegistration.clear();
+        } else {
+            if (!this._hostGroupRegistration.value) {
+                this._hostGroupRegistration.value = this._agentHostFilterService.registerHostGroup(CLOUD_SANDBOX_HOST_GROUP);
+            }
+            void this._discoverAndSeed();
+        }
+    }
+    _ensureProvider(env) {
+        super._ensureProvider(env);
+        if (env.sessionId && env.taskId) {
+            const rawId = env.sessionId;
+            const address = cloudSandboxAddress(env.environmentId);
+            this._providerInstances.get(address)?.setTaskRenameHandler(rawId, title => this._renameSandboxSession(address, rawId, title));
+            this._providerInstances.get(address)?.setTaskArchiveHandler(
+                rawId,
+                archived => this._setSandboxSessionArchived(address, rawId, archived)
+            );
+        }
+    }
+    _createProvider(env, store) {
+        const provider = store.add(this._instantiateProvider({
+            address: cloudSandboxAddress(env.environmentId),
+            name: env.name,
+            connectOnDemand: async () => {
+                await this.connect({
+                    environmentId: env.environmentId,
+                    sessionId: env.sessionId,
+                    name: env.name
+                });
+            },
+            disconnectOnDemand: () => this._disconnectEnvironment(cloudSandboxAddress(env.environmentId)),
+            deleteSessionsOnDemand: {
+                ownsSession: session => isEqual(
+                    session,
+                    AgentSession.uri(CLOUD_SANDBOX_SESSION_SCHEME, AgentSession.id(session))
+                ) && this._ownsSandboxSession(cloudSandboxAddress(env.environmentId), AgentSession.id(session)),
+                deleteSessions: sessions => this._deleteSandboxSession(
+                    cloudSandboxAddress(env.environmentId),
+                    sessions.map(session => AgentSession.id(session)),
+                    rawId => provider.removeDeletedSession(rawId)
+                )
+            },
+            sessionSchemeAlias: {
+                ui: CLOUD_SANDBOX_AGENT_PROVIDER,
+                backend: CLOUD_SANDBOX_SESSION_SCHEME
+            },
+            defaultChangesetKind: ChangesetKind.Session,
+            omitHostFromWorkspaceLabel: true,
+            workspaceTypeIcon: Codicon.package,
+            readOnlyWhenDisconnected: true,
+            connectionLabels: CLOUD_SANDBOX_CONNECTION_LABELS,
+            hostGroup: CLOUD_SANDBOX_HOST_GROUP
+        }));
+        store.add(this._sessionsProvidersService.registerProvider(provider));
+        return provider;
+    }
+    _instantiateProvider(config) {
+        return this._instantiationService.createInstance(CloudSandboxSessionsProvider, config);
+    }
+    async provisionSession(request, token, progress) {
+        if (!this._isEnabled()) {
+            throw ( new Error("Copilot cloud sandbox connections are not enabled."));
+        }
+        const accountKey = await this._apiService.getAccountKey();
+        if (!this._isEnabled() || token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        if (!accountKey) {
+            throw ( new CloudSandboxAuthenticationRequiredError());
+        }
+        this._restoreAccount(accountKey);
+        const enabledToken = this._enabledCts.token;
+        progress?.report(( localize(5138, "Setting up cloud container")));
+        const provisioningStartedAt = Date.now();
+        const created = await this._apiService.createSession(request, token);
+        const name = request.repoNwo ?? created.taskId;
+        const address = cloudSandboxAddress(created.environmentId);
+        if (!this._isEnabled() || token.isCancellationRequested || enabledToken.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        this._provisioning.add(address);
+        let seededProvider;
+        let connectionAttempt;
+        try {
+            const now = Date.now();
+            this._ensureProvider({
+                ...created,
+                name,
+                repoName: request.repoNwo,
+                hasRepository: request.repoNwo !== undefined,
+                updatedAt: ( new Date(now)).toISOString()
+            });
+            const provider = this._providerInstances.get(address);
+            if (!provider) {
+                throw ( new Error(
+                    `No sessions provider was registered for sandbox environment ${created.environmentId}`
+                ));
+            }
+            const project = discoveredSessionProject(request.repoNwo);
+            provider.seedProvisionalSession({
+                session: AgentSession.uri(CLOUD_SANDBOX_SESSION_SCHEME, created.sessionId),
+                provider: CLOUD_SANDBOX_AGENT_PROVIDER,
+                _meta: withSessionWorkspaceless(undefined, request.repoNwo === undefined),
+                startTime: now,
+                modifiedTime: now,
+                summary: name,
+                ...(project ? {
+                    project
+                } : {})
+            });
+            seededProvider = provider;
+            this._persistInventory();
+            progress?.report(( localize(5139, "Connecting to cloud container")));
+            connectionAttempt = this.connect({
+                environmentId: created.environmentId,
+                sessionId: created.sessionId,
+                name,
+                connectionSource: "created",
+                provisioningStartedAt
+            });
+            await raceCancellationError(connectionAttempt, token);
+            if (token.isCancellationRequested || !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 {
+            const releaseProvisioning = () => {
+                this._provisioning.delete(address);
+            };
+            if (connectionAttempt) {
+                void connectionAttempt.then(releaseProvisioning, releaseProvisioning);
+            } else {
+                releaseProvisioning();
+            }
+        }
+    }
+    trackSessionCreationProgress(environmentId, repoNwo, progress) {
+        const store = ( new DisposableStore());
+        const connection = this._remoteService.getConnection(cloudSandboxAddress(environmentId));
+        if (!connection) {
+            return store;
+        }
+        let cloningProjectId;
+        const update = () => {
+            const state = connection.rootState.value;
+            if (!state || state instanceof Error) {
+                return;
+            }
+            const projects = readCloudSandboxProjects(state)?.filter(project => {
+                const remote = project.remoteUrl && getGitHubRepositoryFromRemoteUrl(project.remoteUrl, ["github.com"]);
+                return remote && equalsIgnoreCase(`${remote.owner}/${remote.repo}`, repoNwo);
+            });
+            const project = projects?.find(project => project.status === "ready") ?? projects?.find(project => project.status === "cloning") ?? projects?.[0];
+            if (project?.status === "cloning") {
+                cloningProjectId = project.id;
+                progress.report(project.progress === undefined ? ( localize(5140, "Cloning repository")) : ( localize(5141, "Cloning repository ({0}%)", Math.round(project.progress))));
+            } else if (project?.status === "ready") {
+                progress.report(( localize(5142, "Starting Copilot agent")));
+                store.dispose();
+            } else if (project?.status === "failed" && project.id === cloningProjectId) {
+                progress.report(( localize(5143, "Repository cloning failed")));
+                store.dispose();
+            }
+        };
+        store.add(connection.rootState.onDidChange(update));
+        update();
+        return store;
+    }
+};
+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, IInstantiationService)), ( __param(8, IChatSessionsService)), ( __param(9, ILogService)), ( __param(10, IChatEntitlementService)), ( __param(11, IHostService)), ( __param(12, IStorageService)), ( __param(13, IWorkspaceTrustManagementService)), ( __param(14, IAgentHostService))], CloudSandboxAgentHostContribution));
+
+export { CLOUD_SANDBOX_CREATION_PROVIDER_ID, CloudSandboxAgentHostContribution };

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

@@ -0,0 +1,104 @@
+import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { type IAgentSessionMetadata } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent";
+import type { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import type { AgentHostSessionAdapter } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/agentHost/browser/baseAgentHostSessionsProvider";
+import { RemoteAgentHostSessionsProvider } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+/**
+ * Sessions provider for a Copilot cloud sandbox.
+ *
+ * Adds the handling for sessions this client provisioned but the host has not materialized yet:
+ * Mission Control mints the session id and returns it before the sandbox is even awake, so such a
+ * session is real, addressable, and unknown to the host all at once.
+ */
+export declare class CloudSandboxSessionsProvider extends RemoteAgentHostSessionsProvider {
+    private readonly _configurationUnavailable;
+    protected get supportsOfflineDrafts(): boolean;
+    get environment(): {
+        id: string;
+        label: string;
+    };
+    readonly supportsWorkspaceSelection = false;
+    /** Sandboxes are per-session environments, not persistent Automation hosts. */
+    get automations(): undefined;
+    protected _adoptCachedSessionMeta(meta: IAgentSessionMetadata): IAgentSessionMetadata | undefined;
+    private _taskRenameHandler;
+    private _taskArchiveHandler;
+    private readonly _archiveSequencer;
+    /**
+     * Provisional sessions kept out of {@link getSessions} because the caller is still showing a
+     * placeholder row for them. They stay reachable by resource, so opening one still works.
+     */
+    private readonly _withheldSessions;
+    /**
+     * Backend session key → deadline after which eviction resumes, or `undefined` while the clock has not
+     * started. It starts when a connected host first omits the session, not at seed time, because
+     * waking a sandbox can take minutes.
+     */
+    private readonly _provisionalSessions;
+    private readonly _pendingSessionTitles;
+    /** How long a provisional session resists eviction after the host first omits it. */
+    static readonly PROVISIONAL_GRACE_MS: number;
+    /** Resolves creation options without requiring the host to know the preallocated session yet. */
+    resolveInitialSessionConfig(sessionId: string, values: Record<string, unknown>, token: CancellationToken): Promise<Record<string, unknown>>;
+    protected _adapterOptions(): {
+        readOnly: IObservable<boolean>;
+        allowOfflineDrafts: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservableWithChange<boolean, void>;
+        defaultChangesetKind: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/changesetUri").ChangesetKind.Branch | import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/changesetUri").ChangesetKind.Uncommitted | import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/changesetUri").ChangesetKind.Session | undefined;
+        buildWorkspace: (project: IAgentSessionMetadata["project"], workingDirectories: readonly URI[] | undefined, gitHubInfo: IObservable<import("@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session").IGitHubInfo | undefined>, gitState: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState").ISessionGitState | undefined) => import("@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session").ISessionWorkspace | undefined;
+        preserveStatusWhenDisconnected: boolean;
+        useSessionTitleForDefaultChat: boolean;
+        isSessionTitlePlaceholder: (title: string, session: URI) => boolean;
+        externalSessionState: (resource: URI, store: DisposableStore) => IObservable<boolean>;
+    };
+    private _localSessionStorageKey;
+    protected updateAdapter(adapter: AgentHostSessionAdapter, meta: IAgentSessionMetadata): boolean;
+    protected _onBackendSessionRemoved(rawId: string): void;
+    /** Reopened cached chats also need a background connection, even when content activation is skipped. */
+    prepareSessionForOpen(): Promise<void>;
+    isSessionConfigResolving(sessionId: string): IObservable<boolean>;
+    setSessionConfigValue(sessionId: string, property: string, value: unknown): Promise<void>;
+    replaceSessionConfig(sessionId: string, values: Record<string, unknown>): Promise<void>;
+    private _assertConfigurationAvailable;
+    protected _resolveArchivedState(sessionKey: string, isArchived: boolean): boolean;
+    /** Bind the discovered session's Mission Control archive operation. */
+    setTaskArchiveHandler(rawId: string, setArchived: (archived: boolean) => Promise<void>): void;
+    /** Bind the discovered session's Mission Control rename operation. */
+    setTaskRenameHandler(rawId: string, rename: (title: string) => Promise<void>): void;
+    /** Preserve the initial title without letting a transient task metadata failure block the first turn. */
+    setInitialSessionTitle(sessionId: string, title: string): Promise<void>;
+    renameSession(sessionId: string, title: string): Promise<void>;
+    private _renameSession;
+    archiveSession(sessionId: string): Promise<void>;
+    unarchiveSession(sessionId: string): Promise<void>;
+    private _setArchived;
+    setSessionArchived(rawId: string, archived: boolean): void;
+    /**
+     * Seed a session this client just provisioned. It is cached so a later discovery pass
+     * reconciles against it rather than adding a second entry, but stays out of the sessions list
+     * until {@link publishWithheldSession} and resists eviction until the host lists it.
+     */
+    seedProvisionalSession(rawMeta: IAgentSessionMetadata): void;
+    /**
+     * Reveal a session seeded by {@link seedProvisionalSession}, so {@link getSessions} returns it.
+     *
+     * Pass `announce: false` when the caller immediately fires its own change event covering this
+     * session: the list re-reads {@link getSessions} on any change, so a single event can both drop
+     * a placeholder row and reveal this one.
+     */
+    publishWithheldSession(rawId: string, options?: {
+        announce?: boolean;
+    }): void;
+    /**
+     * Look up a cached session by raw id, **including** ones withheld from {@link getSessions},
+     * which callers that seeded a session need before it is listed.
+     */
+    getCachedSession(rawId: string): ISession | undefined;
+    getSessionModifiedTime(rawId: string): number | undefined;
+    removeDeletedSession(rawId: string): void;
+    getSessions(): ISession[];
+    protected _isSessionEvictable(rawId: string): boolean;
+    protected _onHostListedSessions(rawIds: ReadonlySet<string>): void;
+}