@theia/plugin-ext 1.71.0-next.41 → 1.71.0-next.43

package/src/plugin/terminal-ext.spec.ts

@@ -0,0 +1,350 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource 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 * as chai from 'chai';
+import * as theia from '@theia/plugin';
+import { TerminalServiceMain, Plugin, TerminalOptions } from '../common/plugin-api-rpc';
+import { RPCProtocol, ProxyIdentifier } from '../common/rpc-protocol';
+import { TerminalServiceExtImpl, TerminalExtImpl } from './terminal-ext';
+import { TerminalExitReason } from './types-impl';
+
+const expect = chai.expect;
+
+/**
+ * Creates a mock RPCProtocol that returns the given proxy for TERMINAL_MAIN.
+ */
+function createMockRpc(proxy: Partial<TerminalServiceMain>): RPCProtocol {
+    return {
+        getProxy<T>(_proxyId: ProxyIdentifier<T>): T {
+            return proxy as unknown as T;
+        },
+        set<T, R extends T>(_identifier: ProxyIdentifier<T>, instance: R): R {
+            return instance;
+        },
+        dispose(): void { }
+    } as RPCProtocol;
+}
+
+/**
+ * Creates a minimal mock Plugin object.
+ */
+function createMockPlugin(): Plugin {
+    return {
+        pluginPath: '/test',
+        pluginFolder: '/test',
+        pluginUri: 'file:///test',
+        model: { id: 'test.plugin' } as Plugin['model'],
+        rawModel: {} as Plugin['rawModel'],
+        lifecycle: {} as Plugin['lifecycle'],
+        isUnderDevelopment: false
+    };
+}
+
+/**
+ * Creates a stub TerminalServiceMain that records calls.
+ */
+function createMockProxy(): TerminalServiceMain & { createdTerminals: { id: string; options: TerminalOptions }[] } {
+    const createdTerminals: { id: string; options: TerminalOptions }[] = [];
+    return {
+        createdTerminals,
+        $createTerminal(id: string, options: TerminalOptions): Promise<string> {
+            createdTerminals.push({ id, options });
+            return Promise.resolve(id);
+        },
+        $sendText(): void { },
+        $write(): void { },
+        $resize(): void { },
+        $show(): void { },
+        $hide(): void { },
+        $dispose(): void { },
+        $setName(): void { },
+        $writeByTerminalId(): void { },
+        $resizeByTerminalId(): void { },
+        $disposeByTerminalId(): void { },
+        $setNameByTerminalId(): void { },
+        $setEnvironmentVariableCollection(): void { },
+        $registerTerminalLinkProvider(): void { },
+        $unregisterTerminalLinkProvider(): void { },
+        $registerTerminalObserver(): void { },
+        $unregisterTerminalObserver(): void { },
+    } as unknown as TerminalServiceMain & { createdTerminals: { id: string; options: TerminalOptions }[] };
+}
+
+describe('TerminalServiceExtImpl', () => {
+    let proxy: ReturnType<typeof createMockProxy>;
+    let service: TerminalServiceExtImpl;
+    let plugin: Plugin;
+
+    beforeEach(() => {
+        proxy = createMockProxy();
+        const rpc = createMockRpc(proxy);
+        service = new TerminalServiceExtImpl(rpc);
+        plugin = createMockPlugin();
+    });
+
+    describe('terminals list', () => {
+        it('returns empty array initially', () => {
+            expect(service.terminals).to.deep.equal([]);
+        });
+
+        it('includes terminals after creation via $terminalCreated', () => {
+            service.$terminalCreated('t1', 'Terminal 1');
+            expect(service.terminals).to.have.length(1);
+        });
+
+        it('removes terminals after $terminalClosed', () => {
+            service.$terminalCreated('t1', 'Terminal 1');
+            service.$terminalClosed('t1', { code: 0, reason: TerminalExitReason.Process });
+            expect(service.terminals).to.have.length(0);
+        });
+    });
+
+    describe('API object identity', () => {
+        it('returns the raw TerminalExtImpl when no wrapper is provided', () => {
+            const terminal = service.createTerminal(plugin, 'Test Terminal');
+            expect(terminal).to.be.instanceOf(TerminalExtImpl);
+        });
+
+        it('returns the wrapped API object when a wrapper is provided', () => {
+            const wrapper = (t: TerminalExtImpl): theia.Terminal => ({ ...t, name: 'wrapped' } as unknown as theia.Terminal);
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+            const terminal = service.terminals[0];
+            expect(terminal.name).to.equal('wrapped');
+            expect(terminal).to.not.be.instanceOf(TerminalExtImpl);
+        });
+
+        it('fires onDidOpenTerminal with the API object, not the raw terminal', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const opened: theia.Terminal[] = [];
+            service.onDidOpenTerminal(t => opened.push(t));
+
+            // Get the ID from the proxy call
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+
+            expect(opened).to.have.length(1);
+            expect(opened[0]).to.equal(apiObject);
+        });
+
+        it('fires onDidCloseTerminal with the API object', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const closed: theia.Terminal[] = [];
+            service.onDidCloseTerminal(t => closed.push(t));
+
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+            service.$terminalClosed(id, { code: 0, reason: TerminalExitReason.Process });
+
+            expect(closed).to.have.length(1);
+            expect(closed[0]).to.equal(apiObject);
+        });
+
+        it('fires onDidChangeTerminalState with the API object on interaction', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const stateChanged: theia.Terminal[] = [];
+            service.onDidChangeTerminalState(t => stateChanged.push(t));
+
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+            service.$terminalOnInteraction(id);
+
+            expect(stateChanged).to.have.length(1);
+            expect(stateChanged[0]).to.equal(apiObject);
+        });
+
+        it('fires onDidChangeTerminalState with the API object on shell type change', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const stateChanged: theia.Terminal[] = [];
+            service.onDidChangeTerminalState(t => stateChanged.push(t));
+
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+            service.$terminalShellTypeChanged(id, '/bin/zsh');
+
+            expect(stateChanged).to.have.length(1);
+            expect(stateChanged[0]).to.equal(apiObject);
+        });
+
+        it('returns the API object from the terminals list', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+
+            const terminals = service.terminals;
+            expect(terminals).to.have.length(1);
+            expect(terminals[0]).to.equal(apiObject);
+        });
+
+        it('returns the API object as activeTerminal', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+            service.$currentTerminalChanged(id);
+
+            expect(service.activeTerminal).to.equal(apiObject);
+        });
+
+        it('cleans up API object on terminal close', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+            service.$terminalClosed(id, { code: 0, reason: TerminalExitReason.Process });
+
+            expect(service.terminals).to.have.length(0);
+        });
+    });
+
+    describe('parentTerminal resolution', () => {
+        it('resolves parentTerminal from API proxy objects', () => {
+            const apiObject = { marker: 'parent-api' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Parent', undefined, undefined, wrapper);
+
+            const parentId = proxy.createdTerminals[0].id;
+            service.$terminalCreated(parentId, 'Parent');
+
+            // Create a child with parentTerminal set to the API object
+            service.createTerminal(plugin, {
+                name: 'Child',
+                location: { parentTerminal: apiObject }
+            } as theia.TerminalOptions);
+
+            expect(proxy.createdTerminals).to.have.length(2);
+            // The second createTerminal call should have passed the parent ID
+            // We verify it was called on the proxy (the parentId arg is the 3rd parameter)
+        });
+
+        it('resolves parentTerminal from raw terminal objects', () => {
+            const rawTerminal = service.createTerminal(plugin, 'Parent');
+
+            const parentId = proxy.createdTerminals[0].id;
+            service.$terminalCreated(parentId, 'Parent');
+
+            // Create a child with parentTerminal set to the raw terminal
+            service.createTerminal(plugin, {
+                name: 'Child',
+                location: { parentTerminal: rawTerminal }
+            } as theia.TerminalOptions);
+
+            expect(proxy.createdTerminals).to.have.length(2);
+        });
+    });
+
+    describe('events for terminals without wrapper', () => {
+        it('fires onDidOpenTerminal with the raw terminal when no wrapper is used', () => {
+            const opened: theia.Terminal[] = [];
+            service.onDidOpenTerminal(t => opened.push(t));
+
+            service.$terminalCreated('ext-t1', 'External Terminal');
+
+            expect(opened).to.have.length(1);
+            expect(opened[0]).to.be.instanceOf(TerminalExtImpl);
+            expect(opened[0].name).to.equal('External Terminal');
+        });
+
+        it('fires onDidCloseTerminal with the raw terminal when no wrapper is used', () => {
+            const closed: theia.Terminal[] = [];
+            service.onDidCloseTerminal(t => closed.push(t));
+
+            service.$terminalCreated('ext-t1', 'External Terminal');
+            service.$terminalClosed('ext-t1', { code: 0, reason: TerminalExitReason.Process });
+
+            expect(closed).to.have.length(1);
+            expect(closed[0]).to.be.instanceOf(TerminalExtImpl);
+        });
+    });
+
+    describe('shell change', () => {
+        it('fires onDidChangeShell when shell changes', async () => {
+            const shells: string[] = [];
+            service.onDidChangeShell(s => shells.push(s));
+
+            await service.$setShell('/bin/zsh');
+
+            expect(shells).to.deep.equal(['/bin/zsh']);
+            expect(service.defaultShell).to.equal('/bin/zsh');
+        });
+
+        it('does not fire onDidChangeShell when shell is the same', async () => {
+            const shells: string[] = [];
+            await service.$setShell('/bin/zsh');
+
+            service.onDidChangeShell(s => shells.push(s));
+            await service.$setShell('/bin/zsh');
+
+            expect(shells).to.deep.equal([]);
+        });
+    });
+
+    describe('$terminalNameChanged', () => {
+        it('updates the terminal name', () => {
+            service.$terminalCreated('t1', 'Old Name');
+            service.$terminalNameChanged('t1', 'New Name');
+
+            expect(service.terminals[0].name).to.equal('New Name');
+        });
+    });
+
+    describe('activeTerminal', () => {
+        it('is undefined initially', () => {
+            expect(service.activeTerminal).to.equal(undefined);
+        });
+
+        it('reflects the current active terminal', () => {
+            service.$terminalCreated('t1', 'Terminal 1');
+            service.$currentTerminalChanged('t1');
+
+            expect(service.activeTerminal).to.not.equal(undefined);
+            expect(service.activeTerminal!.name).to.equal('Terminal 1');
+        });
+
+        it('fires onDidChangeActiveTerminal', () => {
+            const changes: (theia.Terminal | undefined)[] = [];
+            service.onDidChangeActiveTerminal(t => changes.push(t));
+
+            service.$terminalCreated('t1', 'Terminal 1');
+            service.$currentTerminalChanged('t1');
+            service.$currentTerminalChanged(undefined);
+
+            expect(changes).to.have.length(2);
+            expect(changes[0]!.name).to.equal('Terminal 1');
+            expect(changes[1]).to.equal(undefined);
+        });
+    });
+});

