@theia/plugin-ext 1.73.0-next.2 → 1.73.0-next.20

package/src/main/browser/main-file-system-event-service.spec.ts

@@ -0,0 +1,78 @@
+// *****************************************************************************
+// Copyright (C) 2026 Safi Seid-Ahmad, K2view and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+const disableJSDOM = enableJSDOM();
+
+import * as assert from 'assert';
+import { Disposable } from '@theia/core/lib/common/disposable';
+import { WatchOptions } from '@theia/filesystem/lib/common/files';
+import { UriComponents } from '../../common/uri-components';
+import { MainFileSystemEventService } from './main-file-system-event-service';
+
+disableJSDOM();
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// A VS Code plugin (e.g. `redhat.java` hosting JDT-LS) that calls
+// `vscode.workspace.createFileSystemWatcher` with a `RelativePattern` rooted at an absolute base
+// triggers `ExtHostFileSystemEventService.ensureWatching`, which sends `$watch` to this main-side
+// service with an EMPTY `excludes` list. As a result the user's `files.watcherExclude` preference
+// was never applied to these (often sibling-of-workspace) recursive watches, so they crawled and
+// watched whole external trees, exhausting the OS file-watch budget.
+//
+// This test pins the fix: the main side must merge the configured `files.watcherExclude` patterns
+// into the watch options before delegating to the `FileService`.
+describe('MainFileSystemEventService files.watcherExclude handling', () => {
+
+    function componentsFor(path: string): UriComponents {
+        return { scheme: 'file', authority: '', path, query: '', fragment: '' };
+    }
+
+    it('applies files.watcherExclude to plugin-created watches that arrive with empty excludes', () => {
+        const watchCalls: WatchOptions[] = [];
+
+        const fileService: any = {
+            onDidFilesChange: () => Disposable.NULL,
+            onDidRunUserOperation: () => Disposable.NULL,
+            addFileOperationParticipant: () => Disposable.NULL,
+            watch: (_resource: any, options: WatchOptions) => {
+                watchCalls.push(options);
+                return Disposable.NULL;
+            }
+        };
+
+        const preferences: any = {
+            get: (preferenceName: string) => preferenceName === 'files.watcherExclude'
+                ? { '**/node_modules/**': true, '**/.git/objects/**': true, '**/disabled-exclude/**': false }
+                : undefined
+        };
+
+        const rpc: any = { getProxy: () => ({}) };
+
+        const service = new MainFileSystemEventService(rpc, {} as any, fileService, preferences);
+
+        // Mirrors what `ensureWatching` sends for an absolute RelativePattern base outside the workspace.
+        service.$watch(1, componentsFor('/outside/workspace/storage'), { recursive: true, excludes: [] });
+
+        assert.strictEqual(watchCalls.length, 1, 'FileService.watch should have been called once');
+        const excludes = watchCalls[0].excludes;
+        assert.ok(excludes.includes('**/node_modules/**'), 'enabled watcherExclude pattern should be applied');
+        assert.ok(excludes.includes('**/.git/objects/**'), 'enabled watcherExclude pattern should be applied');
+        assert.ok(!excludes.includes('**/disabled-exclude/**'), 'patterns set to `false` must not be applied');
+    });
+
+});

package/src/main/browser/main-file-system-event-service.ts

