@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

package/vscode/src/vs/workbench/contrib/chat/common/plugins/agentPluginServiceImpl.js

@@ -0,0 +1,748 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
+import { untildify } from '@codingame/monaco-vscode-api/vscode/vs/base/common/labels';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { cloneAndChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { joinPath, basename, extname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ConfigurationTarget, getConfigValueInTarget } 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 { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { McpServerType } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { parseClaudeHooks } from '../promptSyntax/hookClaudeCompat.js';
+import { parseCopilotHooks } from '../promptSyntax/hookCompatibility.js';
+import { agentPluginDiscoveryRegistry } from './agentPluginService.js';
+import { IAgentPluginRepositoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service';
+import { IPluginMarketplaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+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';
+
+const COMMAND_FILE_SUFFIX = ".md";
+var AgentPluginFormat;
+(function(AgentPluginFormat) {
+    AgentPluginFormat[AgentPluginFormat["Copilot"] = 0] = "Copilot";
+    AgentPluginFormat[AgentPluginFormat["Claude"] = 1] = "Claude";
+})(AgentPluginFormat || (AgentPluginFormat = {}));
+function mapParsedHooks(parsed) {
+    return ( [...parsed.entries()].map((
+        [type, {
+            hooks,
+            originalId
+        }]
+    ) => ({
+        type,
+        hooks,
+        originalId
+    })));
+}
+function resolveWorkspaceRoot(pluginUri, workspaceContextService) {
+    const defaultFolder = workspaceContextService.getWorkspace().folders[0];
+    const folder = workspaceContextService.getWorkspaceFolder(pluginUri) ?? defaultFolder;
+    return folder?.uri;
+}
+let CopilotPluginFormatAdapter = class CopilotPluginFormatAdapter {
+    constructor(_workspaceContextService) {
+        this._workspaceContextService = _workspaceContextService;
+        this.format = AgentPluginFormat.Copilot;
+        this.manifestPaths = ["plugin.json"];
+        this.hookConfigPaths = ["hooks.json"];
+        this.hookWatchPaths = ["hooks.json"];
+    }
+    parseHooks(json, pluginUri, userHome) {
+        const workspaceRoot = resolveWorkspaceRoot(pluginUri, this._workspaceContextService);
+        return mapParsedHooks(parseCopilotHooks(json, workspaceRoot, userHome));
+    }
+};
+CopilotPluginFormatAdapter = ( __decorate([( __param(0, IWorkspaceContextService))], CopilotPluginFormatAdapter));
+const shellUnsafeChars = /[\s&|<>()^;!`"']/;
+function shellQuotePluginRootInCommand(command, fsPath, token = "${CLAUDE_PLUGIN_ROOT}") {
+    if (!command.includes(token)) {
+        return command;
+    }
+    if (!shellUnsafeChars.test(fsPath)) {
+        return command.replaceAll(token, fsPath);
+    }
+    const escapedToken = escapeRegExpCharacters(token);
+    const pattern = ( new RegExp(
+    `(["']?)` + escapedToken + `([\\w./\\\\~:-]*)`, "g"));
+    return command.replace(pattern, (_match, leadingQuote, suffix) => {
+        const fullPath = fsPath + suffix;
+        if (leadingQuote) {
+            return leadingQuote + fullPath;
+        }
+        return "\"" + fullPath.replace(/"/g, "\\\"") + "\"";
+    });
+}
+let ClaudePluginFormatAdapter = class ClaudePluginFormatAdapter {
+    constructor(_workspaceContextService) {
+        this._workspaceContextService = _workspaceContextService;
+        this.format = AgentPluginFormat.Claude;
+        this.manifestPaths = [".claude-plugin/plugin.json"];
+        this.hookConfigPaths = ["hooks/hooks.json"];
+        this.hookWatchPaths = ["hooks"];
+    }
+    parseHooks(json, pluginUri, userHome) {
+        const token = "${CLAUDE_PLUGIN_ROOT}";
+        const fsPath = pluginUri.fsPath;
+        const typedJson = json;
+        const mutateHookCommand = hook => {
+            for (const field of ["command", "windows", "linux", "osx"]) {
+                if (typeof hook[field] === "string") {
+                    hook[field] = shellQuotePluginRootInCommand(hook[field], fsPath, token);
+                }
+            }
+            hook.env ??= {};
+            hook.env.CLAUDE_PLUGIN_ROOT = fsPath;
+        };
+        for (const lifecycle of ( Object.values(typedJson.hooks ?? {}))) {
+            if (!Array.isArray(lifecycle)) {
+                continue;
+            }
+            for (const lifecycleEntry of lifecycle) {
+                if (!lifecycleEntry || typeof lifecycleEntry !== "object") {
+                    continue;
+                }
+                const entry = lifecycleEntry;
+                if (Array.isArray(entry.hooks)) {
+                    for (const hook of entry.hooks) {
+                        mutateHookCommand(hook);
+                    }
+                } else {
+                    mutateHookCommand(entry);
+                }
+            }
+        }
+        const replacer = v => {
+            return typeof v === "string" ? v.replaceAll("${CLAUDE_PLUGIN_ROOT}", pluginUri.fsPath) : undefined;
+        };
+        const workspaceRoot = resolveWorkspaceRoot(pluginUri, this._workspaceContextService);
+        const {
+            hooks,
+            disabledAllHooks
+        } = parseClaudeHooks(cloneAndChange(json, replacer), workspaceRoot, userHome);
+        if (disabledAllHooks) {
+            return [];
+        }
+        return mapParsedHooks(hooks);
+    }
+};
+ClaudePluginFormatAdapter = ( __decorate([( __param(0, IWorkspaceContextService))], ClaudePluginFormatAdapter));
+let AgentPluginService = class AgentPluginService extends Disposable {
+    constructor(instantiationService, configurationService) {
+        super();
+        const pluginsEnabled = observableConfigValue(ChatConfiguration.PluginsEnabled, true, configurationService);
+        const discoveries = [];
+        for (const descriptor of agentPluginDiscoveryRegistry.getAll()) {
+            const discovery = instantiationService.createInstance(descriptor);
+            this._register(discovery);
+            discoveries.push(discovery);
+            discovery.start();
+        }
+        this.allPlugins = derived(read => {
+            if (!pluginsEnabled.read(read)) {
+                return [];
+            }
+            return this._dedupeAndSort(discoveries.flatMap(d => d.plugins.read(read)));
+        });
+        this.plugins = derived(reader => {
+            const all = this.allPlugins.read(reader);
+            return all.filter(p => p.enabled.read(reader));
+        });
+    }
+    setPluginEnabled(pluginUri, enabled) {
+        const plugin = this.allPlugins.get().find(p => ( p.uri.toString()) === ( pluginUri.toString()));
+        if (plugin) {
+            plugin.setEnabled(enabled);
+        }
+    }
+    _dedupeAndSort(plugins) {
+        const unique = [];
+        const seen = ( new ResourceSet());
+        for (const plugin of plugins) {
+            if (( seen.has(plugin.uri))) {
+                continue;
+            }
+            seen.add(plugin.uri);
+            unique.push(plugin);
+        }
+        unique.sort((a, b) => ( a.uri.toString()).localeCompare(( b.uri.toString())));
+        return unique;
+    }
+};
+AgentPluginService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IConfigurationService))], AgentPluginService));
+class AbstractAgentPluginDiscovery extends Disposable {
+    constructor(_fileService, _pathService, _logService, _instantiationService) {
+        super();
+        this._fileService = _fileService;
+        this._pathService = _pathService;
+        this._logService = _logService;
+        this._instantiationService = _instantiationService;
+        this._pluginEntries = ( new Map());
+        this._plugins = observableValue("discoveredAgentPlugins", []);
+        this.plugins = this._plugins;
+        this._discoverVersion = 0;
+    }
+    async _refreshPlugins() {
+        const version = ++this._discoverVersion;
+        const plugins = await this._discoverAndBuildPlugins();
+        if (version !== this._discoverVersion || this._store.isDisposed) {
+            return;
+        }
+        this._plugins.set(plugins, undefined);
+    }
+    async _discoverAndBuildPlugins() {
+        const sources = await this._discoverPluginSources();
+        const plugins = [];
+        const seenPluginUris = ( new Set());
+        for (const source of sources) {
+            const key = ( source.uri.toString());
+            if (!( seenPluginUris.has(key))) {
+                seenPluginUris.add(key);
+                const adapter = await this._detectPluginFormatAdapter(source.uri);
+                plugins.push(this._toPlugin(
+                    source.uri,
+                    source.enabled,
+                    adapter,
+                    source.fromMarketplace,
+                    value => source.setEnabled(value),
+                    () => source.remove()
+                ));
+            }
+        }
+        this._disposePluginEntriesExcept(seenPluginUris);
+        plugins.sort((a, b) => ( a.uri.toString()).localeCompare(( b.uri.toString())));
+        return plugins;
+    }
+    async _detectPluginFormatAdapter(pluginUri) {
+        const isInClaudeDirectory = pluginUri.path.split("/").includes(".claude");
+        if (isInClaudeDirectory || (await this._pathExists(joinPath(pluginUri, ".claude-plugin", "plugin.json")))) {
+            return this._instantiationService.createInstance(ClaudePluginFormatAdapter);
+        }
+        return this._instantiationService.createInstance(CopilotPluginFormatAdapter);
+    }
+    async _pathExists(resource) {
+        try {
+            await this._fileService.resolve(resource);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+    _toPlugin(
+        uri,
+        initialEnabled,
+        adapter,
+        fromMarketplace,
+        setEnabledCallback,
+        removeCallback
+    ) {
+        const key = ( uri.toString());
+        const existing = this._pluginEntries.get(key);
+        if (existing) {
+            if (existing.adapter.format !== adapter.format) {
+                existing.store.dispose();
+                this._pluginEntries.delete(key);
+            } else {
+                existing.plugin.enabled.set(initialEnabled, undefined);
+                return existing.plugin;
+            }
+        }
+        const store = ( new DisposableStore());
+        const commands = observableValue("agentPluginCommands", []);
+        const skills = observableValue("agentPluginSkills", []);
+        const agents = observableValue("agentPluginAgents", []);
+        const hooks = observableValue("agentPluginHooks", []);
+        const mcpServerDefinitions = observableValue("agentPluginMcpServerDefinitions", []);
+        const enabled = observableValue("agentPluginEnabled", initialEnabled);
+        const commandsDir = joinPath(uri, "commands");
+        const skillsDir = joinPath(uri, "skills");
+        const agentsDir = joinPath(uri, "agents");
+        const commandsScheduler = store.add(( new RunOnceScheduler(async () => {
+            commands.set(await this._readCommands(uri), undefined);
+        }, 200)));
+        const skillsScheduler = store.add(( new RunOnceScheduler(async () => {
+            skills.set(await this._readSkills(uri), undefined);
+        }, 200)));
+        const agentsScheduler = store.add(( new RunOnceScheduler(async () => {
+            agents.set(await this._readAgents(uri), undefined);
+        }, 200)));
+        const hooksScheduler = store.add(( new RunOnceScheduler(async () => {
+            hooks.set(await this._readHooks(uri, adapter), undefined);
+        }, 200)));
+        const mcpScheduler = store.add(( new RunOnceScheduler(async () => {
+            mcpServerDefinitions.set(await this._readMcpDefinitions(uri, adapter), undefined);
+        }, 200)));
+        store.add(this._fileService.watch(uri, {
+            recursive: true,
+            excludes: []
+        }));
+        store.add(this._fileService.onDidFilesChange(e => {
+            if (e.affects(commandsDir)) {
+                commandsScheduler.schedule();
+            }
+            if (e.affects(skillsDir)) {
+                skillsScheduler.schedule();
+            }
+            if (e.affects(agentsDir)) {
+                agentsScheduler.schedule();
+            }
+            if (( adapter.hookWatchPaths.some(path => e.affects(joinPath(uri, path))))) {
+                hooksScheduler.schedule();
+            }
+            if (e.affects(joinPath(uri, ".mcp.json")) || ( adapter.manifestPaths.some(path => e.affects(joinPath(uri, path))))) {
+                mcpScheduler.schedule();
+                hooksScheduler.schedule();
+            }
+        }));
+        commandsScheduler.schedule();
+        skillsScheduler.schedule();
+        agentsScheduler.schedule();
+        hooksScheduler.schedule();
+        mcpScheduler.schedule();
+        const plugin = {
+            uri,
+            label: fromMarketplace?.name ?? basename(uri),
+            enabled,
+            setEnabled: setEnabledCallback,
+            remove: removeCallback,
+            hooks,
+            commands,
+            skills,
+            agents,
+            mcpServerDefinitions,
+            fromMarketplace
+        };
+        this._pluginEntries.set(key, {
+            store,
+            plugin,
+            adapter
+        });
+        return plugin;
+    }
+    async _readMcpDefinitions(pluginUri, adapter) {
+        const mcpUri = joinPath(pluginUri, ".mcp.json");
+        const mcpFileConfig = await this._readJsonFile(mcpUri);
+        const fileDefinitions = this._parseMcpServerDefinitionMap(mcpFileConfig);
+        const pluginJsonDefinitions = await this._readInlinePluginJsonMcpDefinitions(pluginUri, adapter);
+        const merged = ( new Map());
+        for (const definition of fileDefinitions) {
+            merged.set(definition.name, definition.configuration);
+        }
+        for (const definition of pluginJsonDefinitions) {
+            if (!( merged.has(definition.name))) {
+                merged.set(definition.name, definition.configuration);
+            }
+        }
+        const definitions = ( [...merged.entries()].map(([name, configuration]) => ({
+            name,
+            configuration
+        }))).sort((a, b) => a.name.localeCompare(b.name));
+        return definitions;
+    }
+    async _readInlinePluginJsonMcpDefinitions(pluginUri, adapter) {
+        for (const manifestPath of ( adapter.manifestPaths.map(path => joinPath(pluginUri, path)))) {
+            const manifest = await this._readJsonFile(manifestPath);
+            if (!manifest || typeof manifest !== "object") {
+                continue;
+            }
+            const definitions = this._parseMcpServerDefinitionMap(manifest);
+            if (definitions.length > 0) {
+                return definitions;
+            }
+        }
+        return [];
+    }
+    _parseMcpServerDefinitionMap(raw) {
+        if (!raw || typeof raw !== "object" || !raw.hasOwnProperty("mcpServers")) {
+            return [];
+        }
+        const definitions = [];
+        for (const [name, configValue] of Object.entries(raw.mcpServers)) {
+            const configuration = this._normalizeMcpServerConfiguration(configValue);
+            if (!configuration) {
+                continue;
+            }
+            definitions.push({
+                name,
+                configuration
+            });
+        }
+        return definitions;
+    }
+    _normalizeMcpServerConfiguration(rawConfig) {
+        if (!rawConfig || typeof rawConfig !== "object") {
+            return undefined;
+        }
+        const candidate = rawConfig;
+        const type = typeof candidate["type"] === "string" ? candidate["type"] : undefined;
+        const command = typeof candidate["command"] === "string" ? candidate["command"] : undefined;
+        const url = typeof candidate["url"] === "string" ? candidate["url"] : undefined;
+        const args = Array.isArray(candidate["args"]) ? candidate["args"].filter(value => typeof value === "string") : undefined;
+        const env = candidate["env"] && typeof candidate["env"] === "object" ? Object.fromEntries(( Object.entries(candidate["env"]).filter(
+            ([, value]) => typeof value === "string" || typeof value === "number" || value === null
+        ).map(([key, value]) => [key, value]))) : undefined;
+        const envFile = typeof candidate["envFile"] === "string" ? candidate["envFile"] : undefined;
+        const cwd = typeof candidate["cwd"] === "string" ? candidate["cwd"] : undefined;
+        const headers = candidate["headers"] && typeof candidate["headers"] === "object" ? Object.fromEntries(( Object.entries(candidate["headers"]).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, value]))) : undefined;
+        const dev = candidate["dev"] && typeof candidate["dev"] === "object" ? candidate["dev"] : undefined;
+        if (type === "ws") {
+            return undefined;
+        }
+        if (type === McpServerType.LOCAL || (!type && command)) {
+            if (!command) {
+                return undefined;
+            }
+            return {
+                type: McpServerType.LOCAL,
+                command,
+                args,
+                env,
+                envFile,
+                cwd,
+                dev
+            };
+        }
+        if (type === McpServerType.REMOTE || type === "sse" || (!type && url)) {
+            if (!url) {
+                return undefined;
+            }
+            return {
+                type: McpServerType.REMOTE,
+                url,
+                headers,
+                dev
+            };
+        }
+        return undefined;
+    }
+    async _readHooks(pluginUri, adapter) {
+        const userHome = (await this._pathService.userHome()).fsPath;
+        for (const hooksUri of ( adapter.hookConfigPaths.map(path => joinPath(pluginUri, path)))) {
+            const json = await this._readJsonFile(hooksUri);
+            if (json) {
+                try {
+                    return adapter.parseHooks(json, pluginUri, userHome);
+                } catch (e) {
+                    this._logService.info(
+                        `[ConfiguredAgentPluginDiscovery] Failed to parse hooks from ${( hooksUri.toString())}:`,
+                        e
+                    );
+                }
+            }
+        }
+        for (const manifestPath of ( adapter.manifestPaths.map(path => joinPath(pluginUri, path)))) {
+            const manifest = await this._readJsonFile(manifestPath);
+            if (manifest && typeof manifest === "object") {
+                const hooks = manifest["hooks"];
+                if (hooks && typeof hooks === "object") {
+                    try {
+                        return adapter.parseHooks({
+                            hooks
+                        }, pluginUri, userHome);
+                    } catch (e) {
+                        this._logService.info(
+                            `[ConfiguredAgentPluginDiscovery] Failed to parse hooks from manifest ${( manifestPath.toString())}:`,
+                            e
+                        );
+                    }
+                }
+            }
+        }
+        return [];
+    }
+    async _readJsonFile(uri) {
+        try {
+            const fileContents = await this._fileService.readFile(uri);
+            return parse(( fileContents.value.toString()));
+        } catch {
+            return undefined;
+        }
+    }
+    async _readSkills(uri) {
+        const skillsDir = joinPath(uri, "skills");
+        let stat;
+        try {
+            stat = await this._fileService.resolve(skillsDir);
+        } catch {
+            return [];
+        }
+        if (!stat.isDirectory || !stat.children) {
+            return [];
+        }
+        const skills = [];
+        for (const child of stat.children) {
+            const skillMd = URI.joinPath(child.resource, "SKILL.md");
+            if (!(await this._pathExists(skillMd))) {
+                continue;
+            }
+            skills.push({
+                uri: skillMd,
+                name: basename(child.resource)
+            });
+        }
+        skills.sort((a, b) => a.name.localeCompare(b.name));
+        return skills;
+    }
+    async _readAgents(uri) {
+        const agentsDir = joinPath(uri, "agents");
+        let stat;
+        try {
+            stat = await this._fileService.resolve(agentsDir);
+        } catch {
+            return [];
+        }
+        if (!stat.isDirectory || !stat.children) {
+            return [];
+        }
+        const agents = [];
+        for (const child of stat.children) {
+            if (!child.isFile || extname(child.resource).toLowerCase() !== COMMAND_FILE_SUFFIX) {
+                continue;
+            }
+            const name = basename(child.resource).slice(0, -COMMAND_FILE_SUFFIX.length);
+            agents.push({
+                uri: child.resource,
+                name
+            });
+        }
+        agents.sort((a, b) => a.name.localeCompare(b.name));
+        return agents;
+    }
+    async _readCommands(uri) {
+        const commandsDir = joinPath(uri, "commands");
+        let stat;
+        try {
+            stat = await this._fileService.resolve(commandsDir);
+        } catch {
+            return [];
+        }
+        if (!stat.isDirectory || !stat.children) {
+            return [];
+        }
+        const commands = [];
+        for (const child of stat.children) {
+            if (!child.isFile || extname(child.resource).toLowerCase() !== COMMAND_FILE_SUFFIX) {
+                continue;
+            }
+            const name = basename(child.resource).slice(0, -COMMAND_FILE_SUFFIX.length);
+            commands.push({
+                uri: child.resource,
+                name
+            });
+        }
+        commands.sort((a, b) => a.name.localeCompare(b.name));
+        return commands;
+    }
+    _disposePluginEntriesExcept(keep) {
+        for (const [key, entry] of this._pluginEntries) {
+            if (!( keep.has(key))) {
+                entry.store.dispose();
+                this._pluginEntries.delete(key);
+            }
+        }
+    }
+    dispose() {
+        this._disposePluginEntriesExcept(( new Set()));
+        super.dispose();
+    }
+}
+let ConfiguredAgentPluginDiscovery = class ConfiguredAgentPluginDiscovery extends AbstractAgentPluginDiscovery {
+    constructor(
+        _configurationService,
+        fileService,
+        _pluginMarketplaceService,
+        _workspaceContextService,
+        pathService,
+        logService,
+        instantiationService
+    ) {
+        super(fileService, pathService, logService, instantiationService);
+        this._configurationService = _configurationService;
+        this._pluginMarketplaceService = _pluginMarketplaceService;
+        this._workspaceContextService = _workspaceContextService;
+        this._pluginLocationsConfig = observableConfigValue(ChatConfiguration.PluginLocations, {}, _configurationService);
+    }
+    start() {
+        const scheduler = this._register(( new RunOnceScheduler(() => this._refreshPlugins(), 0)));
+        this._register(autorun(reader => {
+            this._pluginLocationsConfig.read(reader);
+            scheduler.schedule();
+        }));
+        scheduler.schedule();
+    }
+    async _discoverPluginSources() {
+        const sources = [];
+        const config = this._pluginLocationsConfig.get();
+        const userHome = await this._getUserHome();
+        for (const [path, enabled] of Object.entries(config)) {
+            if (!path.trim()) {
+                continue;
+            }
+            const resources = this._resolvePluginPath(path.trim(), userHome);
+            for (const resource of resources) {
+                let stat;
+                try {
+                    stat = await this._fileService.resolve(resource);
+                } catch {
+                    this._logService.debug(
+                        `[ConfiguredAgentPluginDiscovery] Could not resolve plugin path: ${( resource.toString())}`
+                    );
+                    continue;
+                }
+                if (!stat.isDirectory) {
+                    this._logService.debug(
+                        `[ConfiguredAgentPluginDiscovery] Plugin path is not a directory: ${( resource.toString())}`
+                    );
+                    continue;
+                }
+                const fromMarketplace = this._pluginMarketplaceService.getMarketplacePluginMetadata(stat.resource);
+                const configKey = path;
+                sources.push({
+                    uri: stat.resource,
+                    enabled,
+                    fromMarketplace,
+                    setEnabled: value => this._updatePluginPathEnabled(configKey, value),
+                    remove: () => this._removePluginPath(configKey)
+                });
+            }
+        }
+        return sources;
+    }
+    async _getUserHome() {
+        const userHome = await this._pathService.userHome();
+        return userHome.scheme === "file" ? userHome.fsPath : userHome.path;
+    }
+    _resolvePluginPath(path, userHome) {
+        if (path.startsWith("~")) {
+            path = untildify(path, userHome);
+        }
+        if (win32.isAbsolute(path) || posix.isAbsolute(path)) {
+            return [URI.file(path)];
+        }
+        return ( this._workspaceContextService.getWorkspace().folders.map(folder => joinPath(folder.uri, path)));
+    }
+    _updatePluginPathEnabled(configKey, value) {
+        const inspected = this._configurationService.inspect(ChatConfiguration.PluginLocations);
+        const targets = [
+            ConfigurationTarget.WORKSPACE_FOLDER,
+            ConfigurationTarget.WORKSPACE,
+            ConfigurationTarget.USER_LOCAL,
+            ConfigurationTarget.USER_REMOTE,
+            ConfigurationTarget.USER,
+            ConfigurationTarget.APPLICATION
+        ];
+        for (const target of targets) {
+            const mapping = getConfigValueInTarget(inspected, target);
+            if (mapping && Object.prototype.hasOwnProperty.call(mapping, configKey)) {
+                this._configurationService.updateValue(ChatConfiguration.PluginLocations, {
+                    ...mapping,
+                    [configKey]: value
+                }, target);
+                return;
+            }
+        }
+        const current = getConfigValueInTarget(inspected, ConfigurationTarget.USER_LOCAL) ?? {};
+        this._configurationService.updateValue(ChatConfiguration.PluginLocations, {
+            ...current,
+            [configKey]: value
+        }, ConfigurationTarget.USER_LOCAL);
+    }
+    _removePluginPath(configKey) {
+        const inspected = this._configurationService.inspect(ChatConfiguration.PluginLocations);
+        const targets = [
+            ConfigurationTarget.WORKSPACE_FOLDER,
+            ConfigurationTarget.WORKSPACE,
+            ConfigurationTarget.USER_LOCAL,
+            ConfigurationTarget.USER_REMOTE,
+            ConfigurationTarget.USER,
+            ConfigurationTarget.APPLICATION
+        ];
+        for (const target of targets) {
+            const mapping = getConfigValueInTarget(inspected, target);
+            if (mapping && Object.prototype.hasOwnProperty.call(mapping, configKey)) {
+                const updated = {
+                    ...mapping
+                };
+                delete updated[configKey];
+                this._configurationService.updateValue(ChatConfiguration.PluginLocations, updated, target);
+                return;
+            }
+        }
+    }
+};
+ConfiguredAgentPluginDiscovery = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IFileService)), ( __param(2, IPluginMarketplaceService)), ( __param(3, IWorkspaceContextService)), ( __param(4, IPathService)), ( __param(5, ILogService)), ( __param(6, IInstantiationService))], ConfiguredAgentPluginDiscovery));
+let MarketplaceAgentPluginDiscovery = class MarketplaceAgentPluginDiscovery extends AbstractAgentPluginDiscovery {
+    constructor(
+        _pluginMarketplaceService,
+        _pluginRepositoryService,
+        fileService,
+        pathService,
+        logService,
+        instantiationService
+    ) {
+        super(fileService, pathService, logService, instantiationService);
+        this._pluginMarketplaceService = _pluginMarketplaceService;
+        this._pluginRepositoryService = _pluginRepositoryService;
+    }
+    start() {
+        const scheduler = this._register(( new RunOnceScheduler(() => this._refreshPlugins(), 0)));
+        this._register(autorun(reader => {
+            this._pluginMarketplaceService.installedPlugins.read(reader);
+            scheduler.schedule();
+        }));
+        scheduler.schedule();
+    }
+    async _discoverPluginSources() {
+        const installed = this._pluginMarketplaceService.installedPlugins.get();
+        const sources = [];
+        for (const entry of installed) {
+            let stat;
+            try {
+                stat = await this._fileService.resolve(entry.pluginUri);
+            } catch {
+                this._logService.debug(
+                    `[MarketplaceAgentPluginDiscovery] Could not resolve installed plugin: ${( entry.pluginUri.toString())}`
+                );
+                continue;
+            }
+            if (!stat.isDirectory) {
+                this._logService.debug(
+                    `[MarketplaceAgentPluginDiscovery] Installed plugin path is not a directory: ${( entry.pluginUri.toString())}`
+                );
+                continue;
+            }
+            sources.push({
+                uri: stat.resource,
+                enabled: entry.enabled,
+                fromMarketplace: entry.plugin,
+                setEnabled: value => this._pluginMarketplaceService.setInstalledPluginEnabled(entry.pluginUri, value),
+                remove: () => {
+                    this._pluginMarketplaceService.removeInstalledPlugin(entry.pluginUri);
+                    this._pluginRepositoryService.cleanupPluginSource(entry.plugin).catch(error => {
+                        this._logService.error(
+                            "[MarketplaceAgentPluginDiscovery] Failed to clean up plugin source",
+                            error
+                        );
+                    });
+                }
+            });
+        }
+        return sources;
+    }
+};
+MarketplaceAgentPluginDiscovery = ( __decorate([( __param(0, IPluginMarketplaceService)), ( __param(1, IAgentPluginRepositoryService)), ( __param(2, IFileService)), ( __param(3, IPathService)), ( __param(4, ILogService)), ( __param(5, IInstantiationService))], MarketplaceAgentPluginDiscovery));
+
+export { AbstractAgentPluginDiscovery, AgentPluginService, ConfiguredAgentPluginDiscovery, MarketplaceAgentPluginDiscovery, shellQuotePluginRootInCommand };