@codingame/monaco-vscode-chat-service-override 32.0.2 → 33.0.4

package/vscode/src/vs/platform/agentHost/browser/remoteAgentHostServiceImpl.js

@@ -9,19 +9,29 @@ import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/plat
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { AgentHostAhpJsonlLoggingSettingId } from '../common/agentService.js';
-import { RemoteAgentHostsSettingId, RemoteAgentHostsEnabledSettingId, RemoteAgentHostEntryType, getEntryAddress, RemoteAgentHostConnectionStatus, rawEntryToEntry, entryToRawEntry } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
-import { RemoteAgentHostProtocolClient } from './remoteAgentHostProtocolClient.js';
+import { RemoteAgentHostsSettingId, RemoteAgentHostsEnabledSettingId, RemoteAgentHostEntryType, getEntryAddress, RemoteAgentHostConnectionStatus, entryToRawEntry, rawEntryToEntry } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { RemoteAgentHostProtocolClient, AgentHostClientState } from './remoteAgentHostProtocolClient.js';
 import { WebSocketClientTransport } from './webSocketClientTransport.js';
 import { normalizeRemoteAgentHostAddress, AGENT_HOST_LABEL_FORMATTER, agentHostAuthority, AGENT_HOST_SCHEME } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { PROTOCOL_VERSION } from '../common/state/protocol/version/registry.js';
 
 var RemoteAgentHostService_1;
+const SSH_REMOTE_AGENT_HOSTS_STORAGE_KEY = "remoteAgentHost.sshConnections";
 function disposeEntry(entry) {
     entry.store.dispose();
     entry.transportDisposable?.dispose();
 }
+function isRawRemoteAgentHostEntry(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.address === "string" && typeof candidate.name === "string" && (candidate.connectionToken === undefined || typeof candidate.connectionToken === "string") && (candidate.sshConfigHost === undefined || typeof candidate.sshConfigHost === "string") && (candidate.sshHostName === undefined || typeof candidate.sshHostName === "string") && (candidate.sshUser === undefined || typeof candidate.sshUser === "string") && (candidate.sshPort === undefined || typeof candidate.sshPort === "number");
+}
 let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
     static {
         RemoteAgentHostService_1 = this;
@@ -35,12 +45,16 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
     static {
         this.ReconnectMaxDelay = 30000;
     }
+    static {
+        this.UpgradeRequestTimeout = 5 * 60 * 1000;
+    }
     constructor(
         _configurationService,
         _instantiationService,
         _logService,
         _labelService,
-        _environmentService
+        _environmentService,
+        _storageService
     ) {
         super();
         this._configurationService = _configurationService;
@@ -48,6 +62,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         this._logService = _logService;
         this._labelService = _labelService;
         this._environmentService = _environmentService;
+        this._storageService = _storageService;
         this._onDidChangeConnections = this._register(( new Emitter()));
         this.onDidChangeConnections = this._onDidChangeConnections.event;
         this._entries = ( new Map());
@@ -63,6 +78,13 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
                 this._reconcileConnections();
             }
         }));
+        this._register(
+            this._storageService.onDidChangeValue(StorageScope.APPLICATION, SSH_REMOTE_AGENT_HOSTS_STORAGE_KEY, this._store)(() => {
+                this._reconcileConnections();
+                this._onDidChangeConnections.fire();
+            })
+        );
+        this._migrateSSHEntriesFromSetting();
         this._reconcileConnections();
     }
     get connections() {
@@ -105,6 +127,23 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         }
         return this.configuredEntries.find(e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === normalized);
     }
+    async triggerServerUpgrade(address, method) {
+        const normalized = normalizeRemoteAgentHostAddress(address);
+        const entry = this._entries.get(normalized);
+        if (!entry) {
+            throw ( new Error(`No remote agent host entry found for ${address}.`));
+        }
+        const result = await raceTimeout(
+            entry.client.triggerVscodeUpgrade(method),
+            RemoteAgentHostService_1.UpgradeRequestTimeout
+        );
+        if (result === undefined) {
+            throw ( new Error(
+                `Server upgrade request timed out after ${RemoteAgentHostService_1.UpgradeRequestTimeout}ms.`
+            ));
+        }
+        return result;
+    }
     reconnect(address) {
         const normalized = normalizeRemoteAgentHostAddress(address);
         const configuredEntry = this._getConfiguredEntries().find(e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === normalized);
@@ -163,6 +202,9 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         return connection;
     }
     async addManagedConnection(entry, connection, transportDisposable) {
+        if (!this._configurationService.getValue(RemoteAgentHostsEnabledSettingId)) {
+            throw ( new Error("Remote agent host connections are not enabled."));
+        }
         const address = getEntryAddress(entry);
         const existingEntry = this._entries.get(address);
         if (existingEntry) {
@@ -240,8 +282,8 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             }
             return;
         }
