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

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

@@ -0,0 +1,89 @@
+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 { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { AgentHostPermissionMode, IPendingResourceRequest, IResourceListResult, IResourceReadResult } from "../../../../platform/agentHost/common/agentHostResourceService.js";
+import { IAgentHostResourceService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostResourceService.service";
+import { ResourceCopyParams, ResourceDeleteParams, ResourceMkdirParams, ResourceMoveParams, ResourceRequestParams, ResourceResolveParams, ResourceResolveResult, ResourceWriteParams } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+/**
+ * Default implementation of {@link IAgentHostResourceService} — the unified
+ * owner of agent-host-facing filesystem operations and the permission
+ * policy that gates them. Reads transparently fall back to
+ * {@link ITextModelService} so virtual resources (untitled documents,
+ * notebook cells, ...) work without the host having to know about them.
+ *
+ * Permission storage shape (in user settings):
+ *
+ * ```jsonc
+ * "chat.agentHost.localFilePermissions": {
+ *   "localhost:3000": {
+ *     "file:///Users/me/.gitconfig": "r",
+ *     "file:///Users/me/.agentConfig": "rw"
+ *   },
+ *   "local": { ... }
+ * }
+ * ```
+ *
+ * - Keys are addresses normalized via {@link normalizeRemoteAgentHostAddress},
+ *   with the in-process local agent host keyed under `'local'`.
+ * - Values are URI strings → `r` | `rw`. Descendant URIs are covered by a
+ *   parent grant.
+ */
+export declare class AgentHostResourceService extends Disposable implements IAgentHostResourceService {
+    private readonly _configurationService;
+    private readonly _fileService;
+    private readonly _textModelService;
+    private readonly _logService;
+    readonly _serviceBrand: undefined;
+    private readonly _inMemoryGrants;
+    private readonly _pending;
+    readonly allPending: IObservable<readonly IPendingResourceRequest[]>;
+    constructor(_configurationService: IConfigurationService, _fileService: IFileService, _textModelService: ITextModelService, _logService: ILogService);
+    list(address: string, uri: URI): Promise<IResourceListResult>;
+    read(address: string, uri: URI): Promise<IResourceReadResult>;
+    write(address: string, params: ResourceWriteParams): Promise<void>;
+    del(address: string, params: ResourceDeleteParams): Promise<void>;
+    move(address: string, params: ResourceMoveParams): Promise<void>;
+    copy(address: string, params: ResourceCopyParams): Promise<void>;
+    resolve(address: string, params: ResourceResolveParams): Promise<ResourceResolveResult>;
+    mkdir(address: string, params: ResourceMkdirParams): Promise<void>;
+    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;
+    private _gate;
+    private _readVirtual;
+    /**
+     * Write {@link bytes} as text into the resolved text model for {@link uri},
+     * if one can be resolved and is writable. Returns `true` when the model was
+     * updated, `false` otherwise (no provider, readonly, decode failure).
+     */
+    private _writeVirtual;
+    /**
+     * Resolve {@link uri} via {@link ITextModelService} and synthesize a
+     * {@link ResourceResolveResult} so virtual resources stat as `File` with
+     * a size matching their text content. Returns `undefined` if no model
+     * can be resolved.
+     */
+    private _statVirtual;
+    /**
+     * 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;
+    private _isCovered;
+    private _enqueue;
+    private _resolve;
+    private _dropPending;
+    private _readPersistedGrants;
+    private _persistGrant;
+    private _inspectScopedSetting;
+}

package/vscode/src/vs/workbench/services/agentHost/common/{agentHostPermissionService.js → agentHostResourceService.js}

@@ -1,33 +1,197 @@
 
 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 { 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 '@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 '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+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-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';
 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) {
+let AgentHostResourceService = class AgentHostResourceService extends Disposable {
+    constructor(_configurationService, _fileService, _textModelService, _logService) {
         super();
         this._configurationService = _configurationService;
         this._fileService = _fileService;
+        this._textModelService = _textModelService;
         this._logService = _logService;
         this._inMemoryGrants = ( new Map());
-        this._pending = observableValue("agentHostPermissions.pending", []);
+        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
+        });
+        const stat = await this._fileService.resolve(uri);
+        if (!stat.isDirectory) {
+            throw ( new Error(`Resource is not a directory: ${( uri.toString())}`));
+        }
+        return {
+            entries: ( (stat.children ?? []).map(c => ({
+                name: c.name,
+                type: c.isDirectory ? "directory" : "file"
+            })))
+        };
+    }
+    async read(address, uri) {
+        await this._gate(address, uri, AgentHostPermissionMode.Read, {
+            channel: ROOT_STATE_URI,
+            uri: ( uri.toString()),
+            read: true
+        });
+        try {
+            const content = await this._fileService.readFile(uri);
+            return {
+                bytes: content.value
+            };
+        } catch (err) {
+            const virtual = await this._readVirtual(uri);
+            if (virtual) {
+                return {
+                    bytes: virtual
+                };
+            }
+            throw err;
+        }
+    }
+    async write(address, params) {
+        const uri = ( URI.parse(params.uri));
+        await this._gate(address, uri, AgentHostPermissionMode.Write, {
+            channel: ROOT_STATE_URI,
+            uri: ( uri.toString()),
+            write: true
+        });
+        const buf = params.encoding === ContentEncoding.Base64 ? decodeBase64(params.data) : VSBuffer.fromString(params.data);
+        try {
+            if (params.createOnly) {
+                await this._fileService.createFile(uri, buf, {
+                    overwrite: false
+                });
+            } else {
+                await this._fileService.writeFile(uri, buf);
+            }
+        } catch (err) {
+            if (await this._writeVirtual(uri, buf)) {
+                return;
+            }
+            throw err;
+        }
+    }
+    async del(address, params) {
+        const uri = ( URI.parse(params.uri));
+        await this._gate(address, uri, AgentHostPermissionMode.Write, {
+            channel: ROOT_STATE_URI,
+            uri: ( uri.toString()),
+            write: true
+        });
+        await this._fileService.del(uri, {
+            recursive: !!params.recursive
+        });
+    }
+    async move(address, params) {
+        const source = ( URI.parse(params.source));
+        const destination = ( URI.parse(params.destination));
+        await this._gate(address, source, AgentHostPermissionMode.Write, {
+            channel: ROOT_STATE_URI,
+            uri: ( source.toString()),
+            write: true
+        });
+        await this._gate(address, destination, AgentHostPermissionMode.Write, {
+            channel: ROOT_STATE_URI,
+            uri: ( destination.toString()),
+            write: true
+        });
+        await this._fileService.move(source, destination, !params.failIfExists);
+    }
+    async copy(address, params) {
+        const source = ( URI.parse(params.source));
+        const destination = ( URI.parse(params.destination));
+        await this._gate(address, source, AgentHostPermissionMode.Read, {
+            channel: ROOT_STATE_URI,
+            uri: ( source.toString()),
+            read: true
+        });
+        await this._gate(address, destination, AgentHostPermissionMode.Write, {
+            channel: ROOT_STATE_URI,
+            uri: ( destination.toString()),
+            write: true
+        });
+        await this._fileService.copy(source, destination, !params.failIfExists);
+    }
+    async resolve(address, params) {
+        const uri = ( URI.parse(params.uri));
+        await this._gate(address, uri, AgentHostPermissionMode.Read, {
+            channel: ROOT_STATE_URI,
+            uri: ( uri.toString()),
+            read: true
+        });
+        let stat;
+        try {
+            stat = await this._fileService.stat(uri);
+        } catch (err) {
+            const virtual = await this._statVirtual(uri);
+            if (virtual) {
+                return virtual;
+            }
+            throw err;
+        }
+        let type;
+        if (stat.isSymbolicLink && params.followSymlinks === false) {
+            type = ResourceType.Symlink;
+        } else if (stat.isDirectory) {
+            type = ResourceType.Directory;
+        } else {
+            type = ResourceType.File;
+        }
+        return {
+            uri: ( uri.toString()),
+            type,
+            ...(stat.size !== undefined ? {
+                size: stat.size
+            } : {}),
+            ...(stat.mtime !== undefined ? {
+                mtime: ( new Date(stat.mtime)).toISOString()
+            } : {}),
+            ...(stat.ctime !== undefined ? {
+                ctime: ( new Date(stat.ctime)).toISOString()
+            } : {}),
+            ...(stat.etag ? {
+                etag: stat.etag
+            } : {})
+        };
+    }
+    async mkdir(address, params) {
+        const uri = ( URI.parse(params.uri));
+        await this._gate(address, uri, AgentHostPermissionMode.Write, {
+            channel: ROOT_STATE_URI,
+            uri: ( uri.toString()),
+            write: true
+        });
+        const existing = await this._fileService.stat(uri).catch(() => undefined);
+        if (existing && !existing.isDirectory) {
+            throw ( new Error(`Path exists and is not a directory: ${( uri.toString())}`));
+        }
+        await this._fileService.createFolder(uri);
+    }
     async check(address, uri, mode) {
         const normalized = normalizeRemoteAgentHostAddress(address);
         const canonical = await this._canonicalize(uri);
@@ -83,6 +247,56 @@ let AgentHostPermissionService = class AgentHostPermissionService extends Dispos
             this._pending.set(remaining, undefined);
         }
     }
+    async _gate(address, uri, mode, deniedRequest) {
+        if (!(await this.check(address, uri, mode))) {
+            throw ( new AgentHostResourcePermissionError(deniedRequest));
+        }
+    }
+    async _readVirtual(uri) {
+        try {
+            const ref = await this._textModelService.createModelReference(uri);
+            try {
+                return VSBuffer.fromString(ref.object.textEditorModel.getValue());
+            } finally {
+                ref.dispose();
+            }
+        } catch {
+            return undefined;
+        }
+    }
+    async _writeVirtual(uri, bytes) {
+        try {
+            const ref = await this._textModelService.createModelReference(uri);
+            try {
+                if (ref.object.isReadonly()) {
+                    return false;
+                }
+                ref.object.textEditorModel.setValue(( bytes.toString()));
+                return true;
+            } finally {
+                ref.dispose();
+            }
+        } catch {
+            return false;
+        }
+    }
+    async _statVirtual(uri) {
+        try {
+            const ref = await this._textModelService.createModelReference(uri);
+            try {
+                const size = VSBuffer.fromString(ref.object.textEditorModel.getValue()).byteLength;
+                return {
+                    uri: ( uri.toString()),
+                    type: ResourceType.File,
+                    size
+                };
+            } finally {
+                ref.dispose();
+            }
+        } catch {
+            return undefined;
+        }
+    }
     async _canonicalize(uri) {
         const normalized = extUri.normalizePath(uri);
         const real = await this._fileService.realpath(normalized).catch(() => undefined);
@@ -97,6 +311,9 @@ let AgentHostPermissionService = class AgentHostPermissionService extends Dispos
         return realParent ? extUri.joinPath(realParent, extUri.basename(normalized)) : normalized;
     }
     async _isCovered(address, canonicalUri, mode) {
+        if (address === LOCAL_AGENT_HOST_ADDRESS) {
+            return true;
+        }
         const requireWrite = mode === AgentHostPermissionMode.Write;
         for (const grant of this._readPersistedGrants(address)) {
             if (requireWrite && grant.mode !== AgentHostAccessMode.ReadWrite) {
@@ -152,7 +369,7 @@ let AgentHostPermissionService = class AgentHostPermissionService extends Dispos
         });
         if (scope === "persist") {
             void this._persistGrant(request.address, request.uri, request.mode).catch(err => {
-                this._logService.warn("[AgentHostPermissionService] Failed to persist grant", err);
+                this._logService.warn("[AgentHostResourceService] Failed to persist grant", err);
             });
         }
         this._dropPending(request);
@@ -238,6 +455,6 @@ let AgentHostPermissionService = class AgentHostPermissionService extends Dispos
         };
     }
 };
-AgentHostPermissionService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IFileService)), ( __param(2, ILogService))], AgentHostPermissionService));
+AgentHostResourceService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IFileService)), ( __param(2, ITextModelService)), ( __param(3, ILogService))], AgentHostResourceService));
 
-export { AgentHostPermissionService };
+export { AgentHostResourceService };

package/vscode/src/vs/platform/agentHost/common/state/protocol/reducers.d.ts

@@ -1,30 +0,0 @@
-import { type RootState, type SessionState, type TerminalState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
-import { type RootAction, type ClientRootAction, type SessionAction, type ClientSessionAction, type TerminalAction, type ClientTerminalAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
-/**
- * Soft assertion for exhaustiveness checking. Place in the `default` branch of
- * a switch on a discriminated union so the compiler errors when a new variant
- * is added but not handled.
- *
- * At runtime, logs a warning instead of throwing so that forward-compatible
- * clients receiving unknown actions from a newer server degrade gracefully.
- */
-export declare function softAssertNever(value: never, log?: (msg: string) => void): void;
-/**
- * Pure reducer for root state. Handles all {@link RootAction} variants.
- */
-export declare function rootReducer(state: RootState, action: RootAction, log?: (msg: string) => void): RootState;
-/**
- * Pure reducer for session state. Handles all {@link SessionAction} variants.
- */
-export declare function sessionReducer(state: SessionState, action: SessionAction, log?: (msg: string) => void): SessionState;
-/**
- * Pure reducer for terminal state. Handles all {@link TerminalAction} variants.
- */
-export declare function terminalReducer(state: TerminalState, action: TerminalAction, log?: (msg: string) => void): TerminalState;
-/**
- * Type guard that checks whether an action may be dispatched by a client.
- *
- * Servers SHOULD call this to validate incoming `dispatchAction` requests
- * and reject any action the client is not allowed to originate.
- */
-export declare function isClientDispatchable(action: RootAction | SessionAction | TerminalAction): action is ClientRootAction | ClientSessionAction | ClientTerminalAction;

package/vscode/src/vs/platform/agentPlugins/common/pluginParsers.d.ts

@@ -1,119 +0,0 @@
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
-import { IMcpServerConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes";
-/** A single hook command to execute. Platform resolution happens at conversion time. */
-export interface IParsedHookCommand {
-    /** Cross-platform default command. */
-    readonly command?: string;
-    /** Windows-specific command. */
-    readonly windows?: string;
-    /** Linux-specific command. */
-    readonly linux?: string;
-    /** macOS-specific command. */
-    readonly osx?: string;
-    /** Working directory. */
-    readonly cwd?: URI;
-    /** Environment variables. */
-    readonly env?: Record<string, string>;
-    /** Timeout in seconds. */
-    readonly timeout?: number;
-    /** URI of the file this hook was defined in. */
-    readonly sourceUri?: URI;
-}
-/** A group of hooks for a single lifecycle event. */
-export interface IParsedHookGroup {
-    /** Canonical hook type identifier (e.g. `'SessionStart'`, `'PreToolUse'`). */
-    readonly type: string;
-    /** The commands to execute for this hook type. */
-    readonly commands: readonly IParsedHookCommand[];
-    /** URI where this hook is defined. */
-    readonly uri: URI;
-    /** Original key as it appears in the hook file. */
-    readonly originalId: string;
-}
-export interface IMcpServerDefinition {
-    readonly name: string;
-    readonly configuration: IMcpServerConfiguration;
-    readonly uri: URI;
-}
-/** A named resource (skill, agent, command, or instruction) within a plugin. */
-export interface INamedPluginResource {
-    readonly uri: URI;
-    readonly name: string;
-}
-/** The result of parsing a single plugin directory. */
-export interface IParsedPlugin {
-    readonly hooks: readonly IParsedHookGroup[];
-    readonly mcpServers: readonly IMcpServerDefinition[];
-    readonly skills: readonly INamedPluginResource[];
-    readonly agents: readonly INamedPluginResource[];
-}
-export declare enum PluginFormat {
-    Copilot = 0,
-    Claude = 1,
-    OpenPlugin = 2
-}
-export interface IPluginFormatConfig {
-    readonly format: PluginFormat;
-    readonly manifestPath: string;
-    readonly hookConfigPath: string;
-    readonly pluginRootToken: string | undefined;
-    readonly pluginRootEnvVar: string | undefined;
-    /** Parses hooks from a JSON object using the format's conventions. */
-    parseHooks(hookUri: URI, json: unknown, pluginUri: URI, workspaceRoot: URI | undefined, userHome: string): IParsedHookGroup[];
-}
-export declare function detectPluginFormat(pluginUri: URI, fileService: IFileService): Promise<IPluginFormatConfig>;
-export interface IComponentPathConfig {
-    readonly paths: readonly string[];
-    readonly exclusive: boolean;
-}
-/**
- * Parses a manifest component path field into a normalized config.
- * Supports `undefined`, `string`, `string[]`, and `{ paths: string[], exclusive?: boolean }`.
- */
-export declare function parseComponentPathConfig(raw: unknown): IComponentPathConfig;
-/**
- * Resolves the directories to scan for a given component type, combining
- * the default directory with any custom paths from the manifest config.
- * Paths that resolve outside the boundary are silently ignored.
- * @param boundaryUri The outermost directory that resolved paths must stay within. Defaults to {@link pluginUri}.
- */
-export declare function resolveComponentDirs(pluginUri: URI, defaultDir: string, config: IComponentPathConfig, boundaryUri?: URI): readonly URI[];
-/**
- * Extracts the MCP server map from a raw JSON value. Accepts both the
- * wrapped format `{ mcpServers: { … } }` and the flat format.
- */
-export declare function resolveMcpServersMap(raw: unknown): Record<string, unknown> | undefined;
-/**
- * Normalizes a raw JSON value into a typed MCP server configuration.
- */
-export declare function normalizeMcpServerConfiguration(rawConfig: unknown): IMcpServerConfiguration | undefined;
-/**
- * Replaces a plugin-root token in a shell command string with the
- * given fsPath, shell-quoting if the path contains special characters.
- */
-export declare function shellQuotePluginRootInCommand(command: string, fsPath: string, token: string): string;
-/**
- * Replaces plugin-root token references in MCP server definition string fields
- * with the plugin root filesystem path.
- */
-export declare function interpolateMcpPluginRoot(def: IMcpServerDefinition, fsPath: string, token: string, envVar: string): IMcpServerDefinition;
-/**
- * Converts bare `${VAR}` environment-variable references to VS Code `${env:VAR}` syntax.
- */
-export declare function convertBareEnvVarsToVsCodeSyntax(def: IMcpServerDefinition): IMcpServerDefinition;
-/**
- * Applies plugin-root token interpolation to hook commands for
- * Claude and OpenPlugin formats.
- */
-export declare function interpolateHookPluginRoot(hookUri: URI, json: unknown, pluginUri: URI, workspaceRoot: URI | undefined, userHome: string, token: string, envVar: string): IParsedHookGroup[];
-export declare function readJsonFile(uri: URI, fileService: IFileService): Promise<unknown | undefined>;
-export declare function pathExists(resource: URI, fileService: IFileService): Promise<boolean>;
-export declare function readSkills(pluginRoot: URI, dirs: readonly URI[], fileService: IFileService): Promise<readonly INamedPluginResource[]>;
-export declare function readMarkdownComponents(dirs: readonly URI[], fileService: IFileService): Promise<readonly INamedPluginResource[]>;
-export declare function parseMcpServerDefinitionMap(definitionURI: URI, raw: unknown, pluginFsPath: string, formatConfig: IPluginFormatConfig): IMcpServerDefinition[];
-/**
- * Parses a plugin directory to extract hooks, MCP servers, skills, and agents.
- * This is the main entry point for the agent host to discover plugin contents.
- */
-export declare function parsePlugin(pluginUri: URI, fileService: IFileService, workspaceRoot: URI | undefined, userHome: string, boundaryUri?: URI): Promise<IParsedPlugin>;