@codingame/monaco-vscode-api 36.2.6 → 37.0.0

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

@@ -0,0 +1,195 @@
+
+import { ThrottledDelayer, RunOnceScheduler } from '../../../../../base/common/async.js';
+import { VSBuffer } from '../../../../../base/common/buffer.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { revive } from '../../../../../base/common/marshalling.js';
+import '../../../../../base/common/observableInternal/index.js';
+import { joinPath, isEqual } from '../../../../../base/common/resources.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { StorageScope } from '../../../../../platform/storage/common/storage.js';
+import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
+
+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 "../../../../../base/common/uri.js";
+import { IConfigurationService } from "../../../../../platform/configuration/common/configuration.service.js";
+export { extraKnownMarketplacesToConfigDict } from "../../../../../base/common/managedSettings.js";
+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;

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

@@ -0,0 +1,294 @@
+
+import { URI } from '../../../../../base/common/uri.js';
+import { ChatConfiguration } from '../constants.js';
+
+var MarketplaceReferenceKind;
+(function(MarketplaceReferenceKind) {
+    MarketplaceReferenceKind["GitHubShorthand"] = "githubShorthand";
+    MarketplaceReferenceKind["GitUri"] = "gitUri";
+    MarketplaceReferenceKind["LocalFileUri"] = "localFileUri";
+})(MarketplaceReferenceKind || (MarketplaceReferenceKind = {}));
+const _githubShorthandRe = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?:#.+)?$/;
+function readConfiguredMarketplaces(configurationService) {
+    const userValues = configurationService.getValue(ChatConfiguration.PluginMarketplaces) ?? [];
+    const extraObj = configurationService.getValue(ChatConfiguration.ExtraMarketplaces) ?? {};
+    const extraValues = Object.entries(extraObj).flatMap(([name, value]) => {
+        if (typeof value !== "string") {
+            return [];
+        }
+        const encoded = parseExtraMarketplaceConfigValue(value);
+        const src = encoded?.source ?? value;
+        const autoUpdate = encoded?.autoUpdate;
+        const isGithubShorthand = _githubShorthandRe.test(src);
+        return [isGithubShorthand ? {
+            name,
+            autoUpdate,
+            source: {
+                source: "github",
+                repo: src
+            }
+        } : {
+            name,
+            autoUpdate,
+            source: {
+                source: "git",
+                url: src
+            }
+        }];
+    });
+    return {
+        userValues,
+        extraValues,
+        effectiveValues: [...userValues, ...extraValues]
+    };
+}
+function parseExtraMarketplaceConfigValue(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && typeof parsed.source === "string" && typeof parsed.autoUpdate === "boolean" ? parsed : undefined;
+    } catch {
+        return undefined;
+    }
+}
+function parseMarketplaceReferences(values) {
+    const byCanonicalId = ( new Map());
+    for (const value of values) {
+        let parsed;
+        if (typeof value === "string") {
+            parsed = parseMarketplaceReference(value);
+        } else if (value && typeof value === "object") {
+            parsed = parseMarketplaceObjectEntry(value);
+        }
+        if (parsed) {
+            const existing = byCanonicalId.get(parsed.canonicalId);
+            if (!existing) {
+                byCanonicalId.set(parsed.canonicalId, parsed);
+            } else if (parsed.autoUpdate !== undefined) {
+                byCanonicalId.set(parsed.canonicalId, {
+                    ...existing,
+                    autoUpdate: parsed.autoUpdate
+                });
+            }
+        }
+    }
+    return [...( byCanonicalId.values())];
+}
+function parseMarketplaceObjectEntry(entry) {
+    let sourceType;
+    let repo;
+    let url;
+    let ref;
+    if (entry.source && typeof entry.source === "object") {
+        const nested = entry.source;
+        sourceType = nested.source;
+        repo = nested.repo;
+        url = nested.url;
+        ref = nested.ref;
+    } else {
+        sourceType = entry.source;
+        repo = entry.repo;
+        url = entry.url;
+        ref = entry.ref;
+    }
+    let parsed;
+    if (sourceType === "github" && typeof repo === "string") {
+        parsed = parseMarketplaceReference(appendMarketplaceRef(repo, ref));
+    } else if (sourceType === "git" && typeof url === "string") {
+        parsed = parseMarketplaceReference(appendMarketplaceRef(url, ref));
+    }
+    if (parsed && typeof entry.name === "string" && entry.name.length > 0) {
+        parsed = {
+            ...parsed,
+            displayLabel: entry.name
+        };
+    }
+    if (parsed && typeof entry.autoUpdate === "boolean") {
+        parsed = {
+            ...parsed,
+            autoUpdate: entry.autoUpdate
+        };
+    }
+    return parsed;
+}
+function appendMarketplaceRef(value, ref) {
+    if (!ref) {
+        return value;
+    }
+    const fragmentIndex = value.indexOf("#");
+    const base = fragmentIndex === -1 ? value : value.slice(0, fragmentIndex);
+    return `${base}#${ref}`;
+}
+function deduplicateMarketplaceReferences(primary, secondary) {
+    const byCanonicalId = ( new Map());
+    for (const ref of primary) {
+        byCanonicalId.set(ref.canonicalId, ref);
+    }
+    for (const ref of secondary) {
+        if (!( byCanonicalId.has(ref.canonicalId))) {
+            byCanonicalId.set(ref.canonicalId, ref);
+        }
+    }
+    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];
+        const ref = shorthandMatch[3];
+        return {
+            rawValue,
+            displayLabel: rawValue,
+            cloneUrl: `https://github.com/${owner}/${repo}.git`,
+            canonicalId: getGitHubCanonicalId(owner, repo, ref),
+            cacheSegments: ["github.com", owner, repo, ...getRefCacheSegments(ref)],
+            kind: MarketplaceReferenceKind.GitHubShorthand,
+            ref,
+            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)) {
+        if (uri.fragment) {
+            return undefined;
+        }
+        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 ref = uri.fragment || undefined;
+    const cloneUri = uri.fragment ? uri.with({
+        fragment: ""
+    }) : uri;
+    const sanitizedAuthority = sanitizePathSegment(uri.authority.toLowerCase());
+    const trimmedPath = uri.path.replace(/\/+/g, "/").replace(/\/+$/g, "").replace(/^\/+/, "");
+    if (!trimmedPath) {
+        return {
+            rawValue,
+            displayLabel: rawValue,
+            cloneUrl: ( cloneUri.toString()),
+            canonicalId: appendRefSuffix(`git:${uri.authority.toLowerCase()}/`, ref),
+            cacheSegments: [sanitizedAuthority, ...getRefCacheSegments(ref)],
+            kind: MarketplaceReferenceKind.GitUri,
+            ref
+        };
+    }
+    const gitSuffix = ".git";
+    const pathHasGitSuffix = trimmedPath.toLowerCase().endsWith(gitSuffix);
+    const pathWithoutGit = pathHasGitSuffix ? trimmedPath.slice(0, trimmedPath.length - gitSuffix.length) : trimmedPath;
+    const pathSegments = ( pathWithoutGit.split("/").map(sanitizePathSegment));
+    const canonicalPath = pathHasGitSuffix ? trimmedPath.toLowerCase() : `${trimmedPath.toLowerCase()}${gitSuffix}`;
+    const githubRepo = extractGitHubRepo(uri.authority, pathWithoutGit);
+    let canonicalId;
+    if (githubRepo) {
+        const [owner, repo] = githubRepo.split("/");
+        canonicalId = getGitHubCanonicalId(owner, repo, ref);
+    } else {
+        canonicalId = appendRefSuffix(`git:${uri.authority.toLowerCase()}/${canonicalPath}`, ref);
+    }
+    return {
+        rawValue,
+        displayLabel: rawValue,
+        cloneUrl: ( cloneUri.toString()),
+        canonicalId,
+        cacheSegments: [sanitizedAuthority, ...pathSegments, ...getRefCacheSegments(ref)],
+        kind: MarketplaceReferenceKind.GitUri,
+        ref,
+        githubRepo
+    };
+}
+function parseScpMarketplaceReference(rawValue) {
+    const match = /^([^@\s]+)@([^:\s]+):(.+?\.git)(?:#(.+))?$/i.exec(rawValue);
+    if (!match) {
+        return undefined;
+    }
+    const gitSuffix = ".git";
+    const authority = match[2];
+    const pathWithGit = match[3].replace(/^\/+/, "");
+    const ref = match[4];
+    if (!pathWithGit.toLowerCase().endsWith(gitSuffix)) {
+        return undefined;
+    }
+    const pathWithoutGit = pathWithGit.slice(0, -gitSuffix.length);
+    const pathSegments = ( pathWithoutGit.split("/").map(sanitizePathSegment));
+    const githubRepo = extractGitHubRepo(authority, pathWithoutGit);
+    let canonicalId;
+    if (githubRepo) {
+        const [owner, repo] = githubRepo.split("/");
+        canonicalId = getGitHubCanonicalId(owner, repo, ref);
+    } else {
+        canonicalId = appendRefSuffix(`git:${authority.toLowerCase()}/${pathWithGit.toLowerCase()}`, ref);
+    }
+    return {
+        rawValue,
+        displayLabel: rawValue,
+        cloneUrl: `${match[1]}@${authority}:${pathWithGit}`,
+        canonicalId,
+        cacheSegments: [
+            sanitizePathSegment(authority.toLowerCase()),
+            ...pathSegments,
+            ...getRefCacheSegments(ref)
+        ],
+        kind: MarketplaceReferenceKind.GitUri,
+        ref,
+        githubRepo
+    };
+}
+function extractGitHubRepo(authority, pathWithoutGit) {
+    if (authority.toLowerCase() !== "github.com") {
+        return undefined;
+    }
+    const parts = pathWithoutGit.split("/");
+    if (parts.length >= 2 && parts[0] && parts[1]) {
+        return `${parts[0]}/${parts[1]}`;
+    }
+    return undefined;
+}
+function getGitHubCanonicalId(owner, repo, ref) {
+    return appendRefSuffix(`github:${owner.toLowerCase()}/${repo.toLowerCase()}`, ref);
+}
+function appendRefSuffix(canonicalId, ref) {
+    return ref ? `${canonicalId}#${encodeURIComponent(ref)}` : canonicalId;
+}
+function getRefCacheSegments(ref) {
+    return ref ? [`ref_${encodeURIComponent(ref)}`] : [];
+}
+function sanitizePathSegment(value) {
+    return value.replace(/[\\/:*?"<>|]/g, "_");
+}
+
+export { MarketplaceReferenceKind, deduplicateMarketplaceReferences, parseMarketplaceObjectEntry, parseMarketplaceReference, parseMarketplaceReferences, readConfiguredMarketplaces };

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

@@ -28,6 +28,7 @@ export interface IPluginGitService {
     cloneRepository(cloneUrl: string, targetDir: URI, ref?: string, token?: CancellationToken): Promise<void>;
     pull(repoDir: URI, token?: CancellationToken): Promise<boolean>;
     checkout(repoDir: URI, treeish: string, detached?: boolean, token?: CancellationToken): Promise<void>;
+    checkoutCommit(repoDir: URI, commit: string, token?: CancellationToken): Promise<void>;
     revParse(repoDir: URI, ref: string): Promise<string>;
     fetch(repoDir: URI, token?: CancellationToken): Promise<void>;
     fetchRepository(repoDir: URI, token?: CancellationToken): Promise<void>;

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

@@ -1,4 +1,4 @@
-import { IMarketplacePlugin } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService";
+import { IMarketplacePlugin } from "./pluginMarketplaceService.js";
 export interface IUpdateAllPluginsOptions {
     /**
      * When `true`, also re-installs npm/pip packages that have no pinned
@@ -12,6 +12,10 @@ export interface IUpdateAllPluginsOptions {
      * updated, and error notifications are shown on failure.
      */
     readonly silent?: boolean;
+    /** Restricts updates to plugins installed from these canonical marketplace IDs. */
+    readonly marketplaceIds?: ReadonlySet<string>;
+    /** Rechecks marketplace automatic-update policy before updating. */
+    readonly automatic?: boolean;
 }
 export interface IUpdateAllPluginsResult {
     /** Names of plugins/marketplaces that were updated successfully. */

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

@@ -1,7 +1,7 @@
 import { CancellationToken } from "../../../../../base/common/cancellation.js";
 import { URI } from "../../../../../base/common/uri.js";
 import { IInstallPluginFromSourceOptions, IInstallPluginFromSourceResult, IUpdateAllPluginsOptions, IUpdateAllPluginsResult } from "./pluginInstallService.js";
-import { IMarketplacePlugin } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService";
+import { IMarketplacePlugin } from "./pluginMarketplaceService.js";
 export declare const IPluginInstallService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IPluginInstallService>;
 export interface IPluginInstallService {
     readonly _serviceBrand: undefined;