-        const rawEntries = ( (this._configurationService.getValue(RemoteAgentHostsSettingId) ?? []).map(rawEntryToEntry)).filter(isDefined);
-        const entriesWithAddress = ( rawEntries.map(e => ({
+        const configuredEntries = this._getConfiguredEntries();
+        const entriesWithAddress = ( configuredEntries.map(e => ({
             entry: e,
             address: normalizeRemoteAgentHostAddress(getEntryAddress(e))
         })));
@@ -290,6 +332,9 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         }
     }
     _connectTo(address, connectionToken) {
+        if (!this._configurationService.getValue(RemoteAgentHostsEnabledSettingId)) {
+            return;
+        }
         const existingEntry = this._entries.get(address);
         if (existingEntry) {
             this._entries.delete(address);
@@ -297,15 +342,13 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         }
         const store = ( new DisposableStore());
         const ahpLoggingEnabled = !!this._configurationService.getValue(AgentHostAhpJsonlLoggingSettingId);
-        const transport = store.add(
-            this._instantiationService.createInstance(WebSocketClientTransport, address, connectionToken, ahpLoggingEnabled ? {
-                logsHome: this._environmentService.logsHome,
-                connectionId: address,
-                transport: "websocket"
-            } : undefined)
-        );
+        const transportFactory = () => this._instantiationService.createInstance(WebSocketClientTransport, address, connectionToken, ahpLoggingEnabled ? {
+            logsHome: this._environmentService.logsHome,
+            connectionId: address,
+            transport: "websocket"
+        } : undefined);
         const client = store.add(
-            this._instantiationService.createInstance(RemoteAgentHostProtocolClient, address, transport)
+            this._instantiationService.createInstance(RemoteAgentHostProtocolClient, address, transportFactory, undefined)
         );
         const entry = {
             store,
@@ -325,6 +368,23 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             this._onDidChangeConnections.fire();
             this._scheduleReconnect(address, connectionToken);
         }));
+        store.add(client.onDidChangeConnectionState(state => {
+            if (!isCurrentEntry()) {
+                return;
+            }
+            switch (state) {
+            case AgentHostClientState.Reconnecting:
+                entry.connected = false;
+                entry.status = RemoteAgentHostConnectionStatus.connecting;
+                this._onDidChangeConnections.fire();
+                break;
+            case AgentHostClientState.Connected:
+                entry.connected = true;
+                entry.status = RemoteAgentHostConnectionStatus.connected;
+                this._onDidChangeConnections.fire();
+                break;
+            }
+        }));
         this._logService.info(`[RemoteAgentHost] Connecting to ${address}`);
         this._onDidChangeConnections.fire();
         client.connect().then(() => {
@@ -404,24 +464,10 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         );
     }
     _getConfiguredEntries() {
-        return ( (this._configurationService.getValue(RemoteAgentHostsSettingId) ?? []).map(rawEntryToEntry)).filter(isDefined);
+        return this._mergeConfiguredEntries(this._getConfiguredSettingEntries(), this._getStoredSSHEntries());
     }
     _upsertConfiguredEntry(entry) {
-        const target = this._getConfigurationTarget();
-        const inspected = this._configurationService.inspect(RemoteAgentHostsSettingId);
-        let configuredRaw;
-        switch (target) {
-        case ConfigurationTarget.USER_LOCAL:
-            configuredRaw = inspected.userLocalValue ?? [];
-            break;
-        case ConfigurationTarget.USER_REMOTE:
-            configuredRaw = inspected.userRemoteValue ?? [];
-            break;
-        default:
-            configuredRaw = inspected.userValue ?? [];
-            break;
-        }
-        const configuredEntries = ( configuredRaw.map(rawEntryToEntry)).filter(e => e !== undefined);
+        const configuredEntries = this._mergeConfiguredEntries(this._getConfiguredSettingEntriesForTarget(), this._getStoredSSHEntries());
         const normalizedAddress = normalizeRemoteAgentHostAddress(getEntryAddress(entry));
         const existingIndex = configuredEntries.findIndex(
             e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === normalizedAddress
@@ -445,9 +491,92 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         return ConfigurationTarget.USER;
     }
     async _storeConfiguredEntries(entries) {
-        const raw = ( entries.map(entryToRawEntry)).filter(isDefined);
+        this._storeStoredSSHEntries(
+            entries.filter(entry => entry.connection.type === RemoteAgentHostEntryType.SSH)
+        );
+        const raw = ( entries.filter(entry => entry.connection.type !== RemoteAgentHostEntryType.SSH).map(entryToRawEntry)).filter(isDefined);
         await this._configurationService.updateValue(RemoteAgentHostsSettingId, raw, this._getConfigurationTarget());
     }
+    _getConfiguredSettingEntries() {
+        return ( (this._configurationService.getValue(RemoteAgentHostsSettingId) ?? []).map(rawEntryToEntry)).filter(isDefined);
+    }
+    _getConfiguredSettingEntriesForTarget() {
+        return ( this._getConfiguredRawEntriesForTarget().map(rawEntryToEntry)).filter(isDefined);
+    }
+    _getConfiguredRawEntriesForTarget() {
+        const target = this._getConfigurationTarget();
+        const inspected = this._configurationService.inspect(RemoteAgentHostsSettingId);
+        switch (target) {
+        case ConfigurationTarget.USER_LOCAL:
+            return inspected.userLocalValue ?? [];
+        case ConfigurationTarget.USER_REMOTE:
+            return inspected.userRemoteValue ?? [];
+        default:
+            return inspected.userValue ?? [];
+        }
+    }
+    _getStoredSSHEntries() {
+        const raw = this._storageService.get(SSH_REMOTE_AGENT_HOSTS_STORAGE_KEY, StorageScope.APPLICATION);
+        if (!raw) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed)) {
+                return [];
+            }
+            return ( parsed.map(
+                item => isRawRemoteAgentHostEntry(item) ? rawEntryToEntry(item) : undefined
+            )).filter(entry => entry?.connection.type === RemoteAgentHostEntryType.SSH);
+        } catch {
+            return [];
+        }
+    }
+    _storeStoredSSHEntries(entries) {
+        const raw = ( entries.filter(entry => entry.connection.type === RemoteAgentHostEntryType.SSH).map(entryToRawEntry)).filter(isDefined);
+        if (raw.length === 0) {
+            this._storageService.remove(SSH_REMOTE_AGENT_HOSTS_STORAGE_KEY, StorageScope.APPLICATION);
+        } else {
+            this._storageService.store(
+                SSH_REMOTE_AGENT_HOSTS_STORAGE_KEY,
+                JSON.stringify(raw),
+                StorageScope.APPLICATION,
+                StorageTarget.USER
+            );
+        }
+    }
+    _migrateSSHEntriesFromSetting() {
+        const configuredEntries = this._getConfiguredSettingEntriesForTarget();
+        const sshEntries = configuredEntries.filter(entry => entry.connection.type === RemoteAgentHostEntryType.SSH);
+        if (sshEntries.length === 0) {
+            return;
+        }
+        const migratedEntries = this._mergeConfiguredEntries(this._getStoredSSHEntries(), sshEntries);
+        this._storeStoredSSHEntries(migratedEntries);
+        const nonSSHEntries = configuredEntries.filter(entry => entry.connection.type !== RemoteAgentHostEntryType.SSH);
+        const raw = ( nonSSHEntries.map(entryToRawEntry)).filter(isDefined);
+        this._configurationService.updateValue(RemoteAgentHostsSettingId, raw, this._getConfigurationTarget()).catch(err => {
+            this._logService.error(
+                "[RemoteAgentHost] Failed to migrate SSH connection details from settings to storage",
+                err
+            );
+        });
+    }
+    _mergeConfiguredEntries(base, incoming) {
+        let result = base;
+        for (const entry of incoming) {
+            const normalizedAddress = normalizeRemoteAgentHostAddress(getEntryAddress(entry));
+            const existingIndex = result.findIndex(
+                e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === normalizedAddress
+            );
+            if (existingIndex === -1) {
+                result = [...result, entry];
+            } else {
+                result = ( result.map((e, index) => index === existingIndex ? entry : e));
+            }
+        }
+        return result;
+    }
     _getOrCreateConnectionWait(address) {
         let wait = this._pendingConnectionWaits.get(address);
         if (wait) {
@@ -521,6 +650,6 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         super.dispose();
     }
 };
