@codingame/monaco-vscode-chat-service-override 29.1.0 → 30.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/actions/createPluginAction.js

@@ -0,0 +1,482 @@
+
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/jsonc';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { basename, dirname, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { isUriComponents, URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, MenuId, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IFileDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { InstalledAgentPluginsViewId } from '../agentPluginsView.js';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { McpCollectionSortOrder, McpServerTransportType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+
+const VALID_PLUGIN_NAME = /^[a-z0-9]([a-z0-9\-.]*[a-z0-9])?$/;
+const INVALID_CONSECUTIVE = /--|[.][.]/;
+function validatePluginName(name) {
+    if (!name) {
+        return localize(5052, "Plugin name is required.");
+    }
+    if (name.length > 64) {
+        return localize(5053, "Plugin name must be at most 64 characters.");
+    }
+    if (!VALID_PLUGIN_NAME.test(name)) {
+        return localize(
+            5054,
+            "Plugin name must contain only lowercase alphanumeric characters, hyphens, and periods, and must start and end with an alphanumeric character."
+        );
+    }
+    if (INVALID_CONSECUTIVE.test(name)) {
+        return localize(5055, "Plugin name must not contain consecutive hyphens or periods.");
+    }
+    return undefined;
+}
+function isUserDefined(storage) {
+    return storage === PromptsStorage.local || storage === PromptsStorage.user;
+}
+function isUserDefinedMcpCollection(collection) {
+    const order = collection.presentation?.order;
+    return order === McpCollectionSortOrder.User || order === McpCollectionSortOrder.WorkspaceFolder || order === McpCollectionSortOrder.Workspace;
+}
+function getResourceLabel(r) {
+    if (r.name) {
+        return r.name;
+    }
+    if (r.type === PromptsType.skill && basename(r.uri).toLowerCase() === "skill.md") {
+        return basename(dirname(r.uri));
+    }
+    return basename(r.uri);
+}
+function getResourceFileName(r) {
+    const label = getResourceLabel(r);
+    const colonIndex = label.indexOf(":");
+    return colonIndex >= 0 ? label.substring(colonIndex + 1) : label;
+}
+class CreatePluginAction extends Action2 {
+    static {
+        this.ID = "workbench.action.chat.createPlugin";
+    }
+    constructor() {
+        super({
+            id: CreatePluginAction.ID,
+            title: ( localize2(5056, "Create Plugin")),
+            category: CHAT_CATEGORY,
+            f1: true,
+            precondition: ChatContextKeys.enabled,
+            icon: Codicon.save,
+            menu: [{
+                id: MenuId.ViewTitle,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("view", InstalledAgentPluginsViewId)), ( ChatContextKeys.Setup.hidden.negate()))),
+                group: "navigation",
+                order: 2
+            }]
+        });
+    }
+    async run(accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const promptsService = accessor.get(IPromptsService);
+        const mcpRegistry = accessor.get(IMcpRegistry);
+        const fileDialogService = accessor.get(IFileDialogService);
+        const fileService = accessor.get(IFileService);
+        const commandService = accessor.get(ICommandService);
+        const notificationService = accessor.get(INotificationService);
+        const [instructions, prompts, agents, skills, hooks] = await (async () => {
+            const cts = ( new CancellationTokenSource());
+            try {
+                return await Promise.all([
+                    promptsService.listPromptFiles(PromptsType.instructions, cts.token),
+                    promptsService.listPromptFiles(PromptsType.prompt, cts.token),
+                    promptsService.listPromptFiles(PromptsType.agent, cts.token),
+                    promptsService.listPromptFiles(PromptsType.skill, cts.token),
+                    promptsService.listPromptFiles(PromptsType.hook, cts.token)
+                ]);
+            } finally {
+                cts.dispose(true);
+            }
+        })();
+        const mcpCollections = mcpRegistry.collections.get();
+        let showAll = false;
+        const buildTree = () => {
+            const groups = [];
+            const addGroup = (resources, resourceType, groupLabel, icon) => {
+                const filtered = showAll ? resources : resources.filter(r => isUserDefined(r.storage));
+                if (filtered.length === 0) {
+                    return;
+                }
+                const children = ( filtered.map(r => ({
+                    label: getResourceLabel(r),
+                    description: r.storage,
+                    resourceType,
+                    promptPath: r,
+                    checked: false
+                })));
+                groups.push({
+                    label: groupLabel,
+                    iconClass: ThemeIcon.asClassName(icon),
+                    checked: undefined,
+                    collapsed: false,
+                    pickable: false,
+                    children
+                });
+            };
+            addGroup(instructions, "instruction", ( localize(5057, "Instructions")), Codicon.book);
+            addGroup(prompts, "prompt", ( localize(5058, "Prompts")), Codicon.comment);
+            addGroup(agents, "agent", ( localize(5059, "Agents")), Codicon.copilot);
+            addGroup(skills, "skill", ( localize(5060, "Skills")), Codicon.lightbulb);
+            addGroup(hooks, "hook", ( localize(5061, "Hooks")), Codicon.zap);
+            const mcpChildren = [];
+            for (const collection of mcpCollections) {
+                if (!showAll && !isUserDefinedMcpCollection(collection)) {
+                    continue;
+                }
+                const defs = collection.serverDefinitions.get();
+                for (const def of defs) {
+                    mcpChildren.push({
+                        label: def.label,
+                        description: collection.label,
+                        resourceType: "mcp",
+                        mcpServer: {
+                            collection,
+                            definition: def
+                        },
+                        checked: false
+                    });
+                }
+            }
+            if (mcpChildren.length > 0) {
+                groups.push({
+                    label: ( localize(5062, "MCP Servers")),
+                    iconClass: ThemeIcon.asClassName(Codicon.mcp),
+                    checked: undefined,
+                    collapsed: false,
+                    pickable: false,
+                    children: mcpChildren
+                });
+            }
+            return groups;
+        };
+        const disposables = ( new DisposableStore());
+        const tree = disposables.add(quickInputService.createQuickTree());
+        tree.placeholder = ( localize(5063, "Select resources to include in the plugin"));
+        tree.matchOnDescription = true;
+        tree.matchOnLabel = true;
+        tree.sortByLabel = false;
+        tree.title = ( localize(5064, "Create Plugin"));
+        tree.setItemTree(buildTree());
+        const toggleButton = {
+            iconClass: ThemeIcon.asClassName(Codicon.filter),
+            tooltip: ( localize(5065, "Show Built-in, Extension, and Plugin Resources"))
+        };
+        tree.buttons = [toggleButton];
+        disposables.add(tree.onDidTriggerButton(button => {
+            if (button === toggleButton) {
+                showAll = !showAll;
+                tree.setItemTree(buildTree());
+            }
+        }));
+        const selectedItems = await ( new Promise(resolve => {
+            disposables.add(tree.onDidAccept(() => {
+                resolve(tree.checkedLeafItems);
+                tree.hide();
+            }));
+            disposables.add(tree.onDidHide(() => {
+                resolve(undefined);
+            }));
+            tree.show();
+        }));
+        disposables.dispose();
+        if (!selectedItems || selectedItems.length === 0) {
+            return;
+        }
+        const selected = selectedItems.filter(i => !!i.resourceType);
+        const pluginName = await quickInputService.input({
+            prompt: ( localize(5066, "Enter a name for the plugin")),
+            placeHolder: "my-plugin",
+            validateInput: async value => validatePluginName(value)
+        });
+        if (!pluginName) {
+            return;
+        }
+        const folderUris = await fileDialogService.showOpenDialog({
+            canSelectFiles: false,
+            canSelectFolders: true,
+            canSelectMany: false,
+            title: ( localize(5067, "Select Plugin Save Location")),
+            openLabel: ( localize(5068, "Select Folder"))
+        });
+        if (!folderUris || folderUris.length === 0) {
+            return;
+        }
+        const targetDir = folderUris[0];
+        const pluginRoot = joinPath(targetDir, pluginName);
+        if (await fileService.exists(pluginRoot)) {
+            notificationService.error(( localize(
+                5069,
+                "A directory named '{0}' already exists at this location. Please choose a different name or location.",
+                pluginName
+            )));
+            return;
+        }
+        try {
+            await writePluginToDisk(fileService, pluginRoot, pluginName, selected);
+            await updateMarketplaceIfNeeded(fileService, targetDir, pluginName);
+            try {
+                await commandService.executeCommand("revealFileInOS", pluginRoot);
+            } catch {}
+            notificationService.info(( localize(5070, "Plugin '{0}' created successfully.", pluginName)));
+        } catch (err) {
+            notificationService.error(( localize(5071, "Failed to create plugin: {0}", String(err))));
+        }
+    }
+}
+async function writePluginToDisk(fileService, pluginRoot, pluginName, selected) {
+    await fileService.createFolder(pluginRoot);
+    const manifestDir = joinPath(pluginRoot, ".plugin");
+    await fileService.createFolder(manifestDir);
+    const manifest = {
+        name: pluginName,
+        version: "1.0.0",
+        description: ""
+    };
+    await fileService.writeFile(
+        joinPath(manifestDir, "plugin.json"),
+        VSBuffer.fromString(JSON.stringify(manifest, null, "\t"))
+    );
+    const byType = {
+        instruction: selected.filter(i => i.resourceType === "instruction"),
+        prompt: selected.filter(i => i.resourceType === "prompt"),
+        agent: selected.filter(i => i.resourceType === "agent"),
+        skill: selected.filter(i => i.resourceType === "skill"),
+        hook: selected.filter(i => i.resourceType === "hook"),
+        mcp: selected.filter(i => i.resourceType === "mcp")
+    };
+    if (byType.instruction.length > 0) {
+        const rulesDir = joinPath(pluginRoot, "rules");
+        await fileService.createFolder(rulesDir);
+        for (const item of byType.instruction) {
+            if (!item.promptPath) {
+                continue;
+            }
+            const name = getResourceFileName(item.promptPath);
+            const fileName = name.endsWith(".instructions.md") || name.endsWith(".mdc") || name.endsWith(".md") ? name : name + ".instructions.md";
+            const content = await fileService.readFile(item.promptPath.uri);
+            await fileService.writeFile(joinPath(rulesDir, fileName), content.value);
+        }
+    }
+    if (byType.prompt.length > 0) {
+        const commandsDir = joinPath(pluginRoot, "commands");
+        await fileService.createFolder(commandsDir);
+        for (const item of byType.prompt) {
+            if (!item.promptPath) {
+                continue;
+            }
+            const name = getResourceFileName(item.promptPath);
+            const fileName = name.endsWith(".md") ? name : name + ".md";
+            const content = await fileService.readFile(item.promptPath.uri);
+            await fileService.writeFile(joinPath(commandsDir, fileName), content.value);
+        }
+    }
+    if (byType.agent.length > 0) {
+        const agentsDir = joinPath(pluginRoot, "agents");
+        await fileService.createFolder(agentsDir);
+        for (const item of byType.agent) {
+            if (!item.promptPath) {
+                continue;
+            }
+            const name = getResourceFileName(item.promptPath);
+            const fileName = name.endsWith(".md") ? name : name + ".md";
+            const content = await fileService.readFile(item.promptPath.uri);
+            await fileService.writeFile(joinPath(agentsDir, fileName), content.value);
+        }
+    }
+    if (byType.skill.length > 0) {
+        const skillsDir = joinPath(pluginRoot, "skills");
+        await fileService.createFolder(skillsDir);
+        for (const item of byType.skill) {
+            if (!item.promptPath) {
+                continue;
+            }
+            const sourceUri = item.promptPath.uri;
+            const skillName = getResourceFileName(item.promptPath);
+            const sourceName = basename(sourceUri);
+            const isFile = sourceName.toLowerCase() === "skill.md";
+            const skillSourceDir = isFile ? joinPath(sourceUri, "..") : sourceUri;
+            const destSkillDir = joinPath(skillsDir, skillName);
+            await copyDirectory(fileService, skillSourceDir, destSkillDir);
+        }
+    }
+    if (byType.hook.length > 0) {
+        const hooksDir = joinPath(pluginRoot, "hooks");
+        await fileService.createFolder(hooksDir);
+        const mergedHooks = {};
+        for (const item of byType.hook) {
+            if (!item.promptPath) {
+                continue;
+            }
+            try {
+                const content = await fileService.readFile(item.promptPath.uri);
+                const parsed = parse(( content.value.toString()));
+                const hooksObj = (parsed?.hooks ?? parsed);
+                if (hooksObj && typeof hooksObj === "object") {
+                    for (const [hookType, commands] of Object.entries(hooksObj)) {
+                        if (Array.isArray(commands)) {
+                            if (!mergedHooks[hookType]) {
+                                mergedHooks[hookType] = [];
+                            }
+                            for (const cmd of commands) {
+                                mergedHooks[hookType].push(serializeHookCommand(cmd));
+                            }
+                        }
+                    }
+                }
+            } catch {}
+        }
+        const hooksJson = {
+            hooks: mergedHooks
+        };
+        await fileService.writeFile(
+            joinPath(hooksDir, "hooks.json"),
+            VSBuffer.fromString(JSON.stringify(hooksJson, null, "\t"))
+        );
+    }
+    if (byType.mcp.length > 0) {
+        const mcpServers = {};
+        for (const item of byType.mcp) {
+            if (!item.mcpServer) {
+                continue;
+            }
+            const def = item.mcpServer.definition;
+            mcpServers[def.label] = serializeMcpLaunch(def.launch);
+        }
+        const mcpJson = {
+            mcpServers
+        };
+        await fileService.writeFile(
+            joinPath(pluginRoot, ".mcp.json"),
+            VSBuffer.fromString(JSON.stringify(mcpJson, null, "\t"))
+        );
+    }
+}
+function serializeHookCommand(cmd) {
+    const result = {
+        type: "command"
+    };
+    if (typeof cmd.command === "string") {
+        result["command"] = cmd.command;
+    }
+    if (typeof cmd.windows === "string") {
+        result["windows"] = cmd.windows;
+    }
+    if (typeof cmd.linux === "string") {
+        result["linux"] = cmd.linux;
+    }
+    if (typeof cmd.osx === "string") {
+        result["osx"] = cmd.osx;
+    }
+    if (cmd.cwd !== undefined) {
+        result["cwd"] = isUriComponents(cmd.cwd) ? URI.revive(cmd.cwd).fsPath : String(cmd.cwd);
+    }
+    if (cmd.env && typeof cmd.env === "object" && ( Object.keys(cmd.env)).length > 0) {
+        result["env"] = cmd.env;
+    }
+    if (typeof cmd.timeout === "number") {
+        result["timeout"] = cmd.timeout;
+    }
+    return result;
+}
+function serializeMcpLaunch(launch) {
+    if (launch.type === McpServerTransportType.Stdio) {
+        const result = {
+            type: "stdio",
+            command: launch.command
+        };
+        if (launch.args.length > 0) {
+            result["args"] = [...launch.args];
+        }
+        if (launch.cwd) {
+            result["cwd"] = launch.cwd;
+        }
+        if (( Object.keys(launch.env)).length > 0) {
+            result["env"] = {
+                ...launch.env
+            };
+        }
+        return result;
+    } else {
+        const result = {
+            type: "http",
+            url: ( launch.uri.toString())
+        };
+        if (launch.headers.length > 0) {
+            const headers = {};
+            for (const [key, value] of launch.headers) {
+                headers[key] = value;
+            }
+            result["headers"] = headers;
+        }
+        return result;
+    }
+}
+async function copyDirectory(fileService, source, target) {
+    const stat = await fileService.resolve(source);
+    if (stat.isDirectory) {
+        await fileService.createFolder(target);
+        if (stat.children) {
+            for (const child of stat.children) {
+                const childName = basename(child.resource);
+                await copyDirectory(fileService, child.resource, joinPath(target, childName));
+            }
+        }
+    } else {
+        const content = await fileService.readFile(source);
+        await fileService.writeFile(target, content.value);
+    }
+}
+const MARKETPLACE_PATHS = ["marketplace.json", ".plugin/marketplace.json"];
+async function updateMarketplaceIfNeeded(fileService, targetDir, pluginName) {
+    for (const relPath of MARKETPLACE_PATHS) {
+        const marketplaceUri = joinPath(targetDir, relPath);
+        if (await fileService.exists(marketplaceUri)) {
+            try {
+                const content = await fileService.readFile(marketplaceUri);
+                const marketplace = parse(( content.value.toString()));
+                if (marketplace && typeof marketplace === "object") {
+                    if (!Array.isArray(marketplace["plugins"])) {
+                        marketplace["plugins"] = [];
+                    }
+                    const plugins = marketplace["plugins"];
+                    if (( plugins.some(p => p.name === pluginName))) {
+                        return;
+                    }
+                    plugins.push({
+                        name: pluginName,
+                        source: `./${pluginName}/`
+                    });
+                    await fileService.writeFile(
+                        marketplaceUri,
+                        VSBuffer.fromString(JSON.stringify(marketplace, null, "\t"))
+                    );
+                }
+            } catch {}
+            return;
+        }
+    }
+}
+function registerCreatePluginAction() {
+    registerAction2(CreatePluginAction);
+}
+
+export { copyDirectory, getResourceFileName, getResourceLabel, registerCreatePluginAction, serializeHookCommand, serializeMcpLaunch, updateMarketplaceIfNeeded, validatePluginName, writePluginToDisk };

