@codingame/monaco-vscode-chat-service-override 33.0.9 → 34.0.1

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.js

@@ -0,0 +1,349 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { OS, OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { arch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/process';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.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 { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { SANDBOX_HELPER_CHANNEL_NAME, SandboxHelperChannelClient } from '../../../../../platform/sandbox/common/sandboxHelperIpc.js';
+import { ISandboxHelperService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService.service';
+import { TerminalSandboxEngine } from '../../../../../platform/sandbox/common/terminalSandboxEngine.js';
+import { SANDBOX_SETTING_KEYS, readSandboxSetting } from './sandboxSettingsReader.js';
+export { TerminalSandboxPrerequisiteCheck } from '../../../../../platform/sandbox/common/terminalSandboxService.js';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { ChatModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
+import { ChatElicitationRequestPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatElicitationRequestPart';
+import { ElicitationState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { WillShutdownJoinerOrder } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+
+const SANDBOX_TEMP_DIR_NAME = "tmp";
+function affectsSandboxSettings(e) {
+    return ( SANDBOX_SETTING_KEYS.some(key => e.affectsConfiguration(key)));
+}
+let TerminalSandboxService = class TerminalSandboxService extends Disposable {
+    constructor(
+        _configurationService,
+        fileService,
+        _environmentService,
+        _logService,
+        _remoteAgentService,
+        _workspaceContextService,
+        _productService,
+        lifecycleService,
+        _sandboxHelperService,
+        _chatService,
+        instantiationService
+    ) {
+        super();
+        this._configurationService = _configurationService;
+        this._environmentService = _environmentService;
+        this._logService = _logService;
+        this._remoteAgentService = _remoteAgentService;
+        this._workspaceContextService = _workspaceContextService;
+        this._productService = _productService;
+        this._sandboxHelperService = _sandboxHelperService;
+        this._chatService = _chatService;
+        this._onDidChangeRoots = this._register(( new Emitter()));
+        this._remoteEnvDetailsPromise = this._remoteAgentService.getEnvironment();
+        const onDidChangeSandboxSettings = Event.filter(
+            this._configurationService.onDidChangeConfiguration,
+            affectsSandboxSettings
+        );
+        const host = {
+            getOS: () => this._resolveOS(),
+            getRuntimeInfo: () => this._resolveRuntimeInfo(),
+            getUserHome: () => this._resolveUserHome(),
+            getSandboxTempDir: () => this._resolveSandboxTempDir(),
+            getWorkspaceStorageReadRoot: () => this._resolveWorkspaceStorageReadRoot(),
+            getWriteRoots: () => ( this._workspaceContextService.getWorkspace().folders.map(folder => folder.uri)),
+            onDidChangeRoots: this._onDidChangeRoots.event,
+            checkSandboxDependencies: () => this._resolveSandboxDependencyStatus(),
+            getWindowsMxcFilesystemPolicy: () => this._resolveWindowsMxcFilesystemPolicy(),
+            getWindowsMxcEnvironment: () => this._resolveWindowsMxcEnvironment(),
+            buildWindowsMxcSandboxPayload: (commandLine, policy, workingDirectory, containerName, containment) => this._resolveWindowsMxcSandboxPayload(commandLine, policy, workingDirectory, containerName, containment),
+            getSandboxSetting: settingId => this._readSandboxSetting(settingId),
+            onDidChangeSandboxSettings: ( Event.map(onDidChangeSandboxSettings, () => undefined))
+        };
+        this._engine = this._register(instantiationService.createInstance(TerminalSandboxEngine, host));
+        this._register(
+            this._workspaceContextService.onDidChangeWorkspaceFolders(() => this._onDidChangeRoots.fire())
+        );
+        this._register(lifecycleService.onWillShutdown(e => {
+            if (!this._engine.getTempDir()) {
+                return;
+            }
+            e.join(this._engine.cleanupTempDir(), {
+                id: "join.deleteFilesInSandboxTempDir",
+                label: ( localize(14859, "Delete Files in Sandbox Temp Dir")),
+                order: WillShutdownJoinerOrder.Default
+            });
+        }));
+    }
+    isEnabled(precheckInputs) {
+        return this._engine.isEnabled(precheckInputs);
+    }
+    isSandboxAllowNetworkEnabled(precheckInputs) {
+        return this._engine.isSandboxAllowNetworkEnabled(precheckInputs);
+    }
+    getOS() {
+        return this._engine.getOS();
+    }
+    wrapCommand(
+        command,
+        requestUnsandboxedExecution,
+        shell,
+        cwd,
+        commandDetails,
+        requestAllowNetwork
+    ) {
+        return this._engine.wrapCommand(
+            command,
+            requestUnsandboxedExecution,
+            shell,
+            cwd,
+            commandDetails,
+            requestAllowNetwork
+        );
+    }
+    checkForSandboxingPrereqs(forceRefresh = false, precheckInputs) {
+        return this._engine.checkForSandboxingPrereqs(forceRefresh, precheckInputs);
+    }
+    getSandboxConfigPath(forceRefresh = false, precheckInputs) {
+        return this._engine.getSandboxConfigPath(forceRefresh, precheckInputs);
+    }
+    getTempDir() {
+        return this._engine.getTempDir();
+    }
+    setNeedsForceUpdateConfigFile() {
+        this._engine.setNeedsForceUpdateConfigFile();
+    }
+    getResolvedNetworkDomains() {
+        return this._engine.getResolvedNetworkDomains();
+    }
+    getMissingSandboxDependencies() {
+        return this._engine.getMissingSandboxDependencies();
+    }
+    async _resolveRemoteEnv() {
+        if (this._remoteEnvDetails === undefined) {
+            this._remoteEnvDetails = await this._remoteEnvDetailsPromise;
+        }
+        return this._remoteEnvDetails;
+    }
+    async _resolveOS() {
+        const remoteEnv = await this._resolveRemoteEnv();
+        return remoteEnv ? remoteEnv.os : OS;
+    }
+    _readSandboxSetting(settingId) {
+        return readSandboxSetting(this._configurationService, this._logService, settingId);
+    }
+    async _resolveRuntimeInfo() {
+        const remoteEnv = await this._resolveRemoteEnv();
+        if (remoteEnv) {
+            return {
+                appRoot: remoteEnv.os === OperatingSystem.Windows ? this._toWindowsPath(remoteEnv.appRoot) : remoteEnv.appRoot.path,
+                execPath: remoteEnv.execPath,
+                runAsNode: false,
+                arch: remoteEnv.arch
+            };
+        }
+        const localAppRootUri = ( FileAccess.asFileUri(""));
+        const localAppRoot = OS === OperatingSystem.Windows ? dirname(localAppRootUri.fsPath) : dirname(localAppRootUri.path);
+        const nativeEnv = this._environmentService;
+        return {
+            appRoot: localAppRoot,
+            execPath: nativeEnv.execPath,
+            runAsNode: true,
+            arch
+        };
+    }
+    _toWindowsPath(uri) {
+        let value;
+        if (uri.authority && uri.path.length > 1 && uri.scheme === "file") {
+            value = `\\\\${uri.authority}${uri.path}`;
+        } else if (/^\/[a-zA-Z]:/.test(uri.path)) {
+            value = uri.path.slice(1);
+        } else {
+            value = uri.fsPath;
+        }
+        return value.replace(/\//g, "\\");
+    }
+    async _resolveUserHome() {
+        const remoteEnv = await this._resolveRemoteEnv();
+        if (remoteEnv?.userHome) {
+            return remoteEnv.userHome;
+        }
+        const nativeEnv = this._environmentService;
+        return nativeEnv.userHome;
+    }
+    async _resolveSandboxTempDir() {
+        const remoteEnv = await this._resolveRemoteEnv();
+        const sandboxTempDirName = this._getSandboxWindowTempDirName();
+        if (remoteEnv?.userHome) {
+            const sandboxRoot = URI.joinPath(
+                remoteEnv.userHome,
+                this._productService.serverDataFolderName ?? this._productService.dataFolderName,
+                SANDBOX_TEMP_DIR_NAME
+            );
+            return sandboxTempDirName ? URI.joinPath(sandboxRoot, sandboxTempDirName) : sandboxRoot;
+        }
+        const nativeEnv = this._environmentService;
+        if (nativeEnv.userHome) {
+            const sandboxRoot = URI.joinPath(
+                nativeEnv.userHome,
+                this._productService.dataFolderName,
+                SANDBOX_TEMP_DIR_NAME
+            );
+            return sandboxTempDirName ? URI.joinPath(sandboxRoot, sandboxTempDirName) : sandboxRoot;
+        }
+        return undefined;
+    }
+    async _resolveWorkspaceStorageReadRoot() {
+        const remoteEnv = await this._resolveRemoteEnv();
+        const workspaceStorageHome = remoteEnv?.workspaceStorageHome ?? this._environmentService.workspaceStorageHome;
+        const workspaceId = this._workspaceContextService.getWorkspace().id;
+        return URI.joinPath(workspaceStorageHome, workspaceId);
+    }
+    _getSandboxWindowTempDirName() {
+        const workbenchEnv = this._environmentService;
+        const windowId = workbenchEnv.window?.id;
+        return typeof windowId === "number" ? `tmp_vscode_${windowId}` : undefined;
+    }
+    async _resolveSandboxDependencyStatus() {
+        const connection = this._remoteAgentService.getConnection();
+        if (connection) {
+            return connection.withChannel(SANDBOX_HELPER_CHANNEL_NAME, channel => {
+                const sandboxHelper = ( new SandboxHelperChannelClient(channel));
+                return sandboxHelper.checkSandboxDependencies();
+            });
+        }
+        return this._sandboxHelperService.checkSandboxDependencies();
+    }
+    async _resolveWindowsMxcFilesystemPolicy() {
+        const connection = this._remoteAgentService.getConnection();
+        if (connection) {
+            return connection.withChannel(SANDBOX_HELPER_CHANNEL_NAME, channel => {
+                const sandboxHelper = ( new SandboxHelperChannelClient(channel));
+                return sandboxHelper.getWindowsMxcFilesystemPolicy();
+            });
+        }
+        return this._sandboxHelperService.getWindowsMxcFilesystemPolicy();
+    }
+    async _resolveWindowsMxcEnvironment() {
+        const connection = this._remoteAgentService.getConnection();
+        if (connection) {
+            return connection.withChannel(SANDBOX_HELPER_CHANNEL_NAME, channel => {
+                const sandboxHelper = ( new SandboxHelperChannelClient(channel));
+                return sandboxHelper.getWindowsMxcEnvironment();
+            });
+        }
+        return this._sandboxHelperService.getWindowsMxcEnvironment();
+    }
+    async _resolveWindowsMxcSandboxPayload(commandLine, policy, workingDirectory, containerName, containment) {
+        const connection = this._remoteAgentService.getConnection();
+        if (connection) {
+            return connection.withChannel(SANDBOX_HELPER_CHANNEL_NAME, channel => {
+                const sandboxHelper = ( new SandboxHelperChannelClient(channel));
+                return sandboxHelper.buildWindowsMxcSandboxPayload(commandLine, policy, workingDirectory, containerName, containment);
+            });
+        }
+        return this._sandboxHelperService.buildWindowsMxcSandboxPayload(commandLine, policy, workingDirectory, containerName, containment);
+    }
+    async installMissingSandboxDependencies(missingDependencies, sessionResource, token, options) {
+        const depsList = missingDependencies.join(" ");
+        const installCommand = `sudo apt install -y ${depsList}`;
+        const instance = await options.createTerminal();
+        let installCommandSent = false;
+        const completionPromise = ( new Promise(resolve => {
+            const store = ( new DisposableStore());
+            let resolved = false;
+            const resolveOnce = code => {
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                store.dispose();
+                resolve(code);
+            };
+            const attachListener = () => {
+                const detection = instance.capabilities.get(TerminalCapability.CommandDetection);
+                if (detection) {
+                    store.add(detection.onCommandFinished(cmd => resolveOnce(cmd.exitCode)));
+                }
+            };
+            attachListener();
+            store.add(instance.capabilities.onDidAddCapability(e => {
+                if (e.id === TerminalCapability.CommandDetection) {
+                    attachListener();
+                }
+            }));
+            store.add(instance.onDisposed(() => resolveOnce(undefined)));
+            store.add(token.onCancellationRequested(() => resolveOnce(undefined)));
+            const safetyTimeout = timeout(5 * 60 * 1000);
+            store.add({
+                dispose: () => safetyTimeout.cancel()
+            });
+            safetyTimeout.then(() => resolveOnce(undefined));
+            const passwordPrompt = this._createMissingDependencyPasswordPrompt(sessionResource, {
+                focusTerminal: () => options.focusTerminal(instance),
+                onDidInputData: instance.onDidInputData,
+                onDisposed: instance.onDisposed,
+                didSendInstallCommand: () => installCommandSent
+            }, token);
+            store.add(passwordPrompt);
+        }));
+        await instance.sendText(installCommand, true);
+        installCommandSent = true;
+        return {
+            exitCode: await completionPromise
+        };
+    }
+    _createMissingDependencyPasswordPrompt(sessionResource, promptContext, token) {
+        const chatModel = sessionResource && this._chatService.getSession(sessionResource);
+        if (!(chatModel instanceof ChatModel)) {
+            return ( new DisposableStore());
+        }
+        const request = chatModel.getRequests().at(-1);
+        if (!request) {
+            return ( new DisposableStore());
+        }
+        const part = ( new ChatElicitationRequestPart(( localize(14860, "The terminal is awaiting input.")), ( new MarkdownString(( localize(
+            14861,
+            "Installing missing sandbox dependencies may prompt for your sudo password. Select Focus Terminal to type it in the terminal."
+        )))), "", ( localize(14862, "Focus Terminal")), undefined, async () => {
+            await promptContext.focusTerminal();
+            return ElicitationState.Pending;
+        }));
+        chatModel.acceptResponseProgress(request, part);
+        const store = ( new DisposableStore());
+        const disposePrompt = () => store.dispose();
+        store.add({
+            dispose: () => part.hide()
+        });
+        store.add(token.onCancellationRequested(disposePrompt));
+        store.add(promptContext.onDisposed(disposePrompt));
+        store.add(promptContext.onDidInputData(data => {
+            if (promptContext.didSendInstallCommand() && data.length > 0) {
+                disposePrompt();
+            }
+        }));
+        return store;
+    }
+};
+TerminalSandboxService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IFileService)), ( __param(2, IEnvironmentService)), ( __param(3, ILogService)), ( __param(4, IRemoteAgentService)), ( __param(5, IWorkspaceContextService)), ( __param(6, IProductService)), ( __param(7, ILifecycleService)), ( __param(8, ISandboxHelperService)), ( __param(9, IChatService)), ( __param(10, IInstantiationService))], TerminalSandboxService));
+
+export { TerminalSandboxService };

package/vscode/src/vs/workbench/services/agentHost/browser/editorRemoteAgentHostServiceClient.d.ts

@@ -0,0 +1,75 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IReference } 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 { 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 { IAgentCreateSessionConfig, IAgentHostInspectInfo, IAgentHostSocketInfo, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IAgentSessionMetadata, AuthenticateParams, AuthenticateResult } from "../../../../platform/agentHost/common/agentService.js";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import type { IActiveSubscriptionInfo, IAgentSubscription } from "../../../../platform/agentHost/common/state/agentSubscription.js";
+import type { CompletionsParams, CompletionsResult, CreateTerminalParams, ResolveSessionConfigResult, SessionConfigCompletionsResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import type { InvokeChangesetOperationParams, InvokeChangesetOperationResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/commands";
+import type { ActionEnvelope, INotification, IRootConfigChangedAction, SessionAction, TerminalAction } from "../../../../platform/agentHost/common/state/sessionActions.js";
+import type { IRemoteWatchHandle } from "../../../../platform/agentHost/common/agentHostFileSystemProvider.js";
+import type { CreateResourceWatchParams, CreateResourceWatchResult, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceListResult, ResourceMkdirParams, ResourceMkdirResult, ResourceMoveParams, ResourceMoveResult, ResourceReadResult, ResourceResolveParams, ResourceResolveResult, ResourceWriteParams, ResourceWriteResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
+import { ComponentToState, RootState, StateComponents } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+/**
+ * Connects the renderer to the agent host that the remote server has
+ * already started, by proxying AHP frames over the remote agent's IPC pipe.
+ *
+ * Local-only methods on {@link IAgentHostService} (`restartAgentHost`,
+ * `startWebSocketServer`, `getInspectInfo`) are stubbed — the lifecycle of
+ * the agent host is owned by whoever spawned it on the remote.
+ */
+export declare class EditorRemoteAgentHostServiceClient extends Disposable implements IAgentHostService {
+    private readonly _logService;
+    readonly _serviceBrand: undefined;
+    private readonly _onAgentHostExit;
+    readonly onAgentHostExit: Event<number>;
+    private readonly _onAgentHostStart;
+    readonly onAgentHostStart: Event<void>;
+    private readonly _authenticationPending;
+    readonly authenticationPending: IObservable<boolean>;
+    private _authenticationSettled;
+    private readonly _protocolClient;
+    private readonly _noopRootState;
+    private _connectStarted;
+    constructor(remoteAgentService: IRemoteAgentService, configurationService: IConfigurationService, instantiationService: IInstantiationService, _logService: ILogService);
+    private _connect;
+    private _requireClient;
+    setAuthenticationPending(pending: boolean): void;
+    restartAgentHost(): Promise<void>;
+    startWebSocketServer(): Promise<IAgentHostSocketInfo>;
+    getInspectInfo(_tryEnable: boolean): Promise<IAgentHostInspectInfo | undefined>;
+    get clientId(): string;
+    get rootState(): IAgentSubscription<RootState>;
+    get onDidNotification(): Event<INotification>;
+    get onDidAction(): Event<ActionEnvelope>;
+    getSubscription<T extends StateComponents>(kind: T, resource: URI, owner: string): IReference<IAgentSubscription<ComponentToState[T]>>;
+    getSubscriptionUnmanaged<T extends StateComponents>(kind: T, resource: URI): IAgentSubscription<ComponentToState[T]> | undefined;
+    getActiveSubscriptions(): readonly IActiveSubscriptionInfo[];
+    dispatch(channel: string, action: SessionAction | TerminalAction | IRootConfigChangedAction): void;
+    authenticate(params: AuthenticateParams): Promise<AuthenticateResult>;
+    listSessions(): Promise<IAgentSessionMetadata[]>;
+    createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
+    resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<ResolveSessionConfigResult>;
+    sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<SessionConfigCompletionsResult>;
+    completions(params: CompletionsParams): Promise<CompletionsResult>;
+    getCompletionTriggerCharacters(): Promise<readonly string[]>;
+    disposeSession(session: URI): Promise<void>;
+    createTerminal(params: CreateTerminalParams): Promise<void>;
+    disposeTerminal(terminal: URI): Promise<void>;
+    invokeChangesetOperation(params: InvokeChangesetOperationParams): Promise<InvokeChangesetOperationResult>;
+    resourceList(uri: URI): Promise<ResourceListResult>;
+    resourceRead(uri: URI): Promise<ResourceReadResult>;
+    resourceWrite(params: ResourceWriteParams): Promise<ResourceWriteResult>;
+    resourceCopy(params: ResourceCopyParams): Promise<ResourceCopyResult>;
+    resourceDelete(params: ResourceDeleteParams): Promise<ResourceDeleteResult>;
+    resourceMove(params: ResourceMoveParams): Promise<ResourceMoveResult>;
+    resourceResolve(params: ResourceResolveParams): Promise<ResourceResolveResult>;
+    resourceMkdir(params: ResourceMkdirParams): Promise<ResourceMkdirResult>;
+    createResourceWatch(params: CreateResourceWatchParams): Promise<CreateResourceWatchResult>;
+    watchResource(params: CreateResourceWatchParams): Promise<IRemoteWatchHandle>;
+}

package/vscode/src/vs/workbench/services/agentHost/browser/editorRemoteAgentHostServiceClient.js

@@ -0,0 +1,192 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+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 { isAgentHostEnabled, AgentHostEnabledSettingId, AgentHostIpcChannels } from '../../../../platform/agentHost/common/agentService.js';
+import { AgentHostIpcChannelTransport } from '../../../../platform/agentHost/browser/agentHostIpcChannelTransport.js';
+import { RemoteAgentHostProtocolClient } from '../../../../platform/agentHost/browser/remoteAgentHostProtocolClient.js';
+import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+const REMOTE_NOT_SUPPORTED = op => ( new Error(`${op} is not supported when the agent host runs on a remote.`));
+const LOG_PREFIX = "[AgentHost:remote]";
+let EditorRemoteAgentHostServiceClient = class EditorRemoteAgentHostServiceClient extends Disposable {
+    constructor(
+        remoteAgentService,
+        configurationService,
+        instantiationService,
+        _logService
+    ) {
+        super();
+        this._logService = _logService;
+        this._onAgentHostExit = this._register(( new Emitter()));
+        this.onAgentHostExit = this._onAgentHostExit.event;
+        this._onAgentHostStart = this._register(( new Emitter()));
+        this.onAgentHostStart = this._onAgentHostStart.event;
+        this._authenticationPending = observableValue("authenticationPending", true);
+        this.authenticationPending = this._authenticationPending;
+        this._authenticationSettled = false;
+        this._noopRootState = {
+            value: undefined,
+            verifiedValue: undefined,
+            onDidChange: Event.None,
+            onWillApplyAction: Event.None,
+            onDidApplyAction: Event.None
+        };
+        this._connectStarted = false;
+        const enabled = isAgentHostEnabled(configurationService);
+        const connection = remoteAgentService.getConnection();
+        this._logService.info(
+            `${LOG_PREFIX} Initializing (enabled=${enabled}, remoteAuthority=${connection?.remoteAuthority ?? "none"})`
+        );
+        if (!enabled) {
+            this._logService.info(
+                `${LOG_PREFIX} Disabled via "${AgentHostEnabledSettingId}" or web runtime. Not connecting.`
+            );
+            this.setAuthenticationPending(false);
+            return;
+        }
+        if (!connection) {
+            this._logService.warn(`${LOG_PREFIX} No remote agent connection available. Not connecting.`);
+            this.setAuthenticationPending(false);
+            return;
+        }
+        const channel = connection.getChannel(AgentHostIpcChannels.RemoteProxy);
+        const transport = ( new AgentHostIpcChannelTransport(channel));
+        const address = `vscode-remote://${connection.remoteAuthority}`;
+        this._protocolClient = this._register(
+            instantiationService.createInstance(RemoteAgentHostProtocolClient, address, transport, undefined)
+        );
+        this._register(this._protocolClient.onDidClose(() => {
+            this._logService.info(`${LOG_PREFIX} Protocol client closed`);
+            this._onAgentHostExit.fire(0);
+        }));
+        this._connect().catch(err => this._logService.warn(`${LOG_PREFIX} Connect failed`, err));
+    }
+    async _connect() {
+        if (this._connectStarted || !this._protocolClient) {
+            return;
+        }
+        this._connectStarted = true;
+        this._logService.info(`${LOG_PREFIX} Connecting to remote agent host...`);
+        await this._protocolClient.connect();
+        this._logService.info(`${LOG_PREFIX} Connected; clientId=${this._protocolClient.clientId}`);
+        this._onAgentHostStart.fire();
+    }
+    _requireClient() {
+        if (!this._protocolClient) {
+            throw ( new Error("Remote agent host is not enabled or no remote connection is available."));
+        }
+        return this._protocolClient;
+    }
+    setAuthenticationPending(pending) {
+        if (this._authenticationSettled) {
+            return;
+        }
+        if (!pending) {
+            this._authenticationSettled = true;
+        }
+        this._authenticationPending.set(pending, undefined);
+    }
+    async restartAgentHost() {}
+    async startWebSocketServer() {
+        throw REMOTE_NOT_SUPPORTED("startWebSocketServer");
+    }
+    async getInspectInfo(_tryEnable) {
+        return undefined;
+    }
+    get clientId() {
+        return this._protocolClient?.clientId ?? "";
+    }
+    get rootState() {
+        return this._protocolClient?.rootState ?? this._noopRootState;
+    }
+    get onDidNotification() {
+        return this._protocolClient?.onDidNotification ?? Event.None;
+    }
+    get onDidAction() {
+        return this._protocolClient?.onDidAction ?? Event.None;
+    }
+    getSubscription(kind, resource, owner) {
+        return this._requireClient().getSubscription(kind, resource, owner);
+    }
+    getSubscriptionUnmanaged(kind, resource) {
+        return this._protocolClient?.getSubscriptionUnmanaged(kind, resource);
+    }
+    getActiveSubscriptions() {
+        return this._protocolClient?.getActiveSubscriptions() ?? [];
+    }
+    dispatch(channel, action) {
+        this._protocolClient?.dispatch(channel, action);
+    }
+    authenticate(params) {
+        return this._requireClient().authenticate(params);
+    }
+    listSessions() {
+        return this._requireClient().listSessions();
+    }
+    createSession(config) {
+        return this._requireClient().createSession(config);
+    }
+    resolveSessionConfig(params) {
+        return this._requireClient().resolveSessionConfig(params);
+    }
+    sessionConfigCompletions(params) {
+        return this._requireClient().sessionConfigCompletions(params);
+    }
+    completions(params) {
+        return this._requireClient().completions(params);
+    }
+    getCompletionTriggerCharacters() {
+        return this._requireClient().getCompletionTriggerCharacters();
+    }
+    disposeSession(session) {
+        return this._requireClient().disposeSession(session);
+    }
+    createTerminal(params) {
+        return this._requireClient().createTerminal(params);
+    }
+    disposeTerminal(terminal) {
+        return this._requireClient().disposeTerminal(terminal);
+    }
+    invokeChangesetOperation(params) {
+        return this._requireClient().invokeChangesetOperation(params);
+    }
+    resourceList(uri) {
+        return this._requireClient().resourceList(uri);
+    }
+    resourceRead(uri) {
+        return this._requireClient().resourceRead(uri);
+    }
+    resourceWrite(params) {
+        return this._requireClient().resourceWrite(params);
+    }
+    resourceCopy(params) {
+        return this._requireClient().resourceCopy(params);
+    }
+    resourceDelete(params) {
+        return this._requireClient().resourceDelete(params);
+    }
+    resourceMove(params) {
+        return this._requireClient().resourceMove(params);
+    }
+    resourceResolve(params) {
+        return this._requireClient().resourceResolve(params);
+    }
+    resourceMkdir(params) {
+        return this._requireClient().resourceMkdir(params);
+    }
+    createResourceWatch(params) {
+        return this._requireClient().createResourceWatch(params);
+    }
+    watchResource(params) {
+        return this._requireClient().watchResource(params);
+    }
+};
+EditorRemoteAgentHostServiceClient = ( __decorate([( __param(0, IRemoteAgentService)), ( __param(1, IConfigurationService)), ( __param(2, IInstantiationService)), ( __param(3, ILogService))], EditorRemoteAgentHostServiceClient));
+
+export { EditorRemoteAgentHostServiceClient };