-RemoteAgentHostService = RemoteAgentHostService_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IInstantiationService)), ( __param(2, ILogService)), ( __param(3, ILabelService)), ( __param(4, IEnvironmentService))], RemoteAgentHostService));
+RemoteAgentHostService = RemoteAgentHostService_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IInstantiationService)), ( __param(2, ILogService)), ( __param(3, ILabelService)), ( __param(4, IEnvironmentService)), ( __param(5, IStorageService))], RemoteAgentHostService));
 
 export { RemoteAgentHostService };

package/vscode/src/vs/platform/agentHost/common/agentHostFileSystemService.d.ts

@@ -0,0 +1,8 @@
+export type { IRemoteFilesystemConnection } from "./agentHostFileSystemProvider.js";
+/**
+ * Scheme used for the in-memory plugin filesystem backing synced customizations.
+ *
+ * URIs under this scheme are served by a registered {@link InMemoryFileSystemProvider}
+ * and are reachable by the agent host via `fetchContent`.
+ */
+export declare const SYNCED_CUSTOMIZATION_SCHEME = "vscode-synced-customization";

package/vscode/src/vs/platform/agentHost/common/agentHostFileSystemService.js

@@ -0,0 +1,19 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands';
+
+const SYNCED_CUSTOMIZATION_SCHEME = "vscode-synced-customization";
+
+export { SYNCED_CUSTOMIZATION_SCHEME };