@@ -27,6 +27,7 @@ import { URI } from '@theia/core';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { FileChangeType, WatchOptions } from '@theia/filesystem/lib/common/files';
+import { FileSystemPreferences } from '@theia/filesystem/lib/common/filesystem-preferences';
 
 export class MainFileSystemEventService implements MainFileSystemEventServiceShape {
 
@@ -36,7 +37,8 @@ export class MainFileSystemEventService implements MainFileSystemEventServiceSha
     constructor(
         rpc: RPCProtocol,
         container: interfaces.Container,
-        private readonly fileService = container.get(FileService)
+        private readonly fileService = container.get(FileService),
+        private readonly preferences = container.get<FileSystemPreferences>(FileSystemPreferences)
     ) {
         const proxy = rpc.getProxy(MAIN_RPC_CONTEXT.ExtHostFileSystemEventService);
 
@@ -81,11 +83,29 @@ export class MainFileSystemEventService implements MainFileSystemEventServiceSha
         if (this.watches.has(session)) {
             throw new Error(`There is already a watch request for the key ${session}`);
         }
-        const watch = this.fileService.watch(URI.fromComponents(resource), options);
+        const uri = URI.fromComponents(resource);
+        // Plugin-created watchers (`vscode.workspace.createFileSystemWatcher`) arrive here with an
+        // empty `excludes` list. Language servers frequently request recursive watches rooted at
+        // absolute paths outside the workspace (e.g. JDT-LS's per-project globs), so apply the
+        // user's `files.watcherExclude` here to keep the number of OS file watches bounded.
+        const watch = this.fileService.watch(uri, { ...options, excludes: this.getExcludes(uri, options.excludes) });
         this.toDispose.push(watch);
         this.watches.set(session, watch);
     }
 
+    protected getExcludes(uri: URI, requested: string[] = []): string[] {
+        const configured = this.preferences.get('files.watcherExclude', undefined, uri.toString());
+        const excludes = new Set(requested);
+        if (configured) {
+            for (const pattern of Object.keys(configured)) {
+                if (configured[pattern]) {
+                    excludes.add(pattern);
+                }
+            }
+        }
+        return Array.from(excludes);
+    }
+
     $unwatch(session: number): void {
         const watch = this.watches.get(session);
         if (watch) {

package/src/main/browser/view/plugin-view-registry.spec.ts

@@ -0,0 +1,105 @@
+// *****************************************************************************
+// Copyright (C) 2026 Safi Seid-Ahmad, K2view and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+// PluginViewRegistry transitively imports browser widgets (Lumino) that touch `document` at load time.
+const disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+// Some transitively imported modules read the frontend config at load time.
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import { Disposable } from '@theia/core/lib/common';
+import { PluginViewRegistry, ViewContainerInfo } from './plugin-view-registry';
+
+disableJSDOM();
+
+interface RegisteredMenuAction {
+    commandId: string;
+    label: string;
+    when?: string;
+}
+
+/**
+ * Minimal stand-in for {@link MenuModelRegistry} that records the menu actions registered for the
+ * "Views" menu and removes them again when the returned disposable is disposed. This lets us assert
+ * on the labels {@link PluginViewRegistry} ends up showing without wiring the full DI container.
+ */
+class RecordingMenuModelRegistry {
+    readonly actions = new Map<string, RegisteredMenuAction>();
+
+    registerMenuAction(_menuPath: unknown, action: RegisteredMenuAction): Disposable {
+        this.actions.set(action.commandId, { ...action });
+        return Disposable.create(() => this.actions.delete(action.commandId));
+    }
+}
+
+describe('PluginViewRegistry - view menu labels', () => {
+
+    let registry: PluginViewRegistry;
+    let menus: RecordingMenuModelRegistry;
+
+    const toggleCommandId = (id: string): string => `plugin.view-container.${id}.toggle`;
+    const internals = (): {
+        viewContainers: Map<string, ViewContainerInfo>;
+        registerViewMenuAction(containerId: string, label: string): Disposable;
+    } => registry as unknown as {
+        viewContainers: Map<string, ViewContainerInfo>;
+        registerViewMenuAction(containerId: string, label: string): Disposable;
+    };
+
+    function registerContainer(id: string, label: string, location: string): Disposable {
+        internals().viewContainers.set(id, { id, location, options: { label }, onViewAdded: () => { } });
+        return internals().registerViewMenuAction(id, label);
+    }
+
+    beforeEach(() => {
+        registry = new PluginViewRegistry();
+        menus = new RecordingMenuModelRegistry();
+        (registry as unknown as { menus: unknown }).menus = menus;
+    });
+
+    it('uses the plain label for a single container', () => {
+        registerContainer('a', 'Claude Code', 'left');
+        expect(menus.actions.get(toggleCommandId('a'))?.label).to.equal('Claude Code');
+    });
+
+    it('leaves distinct labels unsuffixed', () => {
+        registerContainer('a', 'Explorer', 'left');
+        registerContainer('b', 'Claude Code', 'right');
+        expect(menus.actions.get(toggleCommandId('a'))?.label).to.equal('Explorer');
+        expect(menus.actions.get(toggleCommandId('b'))?.label).to.equal('Claude Code');
+    });
+
+    it('suffixes the location when two containers share a label', () => {
+        registerContainer('a', 'Claude Code', 'left');
+        registerContainer('b', 'Claude Code', 'right');
+        expect(menus.actions.get(toggleCommandId('a'))?.label).to.equal('Claude Code (Side Bar)');
+        expect(menus.actions.get(toggleCommandId('b'))?.label).to.equal('Claude Code (Secondary Side Bar)');
+    });
+
+    it('drops the suffix from the remaining container once the duplicate is removed', () => {
+        registerContainer('a', 'Claude Code', 'left');
+        const disposeB = registerContainer('b', 'Claude Code', 'right');
+
+        disposeB.dispose();
+
+        expect(menus.actions.get(toggleCommandId('a'))?.label).to.equal('Claude Code');
+        expect(menus.actions.has(toggleCommandId('b'))).to.equal(false);
+    });
+
+});

package/src/main/browser/view/plugin-view-registry.ts

@@ -111,6 +111,9 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
     private readonly viewClauseContexts = new Map<string, Set<string> | undefined>();
     private readonly viewContainerClauseContexts = new Map<string, Set<string> | undefined>();
 
+    private readonly viewMenuLabelToContainerIds = new Map<string, Set<string>>();
+    private readonly viewMenuDisposables = new Map<string, Disposable>();
+
     private readonly viewDataProviders = new Map<string, ViewDataProvider>();
     private readonly viewDataState = new Map<string, object>();
 
@@ -374,13 +377,10 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
             }, {
                 execute: () => this.toggleViewContainer(id)
             }));
