@codingame/monaco-vscode-chat-service-override 28.4.0 → 29.0.0

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

@@ -1,10 +1,12 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { runWhenGlobalIdle } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
 import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
 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 { isEqualOrParent, isEqual, joinPath, normalizePath, relativePath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 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';
@@ -15,20 +17,22 @@ import { asJson } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/
 import { IRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { AutoUpdateConfigurationKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions';
 import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { IAgentPluginRepositoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service';
+import { IWorkspacePluginSettingsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/workspacePluginSettingsService.service';
+import { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { parseMarketplaceReferences, deduplicateMarketplaceReferences, parseMarketplaceReference, MarketplaceReferenceKind } from './marketplaceReference.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 
 var MarketplaceType;
 (function(MarketplaceType) {
     MarketplaceType["Copilot"] = "copilot";
     MarketplaceType["Claude"] = "claude";
+    MarketplaceType["OpenPlugin"] = "openPlugin";
 })(MarketplaceType || (MarketplaceType = {}));
-var MarketplaceReferenceKind;
-(function(MarketplaceReferenceKind) {
-    MarketplaceReferenceKind["GitHubShorthand"] = "githubShorthand";
-    MarketplaceReferenceKind["GitUri"] = "gitUri";
-    MarketplaceReferenceKind["LocalFileUri"] = "localFileUri";
-})(MarketplaceReferenceKind || (MarketplaceReferenceKind = {}));
 var PluginSourceKind;
 (function(PluginSourceKind) {
     PluginSourceKind["RelativePath"] = "relativePath";
@@ -38,6 +42,12 @@ var PluginSourceKind;
     PluginSourceKind["Pip"] = "pip";
 })(PluginSourceKind || (PluginSourceKind = {}));
 const MARKETPLACE_DEFINITIONS = [{
+    type: MarketplaceType.OpenPlugin,
+    path: "marketplace.json"
+}, {
+    type: MarketplaceType.OpenPlugin,
+    path: ".plugin/marketplace.json"
+}, {
     type: MarketplaceType.Copilot,
     path: ".github/plugin/marketplace.json"
 }, {
@@ -46,6 +56,8 @@ const MARKETPLACE_DEFINITIONS = [{
 }];
 const GITHUB_MARKETPLACE_CACHE_TTL_MS = 8 * 60 * 60 * 1000;
 const GITHUB_MARKETPLACE_CACHE_STORAGE_KEY = "chat.plugins.marketplaces.githubCache.v1";
+const PLUGIN_UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const PLUGIN_UPDATE_LAST_CHECK_STORAGE_KEY = "chat.plugins.lastUpdateCheck.v1";
 function ensureSourceDescriptor(plugin) {
     if (plugin.sourceDescriptor) {
         return plugin;
@@ -76,6 +88,24 @@ const trustedMarketplacesMemento = observableMemento({
         return Array.isArray(parsed) ? parsed : [];
     }
 });
+const lastFetchedPluginsMemento = observableMemento({
+    defaultValue: {
+        plugins: [],
+        fetchedAt: 0
+    },
+    key: "chat.plugins.lastFetchedPlugins.v2",
+    toStorage: value => JSON.stringify(value),
+    fromStorage: value => {
+        const parsed = JSON.parse(value);
+        if (parsed && Array.isArray(parsed.plugins)) {
+            return parsed;
+        }
+        return {
+            plugins: [],
+            fetchedAt: 0
+        };
+    }
+});
 let PluginMarketplaceService = class PluginMarketplaceService extends Disposable {
     constructor(
         _configurationService,
@@ -83,7 +113,9 @@ let PluginMarketplaceService = class PluginMarketplaceService extends Disposable
         _fileService,
         _pluginRepositoryService,
         _logService,
-        _storageService
+        _storageService,
+        _workspacePluginSettingsService,
+        _workspaceTrustService
     ) {
         super();
         this._configurationService = _configurationService;
@@ -92,28 +124,81 @@ let PluginMarketplaceService = class PluginMarketplaceService extends Disposable
         this._pluginRepositoryService = _pluginRepositoryService;
         this._logService = _logService;
         this._storageService = _storageService;
+        this._workspacePluginSettingsService = _workspacePluginSettingsService;
+        this._workspaceTrustService = _workspaceTrustService;
         this._gitHubMarketplaceCache = ( new Lazy(() => this._loadPersistedGitHubMarketplaceCache()));
+        this._hasUpdatesAvailable = observableValue("hasUpdatesAvailable", false);
+        this.hasUpdatesAvailable = this._hasUpdatesAvailable;
         this._installedPluginsStore = this._register(
             installedPluginsMemento(StorageScope.APPLICATION, StorageTarget.MACHINE, _storageService)
         );
         this._trustedMarketplacesStore = this._register(
             trustedMarketplacesMemento(StorageScope.APPLICATION, StorageTarget.MACHINE, _storageService)
         );
+        this._lastFetchedPluginsStore = this._register(
+            lastFetchedPluginsMemento(StorageScope.APPLICATION, StorageTarget.MACHINE, _storageService)
+        );
+        this.lastFetchedPlugins = ( this._lastFetchedPluginsStore.map(s => {
+            const revived = revive(s);
+            return ( revived.plugins.map(ensureSourceDescriptor));
+        }));
         this.installedPlugins = ( this._installedPluginsStore.map(s => ( revive(s).map(e => ({
             ...e,
             plugin: ensureSourceDescriptor(e.plugin)
         })))));
-        this.onDidChangeMarketplaces = Event.filter(
+        const workspaceTrusted = observableFromEvent(
+            this,
+            this._workspaceTrustService.onDidChangeTrust,
+            () => this._workspaceTrustService.isWorkspaceTrusted()
+        );
+        this.recommendedPlugins = derived(reader => {
+            if (!workspaceTrusted.read(reader)) {
+                return ( new Set());
+            }
+            const enabledMap = this._workspacePluginSettingsService.enabledPlugins.read(reader);
+            const keys = ( new Set());
+            for (const [key, value] of enabledMap) {
+                if (value) {
+                    keys.add(key);
+                }
+            }
+            return keys;
+        });
+        this.onDidChangeMarketplaces = Event.any(Event.filter(
             _configurationService.onDidChangeConfiguration,
             e => e.affectsConfiguration(ChatConfiguration.PluginsEnabled) || e.affectsConfiguration(ChatConfiguration.PluginMarketplaces)
-        );
+        ), Event.fromObservableLight(this._workspacePluginSettingsService.extraMarketplaces), ( Event.map(this._workspaceTrustService.onDidChangeTrust, () => {})));
+        this._register(runWhenGlobalIdle(() => {
+            this._scheduleUpdateCheck();
+            this._register(Event.filter(
+                _configurationService.onDidChangeConfiguration,
+                e => e.affectsConfiguration(AutoUpdateConfigurationKey)
+            )(() => this._scheduleUpdateCheck()));
+        }));
+    }
+    dispose() {
+        if (this._updateCheckTimer !== undefined) {
+            clearTimeout(this._updateCheckTimer);
+            this._updateCheckTimer = undefined;
+        }
+        super.dispose();
+    }
+    clearUpdatesAvailable() {
+        this._hasUpdatesAvailable.set(false, undefined);
     }
     async fetchMarketplacePlugins(token) {
         if (!this._configurationService.getValue(ChatConfiguration.PluginsEnabled)) {
             return [];
         }
         const configuredRefs = this._configurationService.getValue(ChatConfiguration.PluginMarketplaces) ?? [];
-        const refs = parseMarketplaceReferences(configuredRefs);
+        const configRefs = parseMarketplaceReferences(configuredRefs);
+        let allRefs;
+        if (this._workspaceTrustService.isWorkspaceTrusted()) {
+            const workspaceEntries = this._workspacePluginSettingsService.extraMarketplaces.get();
+            allRefs = deduplicateMarketplaceReferences(( workspaceEntries.map(e => e.reference)), configRefs);
+        } else {
+            allRefs = configRefs;
+        }
         for (const value of configuredRefs) {
             if (typeof value !== "string" || !parseMarketplaceReference(value)) {
                 this._logService.debug(
@@ -121,19 +206,28 @@ let PluginMarketplaceService = class PluginMarketplaceService extends Disposable
                 );
             }
         }
-        const results = await Promise.all(( refs.map(ref => {
+        const results = await Promise.all(( allRefs.map(ref => {
             if (ref.kind === MarketplaceReferenceKind.GitHubShorthand && ref.githubRepo) {
                 return this._fetchFromGitHubRepo(ref, ref.githubRepo, token);
             }
             return this._fetchFromClonedRepo(ref, token);
         })));
-        return results.flat();
+        const plugins = results.flat();
+        this._lastFetchedPluginsStore.set({
+            plugins,
+            fetchedAt: Date.now()
+        }, undefined);
+        return plugins;
     }
     async _fetchFromGitHubRepo(reference, repo, token) {
         const cache = this._gitHubMarketplaceCache.value;
         const cached = this._getCachedGitHubMarketplacePlugins(cache, reference.canonicalId);
         if (cached) {
-            return cached;
+            return ( cached.map(c => ({
+                ...c,
+                marketplace: reference.displayLabel,
+                marketplaceReference: reference
+            })));
         }
         let repoMayBePrivate = true;
         for (const def of MARKETPLACE_DEFINITIONS) {
@@ -144,7 +238,8 @@ let PluginMarketplaceService = class PluginMarketplaceService extends Disposable
             try {
                 const context = await this._requestService.request({
                     type: "GET",
-                    url
+                    url,
+                    callSite: "pluginMarketplaceService.fetchPluginList"
                 }, token);
                 const statusCode = context.res.statusCode;
                 if (statusCode !== 200) {
@@ -277,8 +372,13 @@ let PluginMarketplaceService = class PluginMarketplaceService extends Disposable
     }
     addInstalledPlugin(pluginUri, plugin) {
         const current = this.installedPlugins.get();
-        if (( current.some(e => isEqual(e.pluginUri, pluginUri)))) {
-            this._installedPluginsStore.set([...current], undefined);
+        const existing = current.find(e => isEqual(e.pluginUri, pluginUri));
+        if (existing) {
+            this._installedPluginsStore.set(( current.map(c => c === existing ? {
+                pluginUri,
+                plugin,
+                enabled: existing.enabled
+            } : c)), undefined);
         } else {
             this._installedPluginsStore.set([...current, {
                 pluginUri,
@@ -307,6 +407,65 @@ let PluginMarketplaceService = class PluginMarketplaceService extends Disposable
             this._trustedMarketplacesStore.set([...current, ref.canonicalId], undefined);
         }
     }
+    _isAutoUpdateEnabled() {
+        return this._configurationService.getValue(AutoUpdateConfigurationKey);
+    }
+    _scheduleUpdateCheck() {
+        if (this._updateCheckTimer !== undefined) {
+            clearTimeout(this._updateCheckTimer);
+            this._updateCheckTimer = undefined;
+        }
+        if (!this._isAutoUpdateEnabled()) {
+            return;
+        }
+        const lastCheck = this._storageService.getNumber(PLUGIN_UPDATE_LAST_CHECK_STORAGE_KEY, StorageScope.APPLICATION, 0);
+        const elapsed = Date.now() - lastCheck;
+        const delay = Math.max(0, PLUGIN_UPDATE_CHECK_INTERVAL_MS - elapsed);
+        this._updateCheckTimer = setTimeout(() => this._runUpdateCheck(), delay);
+    }
+    async _runUpdateCheck() {
+        this._updateCheckTimer = undefined;
+        try {
+            const installed = this.installedPlugins.get().filter(e => e.enabled);
+            if (installed.length === 0) {
+                return;
+            }
+            const seenMarketplaces = ( new Set());
+            let hasUpdates = false;
+            for (const entry of installed) {
+                const ref = entry.plugin.marketplaceReference;
+                if (( seenMarketplaces.has(ref.canonicalId))) {
+                    continue;
+                }
+                seenMarketplaces.add(ref.canonicalId);
+                try {
+                    const behind = await this._pluginRepositoryService.fetchRepository(ref);
+                    if (behind) {
+                        hasUpdates = true;
+                        break;
+                    }
+                } catch (err) {
+                    this._logService.debug(
+                        `[PluginMarketplaceService] Update check failed for ${ref.displayLabel}:`,
+                        err
+                    );
+                }
+            }
+            this._hasUpdatesAvailable.set(hasUpdates, undefined);
+            this._storageService.store(
+                PLUGIN_UPDATE_LAST_CHECK_STORAGE_KEY,
+                Date.now(),
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+        } catch (err) {
+            this._logService.debug("[PluginMarketplaceService] Periodic update check failed:", err);
+        } finally {
+            if (this._isAutoUpdateEnabled()) {
+                this._updateCheckTimer = setTimeout(() => this._runUpdateCheck(), PLUGIN_UPDATE_CHECK_INTERVAL_MS);
+            }
+        }
+    }
     async _fetchFromClonedRepo(reference, token) {
         let repoDir;
         try {
@@ -318,8 +477,14 @@ let PluginMarketplaceService = class PluginMarketplaceService extends Disposable
             );
             return [];
         }
+        return this._readPluginsFromDirectory(repoDir, reference, token);
+    }
+    async readPluginsFromDirectory(repoDir, reference) {
+        return this._readPluginsFromDirectory(repoDir, reference);
+    }
+    async _readPluginsFromDirectory(repoDir, reference, token) {
         for (const def of MARKETPLACE_DEFINITIONS) {
-            if (token.isCancellationRequested) {
+            if (token?.isCancellationRequested) {
                 return [];
             }
             const definitionUri = joinPath(repoDir, def.path);
@@ -363,131 +528,7 @@ let PluginMarketplaceService = class PluginMarketplaceService extends Disposable
         return [];
     }
 };
-PluginMarketplaceService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IRequestService)), ( __param(2, IFileService)), ( __param(3, IAgentPluginRepositoryService)), ( __param(4, ILogService)), ( __param(5, IStorageService))], PluginMarketplaceService));
-function parseMarketplaceReferences(values) {
-    const byCanonicalId = ( new Map());
-    for (const value of values) {
-        if (typeof value !== "string") {
-            continue;
-        }
-        const parsed = parseMarketplaceReference(value);
-        if (!parsed) {
-            continue;
-        }
-        if (!( byCanonicalId.has(parsed.canonicalId))) {
-            byCanonicalId.set(parsed.canonicalId, parsed);
-        }
-    }
-    return [...( byCanonicalId.values())];
-}
-function parseMarketplaceReference(value) {
-    const rawValue = value.trim();
-    if (!rawValue) {
-        return undefined;
-    }
-    const uriReference = parseUriMarketplaceReference(rawValue);
-    if (uriReference) {
-        return uriReference;
-    }
-    const scpReference = parseScpMarketplaceReference(rawValue);
-    if (scpReference) {
-        return scpReference;
-    }
-    const shorthandMatch = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(rawValue);
-    if (shorthandMatch) {
-        const owner = shorthandMatch[1];
-        const repo = shorthandMatch[2];
-        return {
-            rawValue,
-            displayLabel: `${owner}/${repo}`,
-            cloneUrl: `https://github.com/${owner}/${repo}.git`,
-            canonicalId: getGitHubCanonicalId(owner, repo),
-            cacheSegments: ["github.com", owner, repo],
-            kind: MarketplaceReferenceKind.GitHubShorthand,
-            githubRepo: `${owner}/${repo}`
-        };
-    }
-    return undefined;
-}
-function parseUriMarketplaceReference(rawValue) {
-    let uri;
-    try {
-        uri = ( URI.parse(rawValue));
-    } catch {
-        return undefined;
-    }
-    const scheme = uri.scheme.toLowerCase();
-    if (scheme === "file" && /^file:\/\//i.test(rawValue)) {
-        const localRepositoryUri = URI.file(uri.fsPath);
-        return {
-            rawValue,
-            displayLabel: localRepositoryUri.fsPath,
-            cloneUrl: rawValue,
-            canonicalId: `file:${( localRepositoryUri.toString()).toLowerCase()}`,
-            cacheSegments: [],
-            kind: MarketplaceReferenceKind.LocalFileUri,
-            localRepositoryUri
-        };
-    }
-    if (scheme !== "http" && scheme !== "https" && scheme !== "ssh") {
-        return undefined;
-    }
-    if (!uri.authority) {
-        return undefined;
-    }
-    const normalizedPath = normalizeGitRepoPath(uri.path);
-    if (!normalizedPath) {
-        return undefined;
-    }
-    const sanitizedAuthority = sanitizePathSegment(uri.authority.toLowerCase());
-    const pathSegments = ( normalizedPath.slice(1, -4).split("/").map(sanitizePathSegment));
-    return {
-        rawValue,
-        displayLabel: rawValue,
-        cloneUrl: rawValue,
-        canonicalId: `git:${uri.authority.toLowerCase()}/${normalizedPath.slice(1).toLowerCase()}`,
-        cacheSegments: [sanitizedAuthority, ...pathSegments],
-        kind: MarketplaceReferenceKind.GitUri
-    };
-}
-function parseScpMarketplaceReference(rawValue) {
-    const match = /^([^@\s]+)@([^:\s]+):(.+\.git)$/i.exec(rawValue);
-    if (!match) {
-        return undefined;
-    }
-    const authority = match[2];
-    const pathWithGit = match[3].replace(/^\/+/, "");
-    if (!pathWithGit.toLowerCase().endsWith(".git")) {
-        return undefined;
-    }
-    const pathSegments = ( pathWithGit.slice(0, -4).split("/").map(sanitizePathSegment));
-    return {
-        rawValue,
-        displayLabel: rawValue,
-        cloneUrl: rawValue,
-        canonicalId: `git:${authority.toLowerCase()}/${pathWithGit.toLowerCase()}`,
-        cacheSegments: [sanitizePathSegment(authority.toLowerCase()), ...pathSegments],
-        kind: MarketplaceReferenceKind.GitUri
-    };
-}
-function normalizeGitRepoPath(path) {
-    const trimmed = path.replace(/\/+/g, "/").replace(/\/+$/g, "");
-    if (!trimmed.toLowerCase().endsWith(".git")) {
-        return undefined;
-    }
-    const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-    const pathWithoutGit = withLeadingSlash.slice(1, -4);
-    if (!pathWithoutGit || !pathWithoutGit.includes("/")) {
-        return undefined;
-    }
-    return withLeadingSlash;
-}
-function getGitHubCanonicalId(owner, repo) {
-    return `github:${owner.toLowerCase()}/${repo.toLowerCase()}`;
-}
-function sanitizePathSegment(value) {
-    return value.replace(/[\\/:*?"<>|]/g, "_");
-}
+PluginMarketplaceService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IRequestService)), ( __param(2, IFileService)), ( __param(3, IAgentPluginRepositoryService)), ( __param(4, ILogService)), ( __param(5, IStorageService)), ( __param(6, IWorkspacePluginSettingsService)), ( __param(7, IWorkspaceTrustManagementService))], PluginMarketplaceService));
 function normalizeMarketplacePath(value) {
     let normalized = value.trim().replace(/\\/g, "/");
     normalized = normalized.replace(/^\.?\/+/, "").replace(/\/+$/g, "");
@@ -561,11 +602,18 @@ function parsePluginSource(rawSource, pluginRoot, logContext) {
                 );
                 return undefined;
             }
+            if (!isOptionalString(rawSource.path)) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': github source 'path' must be a string when provided`
+                );
+                return undefined;
+            }
             return {
                 kind: PluginSourceKind.GitHub,
                 repo: rawSource.repo,
                 ref: rawSource.ref,
-                sha: rawSource.sha
+                sha: rawSource.sha,
+                path: rawSource.path
             };
         }
     case "url":
@@ -659,6 +707,23 @@ function isOptionalGitSha(value) {
 function isValidGitHubRepo(repo) {
     return /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repo);
 }
+function hasSourceChanged(installed, marketplace) {
+    if (installed.kind !== marketplace.kind) {
+        return true;
+    }
+    switch (installed.kind) {
+    case PluginSourceKind.GitHub:
+        return installed.ref !== marketplace.ref || installed.sha !== marketplace.sha || installed.path !== marketplace.path;
+    case PluginSourceKind.GitUrl:
+        return installed.ref !== marketplace.ref || installed.sha !== marketplace.sha;
+    case PluginSourceKind.Npm:
+        return installed.version !== marketplace.version;
+    case PluginSourceKind.Pip:
+        return installed.version !== marketplace.version;
+    default:
+        return false;
+    }
+}
 function getMarketplaceReadmeUri(repo, source) {
     const normalizedSource = source.trim().replace(/^\.?\/+|\/+$/g, "");
     const readmePath = normalizedSource ? `${normalizedSource}/README.md` : "README.md";
@@ -669,4 +734,4 @@ function getMarketplaceReadmeFileUri(repoDir, source) {
     return normalizedSource ? joinPath(repoDir, normalizedSource, "README.md") : joinPath(repoDir, "README.md");
 }
 
-export { MarketplaceReferenceKind, MarketplaceType, PluginMarketplaceService, PluginSourceKind, parseMarketplaceReference, parseMarketplaceReferences, parsePluginSource };
+export { MarketplaceReferenceKind, MarketplaceType, PluginMarketplaceService, PluginSourceKind, deduplicateMarketplaceReferences, hasSourceChanged, parseMarketplaceReference, parseMarketplaceReferences, parsePluginSource };

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

@@ -0,0 +1,20 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+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 { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IMarketplaceReference } from "./marketplaceReference.js";
+import { IWorkspacePluginSettingsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/workspacePluginSettingsService.service";
+/**
+ * Minimal representation of a marketplace entry from `extraKnownMarketplaces`.
+ */
+export interface IWorkspaceMarketplaceEntry {
+    readonly name: string;
+    readonly reference: IMarketplaceReference;
+}
+export declare class WorkspacePluginSettingsService extends Disposable implements IWorkspacePluginSettingsService {
+    readonly _serviceBrand: undefined;
+    readonly extraMarketplaces: IObservable<readonly IWorkspaceMarketplaceEntry[]>;
+    readonly enabledPlugins: IObservable<ReadonlyMap<string, boolean>>;
+    constructor(fileService: IFileService, workspaceContextService: IWorkspaceContextService, logService: ILogService);
+}