package/vscode/src/vs/workbench/contrib/chat/browser/agentPluginActions.js

@@ -17,7 +17,7 @@ import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types
 
 let InstallPluginAction = class InstallPluginAction extends Action {
     constructor(item, pluginInstallService) {
-        super("agentPlugin.install", ( localize(5050, "Install")), "extension-action label prominent install", true, () => pluginInstallService.installPlugin({
+        super("agentPlugin.install", ( localize(5072, "Install")), "extension-action label prominent install", true, () => pluginInstallService.installPlugin({
             name: item.name,
             description: item.description,
             version: "",
@@ -33,7 +33,7 @@ let InstallPluginAction = class InstallPluginAction extends Action {
 InstallPluginAction = ( __decorate([( __param(1, IPluginInstallService))], InstallPluginAction));
 class UninstallPluginAction extends Action {
     constructor(plugin) {
-        super("agentPlugin.uninstall", ( localize(5051, "Uninstall")), "extension-action label uninstall", true, () => {
+        super("agentPlugin.uninstall", ( localize(5073, "Uninstall")), "extension-action label uninstall", true, () => {
             plugin.remove();
             return Promise.resolve();
         });
@@ -41,7 +41,7 @@ class UninstallPluginAction extends Action {
 }
 let OpenPluginFolderAction = class OpenPluginFolderAction extends Action {
     constructor(plugin, commandService, openerService) {
-        super("agentPlugin.openFolder", ( localize(5052, "Open Plugin Folder")), undefined, true, async () => {
+        super("agentPlugin.openFolder", ( localize(5074, "Open Plugin Folder")), undefined, true, async () => {
             try {
                 await commandService.executeCommand("revealFileInOS", plugin.uri);
             } catch {
@@ -53,7 +53,7 @@ let OpenPluginFolderAction = class OpenPluginFolderAction extends Action {
 OpenPluginFolderAction = ( __decorate([( __param(1, ICommandService)), ( __param(2, IOpenerService))], OpenPluginFolderAction));
 let OpenPluginReadmeAction = class OpenPluginReadmeAction extends Action {
     constructor(readmeUri, openerService) {
-        super("agentPlugin.openReadme", ( localize(5053, "Open README")), undefined, true, () => openerService.open(readmeUri));
+        super("agentPlugin.openReadme", ( localize(5075, "Open README")), undefined, true, () => openerService.open(readmeUri));
     }
 };
 OpenPluginReadmeAction = ( __decorate([( __param(1, IOpenerService))], OpenPluginReadmeAction));
@@ -168,11 +168,11 @@ class EnablementDropdownActionViewItem extends ActionWithDropdownActionViewItem
 function createEnablePluginDropDown(plugin, enablementModel, workspaceContextService) {
     const key = ( plugin.uri.toString());
     const hasWorkspace = workspaceContextService.getWorkbenchState() !== WorkbenchState.EMPTY;
-    const enable = ( new EnablementSubAction("agentPlugin.enable", ( localize(5054, "Enable")), "extension-action label prominent", isContributionDisabled(plugin.enablement.get()), () => {
+    const enable = ( new EnablementSubAction("agentPlugin.enable", ( localize(5076, "Enable")), "extension-action label prominent", isContributionDisabled(plugin.enablement.get()), () => {
         enablementModel.setEnabled(key, ContributionEnablementState.EnabledProfile);
         return Promise.resolve();
     }));
-    const enableWorkspace = ( new EnablementSubAction("agentPlugin.enableForWorkspace", ( localize(5055, "Enable (Workspace)")), "extension-action label", isContributionDisabled(plugin.enablement.get()) && hasWorkspace, () => {
+    const enableWorkspace = ( new EnablementSubAction("agentPlugin.enableForWorkspace", ( localize(5077, "Enable (Workspace)")), "extension-action label", isContributionDisabled(plugin.enablement.get()) && hasWorkspace, () => {
         enablementModel.setEnabled(key, ContributionEnablementState.EnabledWorkspace);
         return Promise.resolve();
     }));
@@ -181,11 +181,11 @@ function createEnablePluginDropDown(plugin, enablementModel, workspaceContextSer
 function createDisablePluginDropDown(plugin, enablementModel, workspaceContextService) {
     const key = ( plugin.uri.toString());
     const hasWorkspace = workspaceContextService.getWorkbenchState() !== WorkbenchState.EMPTY;
-    const disable = ( new EnablementSubAction("agentPlugin.disable", ( localize(5056, "Disable")), "extension-action label disable", isContributionEnabled(plugin.enablement.get()), () => {
+    const disable = ( new EnablementSubAction("agentPlugin.disable", ( localize(5078, "Disable")), "extension-action label disable", isContributionEnabled(plugin.enablement.get()), () => {
         enablementModel.setEnabled(key, ContributionEnablementState.DisabledProfile);
         return Promise.resolve();
     }));
-    const disableWorkspace = ( new EnablementSubAction("agentPlugin.disableForWorkspace", ( localize(5057, "Disable (Workspace)")), "extension-action label disable", isContributionEnabled(plugin.enablement.get()) && hasWorkspace, () => {
+    const disableWorkspace = ( new EnablementSubAction("agentPlugin.disableForWorkspace", ( localize(5079, "Disable (Workspace)")), "extension-action label disable", isContributionEnabled(plugin.enablement.get()) && hasWorkspace, () => {
         enablementModel.setEnabled(key, ContributionEnablementState.DisabledWorkspace);
         return Promise.resolve();
     }));

package/vscode/src/vs/workbench/contrib/chat/browser/agentPluginEditor/agentPluginEditor.js

@@ -357,7 +357,7 @@ let AgentPluginEditor = class AgentPluginEditor extends EditorPane {
         this.contentDisposables.add(toDisposable(insert(this.layoutParticipants, {
             layout
         })));
-        return this.openMarkdown(this.pluginReadme.get(), ( localize(5058, "No README available.")), readmeContainer, WebviewIndex.Readme, ( localize(5059, "Readme")), token);
+        return this.openMarkdown(this.pluginReadme.get(), ( localize(5080, "No README available.")), readmeContainer, WebviewIndex.Readme, ( localize(5081, "Readme")), token);
     }
     async openMarkdown(cacheResult, noContentCopy, container, webviewIndex, title, token) {
         try {
@@ -529,7 +529,7 @@ let UpdatePluginEditorAction = class UpdatePluginEditorAction extends Action {
         pluginInstallService,
         pluginMarketplaceService
     ) {
-        super(UpdatePluginEditorAction_1.ID, ( localize(5060, "Update")), "extension-action label prominent install");
+        super(UpdatePluginEditorAction_1.ID, ( localize(5082, "Update")), "extension-action label prominent install");
         this.plugin = plugin;
         this.liveMarketplacePlugin = liveMarketplacePlugin;
         this.pluginInstallService = pluginInstallService;

package/vscode/src/vs/workbench/contrib/chat/browser/agentPluginEditor/agentPluginEditorInput.js

@@ -8,7 +8,7 @@ import { EditorInputCapabilities } from '@codingame/monaco-vscode-api/vscode/vs/
 import { EditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput';
 import { AgentPluginItemKind } from './agentPluginItems.js';
 
-const AgentPluginEditorIcon = registerIcon("agent-plugin-editor-icon", Codicon.extensions, ( localize(5061, "Icon of the Agent Plugin editor.")));
+const AgentPluginEditorIcon = registerIcon("agent-plugin-editor-icon", Codicon.extensions, ( localize(5083, "Icon of the Agent Plugin editor.")));
 function getPluginId(item) {
     if (item.kind === AgentPluginItemKind.Installed) {
         return ( item.plugin.uri.toString());
@@ -39,7 +39,7 @@ class AgentPluginEditorInput extends EditorInput {
         return this._item;
     }
     getName() {
-        return localize(5062, "Plugin: {0}", this._item.name);
+        return localize(5084, "Plugin: {0}", this._item.name);
     }
     getIcon() {
         return AgentPluginEditorIcon;

package/vscode/src/vs/workbench/contrib/chat/browser/agentPluginRepositoryService.d.ts

@@ -1,6 +1,6 @@
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
-import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.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";
@@ -19,11 +19,13 @@ export declare class AgentPluginRepositoryService implements IAgentPluginReposit
     private readonly _progressService;
     private readonly _storageService;
     readonly _serviceBrand: undefined;
+    readonly agentPluginsHome: URI;
     private readonly _cacheRoot;
     private readonly _marketplaceIndex;
     private readonly _pluginSources;
     private readonly _cloneSequencer;
-    constructor(_commandService: ICommandService, environmentService: IEnvironmentService, _fileService: IFileService, instantiationService: IInstantiationService, _logService: ILogService, _notificationService: INotificationService, _progressService: IProgressService, _storageService: IStorageService);
+    private readonly _migrationDone;
+    constructor(_commandService: ICommandService, environmentService: IWorkbenchEnvironmentService, _fileService: IFileService, instantiationService: IInstantiationService, _logService: ILogService, _notificationService: INotificationService, _progressService: IProgressService, _storageService: IStorageService);
     getPluginSource(kind: PluginSourceKind): IPluginSource;
     getRepositoryUri(marketplace: IMarketplaceReference, marketplaceType?: MarketplaceType): URI;
     getPluginInstallUri(plugin: IMarketplacePlugin): URI;
@@ -47,4 +49,10 @@ export declare class AgentPluginRepositoryService implements IAgentPluginReposit
      * of the cache root — returns immediately for paths outside it.
      */
     private _pruneEmptyParents;
+    /**
+     * One-time migration of plugin files from the old internal cache
+     * directory (`{cacheHome}/agentPlugins/`) to the new well-known
+     * location (`~/{dataFolderName}/agent-plugins/`).
+     */
+    private _migrateDirectory;
 }