-            toDispose.push(this.menus.registerMenuAction(CommonMenus.VIEW_VIEWS, {
-                commandId: toggleCommandId,
-                label: options.label,
-                when
-            }));
+            toDispose.push(this.registerViewMenuAction(id, options.label));
             toDispose.push(this.quickView?.registerItem({
                 label: options.label,
+                description: this.getLocationDescription(location),
                 when,
                 open: async () => {
                     const widget = await this.openViewContainer(id);
@@ -408,6 +408,88 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         return toDispose;
     }
 
+    protected getLocationDescription(location: string | undefined): string | undefined {
+        switch (location) {
+            case 'left': return nls.localizeByDefault('Side Bar');
+            case 'right': return nls.localizeByDefault('Secondary Side Bar');
+            case 'bottom': return nls.localizeByDefault('Panel');
+            default: return undefined;
+        }
+    }
+
+    protected getContainerLocation(viewContainerId: string): string | undefined {
+        if (PluginViewRegistry.BUILTIN_VIEW_CONTAINERS.has(viewContainerId)) {
+            return 'left';
+        }
+        return this.viewContainers.get(viewContainerId)?.location;
+    }
+
+    protected getViewQuickPickDescription(viewContainerId: string): string | undefined {
+        const locationDescription = this.getLocationDescription(this.getContainerLocation(viewContainerId));
+        const containerLabel = this.viewContainers.get(viewContainerId)?.options.label;
+        if (locationDescription && containerLabel) {
+            return `${locationDescription} / ${containerLabel}`;
+        }
+        return locationDescription;
+    }
+
+    protected registerViewMenuAction(containerId: string, label: string): Disposable {
+        let ids = this.viewMenuLabelToContainerIds.get(label);
+        if (!ids) {
+            ids = new Set();
+            this.viewMenuLabelToContainerIds.set(label, ids);
+        }
+        ids.add(containerId);
+        this.refreshViewMenuLabel(label);
+        return Disposable.create(() => {
+            const set = this.viewMenuLabelToContainerIds.get(label);
+            if (set) {
+                set.delete(containerId);
+                if (set.size === 0) {
+                    this.viewMenuLabelToContainerIds.delete(label);
+                }
+            }
+            const disposable = this.viewMenuDisposables.get(containerId);
+            if (disposable) {
+                disposable.dispose();
+                this.viewMenuDisposables.delete(containerId);
+            }
+            this.refreshViewMenuLabel(label);
+        });
+    }
+
+    protected refreshViewMenuLabel(label: string): void {
+        const ids = this.viewMenuLabelToContainerIds.get(label);
+        if (!ids) {
+            return;
+        }
+        const useSuffix = ids.size > 1;
+        for (const id of ids) {
+            const existing = this.viewMenuDisposables.get(id);
+            if (existing) {
+                existing.dispose();
+                this.viewMenuDisposables.delete(id);
+            }
+            const containerInfo = this.viewContainers.get(id);
+            if (!containerInfo) {
+                continue;
+            }
+            let menuLabel = label;
+            if (useSuffix) {
+                const description = this.getLocationDescription(containerInfo.location);
+                if (description) {
+                    menuLabel = `${label} (${description})`;
+                }
+            }
+            const disposable = this.menus.registerMenuAction(CommonMenus.VIEW_VIEWS, {
+                commandId: `plugin.view-container.${id}.toggle`,
+                label: menuLabel,
+                when: containerInfo.when
+            });
+            this.viewMenuDisposables.set(id, disposable);
+        }
+    }
+
     protected isViewContainerVisible(containerId: string): boolean {
         const info = this.viewContainers.get(containerId);
         if (!info) {
@@ -471,6 +553,7 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         }
         toDispose.push(this.quickView?.registerItem({
             label: view.name,
+            description: this.getViewQuickPickDescription(viewContainerId),
             when: view.when,
             open: () => this.openView(view.id, { activate: true })
         }));
@@ -560,7 +643,9 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
                 });
                 return _pendingResolution;
             },
-            show: webview.show
+            show: (preserveFocus: boolean) => {
+                this.openView(viewId, preserveFocus ? { reveal: true } : { activate: true });
+            }
         };
 
         const toDispose = this.onNewResolverRegistered(resolver => {