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

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

@@ -1,15 +1,24 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { IDialogService } 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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
 import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { ProgressLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
+import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
 import { IAgentPluginRepositoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service';
-import { PluginSourceKind } from '../common/plugins/pluginMarketplaceService.js';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { PluginSourceKind, MarketplaceType, hasSourceChanged } from '../common/plugins/pluginMarketplaceService.js';
 import { IPluginMarketplaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service';
+import { parseMarketplaceReference, MarketplaceReferenceKind, parseMarketplaceReferences } from '../common/plugins/marketplaceReference.js';
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
 
 let PluginInstallService = class PluginInstallService {
@@ -19,7 +28,11 @@ let PluginInstallService = class PluginInstallService {
         _fileService,
         _notificationService,
         _dialogService,
-        _logService
+        _logService,
+        _progressService,
+        _commandService,
+        _quickInputService,
+        _configurationService
     ) {
         this._pluginRepositoryService = _pluginRepositoryService;
         this._pluginMarketplaceService = _pluginMarketplaceService;
@@ -27,6 +40,10 @@ let PluginInstallService = class PluginInstallService {
         this._notificationService = _notificationService;
         this._dialogService = _dialogService;
         this._logService = _logService;
+        this._progressService = _progressService;
+        this._commandService = _commandService;
+        this._quickInputService = _quickInputService;
+        this._configurationService = _configurationService;
     }
     async installPlugin(plugin) {
         if (!(await this._ensureMarketplaceTrusted(plugin))) {
@@ -37,14 +54,189 @@ let PluginInstallService = class PluginInstallService {
             return this._installRelativePathPlugin(plugin);
         }
         if (kind === PluginSourceKind.Npm || kind === PluginSourceKind.Pip) {
-            return this._installPackagePlugin(plugin);
+            await this._installPackagePlugin(plugin);
+            return;
         }
         return this._installGitPlugin(plugin);
     }
-    async updatePlugin(plugin) {
+    async installPluginFromSource(source) {
+        const reference = parseMarketplaceReference(source);
+        if (!reference) {
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    6380,
+                    "'{0}' is not a valid plugin source. Enter a GitHub repository (owner/repo) or a git clone URL.",
+                    source
+                ))
+            });
+            return;
+        }
+        if (reference.kind === MarketplaceReferenceKind.LocalFileUri) {
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    6381,
+                    "Local file paths are not supported. Enter a GitHub repository (owner/repo) or a git clone URL."
+                ))
+            });
+            return;
+        }
+        const result = await this._doInstallFromSource(reference);
+        if (!result.success && result.message) {
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: result.message
+            });
+        }
+    }
+    validatePluginSource(source) {
+        const reference = parseMarketplaceReference(source);
+        if (!reference) {
+            return localize(
+                6380,
+                "'{0}' is not a valid plugin source. Enter a GitHub repository (owner/repo) or a git clone URL.",
+                source
+            );
+        }
+        if (reference.kind === MarketplaceReferenceKind.LocalFileUri) {
+            return localize(
+                6381,
+                "Local file paths are not supported. Enter a GitHub repository (owner/repo) or a git clone URL."
+            );
+        }
+        return undefined;
+    }
+    async installPluginFromValidatedSource(source) {
+        const reference = parseMarketplaceReference(source);
+        if (!reference) {
+            return {
+                success: false,
+                message: ( localize(
+                    6380,
+                    "'{0}' is not a valid plugin source. Enter a GitHub repository (owner/repo) or a git clone URL.",
+                    source
+                ))
+            };
+        }
+        if (reference.kind === MarketplaceReferenceKind.LocalFileUri) {
+            return {
+                success: false,
+                message: ( localize(
+                    6381,
+                    "Local file paths are not supported. Enter a GitHub repository (owner/repo) or a git clone URL."
+                ))
+            };
+        }
+        return this._doInstallFromSource(reference);
+    }
+    async _doInstallFromSource(reference) {
+        const sourceDescriptor = reference.kind === MarketplaceReferenceKind.GitHubShorthand ? {
+            kind: PluginSourceKind.GitHub,
+            repo: reference.githubRepo
+        } : {
+            kind: PluginSourceKind.GitUrl,
+            url: reference.cloneUrl
+        };
+        const tempPlugin = {
+            name: reference.displayLabel,
+            description: "",
+            version: "",
+            source: "",
+            sourceDescriptor,
+            marketplace: reference.displayLabel,
+            marketplaceReference: reference,
+            marketplaceType: MarketplaceType.OpenPlugin
+        };
+        if (!(await this._ensureMarketplaceTrusted(tempPlugin))) {
+            return {
+                success: false
+            };
+        }
+        let repoDir;
+        try {
+            repoDir = await this._pluginRepositoryService.ensurePluginSource(tempPlugin, {
+                progressTitle: ( localize(6382, "Cloning plugin source '{0}'...", reference.displayLabel)),
+                failureLabel: reference.displayLabel,
+                marketplaceType: MarketplaceType.OpenPlugin
+            });
+        } catch (e) {
+            const detail = e instanceof Error ? e.message : String(e);
+            return {
+                success: false,
+                message: ( localize(
+                    6383,
+                    "Failed to clone plugin source '{0}': {1}",
+                    reference.displayLabel,
+                    detail
+                ))
+            };
+        }
+        const repoExists = await this._fileService.exists(repoDir);
+        if (!repoExists) {
+            return {
+                success: false,
+                message: ( localize(6384, "Failed to clone plugin source '{0}'.", reference.displayLabel))
+            };
+        }
+        const discoveredPlugins = await this._pluginMarketplaceService.readPluginsFromDirectory(repoDir, reference);
+        if (discoveredPlugins.length === 0) {
+            void this._pluginRepositoryService.cleanupPluginSource(tempPlugin);
+            return {
+                success: false,
+                message: ( localize(
+                    6385,
+                    "No plugins found in '{0}'. This does not appear to be a valid plugin marketplace.",
+                    reference.displayLabel
+                ))
+            };
+        }
+        if (discoveredPlugins.length === 1) {
+            const plugin = discoveredPlugins[0];
+            const pluginDir = plugin.source ? URI.joinPath(repoDir, plugin.source) : repoDir;
+            this._pluginMarketplaceService.addInstalledPlugin(pluginDir, plugin);
+            this._addMarketplaceToConfig(reference);
+            return {
+                success: true
+            };
+        }
+        const picks = ( discoveredPlugins.map(p => ({
+            label: p.name,
+            description: p.description,
+            plugin: p
+        })));
+        const selected = await this._quickInputService.pick(picks, {
+            placeHolder: ( localize(6386, "Select a plugin to install from '{0}'", reference.displayLabel)),
+            canPickMany: false
+        });
+        if (!selected) {
+            return {
+                success: false
+            };
+        }
+        const plugin = selected.plugin;
+        const pluginDir = plugin.source ? URI.joinPath(repoDir, plugin.source) : repoDir;
+        this._pluginMarketplaceService.addInstalledPlugin(pluginDir, plugin);
+        this._addMarketplaceToConfig(reference);
+        return {
+            success: true
+        };
+    }
+    _addMarketplaceToConfig(reference) {
+        const currentValues = this._configurationService.getValue(ChatConfiguration.PluginMarketplaces) ?? [];
+        const existingRefs = parseMarketplaceReferences(currentValues);
+        if (( existingRefs.some(r => r.canonicalId === reference.canonicalId))) {
+            return;
+        }
+        this._configurationService.updateValue(
+            ChatConfiguration.PluginMarketplaces,
+            [...currentValues, reference.rawValue]
+        );
+    }
+    async updatePlugin(plugin, silent) {
         const kind = plugin.sourceDescriptor.kind;
         if (kind === PluginSourceKind.Npm || kind === PluginSourceKind.Pip) {
-            return this._installPackagePlugin(plugin);
+            return this._installPackagePlugin(plugin, silent);
         }
         return this._pluginRepositoryService.updatePluginSource(plugin, {
             pluginName: plugin.name,
@@ -52,6 +244,155 @@ let PluginInstallService = class PluginInstallService {
             marketplaceType: plugin.marketplaceType
         });
     }
+    async updateAllPlugins(options, token) {
+        const installed = this._pluginMarketplaceService.installedPlugins.get().filter(e => e.enabled);
+        if (installed.length === 0) {
+            return {
+                updatedNames: [],
+                failedNames: []
+            };
+        }
+        const updatedNames = [];
+        const failedNames = [];
+        const doUpdate = async () => {
+            const gitTasks = [];
+            const packagePlugins = [];
+            const seenMarketplaces = ( new Set());
+            for (const entry of installed) {
+                const ref = entry.plugin.marketplaceReference;
+                if (( seenMarketplaces.has(ref.canonicalId))) {
+                    continue;
+                }
+                seenMarketplaces.add(ref.canonicalId);
+                gitTasks.push((async () => {
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                    try {
+                        const changed = await this._pluginRepositoryService.pullRepository(ref, {
+                            pluginName: ref.displayLabel,
+                            failureLabel: ref.displayLabel,
+                            marketplaceType: entry.plugin.marketplaceType,
+                            silent: options.silent
+                        });
+                        if (changed) {
+                            updatedNames.push(ref.displayLabel);
+                        }
+                    } catch (err) {
+                        this._logService.error(
+                            `[PluginInstallService] Failed to pull marketplace '${ref.displayLabel}':`,
+                            err
+                        );
+                        failedNames.push(ref.displayLabel);
+                    }
+                })());
+            }
+            await Promise.all(gitTasks);
+            const marketplacePlugins = await this._pluginMarketplaceService.fetchMarketplacePlugins(token);
+            const marketplaceByKey = ( new Map());
+            for (const mp of marketplacePlugins) {
+                marketplaceByKey.set(`${mp.marketplaceReference.canonicalId}::${mp.name}`, mp);
+            }
+            const independentGitTasks = [];
+            for (const entry of installed) {
+                if (entry.plugin.sourceDescriptor.kind === PluginSourceKind.RelativePath) {
+                    continue;
+                }
+                const livePlugin = marketplaceByKey.get(`${entry.plugin.marketplaceReference.canonicalId}::${entry.plugin.name}`);
+                if (!livePlugin || !hasSourceChanged(entry.plugin.sourceDescriptor, livePlugin.sourceDescriptor)) {
+                    continue;
+                }
+                const desc = livePlugin.sourceDescriptor;
+                if (desc.kind === PluginSourceKind.Npm || desc.kind === PluginSourceKind.Pip) {
+                    if (!options.force && !desc.version) {
+                        continue;
+                    }
+                    packagePlugins.push({
+                        installed: entry.plugin,
+                        marketplace: livePlugin
+                    });
+                    continue;
+                }
+                independentGitTasks.push((async () => {
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                    try {
+                        const changed = await this._pluginRepositoryService.updatePluginSource(livePlugin, {
+                            pluginName: livePlugin.name,
+                            failureLabel: livePlugin.name,
+                            marketplaceType: livePlugin.marketplaceType,
+                            silent: options.silent
+                        });
+                        if (changed) {
+                            updatedNames.push(livePlugin.name);
+                            this._pluginMarketplaceService.addInstalledPlugin(entry.pluginUri, livePlugin);
+                        }
+                    } catch (err) {
+                        this._logService.error(
+                            `[PluginInstallService] Failed to update plugin '${livePlugin.name}':`,
+                            err
+                        );
+                        failedNames.push(livePlugin.name);
+                    }
+                })());
+            }
+            await Promise.all(independentGitTasks);
+            for (const {
+                installed: _installed,
+                marketplace
+            } of packagePlugins) {
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                try {
+                    const changed = await this.updatePlugin(marketplace, options?.silent);
+                    if (changed) {
+                        updatedNames.push(marketplace.name);
+                        const pluginUri = this._pluginRepositoryService.getPluginSourceInstallUri(marketplace.sourceDescriptor);
+                        this._pluginMarketplaceService.addInstalledPlugin(pluginUri, marketplace);
+                    }
+                } catch (err) {
+                    this._logService.error(
+                        `[PluginInstallService] Failed to update plugin '${marketplace.name}':`,
+                        err
+                    );
+                    failedNames.push(marketplace.name);
+                }
+            }
+        };
+        if (options.silent) {
+            await doUpdate();
+        } else {
+            await this._progressService.withProgress({
+                location: ProgressLocation.Notification,
+                title: ( localize(6387, "Updating plugins..."))
+            }, doUpdate);
+        }
+        if (failedNames.length > 0) {
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(6388, "Failed to update: {0}", failedNames.join(", "))),
+                actions: {
+                    primary: [( new Action("showGitOutput", ( localize(6389, "Show Output")), undefined, true, () => {
+                        this._commandService.executeCommand("git.showOutput");
+                    }))]
+                }
+            });
+        } else if (updatedNames.length > 0) {
+            this._pluginMarketplaceService.clearUpdatesAvailable();
+            this._notificationService.notify({
+                severity: Severity.Info,
+                message: ( localize(6390, "Updated plugins: {0}", updatedNames.join(", ")))
+            });
+        } else if (!token.isCancellationRequested) {
+            this._pluginMarketplaceService.clearUpdatesAvailable();
+        }
+        return {
+            updatedNames,
+            failedNames
+        };
+    }
     getPluginInstallUri(plugin) {
         if (plugin.sourceDescriptor.kind === PluginSourceKind.RelativePath) {
             return this._pluginRepositoryService.getPluginInstallUri(plugin);
@@ -67,16 +408,16 @@ let PluginInstallService = class PluginInstallService {
         } = await this._dialogService.confirm({
             type: "question",
             message: ( localize(
-                6241,
+                6391,
                 "Trust Plugins from '{0}'?",
                 plugin.marketplaceReference.displayLabel
             )),
             detail: ( localize(
-                6242,
+                6392,
                 "Plugins can run code on your machine. Only install plugins from sources you trust.\n\nSource: {0}",
                 plugin.marketplaceReference.rawValue
             )),
-            primaryButton: ( localize(6243, "&&Trust")),
+            primaryButton: ( localize(6393, "&&Trust")),
             custom: {
                 icon: Codicon.shield
             }
@@ -90,7 +431,7 @@ let PluginInstallService = class PluginInstallService {
     async _installRelativePathPlugin(plugin) {
         try {
             await this._pluginRepositoryService.ensureRepository(plugin.marketplaceReference, {
-                progressTitle: ( localize(6244, "Installing plugin '{0}'...", plugin.name)),
+                progressTitle: ( localize(6394, "Installing plugin '{0}'...", plugin.name)),
                 failureLabel: plugin.name,
                 marketplaceType: plugin.marketplaceType
             });
@@ -104,7 +445,7 @@ let PluginInstallService = class PluginInstallService {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    6245,
+                    6395,
                     "Plugin source directory '{0}' is invalid for repository '{1}'.",
                     plugin.source,
                     plugin.marketplace
@@ -117,7 +458,7 @@ let PluginInstallService = class PluginInstallService {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    6246,
+                    6396,
                     "Plugin source directory '{0}' not found in repository '{1}'.",
                     plugin.source,
                     plugin.marketplace
@@ -132,7 +473,7 @@ let PluginInstallService = class PluginInstallService {
         let pluginDir;
         try {
             pluginDir = await this._pluginRepositoryService.ensurePluginSource(plugin, {
-                progressTitle: ( localize(6244, "Installing plugin '{0}'...", plugin.name)),
+                progressTitle: ( localize(6394, "Installing plugin '{0}'...", plugin.name)),
                 failureLabel: plugin.name,
                 marketplaceType: plugin.marketplaceType
             });
@@ -144,7 +485,7 @@ let PluginInstallService = class PluginInstallService {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    6247,
+                    6397,
                     "Plugin source '{0}' not found after cloning.",
                     repo.getLabel(plugin.sourceDescriptor)
                 ))
@@ -153,23 +494,26 @@ let PluginInstallService = class PluginInstallService {
         }
         this._pluginMarketplaceService.addInstalledPlugin(pluginDir, plugin);
     }
-    async _installPackagePlugin(plugin) {
+    async _installPackagePlugin(plugin, silent) {
         const repo = this._pluginRepositoryService.getPluginSource(plugin.sourceDescriptor.kind);
         if (!repo.runInstall) {
             this._logService.error(
                 `[PluginInstallService] Expected package repository for kind '${plugin.sourceDescriptor.kind}'`
             );
-            return;
+            return false;
         }
         const installDir = await this._pluginRepositoryService.ensurePluginSource(plugin);
         const pluginDir = this._pluginRepositoryService.getPluginSourceInstallUri(plugin.sourceDescriptor);
-        const result = await repo.runInstall(installDir, pluginDir, plugin);
+        const result = await repo.runInstall(installDir, pluginDir, plugin, {
+            silent
+        });
         if (!result) {
-            return;
+            return false;
         }
         this._pluginMarketplaceService.addInstalledPlugin(result.pluginDir, plugin);
+        return true;
     }
 };
-PluginInstallService = ( __decorate([( __param(0, IAgentPluginRepositoryService)), ( __param(1, IPluginMarketplaceService)), ( __param(2, IFileService)), ( __param(3, INotificationService)), ( __param(4, IDialogService)), ( __param(5, ILogService))], PluginInstallService));
+PluginInstallService = ( __decorate([( __param(0, IAgentPluginRepositoryService)), ( __param(1, IPluginMarketplaceService)), ( __param(2, IFileService)), ( __param(3, INotificationService)), ( __param(4, IDialogService)), ( __param(5, ILogService)), ( __param(6, IProgressService)), ( __param(7, ICommandService)), ( __param(8, IQuickInputService)), ( __param(9, IConfigurationService))], PluginInstallService));
 
 export { PluginInstallService };

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

@@ -22,8 +22,14 @@ declare abstract class AbstractGitPluginSource implements IPluginSource {
     protected abstract _cloneUrl(descriptor: IPluginSourceDescriptor): string;
     protected abstract _displayLabel(descriptor: IPluginSourceDescriptor): string;
     getCleanupTarget(cacheRoot: URI, descriptor: IPluginSourceDescriptor): URI | undefined;
+    /**
+     * Returns the on-disk directory of the cloned repository. Subclasses that
+     * support a sub-path within a repository should override this to return the
+     * repository root, while {@link getInstallUri} returns root + sub-path.
+     */
+    protected _getRepoDir(cacheRoot: URI, descriptor: IPluginSourceDescriptor): URI;
     ensure(cacheRoot: URI, plugin: IMarketplacePlugin, options?: IEnsureRepositoryOptions): Promise<URI>;
-    update(cacheRoot: URI, plugin: IMarketplacePlugin, options?: IPullRepositoryOptions): Promise<void>;
+    update(cacheRoot: URI, plugin: IMarketplacePlugin, options?: IPullRepositoryOptions): Promise<boolean>;
     private _cloneRepository;
     private _checkoutRevision;
 }
@@ -31,13 +37,16 @@ export declare class RelativePathPluginSource implements IPluginSource {
     readonly kind = PluginSourceKind.RelativePath;
     getInstallUri(_cacheRoot: URI, _descriptor: IPluginSourceDescriptor): URI;
     ensure(_cacheRoot: URI, _plugin: IMarketplacePlugin, _options?: IEnsureRepositoryOptions): Promise<URI>;
-    update(_cacheRoot: URI, _plugin: IMarketplacePlugin, _options?: IPullRepositoryOptions): Promise<void>;
+    update(_cacheRoot: URI, _plugin: IMarketplacePlugin, _options?: IPullRepositoryOptions): Promise<boolean>;
     getCleanupTarget(_cacheRoot: URI, _descriptor: IPluginSourceDescriptor): URI | undefined;
     getLabel(descriptor: IPluginSourceDescriptor): string;
 }
 export declare class GitHubPluginSource extends AbstractGitPluginSource {
     readonly kind = PluginSourceKind.GitHub;
+    /** Returns the URI where the plugin content lives (repo root + optional sub-path). */
     getInstallUri(cacheRoot: URI, descriptor: IPluginSourceDescriptor): URI;
+    /** Returns the cloned repository root (without sub-path). */
+    protected _getRepoDir(cacheRoot: URI, descriptor: IPluginSourceDescriptor): URI;
     getLabel(descriptor: IPluginSourceDescriptor): string;
     protected _cloneUrl(descriptor: IPluginSourceDescriptor): string;
     protected _displayLabel(descriptor: IPluginSourceDescriptor): string;
@@ -72,8 +81,10 @@ export declare abstract class AbstractPackagePluginSource implements IPluginSour
     /** Human-readable package manager name for messages. */
     protected abstract get _managerName(): string;
     ensure(cacheRoot: URI, plugin: IMarketplacePlugin, _options?: IEnsureRepositoryOptions): Promise<URI>;
-    update(cacheRoot: URI, plugin: IMarketplacePlugin, _options?: IPullRepositoryOptions): Promise<void>;
-    runInstall(installDir: URI, pluginDir: URI, plugin: IMarketplacePlugin): Promise<{
+    update(cacheRoot: URI, plugin: IMarketplacePlugin, _options?: IPullRepositoryOptions): Promise<boolean>;
+    runInstall(installDir: URI, pluginDir: URI, plugin: IMarketplacePlugin, options?: {
+        silent?: boolean;
+    }): Promise<{
         pluginDir: URI;
     } | undefined>;
     private _confirmTerminalCommand;