@codingame/monaco-vscode-chat-service-override 37.1.0 → 37.2.0

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

@@ -0,0 +1,178 @@
+
+import { PluginSourceKind } from './pluginMarketplaceService.js';
+import { CollisionEnablementModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
+
+const COPILOT_CLI_INSTALL_PATH_FRAGMENT = "/.copilot/installed-plugins/";
+class AgentPluginCollisionEnablementModel extends CollisionEnablementModel {
+    constructor(base, collisionGroups) {
+        super(base, collisionGroups);
+    }
+}
+function getSortedAgentPlugins(discoveries) {
+    return ( getUniqueAgentPluginCandidates(discoveries).map(candidate => candidate.plugin)).sort((a, b) => ( a.uri.toString()).localeCompare(( b.uri.toString())));
+}
+function getCanonicalAgentPluginCollisionGroups(discoveries, isBlocked) {
+    const candidates = getUniqueAgentPluginCandidates(discoveries);
+    const byCanonicalKey = ( new Map());
+    for (const candidate of candidates) {
+        if (isBlocked?.(candidate.plugin)) {
+            continue;
+        }
+        let group = byCanonicalKey.get(candidate.canonicalKey);
+        if (!group) {
+            group = [];
+            byCanonicalKey.set(candidate.canonicalKey, group);
+        }
+        group.push(( candidate.plugin.uri.toString()));
+    }
+    const groups = ( new Map());
+    for (const group of ( byCanonicalKey.values())) {
+        if (group.length < 2) {
+            continue;
+        }
+        for (const key of group) {
+            groups.set(key, group);
+        }
+    }
+    return groups;
+}
+function isAgentPluginBlockedByPolicy(plugin, enabledPluginsPolicy) {
+    const pluginId = getAgentPluginPolicyId(plugin);
+    return pluginId !== undefined && enabledPluginsPolicy?.[pluginId] === false;
+}
+function isAgentPluginForceEnabledByPolicy(plugin, enabledPluginsPolicy) {
+    const pluginId = getAgentPluginPolicyId(plugin);
+    return pluginId !== undefined && enabledPluginsPolicy?.[pluginId] === true;
+}
+function getAgentPluginPolicyId(plugin) {
+    const identity = getPolicyIdentity(plugin);
+    return identity ? `${identity.name}@${identity.marketplace}` : undefined;
+}
+function getAgentPluginCandidates(discoveries) {
+    const candidates = [];
+    for (const discovery of discoveries) {
+        for (let pluginOrder = 0; pluginOrder < discovery.plugins.length; pluginOrder++) {
+            const plugin = discovery.plugins[pluginOrder];
+            candidates.push({
+                plugin,
+                priority: discovery.priority,
+                order: discovery.order,
+                pluginOrder,
+                canonicalKey: getCanonicalPluginIdentity(plugin)
+            });
+        }
+    }
+    return candidates.sort(
+        (a, b) => a.priority - b.priority || a.order - b.order || a.pluginOrder - b.pluginOrder || ( a.plugin.uri.toString()).localeCompare(( b.plugin.uri.toString()))
+    );
+}
+function getUniqueAgentPluginCandidates(discoveries) {
+    const unique = [];
+    const seen = ( new Set());
+    for (const candidate of getAgentPluginCandidates(discoveries)) {
+        const key = ( candidate.plugin.uri.toString());
+        if (( seen.has(key))) {
+            continue;
+        }
+        seen.add(key);
+        unique.push(candidate);
+    }
+    return unique;
+}
+function getCanonicalPluginIdentity(plugin) {
+    return getMarketplaceCanonicalIdentity(plugin.fromMarketplace) ?? getCopilotCliInstallCanonicalIdentity(plugin) ?? `uri:${( plugin.uri.toString())}`;
+}
+function getMarketplaceCanonicalIdentity(plugin) {
+    if (!plugin) {
+        return undefined;
+    }
+    const normalizedName = normalizePluginIdentitySegment(plugin.name);
+    const source = plugin.sourceDescriptor;
+    switch (source.kind) {
+    case PluginSourceKind.RelativePath:
+        {
+            if (plugin.marketplaceReference.githubRepo) {
+                return `github:${plugin.marketplaceReference.githubRepo.toLowerCase()}|${normalizedName}`;
+            }
+            return `marketplace:${plugin.marketplaceReference.canonicalId}|${normalizedName}`;
+        }
+    case PluginSourceKind.GitHub:
+        {
+            const github = source;
+            return `github:${github.repo.toLowerCase()}|${normalizedName}`;
+        }
+    case PluginSourceKind.GitUrl:
+        {
+            const git = source;
+            return `git:${git.url.toLowerCase()}|${normalizedName}`;
+        }
+    case PluginSourceKind.Npm:
+        {
+            const npm = source;
+            return `npm:${npm.package.toLowerCase()}|${normalizedName}`;
+        }
+    case PluginSourceKind.Pip:
+        {
+            const pip = source;
+            return `pip:${pip.package.toLowerCase()}|${normalizedName}`;
+        }
+    }
+}
+function getCopilotCliInstallCanonicalIdentity(plugin) {
+    if (plugin.uri.scheme !== "file") {
+        return undefined;
+    }
+    const idx = plugin.uri.path.indexOf(COPILOT_CLI_INSTALL_PATH_FRAGMENT);
+    if (idx === -1) {
+        return undefined;
+    }
+    const segments = plugin.uri.path.slice(idx + COPILOT_CLI_INSTALL_PATH_FRAGMENT.length).split("/").filter(s => s.length > 0);
+    if (segments.length !== 2) {
+        return undefined;
+    }
+    const [bucket, installName] = segments;
+    const normalizedName = normalizePluginIdentitySegment(plugin.label || installName);
+    if (bucket !== "_direct") {
+        return `copilot-cli-marketplace:${normalizePluginIdentitySegment(bucket)}|${normalizedName}`;
+    }
+    const match = /^(?<owner>.+)--(?<repo>.+)--(?<plugin>.+)$/.exec(installName);
+    const groups = match?.groups;
+    if (!groups) {
+        return undefined;
+    }
+    return `github:${groups.owner.toLowerCase()}/${groups.repo.toLowerCase()}|${normalizePluginIdentitySegment(groups.plugin)}`;
+}
+function normalizePluginIdentitySegment(value) {
+    return value.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9_.:-]/g, "-").replace(/-+/g, "-").replace(/^[-:.]+|[-:.]+$/g, "");
+}
+function getPolicyIdentity(plugin) {
+    const m = plugin.fromMarketplace;
+    if (m) {
+        return {
+            name: m.name,
+            marketplace: m.marketplace,
+            marketplaceReference: m.marketplaceReference
+        };
+    }
+    if (plugin.uri.scheme !== "file") {
+        return undefined;
+    }
+    const idx = plugin.uri.path.indexOf(COPILOT_CLI_INSTALL_PATH_FRAGMENT);
+    if (idx === -1) {
+        return undefined;
+    }
+    const segments = plugin.uri.path.slice(idx + COPILOT_CLI_INSTALL_PATH_FRAGMENT.length).split("/").filter(s => s.length > 0);
+    if (segments.length !== 2) {
+        return undefined;
+    }
+    const [marketplace, name] = segments;
+    if (marketplace === "_direct") {
+        return undefined;
+    }
+    return {
+        name,
+        marketplace
+    };
+}
+
+export { AgentPluginCollisionEnablementModel, getAgentPluginPolicyId, getCanonicalAgentPluginCollisionGroups, getSortedAgentPlugins, isAgentPluginBlockedByPolicy, isAgentPluginForceEnabledByPolicy };

