@theia/debug 1.77.0-next.4 → 1.77.0-next.47

package/src/browser/console/debug-console-contribution.spec.ts

@@ -0,0 +1,183 @@
+// *****************************************************************************
+// 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+
+let disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import 'reflect-metadata';
+
+import { expect } from 'chai';
+import { Emitter } from '@theia/core/lib/common/event';
+import { ConsoleSessionManager } from '@theia/console/lib/browser/console-session-manager';
+import { DebugConsoleContribution } from './debug-console-contribution';
+import { DebugConsoleSession } from './debug-console-session';
+import { DebugSession } from '../debug-session';
+import { DidChangeActiveDebugSession } from '../debug-session-manager';
+
+disableJSDOM();
+
+class TestDebugSessionManager {
+
+    readonly onDidCreateDebugSessionEmitter = new Emitter<DebugSession>();
+    readonly onDidCreateDebugSession = this.onDidCreateDebugSessionEmitter.event;
+    readonly onDidDestroyDebugSessionEmitter = new Emitter<DebugSession>();
+    readonly onDidDestroyDebugSession = this.onDidDestroyDebugSessionEmitter.event;
+    readonly onDidChangeActiveDebugSession = new Emitter<DidChangeActiveDebugSession>().event;
+
+    protected readonly running = new Map<string, DebugSession>();
+
+    currentSession: DebugSession | undefined;
+
+    get sessions(): DebugSession[] {
+        return Array.from(this.running.values());
+    }
+
+    getSession(id: string): DebugSession | undefined {
+        return this.running.get(id);
+    }
+
+    start(session: DebugSession): void {
+        this.running.set(session.id, session);
+        this.currentSession = session;
+        this.onDidCreateDebugSessionEmitter.fire(session);
+    }
+
+    /** Mirrors `DebugSessionManager.cleanup`, which drops the session before announcing its destruction. */
+    destroy(session: DebugSession): void {
+        this.running.delete(session.id);
+        if (this.currentSession?.id === session.id) {
+            this.currentSession = this.sessions[0];
+        }
+        this.onDidDestroyDebugSessionEmitter.fire(session);
+    }
+
+}
+
+describe('DebugConsoleContribution', () => {
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    let debugSessionManager: TestDebugSessionManager;
+    let consoleSessionManager: ConsoleSessionManager;
+    let contribution: DebugConsoleContribution;
+
+    /** A session whose console is merged into that of `consoleParent`, if given. */
+    const createDebugSession = (id: string, consoleParent?: DebugSession): DebugSession => ({
+        id,
+        label: id,
+        configuration: { name: id, type: 'node', request: 'launch' },
+        options: {},
+        parentSession: consoleParent,
+        findConsoleParent: () => consoleParent,
+        on: () => { }
+    } as unknown as DebugSession);
+
+    const consoleOf = (session: DebugSession): DebugConsoleSession =>
+        consoleSessionManager.all.find((candidate): candidate is DebugConsoleSession =>
+            candidate instanceof DebugConsoleSession && candidate.debugSession?.id === session.id)!;
+
+    /** The session that console input is evaluated in. */
+    const evaluationSessionOf = (consoleSession: DebugConsoleSession): DebugSession | undefined =>
+        (consoleSession as unknown as { findCurrentSession(): DebugSession | undefined }).findCurrentSession();
+
+    beforeEach(() => {
+        debugSessionManager = new TestDebugSessionManager();
+        consoleSessionManager = new ConsoleSessionManager();
+        contribution = new DebugConsoleContribution();
+        // The class uses property injection; `init()` only subscribes to the managers.
+        Object.assign(contribution as unknown as Record<string, unknown>, {
+            consoleSessionManager,
+            debugSessionManager,
+            resources: { add: () => { } },
+            debugConsoleSessionFactory: (session: DebugSession) => {
+                const consoleSession = new DebugConsoleSession();
+                Object.assign(consoleSession as unknown as Record<string, unknown>, { sessionManager: debugSessionManager });
+                consoleSession.startFor(session);
+                return consoleSession;
+            }
+        });
+        (contribution as unknown as { init(): void }).init();
+    });
+
+    afterEach(() => contribution.dispose());
+
+    it('terminates the console when its session ends', () => {
+        const session = createDebugSession('parent');
+        debugSessionManager.start(session);
+        const consoleSession = consoleOf(session);
+
+        debugSessionManager.destroy(session);
+
+        expect(consoleSession.terminated).to.be.true;
+        expect(consoleSession.debugSession).to.be.undefined;
+    });
+
+    it('keeps the console of a session running while a child merged into it outlives that session', () => {
+        const parent = createDebugSession('parent');
+        debugSessionManager.start(parent);
+        const consoleSession = consoleOf(parent);
+        const child = createDebugSession('child', parent);
+        debugSessionManager.start(child);
+
+        debugSessionManager.destroy(parent);
+
+        expect(consoleSession.terminated).to.be.false;
+        expect(evaluationSessionOf(consoleSession)).to.equal(child);
+
+        debugSessionManager.destroy(child);
+
+        expect(consoleSession.terminated).to.be.true;
+        expect(consoleSession.debugSession).to.be.undefined;
+    });
+
+    it('keeps the console of a session running when a child merged into it ends first', () => {
+        const parent = createDebugSession('parent');
+        debugSessionManager.start(parent);
+        const consoleSession = consoleOf(parent);
+        const child = createDebugSession('child', parent);
+        debugSessionManager.start(child);
+
+        debugSessionManager.destroy(child);
+
+        expect(consoleSession.terminated).to.be.false;
+        expect(consoleSession.debugSession).to.equal(parent);
+
+        debugSessionManager.destroy(parent);
+
+        expect(consoleSession.terminated).to.be.true;
+    });
+
+    it('does not let a restarted configuration take over a console still used by a child', () => {
+        const parent = createDebugSession('parent');
+        debugSessionManager.start(parent);
+        const consoleSession = consoleOf(parent);
+        debugSessionManager.start(createDebugSession('child', parent));
+        debugSessionManager.destroy(parent);
+
+        const restarted = createDebugSession('parent-restarted');
+        restarted.configuration.name = parent.configuration.name;
+        debugSessionManager.start(restarted);
+
+        expect(consoleSession.debugSession).to.equal(parent);
+        expect(consoleOf(restarted)).to.not.equal(consoleSession);
+    });
+
+});

