Disabling a plugin not available in the open vsx registery and reloading the page makes the disabled plugin blank (without infos)

[anassdenna]

Bug Description:

The issue can be reproduced using the steps below:

Steps to Reproduce:

1. Download any vscode plugin not available in the open vsx registery and add it to the builtin plugins folder (e.g. vscodeintellicode).
2. Open theia IDE or any theia fork.
3. Open the extensions widget and go to the builtins section.
4. Disable the "vscodeintellicode" plugin and reload the page.
5. After page reload, the plugin appears as a blank plugin with no infos (only "disabled" label is displayed).

theia_issue_builtin_plugins.mp4

Additional Information

• Operating System: Windows 11
• Theia Version: 1.65.1

[ndoschek]

Hi @anassdenna, thanks for reaching out!
Typically, extensions are installed via the Extensions view using the ... > Install from VSIX... option.

If you're looking to add an extension as a built-in to a Theia-based product, this should be done via the theiaPlugins entry in the package.json. See also dev-packages/cli-README.md#downloading-plugins
These extensions or extension packs are then downloaded and extracted during the build process.

[msujew]

I believe this is in fact unrelated to the builtin plugin feature at all. It affects all plugins that are not available on open-vsx. I just reproduced it with a plugin that I've installed via the Install from VSIX command:

I've updated the title of the issue to reflect this.

[ndoschek]

Thanks! Indeed, I also just tested it and observed the same behavior.
However, once I click on the entry, the extension data page loads correctly and the extension entry updates as expected. Also, if the extension page is kept open and you reload the window, the correct data is shown after reload for me.

Screencast.2025-11-20.15.02.57.mp4

[anassdenna]

@ndoschek @msujew i did some investigations and i think that the issue comes from the plugin-service.ts file:

It seems that we only try to load non disabled plugins, while we should load all installed plugins first, then only enable those that are not disabled.

I currently have a workaround using a custom hosted-plugin implementation:

import { inject, injectable, postConstruct } from "inversify";
import { HostedPluginSupport } from "@theia/plugin-ext/lib/hosted/browser/hosted-plugin";
import {
  PluginContributions,
  PluginHost,
} from "@theia/plugin-ext/lib/hosted/common/hosted-plugin";
import {
  HostedPluginServer,
  PluginIdentifiers,
} from "@theia/plugin-ext/lib/common";
import {
  Disposable,
  DisposableCollection,
} from "@theia/core/lib/common/disposable";
import { RpcProxy } from "@theia/core/lib/common/messaging/proxy-factory";

@injectable()
export class CustomHostedPluginSupport extends HostedPluginSupport {
  @inject(HostedPluginServer)
  protected readonly _server!: RpcProxy<HostedPluginServer>;
  protected server!: RpcProxy<HostedPluginServer>;
+  private disabledPluginIds: PluginIdentifiers.UnversionedId[] = [];

+  @postConstruct()
+  protected init(): void {
+    this.server = new Proxy(this._server, {
+      get: (target, prop, receiver) => {
+        if (prop === "getDeployedPluginIds") {
+          // Force getDeployedPluginIds to load all installed plugins
+          return async () => {
+            return await this._server.getInstalledPluginIds();
+          };
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+    });
+  }

+  protected async doLoad(): Promise<void> {
+    this.disabledPluginIds =
+      (await this.server.getDisabledPluginIds()) as PluginIdentifiers.UnversionedId[];
+    super.doLoad();
+  }

  /**
   * Always synchronous in order to simplify handling disconnections.
   * @throws never
   */
  protected loadContributions(
    toDisconnect: DisposableCollection
  ): Map<PluginHost, PluginContributions[]> {
    let loaded = 0;
    const loadPluginsMeasurement = this.measure("loadPlugins");

    const hostContributions = new Map<PluginHost, PluginContributions[]>();
    console.log(`[${this.clientId}] Loading plugin contributions`);
    for (const contributions of this.contributions.values()) {
      const plugin = contributions.plugin.metadata;
      const pluginId = plugin.model.id;
      const unversionedId = PluginIdentifiers.componentsToUnversionedId(
        plugin.model
      );

+      // Do not load disabled plugins
+      if (this.disabledPluginIds.includes(unversionedId)) {
+        continue;
+      }

      if (contributions.state === PluginContributions.State.INITIALIZING) {
        contributions.state = PluginContributions.State.LOADING;
        contributions.push(
          Disposable.create(() =>
            console.log(`[${pluginId}]: Unloaded plugin.`)
          )
        );
        contributions.push(this.handleContributions(contributions.plugin));
        contributions.state = PluginContributions.State.LOADED;
        console.debug(`[${this.clientId}][${pluginId}]: Loaded contributions.`);
        loaded++;
      }

      if (contributions.state === PluginContributions.State.LOADED) {
        contributions.state = PluginContributions.State.STARTING;
        const host = plugin.model.entryPoint.frontend
          ? "frontend"
          : plugin.host;
        const dynamicContributions = hostContributions.get(host) || [];
        dynamicContributions.push(contributions);
        hostContributions.set(host, dynamicContributions);
        toDisconnect.push(
          Disposable.create(() => {
            contributions!.state = PluginContributions.State.LOADED;
            console.debug(`[${this.clientId}][${pluginId}]: Disconnected.`);
          })
        );
      }
    }
    if (loaded > 0) {
      // Only log load measurement if there are were plugins to load.
      loadPluginsMeasurement?.log(
        `Load contributions of ${this.getPluginCount(loaded)}`
      );
    } else {
      loadPluginsMeasurement.stop();
    }

    return hostContributions;
  }
}

Still, i think that my workaround is "maybe" over-engineered and unclean.