@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/contrib/remoteSessions/browser/remoteSessionMessageRouter.d.ts

@@ -0,0 +1,49 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentHostConnectionsService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { IRemoteSessionChatService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/browser/remoteSessionChatService.service";
+export declare const maxRemoteMessageLength: number;
+export interface ISendRemoteMessageOptions {
+    readonly session: string;
+    readonly message: string;
+}
+export interface IRemoteMessageTarget {
+    readonly session: string;
+    readonly chat: string;
+    readonly openLink: string;
+    readonly host: {
+        readonly id: string;
+        readonly label: string;
+    };
+}
+export interface ISendRemoteMessageResult extends IRemoteMessageTarget {
+    readonly status: "sent" | "queued";
+}
+export declare function parseSendRemoteMessageOptions(value: unknown): ISendRemoteMessageOptions;
+/** Routes approved messages without opening a chat or changing its execution configuration. */
+export declare class RemoteSessionMessageRouter {
+    private readonly sessionsService;
+    private readonly providersService;
+    private readonly connectionsService;
+    private readonly configurationService;
+    private readonly backgroundChats;
+    private readonly workspaceTrustService;
+    private readonly requests;
+    private readonly sends;
+    constructor(sessionsService: ISessionsManagementService, providersService: ISessionsProvidersService, connectionsService: IAgentHostConnectionsService, configurationService: IConfigurationService, backgroundChats: IRemoteSessionChatService, workspaceTrustService: IWorkspaceTrustManagementService);
+    prepareTarget(source: URI, target: string, token: CancellationToken): Promise<IRemoteMessageTarget>;
+    send(source: URI, options: ISendRemoteMessageOptions, requestId: string, token: CancellationToken): Promise<ISendRemoteMessageResult>;
+    private queueSend;
+    private checkEnabled;
+    private resolveChat;
+    private resolveProvider;
+    private resolve;
+    private checkConnected;
+    private describeTarget;
+    private checkTargetTrust;
+    private doSend;
+}

package/vscode/src/vs/sessions/contrib/remoteSessions/browser/remoteSessionMessageRouter.js

@@ -0,0 +1,340 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { SequencerByKey, raceCancellationError, disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { getComparisonKey, isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IAgentHostConnectionsService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service';
+import { resolveAgentHostSessionTrustFolders } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostWorkspaceTrust';
+import { toRemoteSessionMessageMetadata } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/meta/vscode/agentRemoteSessionMeta';
+import { buildOpenSessionLinkUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/openSessionLink';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import { ChatInteractivity as ChatInteractivity$1, MessageKind, PendingMessageKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/notifications';
+import { readSessionWorkspaceless, StateComponents, getSessionChatResource, DEFAULT_CHAT_ID, parseChatUri, effectiveChatInteractivity, isSessionStatusArchived } 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 { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { ChatInteractivity } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { resolveRemoteSessionChat, resolveRemoteSessionSource, resolveRemoteSessionReference, readRemoteSessionState } from './remoteSessionSource.js';
+import { IRemoteSessionChatService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/browser/remoteSessionChatService.service';
+import { areRemoteSessionToolsEnabled } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/common/remoteSessions';
+
+const maxRemoteMessages = 50;
+const maxRemoteMessageLength = 64 * 1024;
+function parseSendRemoteMessageOptions(value) {
+    const input = value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+    if (!input || typeof input.session !== "string" || !input.session.trim() || typeof input.message !== "string" || !input.message.trim() || input.message.length > maxRemoteMessageLength || ( ( Object.keys(input)).some(key => key !== "session" && key !== "message"))) {
+        throw ( new Error(( localize(
+            5550,
+            "Provide a session reference and a non-empty message of at most {0} characters.",
+            maxRemoteMessageLength
+        ))));
+    }
+    return {
+        session: input.session.trim(),
+        message: input.message
+    };
+}
+let RemoteSessionMessageRouter = class RemoteSessionMessageRouter {
+    constructor(
+        sessionsService,
+        providersService,
+        connectionsService,
+        configurationService,
+        backgroundChats,
+        workspaceTrustService
+    ) {
+        this.sessionsService = sessionsService;
+        this.providersService = providersService;
+        this.connectionsService = connectionsService;
+        this.configurationService = configurationService;
+        this.backgroundChats = backgroundChats;
+        this.workspaceTrustService = workspaceTrustService;
+        this.requests = ( new Map());
+        this.sends = ( new SequencerByKey());
+    }
+    async prepareTarget(source, target, token) {
+        const resolved = await this.resolve(source, target, token);
+        return this.describeTarget(resolved.target);
+    }
+    send(source, options, requestId, token) {
+        this.checkEnabled();
+        const key = JSON.stringify([getComparisonKey(source), requestId]);
+        const input = JSON.stringify(options);
+        const previous = this.requests.get(key);
+        if (previous) {
+            if (previous.input !== input) {
+                throw ( new Error(( localize(
+                    5551,
+                    "A remote message request cannot be retried with different arguments."
+                ))));
+            }
+            return previous.result;
+        }
+        if (this.requests.size >= maxRemoteMessages) {
+            throw ( new Error(( localize(
+                5552,
+                "Remote message limit reached ({0} requests per window).",
+                maxRemoteMessages
+            ))));
+        }
+        const result = this.queueSend(source, options, token);
+        this.requests.set(key, {
+            input,
+            result
+        });
+        return result;
+    }
+    async queueSend(sourceResource, options, token) {
+        const {
+            source,
+            target
+        } = await this.resolve(sourceResource, options.session, token);
+        return this.sends.queue(
+            getComparisonKey(target.chat),
+            () => this.doSend(source, target, options, token)
+        );
+    }
+    checkEnabled() {
+        if (!areRemoteSessionToolsEnabled(this.configurationService)) {
+            throw ( new Error(( localize(5553, "Remote session tools are disabled."))));
+        }
+    }
+    resolveChat(resource) {
+        const parent = resolveRemoteSessionChat(resource.with({
+            fragment: ""
+        }), this.sessionsService, this.connectionsService);
+        return this.resolveProvider(parent, resource);
+    }
+    resolveProvider(chat, resource = chat.chat.resource) {
+        const provider = this.providersService.getProvider(chat.session.providerId);
+        if (!provider || !isAgentHostProvider(provider) || (provider.connectionStatus && provider.connectionStatus.get().kind !== "connected")) {
+            throw ( new Error(( localize(
+                5554,
+                "The agent host provider for {0} is not registered and connected in this Agents window.",
+                (resource.toString())
+            ))));
+        }
+        return {
+            ...chat,
+            chat: resource,
+            hostLabel: provider.label
+        };
+    }
+    async resolve(sourceResource, targetReference, token) {
+        this.checkEnabled();
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        const sourceContext = await resolveRemoteSessionSource(sourceResource, this.sessionsService, this.connectionsService, token);
+        const source = this.resolveProvider(sourceContext);
+        if (targetReference === "origin") {
+            const origin = sourceContext.origin;
+            if (!origin) {
+                throw ( new Error(( localize(5555, "This session has no saved remote-session origin."))));
+            }
+            targetReference = origin.chat;
+        }
+        const {
+            resource: targetResource
+        } = resolveRemoteSessionReference(targetReference, this.connectionsService);
+        const target = this.resolveChat(targetResource);
+        if (isEqual(source.chat, target.chat)) {
+            throw ( new Error(( localize(5556, "A chat cannot send a remote message to itself."))));
+        }
+        const targetChat = this.sessionsService.getSessionForChatResource(target.chat)?.chat;
+        if (target.session.isArchived.get() || (targetChat && targetChat.interactivity.get() !== ChatInteractivity.Full)) {
+            throw ( new Error(( localize(5557, "The target chat is archived or read-only."))));
+        }
+        this.checkConnected(source);
+        this.checkEnabled();
+        return {
+            source,
+            target
+        };
+    }
+    checkConnected(chat) {
+        const current = this.resolveChat(chat.chat);
+        if (current.host.connection !== chat.host.connection || current.host.connectionAuthority !== chat.host.connectionAuthority || current.clientId !== chat.clientId || !isEqual(current.host.backendSession, chat.host.backendSession)) {
+            throw ( new Error(( localize(
+                5558,
+                "The agent host connection changed. The message was not sent on the replacement connection."
+            ))));
+        }
+    }
+    describeTarget(target) {
+        return {
+            session: ( target.session.resource.toString()),
+            chat: ( target.chat.toString()),
+            openLink: buildOpenSessionLinkUri(target.session.resource, target.chat.fragment),
+            host: {
+                id: target.session.providerId,
+                label: target.hostLabel
+            }
+        };
+    }
+    async checkTargetTrust(target, state, token) {
+        if (!readSessionWorkspaceless(state._meta) && state.workingDirectories === undefined) {
+            throw ( new Error(( localize(
+                5559,
+                "The target session's working directories are unavailable. Open the session before sending a remote message."
+            ))));
+        }
+        const folders = await raceCancellationError(resolveAgentHostSessionTrustFolders(
+            state,
+            this.workspaceTrustService,
+            resource => target.host.connection.resourceUris.fromAgentHost(resource)
+        ), token);
+        if (folders === undefined) {
+            return;
+        }
+        const trusted = folders.length === 0 ? this.workspaceTrustService.isWorkspaceTrusted() : (await raceCancellationError(
+            Promise.all(folders.map(folder => this.workspaceTrustService.getUriTrustInfo(folder))),
+            token
+        )).every(info => info.trusted);
+        if (!trusted) {
+            throw ( new Error(( localize(
+                5560,
+                "The target session's workspace is not trusted. Trust it before sending a remote message."
+            ))));
+        }
+    }
+    async doSend(source, target, options, token) {
+        const store = ( new DisposableStore());
+        let dispatched = false;
+        let rejected = false;
+        let confirmed = false;
+        let started = false;
+        let operationError;
+        let background;
+        try {
+            const cancellation = store.add(( new CancellationTokenSource(token)));
+            store.add(disposableTimeout(() => {
+                operationError = ( new Error(dispatched ? ( localize(5561, "Timed out waiting for remote message acknowledgement.")) : ( localize(5562, "Timed out preparing the remote message."))));
+                cancellation.cancel();
+            }, 10_000));
+            const checkConnections = () => {
+                try {
+                    this.checkConnected(source);
+                    this.checkConnected(target);
+                } catch (error) {
+                    operationError = error instanceof Error ? error : ( new Error(toErrorMessage(error)));
+                    cancellation.cancel();
+                }
+            };
+            store.add(this.connectionsService.onDidChangeConnections(checkConnections));
+            checkConnections();
+            const connection = target.host.connection;
+            const session = store.add(connection.getSubscription(
+                StateComponents.Session,
+                target.host.backendSession,
+                "RemoteSessionMessageRouter"
+            ));
+            const sessionState = await readRemoteSessionState(session.object, cancellation.token, true);
+            const chatResource = getSessionChatResource(sessionState, target.chat.fragment || DEFAULT_CHAT_ID);
+            const identity = chatResource ? parseChatUri(chatResource) : undefined;
+            if (!chatResource || !identity || !isEqual(( URI.parse(identity.session)), target.host.backendSession)) {
+                throw ( new Error(( localize(5563, "The exact target chat no longer exists on its agent host."))));
+            }
+            const chat = store.add(connection.getSubscription(StateComponents.Chat, ( URI.parse(chatResource)), "RemoteSessionMessageRouter"));
+            const chatState = await readRemoteSessionState(chat.object, cancellation.token, true);
+            if (!isEqual(( URI.parse(chatState.resource)), ( URI.parse(chatResource)))) {
+                throw ( new Error(( localize(5564, "The target chat identity changed while preparing the message."))));
+            }
+            if (effectiveChatInteractivity(chatState.interactivity, isSessionStatusArchived(sessionState.status)) !== ChatInteractivity$1.Full) {
+                throw ( new Error(( localize(5557, "The target chat is archived or read-only."))));
+            }
+            await this.checkTargetTrust(target, sessionState, cancellation.token);
+            background = await this.backgroundChats.acquire(target.chat, cancellation.token, true);
+            await this.checkTargetTrust(
+                target,
+                await readRemoteSessionState(session.object, cancellation.token, true),
+                cancellation.token
+            );
+            this.checkEnabled();
+            this.checkConnected(source);
+            this.checkConnected(target);
+            if (cancellation.token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            const messageId = generateUuid();
+            const accepted = ( new Promise((resolve, reject) => {
+                store.add(connection.onDidAction(envelope => {
+                    if (!isEqual(( URI.parse(envelope.channel)), ( URI.parse(chatResource)))) {
+                        return;
+                    }
+                    const action = envelope.action;
+                    if (action.type === ActionType.ChatTurnStarted && action.queuedMessageId === messageId) {
+                        started = !envelope.rejectionReason;
+                    }
+                    if (action.type === ActionType.ChatPendingMessageSet && action.id === messageId) {
+                        if (envelope.rejectionReason) {
+                            rejected = true;
+                            reject(( new Error(envelope.rejectionReason)));
+                        } else {
+                            confirmed = true;
+                            resolve();
+                        }
+                    }
+                }));
+            }));
+            dispatched = true;
+            connection.dispatch(chatResource, {
+                type: ActionType.ChatPendingMessageSet,
+                kind: PendingMessageKind.Queued,
+                id: messageId,
+                message: {
+                    text: options.message,
+                    origin: {
+                        kind: MessageKind.Agent
+                    },
+                    _meta: toRemoteSessionMessageMetadata({
+                        session: ( source.session.resource.toString()),
+                        chat: ( source.chat.toString())
+                    })
+                }
+            });
+            await raceCancellationError(accepted, cancellation.token);
+        } catch (error) {
+            if (!confirmed && dispatched && !rejected) {
+                throw ( new Error(( localize(
+                    5565,
+                    "Remote message delivery was not confirmed. It may already be queued; do not retry automatically. {0}",
+                    toErrorMessage(operationError ?? error)
+                ))));
+            }
+            if (!confirmed) {
+                throw operationError ?? error;
+            }
+        } finally {
+            if (confirmed || (dispatched && !rejected)) {
+                background?.releaseWhenIdle();
+            } else {
+                background?.dispose();
+            }
+            store.dispose();
+        }
+        return {
+            ...this.describeTarget(target),
+            status: started ? "sent" : "queued"
+        };
+    }
+};
+RemoteSessionMessageRouter = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, ISessionsProvidersService)), ( __param(2, IAgentHostConnectionsService)), ( __param(3, IConfigurationService)), ( __param(4, IRemoteSessionChatService)), ( __param(5, IWorkspaceTrustManagementService))], RemoteSessionMessageRouter));
+
+export { RemoteSessionMessageRouter, maxRemoteMessageLength, parseSendRemoteMessageOptions };

package/vscode/src/vs/sessions/contrib/remoteSessions/browser/remoteSessionService.d.ts

@@ -0,0 +1,41 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentHostConnectionsService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.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 { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ICreatedRemoteSession, ICreateRemoteSessionOptions, IRemoteSessionHost } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/common/remoteSessions";
+import { IRemoteSessionService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/common/remoteSessions.service";
+import { IRemoteSessionChatService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/browser/remoteSessionChatService.service";
+export declare class RemoteSessionService implements IRemoteSessionService {
+    private readonly providersService;
+    private readonly sessionsService;
+    private readonly connectionsService;
+    private readonly configurationService;
+    private readonly fileService;
+    private readonly workspaceTrustService;
+    private readonly logService;
+    private readonly backgroundChats;
+    private readonly languageModelsService;
+    private readonly chatSessionsService;
+    readonly _serviceBrand: undefined;
+    private readonly pendingCreations;
+    private readonly lastSelected;
+    private readonly requests;
+    private selectionSequence;
+    constructor(providersService: ISessionsProvidersService, sessionsService: ISessionsManagementService, connectionsService: IAgentHostConnectionsService, configurationService: IConfigurationService, fileService: IFileService, workspaceTrustService: IWorkspaceTrustManagementService, logService: ILogService, backgroundChats: IRemoteSessionChatService, languageModelsService: ILanguageModelsService, chatSessionsService: IChatSessionsService);
+    listHosts(): readonly IRemoteSessionHost[];
+    createSession(options: ICreateRemoteSessionOptions, source: URI, requestId: string, token: CancellationToken): Promise<ICreatedRemoteSession>;
+    private checkEnabled;
+    private remoteProviders;
+    private describeHost;
+    private getCandidate;
+    private assertTargetConnection;
+    private candidates;
+    private doCreateSession;
+}