@codingame/monaco-vscode-chat-service-override 31.0.0 → 32.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/terminalOutputCompressor.js

@@ -0,0 +1,232 @@
+
+import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
+
+function parseCommandHead(command) {
+    if (!command) {
+        return undefined;
+    }
+    const firstSegment = command.split(/[|;&]/)[0].trim();
+    if (!firstSegment) {
+        return undefined;
+    }
+    const tokens = firstSegment.split(/\s+/).filter(t => !/^[A-Z_][A-Z0-9_]*=/.test(t));
+    const head = tokens[0];
+    if (!head) {
+        return undefined;
+    }
+    let sub;
+    for (let i = 1; i < tokens.length; i++) {
+        if (tokens[i].startsWith("--")) {
+            continue;
+        }
+        sub = tokens[i];
+        break;
+    }
+    return {
+        head,
+        sub
+    };
+}
+function isTerminalInput(input) {
+    if (typeof input !== "object" || input === null) {
+        return false;
+    }
+    const terminalInput = input;
+    return terminalInput.command === undefined || typeof terminalInput.command === "string";
+}
+const gitDiffFilter = {
+    id: "terminal.git-diff",
+    toolIds: [TerminalToolId.RunInTerminal],
+    matches(_toolId, input) {
+        if (!isTerminalInput(input)) {
+            return false;
+        }
+        const parsed = parseCommandHead(input.command);
+        return parsed?.head === "git" && (parsed.sub === "diff" || parsed.sub === "show");
+    },
+    apply(text) {
+        const lines = text.split("\n");
+        const out = [];
+        const KEEP_CONTEXT = 1;
+        let contextRun = 0;
+        let inBinaryOrLock = false;
+        let pendingHunkHeaderIndex = -1;
+        let pendingHunkOldStart = 0;
+        let pendingHunkNewStart = 0;
+        let pendingOldLines = 0;
+        let pendingNewLines = 0;
+        const HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+        const flushHunk = () => {
+            if (pendingHunkHeaderIndex < 0) {
+                return;
+            }
+            out[pendingHunkHeaderIndex] = `@@ -${pendingHunkOldStart},${pendingOldLines} +${pendingHunkNewStart},${pendingNewLines} @@`;
+            pendingHunkHeaderIndex = -1;
+        };
+        const flushContextRun = () => {
+            const omitted = contextRun - KEEP_CONTEXT;
+            if (omitted > 0) {
+                out.push(
+                    `... ${omitted} unchanged context line${omitted === 1 ? "" : "s"} omitted ...`
+                );
+            }
+            contextRun = 0;
+        };
+        for (const line of lines) {
+            if (line.startsWith("diff --git")) {
+                flushContextRun();
+                flushHunk();
+                inBinaryOrLock = /package-lock\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb|\.snap$/.test(line);
+                if (inBinaryOrLock) {
+                    out.push(line);
+                    out.push("... lockfile/snapshot diff omitted ...");
+                    continue;
+                }
+                out.push(line);
+                continue;
+            }
+            if (inBinaryOrLock) {
+                continue;
+            }
+            if (line.startsWith("index ") || line.startsWith("similarity index ") || line.startsWith("dissimilarity index ") || line.startsWith("rename from ") || line.startsWith("rename to ")) {
+                continue;
+            }
+            const hunkMatch = HUNK_RE.exec(line);
+            if (hunkMatch) {
+                flushContextRun();
+                flushHunk();
+                pendingHunkOldStart = parseInt(hunkMatch[1], 10);
+                pendingHunkNewStart = parseInt(hunkMatch[3], 10);
+                pendingOldLines = 0;
+                pendingNewLines = 0;
+                pendingHunkHeaderIndex = out.length;
+                out.push(line);
+                continue;
+            }
+            if (line.startsWith("+++ ") || line.startsWith("--- ") || line.startsWith("Binary files ")) {
+                flushContextRun();
+                flushHunk();
+                out.push(line);
+                continue;
+            }
+            if (line.startsWith("+")) {
+                flushContextRun();
+                out.push(line);
+                pendingNewLines++;
+                continue;
+            }
+            if (line.startsWith("-")) {
+                flushContextRun();
+                out.push(line);
+                pendingOldLines++;
+                continue;
+            }
+            if (!line.startsWith(" ")) {
+                flushContextRun();
+                out.push(line);
+                continue;
+            }
+            contextRun++;
+            if (contextRun <= KEEP_CONTEXT) {
+                out.push(line);
+                pendingOldLines++;
+                pendingNewLines++;
+            }
+        }
+        flushContextRun();
+        flushHunk();
+        const result = out.join("\n");
+        return {
+            text: result,
+            compressed: result.length < text.length
+        };
+    }
+};
+const lsFilter = {
+    id: "terminal.ls",
+    toolIds: [TerminalToolId.RunInTerminal],
+    matches(_toolId, input) {
+        if (!isTerminalInput(input)) {
+            return false;
+        }
+        const parsed = parseCommandHead(input.command);
+        if (parsed?.head !== "ls") {
+            return false;
+        }
+        return /\s-\w*l/.test(input.command ?? "");
+    },
+    apply(text) {
+        const lines = text.split("\n");
+        const out = [];
+        const longRe = /^[-dlcbpsDLCBPS][rwx\-tTsS@+.]{9,}\s+\d+\s+\S+\s+\S+\s+\d+\s+\S+\s+\S+\s+\S+\s+(.+)$/;
+        for (const line of lines) {
+            if (!line.trim()) {
+                continue;
+            }
+            if (line.startsWith("total ")) {
+                continue;
+            }
+            const m = longRe.exec(line);
+            if (m) {
+                const isDir = line.startsWith("d");
+                out.push(isDir ? m[1] + "/" : m[1]);
+            } else {
+                out.push(line);
+            }
+        }
+        const result = out.join("\n");
+        return {
+            text: result,
+            compressed: result.length < text.length
+        };
+    }
+};
+const npmInstallFilter = {
+    id: "terminal.npm-install",
+    toolIds: [TerminalToolId.RunInTerminal],
+    matches(_toolId, input) {
+        if (!isTerminalInput(input)) {
+            return false;
+        }
+        const parsed = parseCommandHead(input.command);
+        if (!parsed) {
+            return false;
+        }
+        if (parsed.head === "npm" && (parsed.sub === "install" || parsed.sub === "i" || parsed.sub === "ci")) {
+            return true;
+        }
+        if ((parsed.head === "yarn" || parsed.head === "pnpm") && parsed.sub !== "test") {
+            if (/\binstall\b|\badd\b/.test(input.command ?? "")) {
+                return true;
+            }
+            if (parsed.sub === undefined) {
+                return /^\s*(?:[A-Z_][A-Z0-9_]*=\S+\s+)*(?:yarn|pnpm)\s*$/.test(input.command ?? "");
+            }
+        }
+        return false;
+    },
+    apply(text) {
+        const lines = text.split("\n");
+        const dropPatterns = [/^npm warn deprecated /i,
+        /^\s*\[#+>?\s*\] /, /^npm http /i, /^npm timing /i, /^npm sill /i, /^npm verb /i, /^\s*\d+ packages? are looking for funding/i, /run `npm fund`/i, /^Run `npm audit/i];
+        const out = [];
+        for (const line of lines) {
+            if (( dropPatterns.some(re => re.test(line)))) {
+                continue;
+            }
+            out.push(line);
+        }
+        const result = out.join("\n");
+        return {
+            text: result,
+            compressed: result.length < text.length
+        };
+    }
+};
+function registerTerminalCompressors(compressor) {
+    compressor.registerFilter(gitDiffFilter);
+    compressor.registerFilter(lsFilter);
+    compressor.registerFilter(npmInstallFilter);
+}
+
+export { gitDiffFilter, lsFilter, npmInstallFilter, parseCommandHead, registerTerminalCompressors };

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

@@ -0,0 +1,83 @@
+import { Disposable, IDisposable } 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 { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { AgentHostPermissionMode, IPendingResourceRequest } from "../../../../platform/agentHost/common/agentHostPermissionService.js";
+import { IAgentHostPermissionService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostPermissionService.service";
+import { ResourceRequestParams } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+/**
+ * Default implementation of {@link IAgentHostPermissionService}.
+ *
+ * Permission storage shape (in user settings):
+ *
+ * ```jsonc
+ * "chat.agentHost.localFilePermissions": {
+ *   "localhost:3000": {
+ *     "file:///Users/me/.gitconfig": "r",
+ *     "file:///Users/me/.agentConfig": "rw"
+ *   }
+ * }
+ * ```
+ *
+ * - Keys are addresses normalized via {@link normalizeRemoteAgentHostAddress}.
+ * - Values are URI strings → `r` | `rw`. Descendant URIs are covered by a
+ *   parent grant (e.g. a grant for `.config/` covers `.config/foo.json`).
+ */
+export declare class AgentHostPermissionService extends Disposable implements IAgentHostPermissionService {
+    private readonly _configurationService;
+    private readonly _fileService;
+    private readonly _logService;
+    readonly _serviceBrand: undefined;
+    /**
+     * In-memory grants. Two kinds, both stored here so they share the
+     * `connectionClosed` cleanup pass:
+     *
+     * - **Implicit reads** added by `grantImplicitRead` (read-only, kept alive
+     *   by an explicit disposable revocation handle from the caller).
+     * - **Session grants** from the user clicking "Allow" in the prompt
+     *   (read or write, cleared when the connection closes or the window
+     *   reloads). These have no caller-held disposable.
+     *
+     * Keyed by an opaque handle so callers can revoke independently.
+     */
+    private readonly _inMemoryGrants;
+    /** All pending requests across every connection. */
+    private readonly _pending;
+    readonly allPending: IObservable<readonly IPendingResourceRequest[]>;
+    constructor(_configurationService: IConfigurationService, _fileService: IFileService, _logService: ILogService);
+    check(address: string, uri: URI, mode: AgentHostPermissionMode): Promise<boolean>;
+    request(address: string, params: ResourceRequestParams): Promise<void>;
+    pendingFor(address: string): IObservable<readonly IPendingResourceRequest[]>;
+    findPending(id: string): IPendingResourceRequest | undefined;
+    grantImplicitRead(address: string, uri: URI): IDisposable;
+    connectionClosed(address: string): void;
+    /**
+     * Resolve {@link uri} against the local filesystem, collapsing `..`
+     * segments and following symlinks so the policy check sees the same
+     * path the OS will actually open. For URIs that don't exist (e.g. a
+     * `resourceWrite` for a new file), realpath the deepest existing
+     * ancestor and re-append the leaf.
+     */
+    private _canonicalize;
+    /**
+     * Policy check against in-memory + persisted grants. Asynchronous
+     * because in-memory grants from {@link grantImplicitRead} carry an
+     * unresolved realpath promise — see {@link IInMemoryGrant.realpath}.
+     */
+    private _isCovered;
+    private _enqueue;
+    private _resolve;
+    private _dropPending;
+    private _readPersistedGrants;
+    private _persistGrant;
+    /**
+     * Inspect the setting and pick the scope to write back to. The setting
+     * is registered with `ConfigurationScope.APPLICATION`, so APPLICATION is
+     * the canonical home; we still honour pre-existing values in the
+     * user-* scopes so a hand-edited entry isn't silently relocated, but
+     * fresh writes default to APPLICATION.
+     */
+    private _inspectScopedSetting;
+}

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

@@ -0,0 +1,243 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+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 '@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 { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+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 { normalizeRemoteAgentHostAddress } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { AgentHostPermissionMode, AgentHostAccessMode, AgentHostLocalFilePermissionsSettingId } from '../../../../platform/agentHost/common/agentHostPermissionService.js';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+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';
+
+let AgentHostPermissionService = class AgentHostPermissionService extends Disposable {
+    constructor(_configurationService, _fileService, _logService) {
+        super();
+        this._configurationService = _configurationService;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        this._inMemoryGrants = ( new Map());
+        this._pending = observableValue("agentHostPermissions.pending", []);
+        this.allPending = this._pending;
+    }
+    async check(address, uri, mode) {
+        const normalized = normalizeRemoteAgentHostAddress(address);
+        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)));
+        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);
+        }
+        if (wantsWrite && !(await this._isCovered(normalized, canonical, AgentHostPermissionMode.Write))) {
+            await this._enqueue(normalized, canonical, AgentHostPermissionMode.Write);
+        }
+    }
+    pendingFor(address) {
+        const normalized = normalizeRemoteAgentHostAddress(address);
+        return derived(reader => this._pending.read(reader).filter(r => r.address === normalized));
+    }
+    findPending(id) {
+        return this._pending.get().find(r => r.id === id);
+    }
+    grantImplicitRead(address, 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),
+            realpath,
+            mode: AgentHostAccessMode.Read
+        });
+        return toDisposable(() => this._inMemoryGrants.delete(handle));
+    }
+    connectionClosed(address) {
+        const normalized = normalizeRemoteAgentHostAddress(address);
+        for (const [handle, grant] of this._inMemoryGrants) {
+            if (grant.address === normalized) {
+                this._inMemoryGrants.delete(handle);
+            }
+        }
+        const cancel = ( new CancellationError());
+        const remaining = [];
+        for (const request of this._pending.get()) {
+            if (request.address === normalized) {
+                request.deferred.error(cancel);
+            } else {
+                remaining.push(request);
+            }
+        }
+        if (remaining.length !== this._pending.get().length) {
+            this._pending.set(remaining, undefined);
+        }
+    }
+    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 realParent = await this._fileService.realpath(parent).catch(() => undefined);
+        return realParent ? extUri.joinPath(realParent, extUri.basename(normalized)) : normalized;
+    }
+    async _isCovered(address, canonicalUri, mode) {
+        const requireWrite = mode === AgentHostPermissionMode.Write;
+        for (const grant of this._readPersistedGrants(address)) {
+            if (requireWrite && grant.mode !== AgentHostAccessMode.ReadWrite) {
+                continue;
+            }
+            if (extUri.isEqualOrParent(canonicalUri, grant.uri)) {
+                return true;
+            }
+        }
+        const candidates = [];
+        for (const grant of ( this._inMemoryGrants.values())) {
+            if (grant.address !== address) {
+                continue;
+            }
+            if (requireWrite && grant.mode !== AgentHostAccessMode.ReadWrite) {
+                continue;
+            }
+            candidates.push(grant.realpath);
+        }
+        const realpaths = await Promise.all(candidates);
+        return ( realpaths.some(uri => extUri.isEqualOrParent(canonicalUri, uri)));
+    }
+    _enqueue(address, canonicalUri, mode) {
+        const existing = this._pending.get().find(
+            r => r.address === address && r.mode === mode && extUri.isEqual(r.uri, canonicalUri)
+        );
+        if (existing) {
+            return existing.deferred.p;
+        }
+        const deferred = ( new DeferredPromise());
+        const request = {
+            id: generateUuid(),
+            address,
+            uri: canonicalUri,
+            mode,
+            deferred,
+            allow: () => this._resolve(request, "memory"),
+            allowAlways: () => this._resolve(request, "persist"),
+            deny: () => {
+                this._dropPending(request);
+                deferred.error(( new CancellationError()));
+            }
+        };
+        this._pending.set([...this._pending.get(), request], undefined);
+        return deferred.p;
+    }
+    _resolve(request, scope) {
+        const accessMode = request.mode === AgentHostPermissionMode.Write ? AgentHostAccessMode.ReadWrite : AgentHostAccessMode.Read;
+        this._inMemoryGrants.set(generateUuid(), {
+            address: request.address,
+            realpath: Promise.resolve(request.uri),
+            mode: accessMode
+        });
+        if (scope === "persist") {
+            void this._persistGrant(request.address, request.uri, request.mode).catch(err => {
+                this._logService.warn("[AgentHostPermissionService] Failed to persist grant", err);
+            });
+        }
+        this._dropPending(request);
+        request.deferred.complete();
+    }
+    _dropPending(request) {
+        const next = this._pending.get().filter(r => r !== request);
+        if (next.length !== this._pending.get().length) {
+            this._pending.set(next, undefined);
+        }
+    }
+    *_readPersistedGrants(address) {
+        const forAddress = this._configurationService.getValue(AgentHostLocalFilePermissionsSettingId)?.[address];
+        if (!forAddress) {
+            return;
+        }
+        for (const [uriStr, mode] of Object.entries(forAddress)) {
+            if (mode !== AgentHostAccessMode.Read && mode !== AgentHostAccessMode.ReadWrite) {
+                continue;
+            }
+            try {
+                yield {
+                    uri: ( URI.parse(uriStr)),
+                    mode
+                };
+            } catch {}
+        }
+    }
+    async _persistGrant(address, uri, 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;
+            if (covers && extUri.isEqualOrParent(uri, grant.uri)) {
+                return;
+            }
+        }
+        const {
+            target,
+            value
+        } = this._inspectScopedSetting();
+        const forAddress = {
+            ...(value[address] ?? {})
+        };
+        const uriKey = ( uri.toString());
+        if (forAddress[uriKey] === AgentHostAccessMode.ReadWrite) {
+            return;
+        }
+        forAddress[uriKey] = requested;
+        await this._configurationService.updateValue(AgentHostLocalFilePermissionsSettingId, {
+            ...value,
+            [address]: forAddress
+        }, target);
+    }
+    _inspectScopedSetting() {
+        const inspected = this._configurationService.inspect(AgentHostLocalFilePermissionsSettingId);
+        if (inspected.applicationValue !== undefined) {
+            return {
+                target: ConfigurationTarget.APPLICATION,
+                value: inspected.applicationValue
+            };
+        }
+        if (inspected.userLocalValue !== undefined) {
+            return {
+                target: ConfigurationTarget.USER_LOCAL,
+                value: inspected.userLocalValue
+            };
+        }
+        if (inspected.userRemoteValue !== undefined) {
+            return {
+                target: ConfigurationTarget.USER_REMOTE,
+                value: inspected.userRemoteValue
+            };
+        }
+        if (inspected.userValue !== undefined) {
+            return {
+                target: ConfigurationTarget.USER,
+                value: inspected.userValue
+            };
+        }
+        return {
+            target: ConfigurationTarget.APPLICATION,
+            value: {}
+        };
+    }
+};
+AgentHostPermissionService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IFileService)), ( __param(2, ILogService))], AgentHostPermissionService));
+
+export { AgentHostPermissionService };