@theia/ai-registry 1.73.0-next.2

package/src/browser/mcp/mcp-extensions-contribution.spec.ts

@@ -0,0 +1,294 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// 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 { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+// Entries render against the shared ExtensionCard, which pulls in browser-side modules,
+// so a DOM is required at import time.
+const disableJSDOM = enableJSDOM();
+try {
+    FrontendApplicationConfigProvider.get();
+} catch {
+    FrontendApplicationConfigProvider.set({});
+}
+
+import { expect } from 'chai';
+import { Container } from '@theia/core/shared/inversify';
+import { Emitter, MessageService, PreferenceService } from '@theia/core';
+import { HoverService } from '@theia/core/lib/browser';
+import { MCP_SERVERS_PREF } from '@theia/ai-mcp/lib/common/mcp-preferences';
+import { MCPFrontendService } from '@theia/ai-mcp/lib/common/mcp-server-manager';
+import { MCPServerEditor, MCPServerEditorImpl, MCPServerEditDialogFactory } from '@theia/ai-mcp/lib/browser/mcp-server-editor';
+import { MCPServerInstallDialogFactory } from '@theia/ai-mcp/lib/browser/mcp-server-install-dialog';
+import { RegistryFetchService } from '../../common/registry-fetch-service';
+import { ResolvedRegistryEntry } from '../../common/mcp/mcp-registry-types';
+import { MCPRegistryEntryResolver, MCPRegistryEntryResolverImpl } from '../../common/mcp/mcp-registry-entry-resolver';
+import { MCPInstallService, MCPInstallServiceImpl } from './mcp-install-service';
+import { MCPExtensionsContribution } from './mcp-extensions-contribution';
+import { MCPInstalledEntry, MCPSearchResultEntry } from './mcp-entries';
+
+after(() => disableJSDOM());
+
+class FakePreferenceService {
+    private readonly store = new Map<string, unknown>();
+    private readonly listeners: ((change: { preferenceName: string }) => void)[] = [];
+    get<T>(key: string, defaultValue?: T): T | undefined {
+        return (this.store.has(key) ? this.store.get(key) : defaultValue) as T | undefined;
+    }
+    async set(key: string, value: unknown): Promise<void> {
+        this.store.set(key, value);
+        for (const l of this.listeners) {
+            l({ preferenceName: key });
+        }
+    }
+    onPreferenceChanged(listener: (change: { preferenceName: string }) => void): { dispose(): void } {
+        this.listeners.push(listener);
+        return { dispose: () => { /* no-op for tests */ } };
+    }
+}
+
+class StubRegistryFetchService {
+    protected readonly onDidChangeEmitter = new Emitter<void>();
+    readonly onDidChange = this.onDidChangeEmitter.event;
+    constructor(public entries: ResolvedRegistryEntry[] = []) { }
+    async getEntries(): Promise<ResolvedRegistryEntry[]> {
+        return this.entries;
+    }
+}
+
+function buildContainer(prefs: FakePreferenceService, fetch: StubRegistryFetchService): Container {
+    const container = new Container();
+    container.bind(PreferenceService).toConstantValue(prefs);
+    container.bind(RegistryFetchService).toConstantValue(fetch as unknown as RegistryFetchService);
+    container.bind(MCPRegistryEntryResolverImpl).toSelf().inSingletonScope();
+    container.bind(MCPRegistryEntryResolver).toService(MCPRegistryEntryResolverImpl);
+    // Editor dependencies — the contribution doesn't invoke the install path here, but
+    // MCPInstallService now injects MCPServerEditor so we stub its required services.
+    container.bind(MessageService).toConstantValue({ error: () => undefined } as unknown as MessageService);
+    container.bind(MCPFrontendService).toConstantValue({} as unknown as MCPFrontendService);
+    container.bind(HoverService).toConstantValue({ requestHover: () => undefined } as unknown as HoverService);
+    // The contribution doesn't open dialogs in these tests; bind factories that fail loudly if used.
+    container.bind(MCPServerEditDialogFactory).toConstantValue(() => {
+        throw new Error('MCPServerEditDialogFactory should not be invoked in these tests');
+    });
+    container.bind(MCPServerInstallDialogFactory).toConstantValue(() => {
+        throw new Error('MCPServerInstallDialogFactory should not be invoked in these tests');
+    });
+    container.bind(MCPServerEditorImpl).toSelf().inSingletonScope();
+    container.bind(MCPServerEditor).toService(MCPServerEditorImpl);
+    container.bind(MCPInstallServiceImpl).toSelf().inSingletonScope();
+    container.bind(MCPInstallService).toService(MCPInstallServiceImpl);
+    container.bind(MCPExtensionsContribution).toSelf().inSingletonScope();
+    return container;
+}
+
+const exampleRegistryEntry: ResolvedRegistryEntry = {
+    serverId: 'io.github.example/example-mcp',
+    name: 'Example',
+    description: 'Example MCP server',
+    localName: 'example',
+    config: { command: 'npx', args: ['-y', 'example-mcp'] },
+    version: '^1.0.0',
+    configHash: 'hash-v1',
+    mcpRegistryVerified: true
+};
+
+describe('MCPExtensionsContribution.resolveInstalled', () => {
+
+    it('only surfaces servers tied to a registry entry; user-added entries are filtered out', async () => {
+        const prefs = new FakePreferenceService();
+        await prefs.set(MCP_SERVERS_PREF, {
+            // Linked: matches a registry entry by serverId.
+            example: {
+                command: 'npx',
+                args: ['-y', 'example-mcp'],
+                registryMetadata: {
+                    serverId: exampleRegistryEntry.serverId,
+                    version: exampleRegistryEntry.version,
+                    configHash: exampleRegistryEntry.configHash
+                }
+            },
+            // User-added: no registry counterpart at all.
+            standalone: { command: 'node', args: ['srv.js'] }
+        });
+        const fetch = new StubRegistryFetchService([exampleRegistryEntry]);
+        const contribution = buildContainer(prefs, fetch).get(MCPExtensionsContribution);
+
+        const entries = [...await contribution.resolveInstalled()] as MCPInstalledEntry[];
+
+        expect(entries.map(e => e.local.name)).to.deep.equal(['example']);
+        expect(entries[0].state).to.deep.equal({ kind: 'installed-from-registry', updateAvailable: false });
+    });
+
+    it('surfaces installed-link-stale entries so the view can render the warning + Unlink/Uninstall actions', async () => {
+        const prefs = new FakePreferenceService();
+        await prefs.set(MCP_SERVERS_PREF, {
+            stale: {
+                command: 'npx',
+                args: ['-y', 'gone-mcp'],
+                registryMetadata: {
+                    serverId: 'io.github.example/gone-server',
+                    version: '^1.0.0'
+                }
+            }
+        });
+        const fetch = new StubRegistryFetchService([exampleRegistryEntry]);
+        const contribution = buildContainer(prefs, fetch).get(MCPExtensionsContribution);
+
+        const entries = [...await contribution.resolveInstalled()] as MCPInstalledEntry[];
+
+        expect(entries.map(e => e.local.name)).to.deep.equal(['stale']);
+        expect(entries[0].state).to.deep.equal({ kind: 'installed-link-stale' });
+    });
+
+    it('shows installed-link-stale (Unlink + Uninstall) when the local is linked to a missing id, even if the key still matches a registry entry', async () => {
+        // PR scenario: user installs from the registry, then manually rewrites
+        // `registryMetadata.serverId` to a value that no longer exists. The local key
+        // still matches a registry `localName`, but the broken id linkage must take
+        // precedence - the entry has to surface as link-stale so the user sees the
+        // Unlink + Uninstall affordances and the warning, not Link (which would suggest
+        // the entry is merely unlinked).
+        const prefs = new FakePreferenceService();
+        await prefs.set(MCP_SERVERS_PREF, {
+            example: {
+                command: 'npx',
+                args: ['-y', 'example-mcp'],
+                registryMetadata: {
+                    serverId: 'io.example/gone',
+                    version: '^1.0.0',
+                    configHash: 'hash-v1'
+                }
+            }
+        });
+        const fetch = new StubRegistryFetchService([exampleRegistryEntry]);
+        const contribution = buildContainer(prefs, fetch).get(MCPExtensionsContribution);
+
+        const entries = [...await contribution.resolveInstalled()] as MCPInstalledEntry[];
+
+        expect(entries).to.have.length(1);
+        expect(entries[0].state).to.deep.equal({ kind: 'installed-link-stale' });
+    });
+
+    it('skips malformed stored entries whose `command` is not a string — mere key presence is not enough', async () => {
+        const prefs = new FakePreferenceService();
+        await prefs.set(MCP_SERVERS_PREF, {
+            // `command` is present but typed wrong; the shared MCPServersPreference.isValue
+            // guard must reject this so it doesn't get cast to MCPServerDescription.
+            broken: { command: 42, args: ['-y', 'whatever'] },
+            example: {
+                command: 'npx',
+                args: ['-y', 'example-mcp'],
+                registryMetadata: {
+                    serverId: exampleRegistryEntry.serverId,
+                    version: exampleRegistryEntry.version,
+                    configHash: exampleRegistryEntry.configHash
+                }
+            }
+        });
+        const fetch = new StubRegistryFetchService([exampleRegistryEntry]);
+        const contribution = buildContainer(prefs, fetch).get(MCPExtensionsContribution);
+
+        const entries = [...await contribution.resolveInstalled()] as MCPInstalledEntry[];
+
+        expect(entries.map(e => e.local.name)).to.deep.equal(['example']);
+    });
+});
+
+describe('MCPExtensionsContribution.resolveSearchResults', () => {
+
+    const githubEntry: ResolvedRegistryEntry = {
+        serverId: 'io.github.github/github-mcp-server',
+        name: 'GitHub',
+        description: 'Connect AI assistants to GitHub repositories',
+        localName: 'github',
+        config: { command: 'docker', args: ['run', '-i', '--rm'] },
+        version: '^1.0.0',
+        configHash: 'hash-github',
+        mcpRegistryVerified: true
+    };
+
+    it('returns nothing for an empty or whitespace-only query', async () => {
+        const prefs = new FakePreferenceService();
+        const fetch = new StubRegistryFetchService([exampleRegistryEntry, githubEntry]);
+        const contribution = buildContainer(prefs, fetch).get(MCPExtensionsContribution);
+
+        const empty = [...await contribution.resolveSearchResults('', { verifiedOnly: false })];
+        const whitespace = [...await contribution.resolveSearchResults('   ', { verifiedOnly: false })];
+
+        expect(empty).to.be.empty;
+        expect(whitespace).to.be.empty;
+    });
+
+    it('returns all entries with searchableText covering name, serverId and description so the global fuzzy ranker can match any of them', async () => {
+        const prefs = new FakePreferenceService();
+        const fetch = new StubRegistryFetchService([exampleRegistryEntry, githubEntry]);
+        const contribution = buildContainer(prefs, fetch).get(MCPExtensionsContribution);
+
+        // The contribution intentionally does not filter by the query string: that's the
+        // view's job (`VSXExtensionsSource.collectSearchResults` runs `FuzzySearch.filter`
+        // across results from every contribution). The contribution's only responsibility
+        // is to supply candidates with rich `searchableText`.
+        const results = [...await contribution.resolveSearchResults('REPOSITORIES', { verifiedOnly: false })];
+
+        expect(results).to.have.length(2);
+        const githubResult = results.find(r => (r.element as MCPSearchResultEntry).entry.serverId === githubEntry.serverId)!;
+        expect(githubResult.searchableText).to.contain(githubEntry.name);
+        expect(githubResult.searchableText).to.contain(githubEntry.serverId);
+        expect(githubResult.searchableText).to.contain(githubEntry.description);
+    });
+
+    it('classifies a registry entry as installed-link-stale when the matching-key local is linked to a server id missing from the registry', async () => {
+        // PR scenario: user installed `example` from the registry, then manually pointed
+        // its `registryMetadata.serverId` at an id not in the registry. In Search results
+        // the matching registry entry must show the **Unlink / Uninstall** affordances -
+        // mirroring what the Installed view shows - instead of **Link** (which would
+        // imply the local is merely unlinked rather than stale-linked).
+        const prefs = new FakePreferenceService();
+        await prefs.set(MCP_SERVERS_PREF, {
+            example: {
+                command: 'npx',
+                args: ['-y', 'example-mcp'],
+                registryMetadata: {
+                    serverId: 'io.example/gone',
+                    version: '^1.0.0',
+                    configHash: 'hash-v1'
+                }
+            }
+        });
+        const fetch = new StubRegistryFetchService([exampleRegistryEntry]);
+        const contribution = buildContainer(prefs, fetch).get(MCPExtensionsContribution);
+
+        const results = [...await contribution.resolveSearchResults('example', { verifiedOnly: false })];
+        const exampleResult = results.find(r => (r.element as MCPSearchResultEntry).entry.serverId === exampleRegistryEntry.serverId);
+
+        expect(exampleResult, 'registry entry must surface in search results').to.not.be.undefined;
+        expect((exampleResult!.element as MCPSearchResultEntry).state).to.deep.equal({ kind: 'installed-link-stale' });
+    });
+
+    it('omits unverified entries when verifiedOnly is true and keeps verified ones', async () => {
+        const unverified: ResolvedRegistryEntry = { ...exampleRegistryEntry, mcpRegistryVerified: false };
+        const prefs = new FakePreferenceService();
+        const fetch = new StubRegistryFetchService([unverified, githubEntry]);
+        const contribution = buildContainer(prefs, fetch).get(MCPExtensionsContribution);
+
+        const all = [...await contribution.resolveSearchResults('example', { verifiedOnly: false })];
+        const verifiedOnly = [...await contribution.resolveSearchResults('example', { verifiedOnly: true })];
+
+        expect(all).to.have.length(2);
+        expect(verifiedOnly).to.have.length(1);
+        expect((verifiedOnly[0].element as MCPSearchResultEntry).entry.serverId).to.equal(githubEntry.serverId);
+    });
+});