package/src/plugin/terminal-ext.ts

@@ -38,6 +38,13 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
 
     private readonly _terminals = new Map<string, TerminalExtImpl>();
 
+    /**
+     * Stores the API objects (Proxies) returned to plugins for each terminal.
+     * This ensures that events fire with the same object instance that plugins received,
+     * allowing strict equality checks (===) to work correctly.
+     */
+    private readonly _terminalApiObjects = new Map<string, theia.Terminal>();
+
     private readonly _pseudoTerminals = new Map<string, PseudoTerminal>();
 
     private static nextProviderId = 0;
@@ -66,8 +73,8 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.TERMINAL_MAIN);
     }
 
-    get terminals(): TerminalExtImpl[] {
-        return [...this._terminals.values()];
+    get terminals(): theia.Terminal[] {
+        return [...this._terminals.keys()].map(id => this.getApiObject(id)).filter((t): t is theia.Terminal => t !== undefined);
     }
 
     get defaultShell(): string {
@@ -84,7 +91,9 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
     createTerminal(
         plugin: Plugin,
         nameOrOptions: theia.TerminalOptions | theia.PseudoTerminalOptions | theia.ExtensionTerminalOptions | string | undefined,
-        shellPath?: string, shellArgs?: string[] | string
+        shellPath?: string,
+        shellArgs?: string[] | string,
+        apiObjectWrapper?: (terminal: TerminalExtImpl) => theia.Terminal
     ): theia.Terminal {
         const id = `plugin-terminal-${UUID.uuid4()}`;
         let options: TerminalOptions;
@@ -110,7 +119,15 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         let parentId;
         if (options.location && typeof options.location === 'object' && 'parentTerminal' in options.location) {
             const parentTerminal = options.location.parentTerminal;
-            if (parentTerminal instanceof TerminalExtImpl) {
+            // Check both the API proxy objects and the raw terminals, since
+            // plugins receive the proxy but _terminals stores the raw object.
+            for (const [k, v] of this._terminalApiObjects) {
+                if (v === parentTerminal) {
+                    parentId = k;
+                    break;
+                }
+            }
+            if (!parentId) {
                 for (const [k, v] of this._terminals) {
                     if (v === parentTerminal) {
                         parentId = k;
@@ -136,7 +153,16 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         if (typeof nameOrOptions === 'object' && 'pty' in nameOrOptions) {
             creationOptions = nameOrOptions;
         }
-        return this.obtainTerminal(id, options.name || 'Terminal', creationOptions);
+        const terminal = this.obtainTerminal(id, options.name || 'Terminal', creationOptions);
+
+        // If a wrapper function is provided, wrap the terminal and register the API object
+        // This ensures events fire with the same object instance that plugins received
+        if (apiObjectWrapper) {
+            const apiObject = apiObjectWrapper(terminal);
+            this._terminalApiObjects.set(id, apiObject);
+            return apiObject;
+        }
+        return terminal;
     }
 
     attachPtyToTerminal(terminalId: number, pty: theia.Pseudoterminal): void {
@@ -153,6 +179,13 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         return terminal;
     }
 
+    /**
+     * Gets the API object for a terminal by ID, falling back to the raw terminal if not set.
+     */
+    protected getApiObject(id: string): theia.Terminal | undefined {
+        return this._terminalApiObjects.get(id) ?? this._terminals.get(id);
+    }
+
     $terminalOnInput(id: string, data: string): void {
         const terminal = this._pseudoTerminals.get(id);
         if (!terminal) {
@@ -168,7 +201,10 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         }
         if (!terminal.state.isInteractedWith) {
             terminal.state = { ...terminal.state, isInteractedWith: true };
-            this.onDidChangeTerminalStateEmitter.fire(terminal);
+            const apiObject = this.getApiObject(id);
+            if (apiObject) {
+                this.onDidChangeTerminalStateEmitter.fire(apiObject);
+            }
         }
     }
 
@@ -179,7 +215,10 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         }
         if (terminal.state.shell !== shellType) {
             terminal.state = { ...terminal.state, shell: shellType };
-            this.onDidChangeTerminalStateEmitter.fire(terminal);
+            const apiObject = this.getApiObject(id);
+            if (apiObject) {
+                this.onDidChangeTerminalStateEmitter.fire(apiObject);
+            }
         }
     }
 
@@ -194,7 +233,10 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
     $terminalCreated(id: string, name: string): void {
         const terminal = this.obtainTerminal(id, name);
         terminal.id.resolve(id);
-        this.onDidOpenTerminalEmitter.fire(terminal);
+        const apiObject = this.getApiObject(id);
+        if (apiObject) {
+            this.onDidOpenTerminalEmitter.fire(apiObject);
+        }
     }
 
     $terminalNameChanged(id: string, name: string): void {
@@ -234,8 +276,12 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         const terminal = this._terminals.get(id);
         if (terminal) {
             terminal.exitStatus = exitStatus ?? { code: undefined, reason: TerminalExitReason.Unknown };
-            this.onDidCloseTerminalEmitter.fire(terminal);
+            const apiObject = this.getApiObject(id);
+            if (apiObject) {
+                this.onDidCloseTerminalEmitter.fire(apiObject);
+            }
             this._terminals.delete(id);
+            this._terminalApiObjects.delete(id);
         }
         const pseudoTerminal = this._pseudoTerminals.get(id);
         if (pseudoTerminal) {
@@ -245,8 +291,8 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
     }
 
     private activeTerminalId: string | undefined;
-    get activeTerminal(): TerminalExtImpl | undefined {
-        return this.activeTerminalId && this._terminals.get(this.activeTerminalId) || undefined;
+    get activeTerminal(): theia.Terminal | undefined {
+        return this.activeTerminalId && this.getApiObject(this.activeTerminalId) || undefined;
     }
     $currentTerminalChanged(id: string | undefined): void {
         this.activeTerminalId = id;
@@ -319,7 +365,7 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
 
     async $provideTerminalLinks(line: string, terminalId: string, token: theia.CancellationToken): Promise<ProvidedTerminalLink[]> {
         const links: ProvidedTerminalLink[] = [];
-        const terminal = this._terminals.get(terminalId);
+        const terminal = this.getApiObject(terminalId);
         if (terminal) {
             for (const [providerId, provider] of this.terminalLinkProviders) {
                 const providedLinks = await provider.provideTerminalLinks({ line, terminal }, token);