@theia/plugin-ext 1.66.0-next.32 → 1.66.0-next.44

package/src/hosted/node/metadata-scanner.ts

@@ -36,7 +36,7 @@ export class MetadataScanner {
             host: PLUGIN_HOST_BACKEND,
             model: scanner.getModel(plugin),
             lifecycle: scanner.getLifecycle(plugin),
-            outOfSync: this.uninstallationManager.isUninstalled(id) || await this.uninstallationManager.isDisabled(id),
+            outOfSync: this.uninstallationManager.isUninstalled(id) || await this.uninstallationManager.isDisabled(PluginIdentifiers.toUnversioned(id)),
         };
     }
 

package/src/hosted/node/plugin-deployer-handler-impl.ts

@@ -275,11 +275,11 @@ export class PluginDeployerHandlerImpl implements PluginDeployerHandler {
         this.sourceLocations.set(id, knownLocations);
     }
 
-    async enablePlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+    async enablePlugin(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean> {
         return this.uninstallationManager.markAsEnabled(pluginId);
     }
 
-    async disablePlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+    async disablePlugin(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean> {
         return this.uninstallationManager.markAsDisabled(pluginId);
     }
 }

package/src/hosted/node/plugin-reader.ts

@@ -49,7 +49,8 @@ export class HostedPluginReader implements BackendApplicationContribution {
 
             const localPath = this.pluginsIdsFiles.get(pluginId);
             if (localPath) {
-                res.sendFile(filePath, { root: localPath }, e => {
+                const absolutePath = path.resolve(localPath, filePath);
+                res.sendFile(absolutePath, e => {
                     if (!e) {
                         // the file was found and successfully transferred
                         return;

package/src/hosted/node/plugin-service.ts

@@ -63,7 +63,7 @@ export class HostedPluginServerImpl implements HostedPluginServer {
     protected toDispose = new DisposableCollection();
 
     protected uninstalledPlugins: Set<PluginIdentifiers.VersionedId>;
-    protected disabledPlugins: Set<PluginIdentifiers.VersionedId>;
+    protected disabledPlugins: Set<PluginIdentifiers.UnversionedId>;
 
     protected readonly pluginVersions = new Map<PluginIdentifiers.UnversionedId, string>();
 
@@ -129,6 +129,11 @@ export class HostedPluginServerImpl implements HostedPluginServer {
     }
 
     async getDeployedPluginIds(): Promise<PluginIdentifiers.VersionedId[]> {
+        return this.getInstalledPluginIds()
+            .then(ids => ids.filter(candidate => this.isInstalledPlugin(candidate) && !this.disabledPlugins.has(PluginIdentifiers.toUnversioned(candidate))));
+    }
+
+    async getInstalledPluginIds(): Promise<PluginIdentifiers.VersionedId[]> {
         await this.initialized.promise;
         const backendPlugins = (await this.deployerHandler.getDeployedBackendPlugins())
             .filter(this.backendPluginHostableFilter);
@@ -136,15 +141,13 @@ export class HostedPluginServerImpl implements HostedPluginServer {
             this.hostedPlugin.runPluginServer(this.getServerName());
         }
         const plugins = new Set<PluginIdentifiers.VersionedId>();
-        const addIds = async (identifiers: PluginIdentifiers.VersionedId[]): Promise<void> => {
-            for (const pluginId of identifiers) {
-                if (this.isRelevantPlugin(pluginId)) {
-                    plugins.add(pluginId);
-                }
-            }
-        };
-        addIds(await this.deployerHandler.getDeployedFrontendPluginIds());
-        addIds(await this.deployerHandler.getDeployedBackendPluginIds());
+        const addIds = (identifiers: Promise<PluginIdentifiers.VersionedId[]>): Promise<void> => identifiers
+            .then(ids => ids.forEach(id => this.isInstalledPlugin(id) && plugins.add(id)));
+
+        await Promise.all([
+            addIds(this.deployerHandler.getDeployedFrontendPluginIds()),
+            addIds(this.deployerHandler.getDeployedBackendPluginIds()),
+        ]);
         return Array.from(plugins);
     }
 
@@ -155,7 +158,7 @@ export class HostedPluginServerImpl implements HostedPluginServer {
      * The deployment system may have multiple versions of the same plugin available, but
      * a single session should only ever activate one of them.
      */
-    protected isRelevantPlugin(identifier: PluginIdentifiers.VersionedId): boolean {
+    protected isInstalledPlugin(identifier: PluginIdentifiers.VersionedId): boolean {
         const versionAndId = PluginIdentifiers.idAndVersionFromVersionedId(identifier);
         if (!versionAndId) {
             return false;
@@ -168,9 +171,6 @@ export class HostedPluginServerImpl implements HostedPluginServer {
             return false;
         }
 
-        if (this.disabledPlugins.has(identifier)) {
-            return false;
-        }
         if (knownVersion === undefined) {
             this.pluginVersions.set(versionAndId.id, versionAndId.version);
         }
@@ -181,7 +181,7 @@ export class HostedPluginServerImpl implements HostedPluginServer {
         return Promise.resolve(this.uninstallationManager.getUninstalledPluginIds());
     }
 
-    getDisabledPluginIds(): Promise<readonly PluginIdentifiers.VersionedId[]> {
+    getDisabledPluginIds(): Promise<readonly PluginIdentifiers.UnversionedId[]> {
         return Promise.resolve(this.uninstallationManager.getDisabledPluginIds());
     }
 

package/src/main/browser/lm-main.ts

@@ -23,7 +23,7 @@ import {
     isMcpHttpServerDefinitionDto,
 } from '../../common/lm-protocol';
 import { MAIN_RPC_CONTEXT } from '../../common/plugin-api-rpc';
-import { MCPServerManager, MCPServerDescription } from '@theia/ai-mcp/lib/common';
+import { MCPServerManager, MCPServerDescription, RemoteMCPServerDescription } from '@theia/ai-mcp/lib/common';
 import { URI } from '@theia/core';
 
 export class McpServerDefinitionRegistryMainImpl implements McpServerDefinitionRegistryMain {
@@ -106,18 +106,16 @@ export class McpServerDefinitionRegistryMainImpl implements McpServerDefinitionR
             const definitions = await this.$getServerDefinitions(handle);
 
             for (const definition of definitions) {
-                const resolved = await this.$resolveServerDefinition(handle, definition);
-                if (resolved) {
-                    const mcpServerDescription = this.convertToMcpServerDescription(resolved);
-                    this.mcpServerManager.addOrUpdateServer(mcpServerDescription);
-                }
+                const mcpServerDescription = this.convertToMcpServerDescription(handle, definition);
+                this.mcpServerManager.addOrUpdateServer(mcpServerDescription);
             }
         } catch (error) {
             console.error('Error loading MCP server definitions:', error);
         }
     }
 
-    private convertToMcpServerDescription(definition: McpServerDefinitionDto): MCPServerDescription {
+    private convertToMcpServerDescription(handle: number, definition: McpServerDefinitionDto): MCPServerDescription {
+        const self = this;
         if (isMcpHttpServerDefinitionDto(definition)) {
             // Convert headers values to strings, filtering out null values
             let convertedHeaders: Record<string, string> | undefined;
@@ -130,12 +128,21 @@ export class McpServerDefinitionRegistryMainImpl implements McpServerDefinitionR
                 }
             }
 
-            return {
+            const serverDescription: RemoteMCPServerDescription = {
                 name: definition.label,
                 serverUrl: URI.fromComponents(definition.uri).toString(),
                 headers: convertedHeaders,
-                autostart: false, // Extensions should manage their own server lifecycle
+                autostart: false,
+                async resolve(description: MCPServerDescription): Promise<MCPServerDescription> {
+                    const resolved = await self.$resolveServerDefinition(handle, definition);
+                    if (resolved) {
+                        return self.convertToMcpServerDescription(handle, resolved);
+                    }
+                    return description;
+                }
             };
+
+            return serverDescription;
         }
 
         // Convert env values to strings, filtering out null values
@@ -155,6 +162,13 @@ export class McpServerDefinitionRegistryMainImpl implements McpServerDefinitionR
             args: definition.args,
             env: convertedEnv,
             autostart: false, // Extensions should manage their own server lifecycle
+            async resolve(serverDescription: MCPServerDescription): Promise<MCPServerDescription> {
+                const resolved = await self.$resolveServerDefinition(handle, definition);
+                if (resolved) {
+                    return self.convertToMcpServerDescription(handle, resolved);
+                }
+                return serverDescription;
+            }
         };
     }
 }

package/src/main/node/plugin-deployer-impl.ts

@@ -141,11 +141,11 @@ export class PluginDeployerImpl implements PluginDeployer {
         await this.pluginDeployerHandler.uninstallPlugin(pluginId);
     }
 
-    enablePlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+    enablePlugin(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean> {
         return this.pluginDeployerHandler.enablePlugin(pluginId);
     }
 
-    disablePlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+    disablePlugin(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean> {
         return this.pluginDeployerHandler.disablePlugin(pluginId);
     }
 

package/src/main/node/plugin-server-impl.ts

@@ -64,7 +64,7 @@ export class PluginServerImpl implements PluginServer {
         return Promise.resolve(this.uninstallationManager.getUninstalledPluginIds());
     }
 
-    getDisabledPlugins(): Promise<readonly PluginIdentifiers.VersionedId[]> {
+    getDisabledPlugins(): Promise<readonly PluginIdentifiers.UnversionedId[]> {
         return Promise.resolve(this.uninstallationManager.getDisabledPluginIds());
     }
 
@@ -72,11 +72,11 @@ export class PluginServerImpl implements PluginServer {
         return this.pluginDeployer.uninstall(pluginId);
     }
 
-    enablePlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+    enablePlugin(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean> {
         return this.pluginDeployer.enablePlugin(pluginId);
     }
 
-    disablePlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+    disablePlugin(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean> {
         return this.pluginDeployer.disablePlugin(pluginId);
     }
 

package/src/main/node/plugin-uninstallation-manager.ts

@@ -30,11 +30,11 @@ export class PluginUninstallationManager {
     protected readonly onDidChangeUninstalledPluginsEmitter = new Emitter<readonly PluginIdentifiers.VersionedId[]>();
     onDidChangeUninstalledPlugins: Event<readonly PluginIdentifiers.VersionedId[]> = this.onDidChangeUninstalledPluginsEmitter.event;
 
-    protected readonly onDidChangeDisabledPluginsEmitter = new Emitter<readonly PluginIdentifiers.VersionedId[]>();
-    onDidChangeDisabledPlugins: Event<readonly PluginIdentifiers.VersionedId[]> = this.onDidChangeDisabledPluginsEmitter.event;
+    protected readonly onDidChangeDisabledPluginsEmitter = new Emitter<readonly PluginIdentifiers.UnversionedId[]>();
+    onDidChangeDisabledPlugins: Event<readonly PluginIdentifiers.UnversionedId[]> = this.onDidChangeDisabledPluginsEmitter.event;
 
     protected uninstalledPlugins: Set<PluginIdentifiers.VersionedId> = new Set();
-    protected disabledPlugins: Set<PluginIdentifiers.VersionedId> = new Set();
+    protected disabledPlugins: Set<PluginIdentifiers.UnversionedId> = new Set();
 
     protected readonly initialized = new Deferred<void>();
 
@@ -45,8 +45,10 @@ export class PluginUninstallationManager {
 
     protected async load(): Promise<void> {
         try {
-            const disabled: PluginIdentifiers.VersionedId[] = JSON.parse(await this.settingService.get(PluginUninstallationManager.DISABLED_PLUGINS) || '[]');
-            disabled.forEach(id => this.disabledPlugins.add(id));
+            const disabled: (PluginIdentifiers.VersionedId | PluginIdentifiers.UnversionedId)[] =
+               JSON.parse(await this.settingService.get(PluginUninstallationManager.DISABLED_PLUGINS) || '[]');
+
+            disabled.forEach(id => this.disabledPlugins.add(PluginIdentifiers.toUnversioned(id)));
         } catch (e) {
             // settings may be corrupt; just carry on
             console.warn(e);
@@ -91,7 +93,7 @@ export class PluginUninstallationManager {
         return [...this.uninstalledPlugins];
     }
 
-    async markAsDisabled(...pluginIds: PluginIdentifiers.VersionedId[]): Promise<boolean> {
+    async markAsDisabled(...pluginIds: PluginIdentifiers.UnversionedId[]): Promise<boolean> {
         await this.initialized.promise;
         let didChange = false;
         for (const id of pluginIds) {
@@ -107,7 +109,7 @@ export class PluginUninstallationManager {
         return didChange;
     }
 
-    async markAsEnabled(...pluginIds: PluginIdentifiers.VersionedId[]): Promise<boolean> {
+    async markAsEnabled(...pluginIds: PluginIdentifiers.UnversionedId[]): Promise<boolean> {
         await this.initialized.promise;
         let didChange = false;
         for (const id of pluginIds) {
@@ -120,12 +122,12 @@ export class PluginUninstallationManager {
         return didChange;
     }
 
-    async isDisabled(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+    async isDisabled(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean> {
         await this.initialized.promise;
         return this.disabledPlugins.has(pluginId);
     }
 
-    async getDisabledPluginIds(): Promise<readonly PluginIdentifiers.VersionedId[]> {
+    async getDisabledPluginIds(): Promise<readonly PluginIdentifiers.UnversionedId[]> {
         await this.initialized.promise;
         return [...this.disabledPlugins];
     }

package/src/plugin/output-channel/log-output-channel.ts

@@ -32,6 +32,16 @@ export class LogOutputChannelImpl extends OutputChannelImpl implements theia.Log
     constructor(name: string, proxy: OutputChannelRegistryMain, pluginInfo: PluginInfo) {
         super(name, proxy, pluginInfo);
         this.setLogLevel(LogLevel.Info);
+
+        // Bind overridden and new methods to preserve 'this' context
+        // These bindings are needed because the parent class bindings don't apply to overridden methods
+        this.append = this.append.bind(this);
+        this.appendLine = this.appendLine.bind(this);
+        this.trace = this.trace.bind(this);
+        this.debug = this.debug.bind(this);
+        this.info = this.info.bind(this);
+        this.warn = this.warn.bind(this);
+        this.error = this.error.bind(this);
     }
 
     setLogLevel(level: theia.LogLevel): void {

package/src/plugin/output-channel/output-channel-item.ts

@@ -21,6 +21,14 @@ export class OutputChannelImpl implements theia.OutputChannel {
     private disposed: boolean;
 
     constructor(readonly name: string, protected readonly proxy: OutputChannelRegistryMain, protected readonly pluginInfo: PluginInfo) {
+        // Bind methods to preserve 'this' context when passed as callbacks
+        // This ensures compatibility with extensions that pass these methods as function references
+        this.append = this.append.bind(this);
+        this.appendLine = this.appendLine.bind(this);
+        this.replace = this.replace.bind(this);
+        this.clear = this.clear.bind(this);
+        this.show = this.show.bind(this);
+        this.hide = this.hide.bind(this);
     }
 
     dispose(): void {