@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/services/agentHost/common/agentHostResourceService.js

@@ -4,16 +4,19 @@ import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/com
 import { decodeBase64, VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { extUri } 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 { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
-import { AgentHostPermissionMode, AgentHostAccessMode, AgentHostResourcePermissionError, LOCAL_AGENT_HOST_ADDRESS, AgentHostLocalFilePermissionsSettingId } from '../../../../platform/agentHost/common/agentHostResourceService.js';
+import { AgentHostAccessMode, LOCAL_AGENT_HOST_RESOURCE_IDENTITY, AgentHostPermissionMode, AgentHostResourcePermissionError, AgentHostLocalFilePermissionsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostResourceService';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { getGlobalConfigurationValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConfigurationSync';
 import { normalizeRemoteAgentHostAddress } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { ContentEncoding, ResourceType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/commands';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/commands';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/commands';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/commands';
 import { ROOT_STATE_URI } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
@@ -24,6 +27,18 @@ import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 
+function getGrantMode(grant) {
+    if (grant === AgentHostAccessMode.Read || grant === AgentHostAccessMode.ReadWrite) {
+        return grant;
+    }
+    if (typeof grant === "object" && grant !== null && (grant.mode === AgentHostAccessMode.Read || grant.mode === AgentHostAccessMode.ReadWrite)) {
+        return grant.mode;
+    }
+    return undefined;
+}
+function normalizeResourceIdentity(identity) {
+    return identity === LOCAL_AGENT_HOST_RESOURCE_IDENTITY ? identity : normalizeRemoteAgentHostAddress(identity);
+}
 let AgentHostResourceService = class AgentHostResourceService extends Disposable {
     constructor(_configurationService, _fileService, _textModelService, _logService) {
         super();
@@ -35,12 +50,22 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
         this._pending = observableValue("agentHostResources.pending", []);
         this.allPending = this._pending;
     }
-    async list(address, uri) {
-        await this._gate(address, uri, AgentHostPermissionMode.Read, {
-            channel: ROOT_STATE_URI,
-            uri: ( uri.toString()),
-            read: true
-        });
+    async list(identity, uri) {
+        const normalized = normalizeResourceIdentity(identity);
+        const canonical = await this._canonicalize(uri);
+        if (!(await this._isCovered(normalized, canonical, AgentHostPermissionMode.Read))) {
+            const entries = await this._getGrantedChildren(normalized, extUri.normalizePath(uri));
+            if (entries) {
+                return {
+                    entries
+                };
+            }
+            throw ( new AgentHostResourcePermissionError({
+                channel: ROOT_STATE_URI,
+                uri: ( uri.toString()),
+                read: true
+            }));
+        }
         const stat = await this._fileService.resolve(uri);
         if (!stat.isDirectory) {
             throw ( new Error(`Resource is not a directory: ${( uri.toString())}`));
@@ -52,8 +77,8 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
             })))
         };
     }
-    async read(address, uri) {
-        await this._gate(address, uri, AgentHostPermissionMode.Read, {
+    async read(identity, uri) {
+        await this._gate(identity, uri, AgentHostPermissionMode.Read, {
             channel: ROOT_STATE_URI,
             uri: ( uri.toString()),
             read: true
@@ -73,9 +98,9 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
             throw err;
         }
     }
-    async write(address, params) {
+    async write(identity, params) {
         const uri = ( URI.parse(params.uri));
-        await this._gate(address, uri, AgentHostPermissionMode.Write, {
+        await this._gate(identity, uri, AgentHostPermissionMode.Write, {
             channel: ROOT_STATE_URI,
             uri: ( uri.toString()),
             write: true
@@ -96,9 +121,9 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
             throw err;
         }
     }
-    async del(address, params) {
+    async del(identity, params) {
         const uri = ( URI.parse(params.uri));
-        await this._gate(address, uri, AgentHostPermissionMode.Write, {
+        await this._gate(identity, uri, AgentHostPermissionMode.Write, {
             channel: ROOT_STATE_URI,
             uri: ( uri.toString()),
             write: true
@@ -107,39 +132,39 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
             recursive: !!params.recursive
         });
     }
-    async move(address, params) {
+    async move(identity, params) {
         const source = ( URI.parse(params.source));
         const destination = ( URI.parse(params.destination));
-        await this._gate(address, source, AgentHostPermissionMode.Write, {
+        await this._gate(identity, source, AgentHostPermissionMode.Write, {
             channel: ROOT_STATE_URI,
             uri: ( source.toString()),
             write: true
         });
-        await this._gate(address, destination, AgentHostPermissionMode.Write, {
+        await this._gate(identity, destination, AgentHostPermissionMode.Write, {
             channel: ROOT_STATE_URI,
             uri: ( destination.toString()),
             write: true
         });
         await this._fileService.move(source, destination, !params.failIfExists);
     }
-    async copy(address, params) {
+    async copy(identity, params) {
         const source = ( URI.parse(params.source));
         const destination = ( URI.parse(params.destination));
-        await this._gate(address, source, AgentHostPermissionMode.Read, {
+        await this._gate(identity, source, AgentHostPermissionMode.Read, {
             channel: ROOT_STATE_URI,
             uri: ( source.toString()),
             read: true
         });
-        await this._gate(address, destination, AgentHostPermissionMode.Write, {
+        await this._gate(identity, destination, AgentHostPermissionMode.Write, {
             channel: ROOT_STATE_URI,
             uri: ( destination.toString()),
             write: true
         });
         await this._fileService.copy(source, destination, !params.failIfExists);
     }
-    async resolve(address, params) {
+    async resolve(identity, params) {
         const uri = ( URI.parse(params.uri));
-        await this._gate(address, uri, AgentHostPermissionMode.Read, {
+        await this._gate(identity, uri, AgentHostPermissionMode.Read, {
             channel: ROOT_STATE_URI,
             uri: ( uri.toString()),
             read: true
@@ -179,9 +204,9 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
             } : {})
         };
     }
-    async mkdir(address, params) {
+    async mkdir(identity, params) {
         const uri = ( URI.parse(params.uri));
-        await this._gate(address, uri, AgentHostPermissionMode.Write, {
+        await this._gate(identity, uri, AgentHostPermissionMode.Write, {
             channel: ROOT_STATE_URI,
             uri: ( uri.toString()),
             write: true
@@ -192,21 +217,25 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
         }
         await this._fileService.createFolder(uri);
     }
-    async check(address, uri, mode) {
-        const normalized = normalizeRemoteAgentHostAddress(address);
+    async check(identity, uri, mode) {
+        const normalized = normalizeResourceIdentity(identity);
         const canonical = await this._canonicalize(uri);
         return this._isCovered(normalized, canonical, mode);
     }
-    async request(address, params) {
-        const normalized = normalizeRemoteAgentHostAddress(address);
-        const canonical = await this._canonicalize(( URI.parse(params.uri)));
+    async request(identity, params) {
+        const normalized = normalizeResourceIdentity(identity);
+        const lexical = extUri.normalizePath(( URI.parse(params.uri)));
+        const canonical = await this._canonicalize(lexical);
+        if (normalized === LOCAL_AGENT_HOST_RESOURCE_IDENTITY) {
+            return;
+        }
         const wantsWrite = params.write === true;
         const wantsRead = params.read === true || !wantsWrite;
         if (wantsRead && !(await this._isCovered(normalized, canonical, AgentHostPermissionMode.Read))) {
-            await this._enqueue(normalized, canonical, AgentHostPermissionMode.Read);
+            await this._enqueue(normalized, canonical, lexical, AgentHostPermissionMode.Read);
         }
         if (wantsWrite && !(await this._isCovered(normalized, canonical, AgentHostPermissionMode.Write))) {
-            await this._enqueue(normalized, canonical, AgentHostPermissionMode.Write);
+            await this._enqueue(normalized, canonical, lexical, AgentHostPermissionMode.Write);
         }
     }
     pendingFor(address) {
@@ -216,24 +245,28 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
     findPending(id) {
         return this._pending.get().find(r => r.id === id);
     }
-    grantImplicitRead(address, uri) {
+    grantImplicitRead(identity, uri) {
         const handle = generateUuid();
         const lexical = extUri.normalizePath(uri);
         const realpath = this._fileService.realpath(lexical).then(real => real ?? lexical, () => lexical);
         this._inMemoryGrants.set(handle, {
-            address: normalizeRemoteAgentHostAddress(address),
+            identity: normalizeResourceIdentity(identity),
+            uri: lexical,
             realpath,
             mode: AgentHostAccessMode.Read
         });
         return toDisposable(() => this._inMemoryGrants.delete(handle));
     }
-    connectionClosed(address) {
-        const normalized = normalizeRemoteAgentHostAddress(address);
+    connectionClosed(identity) {
+        const normalized = normalizeResourceIdentity(identity);
         for (const [handle, grant] of this._inMemoryGrants) {
-            if (grant.address === normalized) {
+            if (grant.identity === normalized) {
                 this._inMemoryGrants.delete(handle);
             }
         }
+        if (normalized === LOCAL_AGENT_HOST_RESOURCE_IDENTITY) {
+            return;
+        }
         const cancel = ( new CancellationError());
         const remaining = [];
         for (const request of this._pending.get()) {
@@ -247,8 +280,8 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
             this._pending.set(remaining, undefined);
         }
     }
-    async _gate(address, uri, mode, deniedRequest) {
-        if (!(await this.check(address, uri, mode))) {
+    async _gate(identity, uri, mode, deniedRequest) {
+        if (!(await this.check(identity, uri, mode))) {
             throw ( new AgentHostResourcePermissionError(deniedRequest));
         }
     }
@@ -299,23 +332,27 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
     }
     async _canonicalize(uri) {
         const normalized = extUri.normalizePath(uri);
-        const real = await this._fileService.realpath(normalized).catch(() => undefined);
-        if (real) {
-            return real;
-        }
-        const parent = extUri.dirname(normalized);
-        if (extUri.isEqual(parent, normalized)) {
-            return normalized;
+        const suffix = [];
+        let current = normalized;
+        while (true) {
+            const real = await this._fileService.realpath(current).catch(() => undefined);
+            if (real) {
+                return suffix.length ? extUri.joinPath(real, ...suffix) : real;
+            }
+            const parent = extUri.dirname(current);
+            if (extUri.isEqual(parent, current)) {
+                return normalized;
+            }
+            suffix.unshift(extUri.basename(current));
+            current = parent;
         }
-        const realParent = await this._fileService.realpath(parent).catch(() => undefined);
-        return realParent ? extUri.joinPath(realParent, extUri.basename(normalized)) : normalized;
     }
-    async _isCovered(address, canonicalUri, mode) {
-        if (address === LOCAL_AGENT_HOST_ADDRESS) {
+    async _isCovered(identity, canonicalUri, mode) {
+        if (identity === LOCAL_AGENT_HOST_RESOURCE_IDENTITY) {
             return true;
         }
         const requireWrite = mode === AgentHostPermissionMode.Write;
-        for (const grant of this._readPersistedGrants(address)) {
+        for (const grant of this._readPersistedGrants(identity)) {
             if (requireWrite && grant.mode !== AgentHostAccessMode.ReadWrite) {
                 continue;
             }
@@ -325,7 +362,7 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
         }
         const candidates = [];
         for (const grant of ( this._inMemoryGrants.values())) {
-            if (grant.address !== address) {
+            if (grant.identity !== identity) {
                 continue;
             }
             if (requireWrite && grant.mode !== AgentHostAccessMode.ReadWrite) {
@@ -336,7 +373,45 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
         const realpaths = await Promise.all(candidates);
         return ( realpaths.some(uri => extUri.isEqualOrParent(canonicalUri, uri)));
     }
-    _enqueue(address, canonicalUri, mode) {
+    async _getGrantedChildren(identity, directory) {
+        if (identity === LOCAL_AGENT_HOST_RESOURCE_IDENTITY) {
+            return undefined;
+        }
+        const grantUris = ( [...this._readPersistedGrants(identity)].filter(
+            grant => grant.mode === AgentHostAccessMode.Read || grant.mode === AgentHostAccessMode.ReadWrite
+        ).map(grant => grant.lexicalUri));
+        for (const grant of ( this._inMemoryGrants.values())) {
+            if (grant.identity === identity) {
+                grantUris.push(grant.uri);
+            }
+        }
+        const grantedChildren = ( new ResourceSet(uri => extUri.getComparisonKey(uri)));
+        for (const grantUri of grantUris) {
+            if (extUri.isEqual(directory, grantUri) || !extUri.isEqualOrParent(grantUri, directory)) {
+                continue;
+            }
+            const relativePath = extUri.relativePath(directory, grantUri);
+            const segments = relativePath?.split("/").filter(Boolean);
+            if (!segments?.length) {
+                continue;
+            }
+            const name = segments[0];
+            const childUri = extUri.joinPath(directory, name);
+            grantedChildren.add(childUri);
+        }
+        if (grantedChildren.size === 0) {
+            return undefined;
+        }
+        const stat = await this._fileService.resolve(directory);
+        if (!stat.isDirectory) {
+            throw ( new Error(`Resource is not a directory: ${( directory.toString())}`));
+        }
+        return ( (stat.children ?? []).filter(child => ( grantedChildren.has(extUri.joinPath(directory, child.name)))).map(child => ({
+            name: child.name,
+            type: child.isDirectory ? "directory" : "file"
+        })));
+    }
+    _enqueue(address, canonicalUri, lexicalUri, mode) {
         const existing = this._pending.get().find(
             r => r.address === address && r.mode === mode && extUri.isEqual(r.uri, canonicalUri)
         );
@@ -348,6 +423,7 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
             id: generateUuid(),
             address,
             uri: canonicalUri,
+            lexicalUri,
             mode,
             deferred,
             allow: () => this._resolve(request, "memory"),
@@ -363,12 +439,13 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
     _resolve(request, scope) {
         const accessMode = request.mode === AgentHostPermissionMode.Write ? AgentHostAccessMode.ReadWrite : AgentHostAccessMode.Read;
         this._inMemoryGrants.set(generateUuid(), {
-            address: request.address,
+            identity: request.address,
+            uri: request.lexicalUri,
             realpath: Promise.resolve(request.uri),
             mode: accessMode
         });
         if (scope === "persist") {
-            void this._persistGrant(request.address, request.uri, request.mode).catch(err => {
+            void this._persistGrant(request.address, request.uri, request.lexicalUri, request.mode).catch(err => {
                 this._logService.warn("[AgentHostResourceService] Failed to persist grant", err);
             });
         }
@@ -382,23 +459,32 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
         }
     }
     *_readPersistedGrants(address) {
-        const forAddress = this._configurationService.getValue(AgentHostLocalFilePermissionsSettingId)?.[address];
+        const forAddress = getGlobalConfigurationValue(this._configurationService, AgentHostLocalFilePermissionsSettingId)?.[address];
         if (!forAddress) {
             return;
         }
-        for (const [uriStr, mode] of Object.entries(forAddress)) {
-            if (mode !== AgentHostAccessMode.Read && mode !== AgentHostAccessMode.ReadWrite) {
+        for (const [uriStr, grant] of Object.entries(forAddress)) {
+            const mode = getGrantMode(grant);
+            if (!mode) {
                 continue;
             }
             try {
+                const uri = ( URI.parse(uriStr));
+                let lexicalUri = uri;
+                if (typeof grant === "object" && typeof grant.lexicalUri === "string") {
+                    try {
+                        lexicalUri = ( URI.parse(grant.lexicalUri));
+                    } catch {}
+                }
                 yield {
-                    uri: ( URI.parse(uriStr)),
+                    uri,
+                    lexicalUri,
                     mode
                 };
             } catch {}
         }
     }
-    async _persistGrant(address, uri, mode) {
+    async _persistGrant(address, uri, lexicalUri, mode) {
         const requested = mode === AgentHostPermissionMode.Write ? AgentHostAccessMode.ReadWrite : AgentHostAccessMode.Read;
         for (const grant of this._readPersistedGrants(address)) {
             const covers = grant.mode === AgentHostAccessMode.ReadWrite || requested === AgentHostAccessMode.Read;
@@ -414,10 +500,23 @@ let AgentHostResourceService = class AgentHostResourceService extends Disposable
             ...(value[address] ?? {})
         };
         const uriKey = ( uri.toString());
-        if (forAddress[uriKey] === AgentHostAccessMode.ReadWrite) {
+        const existing = forAddress[uriKey];
+        if (getGrantMode(existing) === AgentHostAccessMode.ReadWrite) {
             return;
         }
-        forAddress[uriKey] = requested;
+        if (typeof existing === "object") {
+            forAddress[uriKey] = {
+                mode: requested,
+                lexicalUri: existing.lexicalUri
+            };
+        } else if (!extUri.isEqual(uri, lexicalUri)) {
+            forAddress[uriKey] = {
+                mode: requested,
+                lexicalUri: ( lexicalUri.toString())
+            };
+        } else {
+            forAddress[uriKey] = requested;
+        }
         await this._configurationService.updateValue(AgentHostLocalFilePermissionsSettingId, {
             ...value,
             [address]: forAddress

package/vscode/src/vs/workbench/services/agentHost/common/editorRemoteAgentHostTransport.d.ts

@@ -0,0 +1,47 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type ProtocolMessage } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
+import type { IClientTransport } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionTransport";
+/** Maps working-directory identities at the editor's remote connection, leaving opaque protocol content untouched. */
+export declare class EditorRemoteAgentHostTransport extends Disposable implements IClientTransport {
+    private readonly _transport;
+    private readonly _remoteAuthority;
+    private readonly _requests;
+    private readonly _uriTransformer;
+    private readonly _onMessage;
+    readonly onMessage: Event<ProtocolMessage>;
+    readonly onClose: Event<void>;
+    /** Preserves the underlying connection's client-route classification. */
+    get clientConnectionKind(): import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostTelemetry").AgentHostClientConnectionKind | undefined;
+    /** Reports the physical transport wrapped by this URI-mapping adapter. */
+    get transportKind(): import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostTelemetry").AgentHostTransportKind | undefined;
+    /** Owns the underlying transport and translates incoming messages before exposing them to the protocol client. */
+    constructor(_transport: IClientTransport, _remoteAuthority: string);
+    /** Opens the underlying connection; this adapter does not establish a separate connection. */
+    connect(): Promise<void>;
+    /**
+     * Maps outgoing working directories to host-local URIs before forwarding the message.
+     * Records request methods when their responses may contain directories that need reverse mapping.
+     */
+    send(message: ProtocolMessage): void;
+    /** Converts a directory on the connected remote authority to a file URI, leaving other resources unchanged. */
+    private _toHostDirectory;
+    /** Converts a host-local file URI to the workbench's remote URI so it matches the corresponding workspace folder. */
+    private _fromHostDirectory;
+    /** Copies a payload with mapped working directories and folder-picker primary, preserving unrelated fields and metadata. */
+    private _mapDirectories;
+    /** Maps directory-bearing action fields in either direction, leaving other action types untouched. */
+    private _mapAction;
+    private _mapActiveClient;
+    private _mapCustomizationEnablement;
+    private _mapCustomization;
+    /** Restores workbench directory identities in session and chat snapshots, including nested chat summaries. */
+    private _mapSnapshot;
+    /**
+     * Maps directories in host notifications and response payloads back to workbench URIs.
+     * Correlates responses with recorded request methods because JSON-RPC responses contain only the request ID.
+     */
+    private _fromHost;
+    /** Clears response-correlation state and disposes the owned transport and event listeners. */
+    dispose(): void;
+}