package/vscode/src/vs/workbench/contrib/chat/common/plugins/agentPluginService.d.ts

@@ -0,0 +1,78 @@
+import { 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 { SyncDescriptor0 } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors";
+import { type INamedPluginResource, type IMcpServerDefinition, type IParsedHookCommand, type PluginFormat } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentPlugins/common/pluginParsers";
+import { ContributionEnablementState, IEnablementModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement";
+import { IAutomationBlueprint } from "../automations/automationBlueprint.js";
+import { HookType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes";
+import { IMarketplacePlugin } from "./pluginMarketplaceService.js";
+export interface IAgentPluginHook {
+    readonly type: HookType;
+    readonly hooks: readonly IParsedHookCommand[];
+    /** URI where this hook is defined -- not unique, multiple hooks may be in a manifest */
+    readonly uri: URI;
+    readonly originalId: string;
+}
+export type IAgentPluginCommand = INamedPluginResource;
+export type IAgentPluginSkill = INamedPluginResource;
+export type IAgentPluginAgent = INamedPluginResource;
+export type IAgentPluginInstruction = INamedPluginResource;
+export type IAgentPluginMcpServerDefinition = IMcpServerDefinition;
+export interface IAgentPluginAutomation {
+    readonly uri: URI;
+    readonly blueprint: IAutomationBlueprint;
+}
+export interface IAgentPlugin {
+    readonly uri: URI;
+    readonly format: PluginFormat;
+    /** Human-readable display name for the plugin. */
+    readonly label: string;
+    /** Version declared by the plugin manifest, falling back to marketplace metadata. */
+    readonly version?: IObservable<string | undefined>;
+    readonly enablement: IObservable<ContributionEnablementState>;
+    /**
+     * When `true`, the plugin is blocked by enterprise policy. It remains
+     * visible (shown as disabled) but its contributions are inactive and the
+     * user cannot re-enable it. Folded into {@link enablement} so all gating
+     * consumers honor it automatically.
+     */
+    readonly policyBlocked?: IObservable<boolean>;
+    /** Removes this plugin from its discovery source (config or installed storage). Undefined for policy-managed plugins that cannot be removed by the user. */
+    remove?(): Promise<boolean>;
+    readonly hooks: IObservable<readonly IAgentPluginHook[]>;
+    readonly commands: IObservable<readonly IAgentPluginCommand[]>;
+    readonly skills: IObservable<readonly IAgentPluginSkill[]>;
+    readonly agents: IObservable<readonly IAgentPluginAgent[]>;
+    readonly instructions: IObservable<readonly IAgentPluginInstruction[]>;
+    readonly mcpServerDefinitions: IObservable<readonly IAgentPluginMcpServerDefinition[]>;
+    readonly automations: IObservable<readonly IAgentPluginAutomation[]>;
+    /** Set when the plugin was installed from a marketplace repository. */
+    readonly fromMarketplace?: IMarketplacePlugin;
+}
+export interface IAgentPluginDiscovery extends IDisposable {
+    readonly plugins: IObservable<readonly IAgentPlugin[] | undefined>;
+    start(enablementModel: IEnablementModel): void;
+}
+export declare enum AgentPluginDiscoveryPriority {
+    Configured = 10,
+    Marketplace = 20,
+    Extension = 30,
+    CopilotCli = 40
+}
+export declare function getCanonicalPluginCommandId(plugin: {
+    readonly uri: URI;
+    readonly label?: string;
+}, commandName: string): string;
+declare class AgentPluginDiscoveryRegistry {
+    private readonly _discovery;
+    private _order;
+    register(descriptor: SyncDescriptor0<IAgentPluginDiscovery>, priority: AgentPluginDiscoveryPriority): IDisposable;
+    getAll(): readonly {
+        readonly descriptor: SyncDescriptor0<IAgentPluginDiscovery>;
+        readonly priority: AgentPluginDiscoveryPriority;
+        readonly order: number;
+    }[];
+}
+export declare const agentPluginDiscoveryRegistry: AgentPluginDiscoveryRegistry;
+export {};

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

@@ -0,0 +1,51 @@
+
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+
+var AgentPluginDiscoveryPriority;
+(function(AgentPluginDiscoveryPriority) {
+    AgentPluginDiscoveryPriority[AgentPluginDiscoveryPriority["Configured"] = 10] = "Configured";
+    AgentPluginDiscoveryPriority[AgentPluginDiscoveryPriority["Marketplace"] = 20] = "Marketplace";
+    AgentPluginDiscoveryPriority[AgentPluginDiscoveryPriority["Extension"] = 30] = "Extension";
+    AgentPluginDiscoveryPriority[AgentPluginDiscoveryPriority["CopilotCli"] = 40] = "CopilotCli";
+})(AgentPluginDiscoveryPriority || (AgentPluginDiscoveryPriority = {}));
+function getCanonicalPluginCommandId(plugin, commandName) {
+    const prefix = (plugin.label ? normalizePluginToken(plugin.label) : "") || normalizePluginToken(basename(plugin.uri));
+    const normalizedCommand = normalizePluginToken(commandName);
+    if (normalizedCommand.startsWith(`${prefix}:`)) {
+        return normalizedCommand;
+    }
+    if (prefix === normalizedCommand) {
+        return prefix;
+    }
+    return `${prefix}:${normalizedCommand}`;
+}
+function normalizePluginToken(value) {
+    return value.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9_.:-]/g, "-").replace(/-+/g, "-").replace(/^[-:.]+|[-:.]+$/g, "");
+}
+class AgentPluginDiscoveryRegistry {
+    constructor() {
+        this._discovery = [];
+        this._order = 0;
+    }
+    register(descriptor, priority) {
+        const registration = {
+            descriptor,
+            priority,
+            order: this._order++
+        };
+        this._discovery.push(registration);
+        return toDisposable(() => {
+            const index = this._discovery.indexOf(registration);
+            if (index >= 0) {
+                this._discovery.splice(index, 1);
+            }
+        });
+    }
+    getAll() {
+        return [...this._discovery].sort((a, b) => a.priority - b.priority || a.order - b.order);
+    }
+}
+const agentPluginDiscoveryRegistry = ( new AgentPluginDiscoveryRegistry());
+
+export { AgentPluginDiscoveryPriority, agentPluginDiscoveryRegistry, getCanonicalPluginCommandId };

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

@@ -13,9 +13,9 @@ import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/
 import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
 import { IEnablementModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement";
 import { IAgentPluginRepositoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service";
-import { IAgentPlugin, IAgentPluginDiscovery } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService";
+import { IAgentPlugin, IAgentPluginDiscovery } from "./agentPluginService.js";
 import { IAgentPluginService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service";
-import { IMarketplacePlugin } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService";
+import { IMarketplacePlugin } from "./pluginMarketplaceService.js";
 import { IPluginMarketplaceService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service";
 export { shellQuotePluginRootInCommand, resolveMcpServersMap, convertBareEnvVarsToVsCodeSyntax } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentPlugins/common/pluginParsers";
 export declare class AgentPluginService extends Disposable implements IAgentPluginService {

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

@@ -36,9 +36,9 @@ import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbe
 import { EnablementModel, ContributionEnablementState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
 import { AUTOMATION_BLUEPRINT_FILE_SUFFIX, parseAutomationBlueprint } from '../automations/automationBlueprint.js';
 import { HookType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes';
-import { getCanonicalAgentPluginCollisionGroups, isAgentPluginBlockedByPolicy, AgentPluginCollisionEnablementModel, getSortedAgentPlugins, getAgentPluginPolicyId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginEnablement';
+import { getCanonicalAgentPluginCollisionGroups, isAgentPluginBlockedByPolicy, AgentPluginCollisionEnablementModel, getSortedAgentPlugins, getAgentPluginPolicyId } from './agentPluginEnablement.js';
 import { IAgentPluginRepositoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service';
-import { agentPluginDiscoveryRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService';
+import { agentPluginDiscoveryRegistry } from './agentPluginService.js';
 import { IPluginMarketplaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service';
 import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';

package/vscode/src/vs/workbench/contrib/chat/common/plugins/fileBackedInstalledPluginsStore.d.ts

@@ -0,0 +1,67 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable, ITransaction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+/**
+ * In-memory representation of an installed plugin entry.
+ */
+export interface IStoredInstalledPlugin {
+    readonly pluginUri: URI;
+    readonly marketplace: string;
+    readonly name?: string;
+}
+/**
+ * An observable store for installed agent plugins that is backed by a
+ * `installed.json` file within the agent-plugins directory. This makes
+ * the installed-plugin manifest discoverable by external tools (CLIs,
+ * other editors, etc.) without depending on VS Code internals.
+ *
+ * The on-disk format stores only the plugin URI (as a string), marketplace
+ * identifier, and plugin name. Full plugin metadata (description, source
+ * descriptor, etc.) is read from marketplace data by the discovery layer -
+ * keeping a single source of truth.
+ *
+ * On construction the store:
+ * 1. Attempts to read `installed.json` from the agent-plugins directory.
+ * 2. If no file exists, migrates data from the legacy {@link StorageService}
+ *    key (`chat.plugins.installed.v1`), rebasing plugin URIs from the old
+ *    cache directory to the new agent-plugins directory.
+ * 3. Sets up a correlated file watcher so that external edits to
+ *    `installed.json` are picked up automatically.
+ *
+ * Write operations update the in-memory observable synchronously and
+ * schedule a debounced file write so that rapid successive mutations
+ * (e.g. batch enables) are coalesced into a single I/O operation.
+ */
+export declare class FileBackedInstalledPluginsStore extends Disposable {
+    private readonly _agentPluginsHome;
+    private readonly _oldCacheRoot;
+    private readonly _fileService;
+    private readonly _logService;
+    private readonly _storageService;
+    private readonly _installed;
+    private readonly _fileUri;
+    private readonly _writeDelayer;
+    private _suppressFileWatch;
+    private _initialized;
+    readonly value: IObservable<readonly IStoredInstalledPlugin[]>;
+    constructor(_agentPluginsHome: URI, _oldCacheRoot: URI | undefined, _fileService: IFileService, _logService: ILogService, _storageService: IStorageService);
+    get(): readonly IStoredInstalledPlugin[];
+    set(newValue: readonly IStoredInstalledPlugin[], tx: ITransaction | undefined): void;
+    private _initialize;
+    private _readFromFile;
+    private _scheduleWrite;
+    private _writeToFile;
+    private _setupFileWatcher;
+    private _onFileChanged;
+    private _setValue;
+    private _migrateFromStorage;
+    /**
+     * If the plugin URI was under the old cache root, rebase it to the
+     * new agent-plugins directory. Otherwise, return `undefined` to keep
+     * the original.
+     */
+    private _rebasePluginUri;
+}

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

@@ -0,0 +1,195 @@
+
+import { ThrottledDelayer, RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { joinPath, isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+const INSTALLED_JSON_FILENAME = "installed.json";
+const INSTALLED_JSON_VERSION = 1;
+const LEGACY_INSTALLED_PLUGINS_STORAGE_KEY = "chat.plugins.installed.v1";
+const LEGACY_MARKETPLACE_INDEX_STORAGE_KEY = "chat.plugins.marketplaces.index.v1";
+class FileBackedInstalledPluginsStore extends Disposable {
+    constructor(
+        _agentPluginsHome,
+        _oldCacheRoot,
+        _fileService,
+        _logService,
+        _storageService
+    ) {
+        super();
+        this._agentPluginsHome = _agentPluginsHome;
+        this._oldCacheRoot = _oldCacheRoot;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        this._storageService = _storageService;
+        this._installed = observableValue("file/installed.json", []);
+        this._suppressFileWatch = false;
+        this._initialized = false;
+        this.value = this._installed;
+        this._fileUri = joinPath(_agentPluginsHome, INSTALLED_JSON_FILENAME);
+        this._writeDelayer = this._register(( new ThrottledDelayer(100)));
+        void this._initialize();
+    }
+    get() {
+        return this._installed.get();
+    }
+    set(newValue, tx) {
+        this._setValue(newValue, tx, true);
+    }
+    async _initialize() {
+        try {
+            const read = await this._readFromFile();
+            if (read !== undefined) {
+                this._setValue(read, undefined, false);
+            } else {
+                await this._migrateFromStorage();
+            }
+        } catch (error) {
+            this._logService.error("[FileBackedInstalledPluginsStore] Initialization failed", error);
+        }
+        this._initialized = true;
+        this._setupFileWatcher();
+    }
+    async _readFromFile() {
+        try {
+            const exists = await this._fileService.exists(this._fileUri);
+            if (!exists) {
+                return undefined;
+            }
+            const content = await this._fileService.readFile(this._fileUri);
+            const json = JSON.parse(( content.value.toString()));
+            if (!json || !Array.isArray(json.installed)) {
+                this._logService.warn(
+                    "[FileBackedInstalledPluginsStore] installed.json has unexpected format, ignoring"
+                );
+                return undefined;
+            }
+            return ( json.installed.filter(
+                entry => typeof entry.pluginUri === "string" && typeof entry.marketplace === "string"
+            ).map(entry => ({
+                pluginUri: ( URI.parse(entry.pluginUri)),
+                marketplace: entry.marketplace,
+                name: typeof entry.name === "string" ? entry.name : undefined
+            })));
+        } catch {
+            return undefined;
+        }
+    }
+    _scheduleWrite() {
+        void this._writeDelayer.trigger(async () => {
+            await this._writeToFile();
+        });
+    }
+    async _writeToFile() {
+        const entries = ( this.get().map(e => ({
+            pluginUri: ( e.pluginUri.toString()),
+            marketplace: e.marketplace,
+            ...(e.name ? {
+                name: e.name
+            } : {})
+        })));
+        const data = {
+            version: INSTALLED_JSON_VERSION,
+            installed: entries
+        };
+        try {
+            this._suppressFileWatch = true;
+            const content = JSON.stringify(data, undefined, "\t");
+            await this._fileService.createFolder(this._agentPluginsHome);
+            await this._fileService.writeFile(this._fileUri, VSBuffer.fromString(content));
+            return true;
+        } catch (error) {
+            this._logService.error("[FileBackedInstalledPluginsStore] Failed to write installed.json", error);
+            return false;
+        } finally {
+            this._suppressFileWatch = false;
+        }
+    }
+    _setupFileWatcher() {
+        if (typeof this._fileService.createWatcher !== "function") {
+            return;
+        }
+        const dir = this._agentPluginsHome;
+        const watcher = this._fileService.createWatcher(dir, {
+            recursive: false,
+            excludes: []
+        });
+        this._register(watcher);
+        const scheduler = this._register(( new RunOnceScheduler(() => this._onFileChanged(), 100)));
+        this._register(watcher.onDidChange(e => {
+            if (!this._suppressFileWatch && e.affects(this._fileUri)) {
+                scheduler.schedule();
+            }
+        }));
+    }
+    async _onFileChanged() {
+        const read = await this._readFromFile();
+        if (read !== undefined) {
+            this._suppressFileWatch = true;
+            try {
+                this._setValue(read, undefined, false);
+            } finally {
+                this._suppressFileWatch = false;
+            }
+        }
+    }
+    _setValue(newValue, tx, scheduleWrite) {
+        this._installed.set(newValue, tx);
+        if (scheduleWrite && this._initialized && !this._suppressFileWatch) {
+            this._scheduleWrite();
+        }
+    }
+    async _migrateFromStorage() {
+        const raw = this._storageService.get(LEGACY_INSTALLED_PLUGINS_STORAGE_KEY, StorageScope.APPLICATION);
+        if (!raw) {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed) || parsed.length === 0) {
+                return;
+            }
+            const migrated = ( revive(parsed).map(entry => {
+                const uri = URI.revive(entry.pluginUri);
+                const rebased = this._rebasePluginUri(uri);
+                return {
+                    pluginUri: rebased ?? uri,
+                    marketplace: entry.plugin?.marketplaceReference?.rawValue ?? "",
+                    name: entry.plugin?.name
+                };
+            })).filter(e => !!e.marketplace);
+            this._logService.info(
+                `[FileBackedInstalledPluginsStore] Migrating ${migrated.length} plugin(s) from storage to installed.json`
+            );
+            this._setValue(migrated, undefined, false);
+            const didPersist = await this._writeToFile();
+            if (!didPersist) {
+                return;
+            }
+            this._storageService.remove(LEGACY_INSTALLED_PLUGINS_STORAGE_KEY, StorageScope.APPLICATION);
+            this._storageService.remove(LEGACY_MARKETPLACE_INDEX_STORAGE_KEY, StorageScope.APPLICATION);
+        } catch (error) {
+            this._logService.error("[FileBackedInstalledPluginsStore] Migration from storage failed", error);
+        }
+    }
+    _rebasePluginUri(uri) {
+        if (!this._oldCacheRoot) {
+            return undefined;
+        }
+        const oldRoot = this._oldCacheRoot;
+        if (!isEqual(uri, oldRoot) && uri.scheme === oldRoot.scheme && uri.path.startsWith(oldRoot.path + "/")) {
+            const relativePart = uri.path.substring(oldRoot.path.length);
+            return uri.with({
+                path: this._agentPluginsHome.path + relativePart
+            });
+        }
+        return undefined;
+    }
+}
+
+export { FileBackedInstalledPluginsStore };

package/vscode/src/vs/workbench/contrib/chat/common/plugins/marketplaceReference.d.ts

@@ -0,0 +1,67 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+export { extraKnownMarketplacesToConfigDict } from "@codingame/monaco-vscode-api/vscode/vs/base/common/managedSettings";
+export declare enum MarketplaceReferenceKind {
+    GitHubShorthand = "githubShorthand",
+    GitUri = "gitUri",
+    LocalFileUri = "localFileUri"
+}
+export interface IMarketplaceReference {
+    readonly rawValue: string;
+    readonly displayLabel: string;
+    readonly cloneUrl: string;
+    readonly canonicalId: string;
+    readonly cacheSegments: readonly string[];
+    readonly kind: MarketplaceReferenceKind;
+    readonly ref?: string;
+    readonly githubRepo?: string;
+    readonly localRepositoryUri?: URI;
+    readonly autoUpdate?: boolean;
+}
+/**
+ * The two configuration layers behind plugin marketplaces:
+ * - `userValues` — what's stored at {@link ChatConfiguration.PluginMarketplaces}
+ *   (default + user). Writable by the user.
+ * - `extraValues` — what's delivered via the `ChatExtraMarketplaces` enterprise
+ *   policy into {@link ChatConfiguration.ExtraMarketplaces}. Read-only.
+ *
+ * Entries may be strings (`<owner>/<repo>` or git URIs) or, in the policy case,
+ * {@link IExtraMarketplaceObjectEntry} objects — both shapes flow through
+ * {@link parseMarketplaceReferences}.
+ */
+export interface IConfiguredMarketplaces {
+    readonly userValues: readonly unknown[];
+    readonly extraValues: readonly unknown[];
+    readonly effectiveValues: readonly unknown[];
+}
+export declare function readConfiguredMarketplaces(configurationService: IConfigurationService): IConfiguredMarketplaces;
+export declare function parseMarketplaceReferences(values: readonly unknown[]): IMarketplaceReference[];
+/**
+ * Object-form marketplace entry shape, as delivered via the enterprise
+ * `managed_settings` policy or `.github/copilot/settings.json` workspace
+ * file. `name` (when present) is used as the marketplace's `displayLabel`
+ * so that `enabledPlugins["plugin@name"]` keys match consistently.
+ *
+ * Both the nested form (`source: { source, repo|url }`) and the flat form
+ * (`source: 'github', repo: ...`) are accepted.
+ */
+export interface IExtraMarketplaceObjectEntry {
+    readonly name?: string;
+    readonly source?: string | {
+        readonly source?: string;
+        readonly repo?: string;
+        readonly url?: string;
+        readonly ref?: string;
+    };
+    readonly repo?: string;
+    readonly url?: string;
+    readonly ref?: string;
+    readonly autoUpdate?: boolean;
+}
+export declare function parseMarketplaceObjectEntry(entry: IExtraMarketplaceObjectEntry): IMarketplaceReference | undefined;
+/**
+ * Merges two sets of marketplace references, deduplicating by canonical ID.
+ * The first set takes precedence when IDs collide.
+ */
+export declare function deduplicateMarketplaceReferences(primary: readonly IMarketplaceReference[], secondary: readonly IMarketplaceReference[]): IMarketplaceReference[];
+export declare function parseMarketplaceReference(value: string): IMarketplaceReference | undefined;