package/vscode/src/vs/platform/agentHost/common/agentHostSchema.d.ts

@@ -0,0 +1,134 @@
+import { TelemetryConfiguration, TelemetryLevel } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry";
+import type { SessionConfigPropertySchema, SessionConfigSchema } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+/**
+ * A schema property with a phantom TypeScript type and a precomputed
+ * runtime validator.
+ *
+ * The `<T>` type parameter is the developer's assertion about the
+ * property's runtime shape; the validator derived from `protocol`
+ * (`type`, `enum`, `items`, `properties`, `required`) enforces it at
+ * runtime.
+ */
+export interface ISchemaProperty<T> {
+    readonly protocol: SessionConfigPropertySchema;
+    /**
+     * Returns `true` iff `value` conforms to {@link protocol}. Narrows
+     * the type to `T` for callers. The boolean form is preferred for
+     * control flow; use {@link assertValid} when you want a descriptive
+     * error for the offending path.
+     */
+    validate(value: unknown): value is T;
+    /**
+     * Throws a {@link ProtocolError} with `JsonRpcErrorCodes.InvalidParams`
+     * describing the offending path (e.g. `'permissions.allow[2]'`) when
+     * `value` does not conform to {@link protocol}. Otherwise returns and
+     * narrows the type to `T`.
+     *
+     * @param path Dotted path prefix to embed in error messages. Defaults
+     * to empty (the value itself).
+     */
+    assertValid(value: unknown, path?: string): asserts value is T;
+}
+/**
+ * Defines a strongly-typed schema property whose runtime validator is
+ * derived from the supplied JSON-schema descriptor.
+ */
+export declare function schemaProperty<T>(protocol: SessionConfigPropertySchema): ISchemaProperty<T>;
+export type SchemaDefinition = Record<string, ISchemaProperty<any>>;
+export type SchemaValue<P> = P extends ISchemaProperty<infer T> ? T : never;
+export type SchemaValues<D extends SchemaDefinition> = {
+    [K in keyof D]?: SchemaValue<D[K]>;
+};
+/**
+ * A bundle of named schema properties plus helpers for serializing to the
+ * protocol shape, validating a values bag at write sites, and validating
+ * a single key at read sites.
+ */
+export interface ISchema<D extends SchemaDefinition> {
+    readonly definition: D;
+    /** Returns the protocol-serializable schema for this bundle. */
+    toProtocol(): SessionConfigSchema;
+    /**
+     * Validates each known key in `values` against its schema and returns
+     * a new plain record. Throws a {@link ProtocolError} with a path like
+     * `'permissions.allow[2]'` when any supplied value fails validation.
+     * Unknown keys are passed through untouched for forward-compatibility.
+     */
+    values(values: SchemaValues<D>): Record<string, unknown>;
+    /**
+     * Returns `true` iff `value` validates against the schema for `key`.
+     * Unknown keys return `false`.
+     */
+    validate<K extends keyof D & string>(key: K, value: unknown): value is SchemaValue<D[K]>;
+    /**
+     * Throws a {@link ProtocolError} describing the offending path when
+     * `value` does not validate against the schema for `key`, or when
+     * `key` is not defined in the schema.
+     */
+    assertValid<K extends keyof D & string>(key: K, value: unknown): asserts value is SchemaValue<D[K]>;
+    /**
+     * Returns a fully-typed values bag by validating each key of the
+     * schema against `values` and falling back to the default when
+     * the incoming value is missing or fails validation.
+     *
+     * Semantics: for every key declared in the schema `definition`:
+     * - if `values[key]` validates, it is kept;
+     * - else if `key` is present in `defaults`, the default is used;
+     * - else the key is omitted from the result.
+     *
+     * This means callers MAY supply defaults for only a subset of the
+     * schema — keys not present in `defaults` are simply left unset
+     * when the incoming value is missing or invalid. This is useful
+     * when some properties (e.g. per-session `permissions`) should be
+     * inherited from a higher scope rather than materialized on every
+     * new session.
+     *
+     * Intended for sanitizing untrusted input at protocol boundaries
+     * (e.g. `resolveSessionConfig`). Keys that fail validation are
+     * silently replaced with their default or dropped; use
+     * {@link values} or {@link assertValid} when you want a descriptive
+     * {@link ProtocolError} instead.
+     */
+    validateOrDefault<T extends Partial<{
+        [K in keyof D]: SchemaValue<D[K]>;
+    }>>(values: {
+        [K in keyof T]?: unknown;
+    } | undefined, defaults: T): T;
+}
+export declare function createSchema<D extends SchemaDefinition>(definition: D): ISchema<D>;
+export type AutoApproveLevel = "default" | "autoApprove" | "autopilot";
+export type SessionMode = "interactive" | "plan";
+export interface IPermissionsValue {
+    readonly allow: readonly string[];
+    readonly deny: readonly string[];
+}
+/**
+ * Session-config properties owned by the platform itself — i.e. consumed
+ * by the agent host rather than by any particular agent.
+ *
+ * Agents extend this schema by spreading `platformSessionSchema.definition`
+ * into their own {@link createSchema} call together with any
+ * provider-specific properties.
+ */
+export declare const platformSessionSchema: ISchema<{
+    autoApprove: ISchemaProperty<AutoApproveLevel>;
+    permissions: ISchemaProperty<IPermissionsValue>;
+    mode: ISchemaProperty<SessionMode>;
+}>;
+/**
+ * Root (agent host) config properties owned by the platform itself.
+ *
+ * Root config acts as the baseline that applies to every session:
+ *
+ * - {@link SessionConfigKey.Permissions} — host-wide allow/deny lists
+ *   unioned with each session's own permissions when evaluating tool
+ *   auto-approval. See `SessionPermissionManager` for the evaluation
+ *   rules.
+ */
+export declare const AgentHostTelemetryLevelConfigKey = "telemetryLevel";
+export declare function telemetryLevelToAgentHostConfigValue(telemetryLevel: TelemetryLevel): TelemetryConfiguration;
+export declare function agentHostConfigValueToTelemetryLevel(value: unknown): TelemetryLevel | undefined;
+export declare const platformRootSchema: ISchema<{
+    permissions: ISchemaProperty<IPermissionsValue>;
+    telemetryLevel: ISchemaProperty<TelemetryConfiguration>;
+}>;