package/src/browser/console/debug-console-contribution.tsx

@@ -92,23 +92,18 @@ export class DebugConsoleContribution extends AbstractViewContribution<ConsoleWi
             this.debugSessionManager.onDidCreateDebugSession(session => {
                 const consoleParent = session.findConsoleParent();
                 if (consoleParent) {
-                    const parentConsoleSession = this.consoleSessionManager.get(consoleParent.id);
-                    if (parentConsoleSession instanceof DebugConsoleSession) {
-                        session.on('output', event => parentConsoleSession.logOutput(parentConsoleSession.debugSession, event));
+                    const parentConsoleSession = this.findConsoleSession(consoleParent);
+                    if (parentConsoleSession) {
+                        // Log against the session the output came from, so that variable references resolve on its adapter.
+                        session.on('output', event => parentConsoleSession.logOutput(session, event));
                     }
                 } else {
-                    const consoleSession = this.debugConsoleSessionFactory(session);
-                    this.consoleSessionManager.add(consoleSession);
+                    const consoleSession = this.getOrCreateConsoleSession(session);
                     session.on('output', event => consoleSession.logOutput(session, event));
                 }
             }),
             this.debugSessionManager.onDidChangeActiveDebugSession(event => this.handleActiveDebugSessionChanged(event)),
-            this.debugSessionManager.onDidDestroyDebugSession(session => {
-                const consoleSession = this.consoleSessionManager.get(session.id);
-                if (consoleSession instanceof DebugConsoleSession) {
-                    consoleSession.markTerminated();
-                }
-            }),
+            this.debugSessionManager.onDidDestroyDebugSession(session => this.handleDebugSessionDestroyed(session)),
             this.consoleSessionManager.onDidChangeSelectedSession(() => {
                 const session = this.consoleSessionManager.selectedSession;
                 if (session && this.filterInputRef) {
@@ -121,12 +116,56 @@ export class DebugConsoleContribution extends AbstractViewContribution<ConsoleWi
         ]);
     }
 
+    /**
+     * Returns the console of the given session, if it still belongs to one.
+     *
+     * A console keeps the id it was created with even when it is reused by a restarted session, so it cannot be
+     * looked up by the session id.
+     */
+    protected findConsoleSession(debugSession: DebugSession): DebugConsoleSession | undefined {
+        return this.consoleSessionManager.all.find((candidate): candidate is DebugConsoleSession =>
+            candidate instanceof DebugConsoleSession && candidate.debugSession?.id === debugSession.id);
+    }
+
+    /**
+     * Returns the console for a newly created session.
+     *
+     * A session reuses the console of a terminated session started from the same configuration, so that restarting
+     * does not leave a stopped console behind on every run.
+     */
+    protected getOrCreateConsoleSession(debugSession: DebugSession): DebugConsoleSession {
+        const reusable = this.consoleSessionManager.all.find((candidate): candidate is DebugConsoleSession =>
+            candidate instanceof DebugConsoleSession && candidate.isReusableBy(debugSession));
+        if (reusable) {
+            reusable.startFor(debugSession);
+            return reusable;
+        }
+        const consoleSession = this.debugConsoleSessionFactory(debugSession);
+        this.consoleSessionManager.add(consoleSession);
+        return consoleSession;
+    }
+
+    /**
+     * Terminates the console of the given session once no session runs in it any more.
+     *
+     * A child session merged into its parent's console may outlive the parent if its lifecycle is not managed by the
+     * parent, and it still needs the console to evaluate expressions while it runs.
+     */
+    protected handleDebugSessionDestroyed(debugSession: DebugSession): void {
+        const consoleOwner = debugSession.findConsoleParent() ?? debugSession;
+        const consoleSession = this.findConsoleSession(consoleOwner);
+        if (consoleSession && !this.debugSessionManager.sessions.some(candidate =>
+            candidate.id === consoleOwner.id || candidate.findConsoleParent()?.id === consoleOwner.id)) {
+            consoleSession.markTerminated();
+        }
+    }
+
     protected handleActiveDebugSessionChanged(event: DidChangeActiveDebugSession): void {
         if (!event.current) {
             return;
         } else {
             const topSession = event.current.findConsoleParent() || event.current;
-            const consoleSession = topSession ? this.consoleSessionManager.get(topSession.id) : undefined;
+            const consoleSession = topSession ? this.findConsoleSession(topSession) : undefined;
             this.consoleSessionManager.selectedSession = consoleSession;
             const consoleSelector = document.getElementById('debugConsoleSelector');
             if (consoleSession && consoleSelector instanceof HTMLSelectElement) {
@@ -217,7 +256,7 @@ export class DebugConsoleContribution extends AbstractViewContribution<ConsoleWi
         bind(DebugConsoleSession).toSelf().inRequestScope();
         bind(DebugConsoleSessionFactory).toFactory(context => (session: DebugSession) => {
             const consoleSession = context.container.get(DebugConsoleSession);
-            consoleSession.debugSession = session;
+            consoleSession.startFor(session);
             return consoleSession;
         });
         bind(ConsoleSessionManager).toSelf().inSingletonScope();
@@ -271,7 +310,7 @@ export class DebugConsoleContribution extends AbstractViewContribution<ConsoleWi
             });
 
         sortedSessions.forEach(session => {
-            let label = session.debugSession.label;
+            let label = session.label;
             if (session.terminated) {
                 label = `${label} (${nls.localizeByDefault('Stopped')})`;
             }

package/src/browser/console/debug-console-items.tsx

@@ -92,12 +92,17 @@ export class ExpressionContainer implements CompositeConsoleItem {
 
     protected elements: Promise<ExpressionContainer[]> | undefined;
     async getElements(): Promise<IterableIterator<ExpressionContainer>> {
-        if (!this.hasElements || !this.session) {
+        if (!this.hasElements) {
             return [][Symbol.iterator]();
         }
         if (!this.elements) {
+            if (!this.session) {
+                // Nothing was resolved while the session ran, and there is no session left to resolve it with.
+                return [][Symbol.iterator]();
+            }
             this.elements = this.doResolve();
         }
+        // What was resolved while the session ran stays available after it has ended, as it does in VS Code.
         return (await this.elements)[Symbol.iterator]();
     }
     protected async doResolve(): Promise<ExpressionContainer[]> {

package/src/browser/console/debug-console-session.spec.ts

@@ -0,0 +1,246 @@
+// *****************************************************************************
+// 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+
+let disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import 'reflect-metadata';
+
+import { expect } from 'chai';
+import { DebugProtocol } from '@vscode/debugprotocol/lib/debugProtocol';
+import { ExpressionContainer } from './debug-console-items';
+import { DebugConsoleSession } from './debug-console-session';
+import { DebugSession } from '../debug-session';
+
+disableJSDOM();
+
+/**
+ * The variables the fake adapter answers with, so that an output event with a variables reference resolves to an
+ * expandable item, as it does when a program logs an object rather than a string.
+ */
+const VARIABLES: Record<number, DebugProtocol.Variable[]> = {
+    1: [{ name: 'logged', value: 'Object', variablesReference: 2 }],
+    2: [{ name: 'answer', value: '42', variablesReference: 0 }]
+};
+
+class TestDebugSessionManager {
+
+    protected readonly sessions = new Map<string, DebugSession>();
+
+    currentSession: DebugSession | undefined;
+
+    getSession(id: string): DebugSession | undefined {
+        return this.sessions.get(id);
+    }
+
+    add(session: DebugSession): void {
+        this.sessions.set(session.id, session);
+        this.currentSession = session;
+    }
+
+    /** Mirrors `DebugSessionManager.cleanup`, which drops the session before announcing its destruction. */
+    remove(id: string): void {
+        this.sessions.delete(id);
+        if (this.currentSession?.id === id) {
+            this.currentSession = undefined;
+        }
+    }
+
+}
+
+describe('DebugConsoleSession', () => {
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    let manager: TestDebugSessionManager;
+    let consoleSession: DebugConsoleSession;
+    let maximumLines: number;
+
+    const createDebugSession = (id: string, configurationName: string, workspaceFolderUri?: string): DebugSession => ({
+        id,
+        label: configurationName,
+        configuration: { name: configurationName, type: 'node', request: 'launch' },
+        options: { workspaceFolderUri },
+        autoExpandLazyVariables: false,
+        sendRequest: async (_command: string, args: { variablesReference: number }) => ({
+            body: { variables: VARIABLES[args.variablesReference] ?? [] }
+        })
+    } as unknown as DebugSession);
+
+    const outputEvent = (body: Partial<DebugProtocol.OutputEvent['body']>): DebugProtocol.OutputEvent =>
+        ({ event: 'output', body: { category: 'stdout', ...body } } as DebugProtocol.OutputEvent);
+
+    const contentsOf = (session: DebugConsoleSession): string[] =>
+        Array.from(session.getElements(), item => (item as { content?: string }).content ?? '');
+
+    beforeEach(() => {
+        manager = new TestDebugSessionManager();
+        maximumLines = 10000;
+        consoleSession = new DebugConsoleSession();
+        // The class uses property injection, and `init()` only registers a Monaco completion provider.
+        Object.assign(consoleSession as unknown as Record<string, unknown>, {
+            sessionManager: manager,
+            logger: { debug: () => { } },
+            preferences: { get 'debug.console.maximumLines'(): number { return maximumLines; } }
+        });
+    });
+
+    describe('when the session terminates', () => {
+
+        it('releases the session but keeps its output', async () => {
+            const session = createDebugSession('session-1', 'Launch Program');
+            manager.add(session);
+            consoleSession.startFor(session);
+            await consoleSession.logOutput(session, outputEvent({ output: 'hello' }));
+
+            expect(consoleSession.debugSession).to.equal(session);
+
+            manager.remove(session.id);
+            consoleSession.markTerminated();
+
+            expect(consoleSession.terminated).to.be.true;
+            expect(consoleSession.debugSession).to.be.undefined;
+            expect(contentsOf(consoleSession)).to.deep.equal(['hello']);
+        });
+
+        it('keeps the label and the configuration of the released session', () => {
+            const session = createDebugSession('session-1', 'Launch Program');
+            manager.add(session);
+            consoleSession.startFor(session);
+
+            manager.remove(session.id);
+            consoleSession.markTerminated();
+
+            expect(consoleSession.label).to.equal('Launch Program');
+            expect(consoleSession.configurationName).to.equal('Launch Program');
+        });
+
+        it('keeps what was expanded while the session ran', async () => {
+            const session = createDebugSession('session-1', 'Launch Program');
+            manager.add(session);
+            consoleSession.startFor(session);
+            // An output event carrying a variables reference, as sent for a logged object, yields expandable items
+            // that resolve their children through the session.
+            await consoleSession.logOutput(session, outputEvent({ variablesReference: 1 }));
+
+            const [logged] = Array.from(consoleSession.getElements()) as ExpressionContainer[];
+            expect(Array.from(await logged.getElements())).to.have.lengthOf(1, 'expandable while the session runs');
+
+            manager.remove(session.id);
+            consoleSession.markTerminated();
+
+            expect(Array.from(consoleSession.getElements())).to.have.lengthOf(1, 'output is preserved');
+            expect(Array.from(await logged.getElements())).to.have.lengthOf(1, 'expanded children are preserved');
+        });
+
+        it('does not retain the session through the items it logged', async () => {
+            const session = createDebugSession('session-1', 'Launch Program');
+            manager.add(session);
+            consoleSession.startFor(session);
+            await consoleSession.logOutput(session, outputEvent({ variablesReference: 1 }));
+
+            const [logged] = Array.from(consoleSession.getElements()) as ExpressionContainer[];
+
+            manager.remove(session.id);
+            consoleSession.markTerminated();
+
+            // Nothing was expanded before the session ended, so there is nothing cached to fall back on. The item
+            // resolves its session by id through the manager, which has dropped it, rather than holding on to it,
+            // so it has nothing left to ask.
+            expect(Array.from(await logged.getElements())).to.be.empty;
+        });
+
+    });
+
+    describe('when a session reuses the console', () => {
+
+        it('drops the output of the previous run and runs the new session', async () => {
+            const first = createDebugSession('session-1', 'Launch Program');
+            manager.add(first);
+            consoleSession.startFor(first);
+            await consoleSession.logOutput(first, outputEvent({ output: 'first run' }));
+            manager.remove(first.id);
+            consoleSession.markTerminated();
+
+            const second = createDebugSession('session-2', 'Launch Program');
+            manager.add(second);
+            consoleSession.startFor(second);
+
+            expect(consoleSession.terminated).to.be.false;
+            expect(consoleSession.debugSession).to.equal(second);
+            expect(contentsOf(consoleSession)).to.be.empty;
+
+            await consoleSession.logOutput(second, outputEvent({ output: 'second run' }));
+            expect(contentsOf(consoleSession)).to.deep.equal(['second run']);
+        });
+
+        it('is reusable only by a session of the same configuration once terminated', () => {
+            consoleSession.startFor(createDebugSession('session-1', 'Launch Program'));
+            expect(consoleSession.isReusableBy(createDebugSession('session-2', 'Launch Program'))).to.be.false;
+
+            consoleSession.markTerminated();
+
+            expect(consoleSession.isReusableBy(createDebugSession('session-2', 'Launch Program'))).to.be.true;
+            expect(consoleSession.isReusableBy(createDebugSession('session-2', 'Attach'))).to.be.false;
+        });
+
+        it('is not reusable by a configuration of the same name from another workspace folder', () => {
+            consoleSession.startFor(createDebugSession('session-1', 'Launch Program', 'file:///a'));
+            consoleSession.markTerminated();
+
+            expect(consoleSession.isReusableBy(createDebugSession('session-2', 'Launch Program', 'file:///b'))).to.be.false;
+            expect(consoleSession.isReusableBy(createDebugSession('session-2', 'Launch Program'))).to.be.false;
+            expect(consoleSession.isReusableBy(createDebugSession('session-2', 'Launch Program', 'file:///a'))).to.be.true;
+        });
+
+        it('keeps the id it was created with, so that it is not the id of either session', () => {
+            const first = createDebugSession('session-1', 'Launch Program');
+            consoleSession.startFor(first);
+            const id = consoleSession.id;
+
+            consoleSession.markTerminated();
+            consoleSession.startFor(createDebugSession('session-2', 'Launch Program'));
+
+            expect(consoleSession.id).to.equal(id);
+            expect(consoleSession.id).to.not.equal('session-1');
+            expect(consoleSession.id).to.not.equal('session-2');
+        });
+
+    });
+
+    describe('output limit', () => {
+
+        it('drops the oldest lines beyond `debug.console.maximumLines`', async () => {
+            maximumLines = 3;
+            const session = createDebugSession('session-1', 'Launch Program');
+            manager.add(session);
+            consoleSession.startFor(session);
+
+            await consoleSession.logOutput(session, outputEvent({ output: 'one\ntwo\nthree\nfour' }));
+            expect(contentsOf(consoleSession)).to.deep.equal(['two', 'three', 'four']);
+
+            consoleSession.appendLine('five');
+            expect(contentsOf(consoleSession)).to.deep.equal(['three', 'four', 'five']);
+        });
+
+    });
+
+});