package/src/browser/mcp/mcp-extensions-contribution.ts

@@ -0,0 +1,199 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// 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 { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { Disposable, DisposableCollection, Emitter, Event, nls, PreferenceChange, PreferenceService } from '@theia/core';
+import { HoverService } from '@theia/core/lib/browser';
+import { TreeElement } from '@theia/core/lib/browser/source-tree';
+import { ExtensionsSourceContribution, SearchContext, SearchResult } from '@theia/vsx-registry/lib/browser/extensions-source-contribution';
+import { MCP_SERVERS_PREF } from '@theia/ai-mcp/lib/common/mcp-preferences';
+import { MCPServerDescription } from '@theia/ai-mcp/lib/common/mcp-server-manager';
+import { MCPServersPreference, MCPServersPreferenceValue } from '@theia/ai-mcp/lib/common/mcp-servers-preference';
+import { MCPServerInstallDialogFactory } from '@theia/ai-mcp/lib/browser/mcp-server-install-dialog';
+import { RegistryFetchService } from '../../common/registry-fetch-service';
+import { ResolvedRegistryEntry } from '../../common/mcp/mcp-registry-types';
+import { MCPInstallService } from './mcp-install-service';
+import { MCPEntryHandlers, MCPInstalledEntry, MCPSearchResultEntry } from './mcp-entries';
+
+type StoredServer = MCPServersPreferenceValue;
+
+@injectable()
+export class MCPExtensionsContribution implements ExtensionsSourceContribution, Disposable {
+
+    readonly type = 'mcp-server';
+    readonly displayName = nls.localizeByDefault('MCP Servers');
+    readonly priority = 100;
+
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
+    @inject(MCPInstallService)
+    protected readonly installService: MCPInstallService;
+
+    @inject(RegistryFetchService)
+    protected readonly fetchService: RegistryFetchService;
+
+    @inject(HoverService)
+    protected readonly hoverService: HoverService;
+
+    @inject(MCPServerInstallDialogFactory)
+    protected readonly installDialogFactory: MCPServerInstallDialogFactory;
+
+    protected readonly onDidChangeEmitter = new Emitter<void>();
+    readonly onDidChange: Event<void> = this.onDidChangeEmitter.event;
+
+    protected readonly toDispose = new DisposableCollection(this.onDidChangeEmitter);
+
+    protected handlers: MCPEntryHandlers;
+
+    @postConstruct()
+    protected init(): void {
+        this.handlers = {
+            install: entry => this.confirmAndInstall(entry),
+            uninstall: serverKey => this.installService.uninstall(serverKey),
+            unlink: serverKey => this.installService.unlink(serverKey),
+            update: entry => this.installService.update(entry),
+            link: entry => this.installService.link(entry),
+            fixConfig: entry => this.installService.fixConfig(entry)
+        };
+        this.toDispose.push(this.preferenceService.onPreferenceChanged((change: PreferenceChange) => {
+            if (change.preferenceName === MCP_SERVERS_PREF) {
+                this.onDidChangeEmitter.fire();
+            }
+        }));
+        this.toDispose.push(this.fetchService.onDidChange(() => this.onDidChangeEmitter.fire()));
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
+    async resolveInstalled(): Promise<Iterable<TreeElement>> {
+        const stored = this.readStoredServers();
+        const registryEntries = await this.safeGetRegistryEntries();
+        const byServerId = new Map(registryEntries.map(e => [e.serverId, e]));
+        const byName = new Map(registryEntries.map(e => [e.localName, e]));
+        const result: TreeElement[] = [];
+        for (const [name, config] of Object.entries(stored)) {
+            const local = this.toServerDescription(name, config);
+            if (!local) {
+                continue;
+            }
+            const state = this.installService.classifyLocalServer(local, registryEntries);
+            // Hand-added local servers belong to the MCP configuration widget, not this view.
+            // Stale-linked entries (registryMetadata.serverId set but registry no longer lists
+            // it) do belong here so we can surface the warning and offer Unlink / Uninstall.
+            if (state.kind === 'installed-user-added') {
+                continue;
+            }
+            const linkedId = local.registryMetadata?.serverId;
+            const matchedEntry = (linkedId && byServerId.get(linkedId)) || byName.get(local.name);
+            result.push(new MCPInstalledEntry(local, matchedEntry, state, this.handlers, this.hoverService));
+        }
+        return result;
+    }
+
+    async resolveSearchResults(query: string, context: SearchContext): Promise<Iterable<SearchResult>> {
+        if (!query.trim()) {
+            return [];
+        }
+        const registryEntries = await this.safeGetRegistryEntries();
+        const localDescriptions: MCPServerDescription[] = [];
+        for (const [name, cfg] of Object.entries(this.readStoredServers())) {
+            const local = this.toServerDescription(name, cfg);
+            if (local) {
+                localDescriptions.push(local);
+            }
+        }
+        const result: SearchResult[] = [];
+        for (const entry of registryEntries) {
+            // `verifiedOnly` comes from the OVSX-named `extensions.onlyShowVerifiedExtensions`
+            // preference. In this contribution "verified" maps to `mcpRegistryVerified`
+            // (i.e. approved in the AI registry), piggy-backing on the same toggle.
+            if (context.verifiedOnly && !entry.mcpRegistryVerified) {
+                continue;
+            }
+            // Hand all candidates to the view's global fuzzy ranker (`FuzzySearch.filter`
+            // in `VSXExtensionsSource.collectSearchResults`). It already discards entries
+            // that don't match the query, and a substring pre-filter would drop legitimate
+            // fuzzy matches such as "ChroDevTo" → "Chrome DevTools".
+            const searchableText = `${entry.name} ${entry.serverId} ${entry.description}`;
+            const state = this.installService.classifyRegistryEntry(entry, localDescriptions, registryEntries);
+            result.push({
+                element: new MCPSearchResultEntry(entry, state, this.handlers, this.hoverService),
+                searchableText
+            });
+        }
+        return result;
+    }
+
+    async refresh(): Promise<void> {
+        await this.fetchService.getEntries(true);
+    }
+
+    /**
+     * Returns the raw (untyped) servers preference; per-entry validation happens in
+     * `toServerDescription`, which uses the shared `MCPServersPreference.isValue` guard
+     * so this view and `McpFrontendApplicationContribution` apply the same value checks.
+     */
+    protected readStoredServers(): Record<string, unknown> {
+        return this.preferenceService.get<Record<string, unknown>>(MCP_SERVERS_PREF, {}) ?? {};
+    }
+
+    protected async safeGetRegistryEntries(): Promise<ResolvedRegistryEntry[]> {
+        try {
+            return await this.fetchService.getEntries();
+        } catch (error) {
+            // Without entries, locally-installed servers classify as user-added and the
+            // MCP section shows nothing; users can still manage servers from the AI
+            // configuration widget directly.
+            console.warn('AI registry fetch failed; MCP entries unavailable.', error);
+            return [];
+        }
+    }
+
+    protected toServerDescription(name: string, stored: unknown): MCPServerDescription | undefined {
+        // Reuse the same value guard the MCP frontend contribution applies to the
+        // preference, so a `command: 42` (or any non-string) entry is rejected here too
+        // instead of being cast straight to `MCPServerDescription`.
+        if (!MCPServersPreference.isValue(stored)) {
+            console.warn(`Ignoring malformed MCP server "${name}": value does not match the MCP servers preference schema.`);
+            return undefined;
+        }
+        return { name, ...(stored as StoredServer) } as MCPServerDescription;
+    }
+
+    /**
+     * Prompts the user for parameters the registry can't decide for them (autostart,
+     * auth token) before writing the entry. Cancelling the dialog aborts the install.
+     * The dialog is created through an injected factory so this contribution doesn't
+     * import the DOM-touching `ReactDialog` chain directly.
+     */
+    protected async confirmAndInstall(entry: ResolvedRegistryEntry): Promise<void> {
+        const dialog = this.installDialogFactory({
+            name: entry.localName,
+            autostart: true,
+            // The registry sets `serverAuthToken` to mark auth as part of the connection
+            // contract, even with no default value — so we check key presence, not value.
+            requireAuthToken: 'serverAuthToken' in entry.config
+        });
+        const result = await dialog.open();
+        if (!result) {
+            return;
+        }
+        await this.installService.install(entry, result);
+    }
+}