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

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

@@ -0,0 +1,345 @@
+
+import { Sequencer, raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
+import { CLOUD_SANDBOX_AGENT_PROVIDER, CLOUD_SANDBOX_SESSION_SCHEME, CloudSandboxAutoConnectOnOpenSettingId, CloudSandboxRequestError, isRetryableCloudSandboxError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { RemoteAgentHostSessionsProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider';
+import { validateSessionConfigWrite } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigProperties';
+import { RemoteAgentHostConnectionStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { readSessionWorkspaceless } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+
+class CloudSandboxSessionsProvider extends RemoteAgentHostSessionsProvider {
+    constructor() {
+        super(...arguments);
+        this._configurationUnavailable = derived(
+            this,
+            reader => !RemoteAgentHostConnectionStatus.isConnected(this.connectionStatus.read(reader)) || this.authenticationPending.read(reader) || this.passiveRelay.read(reader)
+        );
+        this.supportsWorkspaceSelection = false;
+        this._archiveSequencer = ( new Sequencer());
+        this._withheldSessions = ( new Set());
+        this._provisionalSessions = ( new Map());
+        this._pendingSessionTitles = ( new Map());
+    }
+    get supportsOfflineDrafts() {
+        return true;
+    }
+    get environment() {
+        return {
+            id: "cloud",
+            label: ( localize(5144, "Cloud"))
+        };
+    }
+    get automations() {
+        return undefined;
+    }
+    _adoptCachedSessionMeta(meta) {
+        const adopted = super._adoptCachedSessionMeta(meta);
+        return adopted?.session.scheme === CLOUD_SANDBOX_AGENT_PROVIDER && adopted.provider === CLOUD_SANDBOX_AGENT_PROVIDER ? {
+            ...adopted,
+            session: adopted.session.with({
+                scheme: CLOUD_SANDBOX_SESSION_SCHEME
+            })
+        } : adopted;
+    }
+    static {
+        this.PROVISIONAL_GRACE_MS = 2 * 60_000;
+    }
+    async resolveInitialSessionConfig(sessionId, values, token) {
+        const rawId = this._sessionKeyFromChatId(sessionId);
+        const connection = this.connection;
+        if (!connection || !rawId || !( this._sessionCache.has(rawId))) {
+            throw ( new Error(( localize(5145, "The sandbox connection is unavailable. Your prompt was not sent."))));
+        }
+        const config = await raceCancellationError(connection.resolveSessionConfig({
+            provider: CLOUD_SANDBOX_AGENT_PROVIDER,
+            config: values
+        }), token);
+        for (const [key, value] of Object.entries(values)) {
+            validateSessionConfigWrite(config.schema, config.values, key, value, true);
+            if (config.values[key] !== value) {
+                throw ( new Error(( localize(
+                    5146,
+                    "The sandbox could not apply the selected {0}. Your prompt was not sent.",
+                    key
+                ))));
+            }
+        }
+        return {
+            ...values
+        };
+    }
+    _adapterOptions() {
+        return {
+            ...super._adapterOptions(),
+            preserveStatusWhenDisconnected: true,
+            useSessionTitleForDefaultChat: true,
+            isSessionTitlePlaceholder: (title, session) => session.scheme === CLOUD_SANDBOX_SESSION_SCHEME && title === AgentSession.id(session),
+            externalSessionState: (resource, store) => {
+                const key = this._localSessionStorageKey(AgentSession.id(resource));
+                store.add(this._chatService.onDidAcceptRequest((
+                    {
+                        chatSessionResource
+                    }
+                ) => {
+                    if (isEqual(resource, chatSessionResource.with({
+                        fragment: ""
+                    }))) {
+                        this._storageService.store(key, true, StorageScope.PROFILE, StorageTarget.MACHINE);
+                    }
+                }));
+                return constObservable(false);
+            }
+        };
+    }
+    _localSessionStorageKey(rawId) {
+        return `sessions.cloudSandbox.localSession.${this.id}.${rawId}`;
+    }
+    updateAdapter(adapter, meta) {
+        const changed = super.updateAdapter(adapter, meta);
+        const sessionKey = ( meta.session.toString());
+        this._provisionalSessions.delete(sessionKey);
+        const title = this._pendingSessionTitles.get(sessionKey);
+        if (title !== undefined && this.connection) {
+            this._pendingSessionTitles.delete(sessionKey);
+            void super.renameSession(adapter.sessionId, title).catch(error => {
+                this._logService.error(
+                    `[CloudSandboxSessionsProvider] Failed to apply initial title for ${sessionKey}`,
+                    error
+                );
+            });
+            return true;
+        }
+        return changed;
+    }
+    _onBackendSessionRemoved(rawId) {
+        super._onBackendSessionRemoved(rawId);
+        this._pendingSessionTitles.delete(rawId);
+    }
+    async prepareSessionForOpen() {
+        if (this._baseConfigurationService.getValue(CloudSandboxAutoConnectOnOpenSettingId) === true && !this.connection && RemoteAgentHostConnectionStatus.isDisconnected(this.connectionStatus.get())) {
+            void this.connect().catch(error => {
+                this._logService.warn(
+                    "[CloudSandboxSessionsProvider] Background connection on open failed",
+                    error
+                );
+            });
+        }
+    }
+    isSessionConfigResolving(sessionId) {
+        const resolving = super.isSessionConfigResolving(sessionId);
+        return derived(
+            this,
+            reader => this._configurationUnavailable.read(reader) || resolving.read(reader)
+        );
+    }
+    async setSessionConfigValue(sessionId, property, value) {
+        this._assertConfigurationAvailable();
+        await super.setSessionConfigValue(sessionId, property, value);
+    }
+    async replaceSessionConfig(sessionId, values) {
+        this._assertConfigurationAvailable();
+        await super.replaceSessionConfig(sessionId, values);
+    }
+    _assertConfigurationAvailable() {
+        if (this.passiveRelay.get()) {
+            throw ( new Error(( localize(5147, "This connection is read-only. Session settings cannot be changed."))));
+        }
+        if (this._configurationUnavailable.get()) {
+            throw ( new Error(( localize(5148, "Connect to the environment before changing session settings."))));
+        }
+    }
+    _resolveArchivedState(sessionKey, isArchived) {
+        return this._taskArchiveHandler?.sessionKey === sessionKey ? this._sessionCache.get(sessionKey)?.isArchived.get() ?? isArchived : super._resolveArchivedState(sessionKey, isArchived);
+    }
+    setTaskArchiveHandler(rawId, setArchived) {
+        this._taskArchiveHandler = {
+            sessionKey: ( AgentSession.uri(CLOUD_SANDBOX_SESSION_SCHEME, rawId).toString()),
+            setArchived
+        };
+    }
+    setTaskRenameHandler(rawId, rename) {
+        this._taskRenameHandler = {
+            sessionKey: ( AgentSession.uri(CLOUD_SANDBOX_SESSION_SCHEME, rawId).toString()),
+            rename
+        };
+    }
+    setInitialSessionTitle(sessionId, title) {
+        return this._renameSession(sessionId, title, true);
+    }
+    renameSession(sessionId, title) {
+        return this._renameSession(sessionId, title, false);
+    }
+    async _renameSession(sessionId, title, initial) {
+        const sessionKey = this._sessionKeyFromChatId(sessionId);
+        const session = sessionKey ? this._sessionCache.get(sessionKey) : undefined;
+        if (!session || !sessionKey) {
+            throw ( new Error(( localize(5149, "Sandbox session not found."))));
+        }
+        const handler = this._taskRenameHandler;
+        if (handler?.sessionKey !== sessionKey) {
+            if (!this.connection && !( this._provisionalSessions.has(sessionKey))) {
+                throw ( new Error(( localize(5150, "Connect to the environment to rename this session."))));
+            }
+        } else {
+            try {
+                await handler.rename(title);
+            } catch (error) {
+                if (!initial || !(error instanceof CloudSandboxRequestError) || !isRetryableCloudSandboxError(error)) {
+                    throw error;
+                }
+                this._logService.warn(
+                    `[CloudSandboxSessionsProvider] Failed to synchronize initial task title for ${sessionKey}; continuing with the first turn`,
+                    error
+                );
+            }
+            if (this._store.isDisposed || this._sessionCache.get(sessionKey) !== session) {
+                throw ( new CancellationError());
+            }
+        }
+        if (( this._provisionalSessions.has(sessionKey))) {
+            this._pendingSessionTitles.set(sessionKey, title);
+        } else if (this.connection) {
+            return super.renameSession(sessionId, title);
+        }
+        session.setTitleFromUser(title);
+        this._onDidChangeSessions.fire({
+            added: [],
+            removed: [],
+            changed: [session]
+        });
+    }
+    async archiveSession(sessionId) {
+        await this._archiveSequencer.queue(() => this._setArchived(sessionId, true));
+    }
+    async unarchiveSession(sessionId) {
+        await this._archiveSequencer.queue(() => this._setArchived(sessionId, false));
+    }
+    async _setArchived(sessionId, isArchived) {
+        if (this._store.isDisposed) {
+            throw ( new CancellationError());
+        }
+        const sessionKey = this._sessionKeyFromChatId(sessionId);
+        const session = sessionKey ? this._sessionCache.get(sessionKey) : undefined;
+        if (!session || !sessionKey) {
+            throw ( new Error(( localize(5149, "Sandbox session not found."))));
+        }
+        const handler = this._taskArchiveHandler;
+        if (handler?.sessionKey !== sessionKey) {
+            if (!this.connection) {
+                throw ( new Error(( localize(5151, "Connect to the environment to change this session's archive state."))));
+            }
+            return isArchived ? super.archiveSession(sessionId) : super.unarchiveSession(sessionId);
+        }
+        await handler.setArchived(isArchived);
+        if (this._store.isDisposed || this._sessionCache.get(sessionKey) !== session) {
+            throw ( new CancellationError());
+        }
+        this.setSessionArchived(AgentSession.id(session.backendUri), isArchived);
+    }
+    setSessionArchived(rawId, archived) {
+        const session = this._sessionCache.get(( AgentSession.uri(CLOUD_SANDBOX_SESSION_SCHEME, rawId).toString()));
+        if (!session) {
+            throw ( new Error(( localize(5149, "Sandbox session not found."))));
+        }
+        if (session.isArchived.get() === archived) {
+            return;
+        }
+        session.isArchived.set(archived, undefined);
+        this._onDidChangeSessions.fire({
+            added: [],
+            removed: [],
+            changed: [session]
+        });
+    }
+    seedProvisionalSession(rawMeta) {
+        const meta = this._adoptSessionMeta(rawMeta);
+        const rawId = AgentSession.id(meta.session);
+        this._storageService.store(
+            this._localSessionStorageKey(rawId),
+            true,
+            StorageScope.PROFILE,
+            StorageTarget.MACHINE
+        );
+        if (( this._sessionCache.has(( meta.session.toString())))) {
+            return;
+        }
+        const adapter = this.createAdapter(meta);
+        adapter.updateDiscoveryMetadata(meta, readSessionWorkspaceless(meta._meta) || undefined);
+        this._sessionCache.set(( meta.session.toString()), adapter);
+        this._withheldSessions.add(( meta.session.toString()));
+        this._provisionalSessions.set(( meta.session.toString()), undefined);
+    }
+    publishWithheldSession(rawId, options) {
+        if (!this._withheldSessions.delete(( AgentSession.uri(CLOUD_SANDBOX_SESSION_SCHEME, rawId).toString()))) {
+            return;
+        }
+        const session = this.getCachedSession(rawId);
+        if (session && options?.announce !== false) {
+            this._onDidChangeSessions.fire({
+                added: [session],
+                removed: [],
+                changed: []
+            });
+        }
+    }
+    getCachedSession(rawId) {
+        return this._sessionCache.get(( AgentSession.uri(CLOUD_SANDBOX_SESSION_SCHEME, rawId).toString()));
+    }
+    getSessionModifiedTime(rawId) {
+        return this.getCachedSession(rawId)?.updatedAt.get().getTime();
+    }
+    removeDeletedSession(rawId) {
+        const cached = this.getCachedSession(rawId);
+        const key = cached ? this._sessionKeyFromChatId(cached.sessionId) : undefined;
+        const session = key ? this._removeCachedSession(key) : undefined;
+        const taskKey = ( AgentSession.uri(CLOUD_SANDBOX_SESSION_SCHEME, rawId).toString());
+        this._withheldSessions.delete(taskKey);
+        this._provisionalSessions.delete(taskKey);
+        this._pendingSessionTitles.delete(taskKey);
+        if (session) {
+            this._onDidChangeSessions.fire({
+                added: [],
+                removed: [session],
+                changed: []
+            });
+            session.dispose();
+        }
+    }
+    getSessions() {
+        const sessions = super.getSessions();
+        return this._withheldSessions.size === 0 ? sessions : sessions.filter(session => !( this._withheldSessions.has(this._sessionKeyFromChatId(session.sessionId) ?? "")));
+    }
+    _isSessionEvictable(rawId) {
+        if (!( this._provisionalSessions.has(rawId))) {
+            return true;
+        }
+        const deadline = this._provisionalSessions.get(rawId);
+        if (deadline === undefined || Date.now() < deadline) {
+            return false;
+        }
+        this._provisionalSessions.delete(rawId);
+        this._pendingSessionTitles.delete(rawId);
+        return true;
+    }
+    _onHostListedSessions(rawIds) {
+        if (this._provisionalSessions.size === 0) {
+            return;
+        }
+        for (const [rawId, deadline] of [...this._provisionalSessions]) {
+            if (( rawIds.has(rawId))) {
+                this._provisionalSessions.delete(rawId);
+            } else if (deadline === undefined) {
+                this._provisionalSessions.set(rawId, Date.now() + CloudSandboxSessionsProvider.PROVISIONAL_GRACE_MS);
+            }
+        }
+    }
+}
+
+export { CloudSandboxSessionsProvider };

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.