@theia/debug 1.77.0-next.6 → 1.77.0-next.63

package/src/browser/console/debug-copy-value.spec.ts

@@ -0,0 +1,144 @@
+// *****************************************************************************
+// Copyright (C) 2026 Karthik Harikrishnan 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
+// http://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';
+const disableJSDOM = enableJSDOM();
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import { DebugProtocol } from '@vscode/debugprotocol';
+import { DebugSession } from '../debug-session';
+import { DebugWatchExpression } from '../view/debug-watch-expression';
+import { DebugVariable, ExpressionContainer } from './debug-console-items';
+
+disableJSDOM();
+
+interface TestSession extends Pick<DebugSession, 'capabilities' | 'evaluate'> { }
+
+class TestDebugWatchExpression extends DebugWatchExpression {
+
+    setValue(value: string): void {
+        this._value = value;
+    }
+}
+
+function createVariable(session: TestSession, overrides: Partial<DebugProtocol.Variable> = { evaluateName: 'object.value' }): DebugVariable {
+    const sessionProvider = () => session as DebugSession;
+    const parent = new ExpressionContainer({ session: sessionProvider, id: 'parent' });
+    const variable: DebugProtocol.Variable = {
+        name: 'value',
+        value: 'truncated',
+        variablesReference: 0,
+        ...overrides
+    };
+    return new DebugVariable(sessionProvider, variable, parent);
+}
+
+function createWatchExpression(session: TestSession): TestDebugWatchExpression {
+    const watchExpression = new TestDebugWatchExpression({
+        id: 1,
+        expression: 'object.value',
+        session: () => session as DebugSession,
+        remove: () => undefined,
+        onDidChange: () => undefined
+    });
+    watchExpression.setValue('truncated');
+    return watchExpression;
+}
+
+describe('Debugger Copy Value', () => {
+
+    it('evaluates a variable using the clipboard context when supported', async () => {
+        const evaluations: Array<{ expression: string; context?: string }> = [];
+        const session: TestSession = {
+            capabilities: { supportsClipboardContext: true },
+            evaluate: async (expression, context) => {
+                evaluations.push({ expression, context });
+                return { result: 'full value', variablesReference: 0 };
+            }
+        };
+        const value = await createVariable(session).getValueToCopy();
+
+        expect(evaluations).to.deep.equal([{ expression: 'object.value', context: 'clipboard' }]);
+        expect(value).to.equal('full value');
+    });
+
+    it('uses the variables context when the clipboard context is unsupported', async () => {
+        const evaluations: Array<{ expression: string; context?: string }> = [];
+        const session: TestSession = {
+            capabilities: {},
+            evaluate: async (expression, context) => {
+                evaluations.push({ expression, context });
+                return { result: 'full value', variablesReference: 0 };
+            }
+        };
+        const value = await createVariable(session).getValueToCopy();
+
+        expect(evaluations).to.deep.equal([{ expression: 'object.value', context: 'variables' }]);
+        expect(value).to.equal('full value');
+    });
+
+    it('copies the rendered variable value when evaluateName is unavailable', async () => {
+        let evaluated = false;
+        const session: TestSession = {
+            capabilities: { supportsClipboardContext: true },
+            evaluate: async () => {
+                evaluated = true;
+                return { result: 'full value', variablesReference: 0 };
+            }
+        };
+        const value = await createVariable(session, { evaluateName: undefined }).getValueToCopy();
+
+        expect(evaluated).to.be.false;
+        expect(value).to.equal('truncated');
+    });
+
+    it('copies the rendered variable value when evaluation fails', async () => {
+        const session: TestSession = {
+            capabilities: { supportsClipboardContext: true },
+            evaluate: async () => { throw new Error('evaluation failed'); }
+        };
+        const value = await createVariable(session).getValueToCopy();
+
+        expect(value).to.equal('truncated');
+    });
+
+    it('evaluates a watch expression using the watch context', async () => {
+        const evaluations: Array<{ expression: string; context?: string }> = [];
+        const session: TestSession = {
+            capabilities: {},
+            evaluate: async (expression, context) => {
+                evaluations.push({ expression, context });
+                return { result: 'full value', variablesReference: 0 };
+            }
+        };
+        const value = await createWatchExpression(session).getValueToCopy();
+
+        expect(evaluations).to.deep.equal([{ expression: 'object.value', context: 'watch' }]);
+        expect(value).to.equal('full value');
+    });
+
+    it('copies the rendered watch value when evaluation fails', async () => {
+        const session: TestSession = {
+            capabilities: { supportsClipboardContext: true },
+            evaluate: async () => { throw new Error('evaluation failed'); }
+        };
+        const value = await createWatchExpression(session).getValueToCopy();
+
+        expect(value).to.equal('truncated');
+    });
+});

package/src/browser/debug-frontend-application-contribution.ts

@@ -69,6 +69,7 @@ import {
     DebugEditorContextCommands, DebugBreakpointWidgetCommands, nlsEnableBreakpoint, nlsDisableBreakpoint
 } from './debug-commands';
 import { ILogger } from '@theia/core';
+import { ClipboardService } from '@theia/core/lib/browser/clipboard-service';
 
 @injectable()
 export class DebugFrontendApplicationContribution extends AbstractViewContribution<DebugWidget>
@@ -119,6 +120,9 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
     @inject(ILogger) @named('debug:DebugFrontendApplicationContribution')
     protected readonly logger: ILogger;
 
+    @inject(ClipboardService)
+    protected readonly clipboardService: ClipboardService;
+
     constructor() {
         super({
             widgetId: DebugWidget.ID,
@@ -697,7 +701,7 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             isVisible: () => !!this.selectedVariable && this.selectedVariable.supportSetVariable
         });
         registry.registerCommand(DebugCommands.COPY_VARIABLE_VALUE, {
-            execute: () => this.selectedVariable && this.selectedVariable.copyValue(),
+            execute: () => this.copyValue(this.selectedVariable),
             isEnabled: () => !!this.selectedVariable && this.selectedVariable.supportCopyValue,
             isVisible: () => !!this.selectedVariable && this.selectedVariable.supportCopyValue
         });
@@ -826,7 +830,7 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             isVisible: () => !!this.watchExpression
         });
         registry.registerCommand(DebugCommands.COPY_WATCH_EXPRESSION_VALUE, {
-            execute: () => this.watchExpression && this.watchExpression.copyValue(),
+            execute: () => this.copyValue(this.watchExpression),
             isEnabled: () => !!this.watchExpression && this.watchExpression.supportCopyValue,
             isVisible: () => !!this.watchExpression && this.watchExpression.supportCopyValue
         });
@@ -865,6 +869,12 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
         });
     }
 
+    protected async copyValue(item: { getValueToCopy(): Promise<string> } | undefined): Promise<void> {
+        if (item) {
+            await this.clipboardService.writeText(await item.getValueToCopy());
+        }
+    }
+
     override registerKeybindings(keybindings: KeybindingRegistry): void {
         super.registerKeybindings(keybindings);
         keybindings.registerKeybinding({

package/src/browser/debug-session-connection.ts

@@ -151,6 +151,15 @@ export class DebugSessionConnection implements Disposable {
         return this.toDispose.disposed;
     }
 
+    /**
+     * Whether the underlying channel has been closed, so that no further request can be sent.
+     *
+     * This becomes `true` as soon as the channel closes, which is before the connection itself is disposed.
+     */
+    get closed(): boolean {
+        return this.isClosed;
+    }
+
     protected checkDisposed(): void {
         if (this.disposed) {
             throw new Error('the debug session connection is disposed, id: ' + this.sessionId);

package/src/browser/debug-session-manager.ts

@@ -568,9 +568,12 @@ export class DebugSessionManager {
             this.disposeOnCurrentSessionChanged.push(current.onDidResolveLazyVariable(variable => this.onDidResolveLazyVariableEmitter.fire({ session: current, variable })));
             this.disposeOnCurrentSessionChanged.push(current.onDidFocusStackFrame(frame => this.onDidFocusStackFrameEmitter.fire(frame)));
             this.disposeOnCurrentSessionChanged.push(current.onDidFocusThread(thread => this.onDidFocusThreadEmitter.fire(thread)));
-            const { currentThread } = current;
-            this.onDidFocusThreadEmitter.fire(currentThread);
         }
+        // Announce what is focused now, also when nothing is: the forwarding above is torn down with the previous
+        // session, so without this the last thread and frame of a session that has ended stay the focused ones.
+        const { currentThread, currentFrame } = this;
+        this.onDidFocusThreadEmitter.fire(currentThread);
+        this.onDidFocusStackFrameEmitter.fire(currentFrame);
         this.open();
         this.fireDidChange(current);
     }

package/src/browser/debug-session-options.ts

@@ -113,7 +113,7 @@ export namespace InternalDebugSessionOptions {
     }
 
     /** @deprecated Please use `JSON.parse` to restore previously serialized debug session options. */
-    // eslint-disable-next-line deprecation/deprecation
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     export function parseValue(value: string): DebugSessionOptionsData {
         const split = value.split(SEPARATOR);
         if (split.length === 5) {

package/src/browser/debug-session.tsx

@@ -733,6 +733,12 @@ export class DebugSession implements CompositeTreeElement {
         const { uri, sourceModified } = options;
         await this.deferredOnDidConfigureCapabilities.promise;
         for (const affectedUri of this.getAffectedUris(uri)) {
+            if (this.connection.closed) {
+                // The session ended while the breakpoints were being sent, which happens because ending one session
+                // updates the breakpoints of all of them. There is nothing left to send them to, and reporting them
+                // as unverified would outlive the session they failed for.
+                return;
+            }
             if (affectedUri.toString() === BreakpointManager.EXCEPTION_URI.toString()) {
                 await this.sendExceptionBreakpoints();
             } else if (affectedUri.toString() === BreakpointManager.FUNCTION_URI.toString()) {

package/src/browser/view/debug-variables-widget.ts

@@ -118,6 +118,12 @@ export class DebugVariablesWidget extends SourceTreeWidget {
 
     protected handleDidDestroyDebugSession(session: DebugSession): void {
         this.statePerSession.delete(session.id);
+        if (this.stackFrame?.session.id === session.id) {
+            // Release the frame, which holds its session: this widget outlives every session, and no stack frame is
+            // focused when the session it belongs to is gone. `onDidFocusStackFrame` does not announce that, as the
+            // session manager stops forwarding the event as soon as the session is no longer the current one.
+            this.stackFrame = undefined;
+        }
     }
 
     protected override handleContextMenuEvent(node: TreeNode | undefined, event: MouseEvent<HTMLElement>): void {

package/src/browser/view/debug-watch-expression.tsx

@@ -63,7 +63,7 @@ export class DebugWatchExpression extends ExpressionItem {
         return <div className='theia-debug-console-variable theia-debug-watch-expression'>
             <div className={TREE_NODE_SEGMENT_GROW_CLASS}>
                 <span title={this.type || this._expression} className='name'>{this._expression}:</span>
-                <span title={this._value} ref={this.setValueRef} className={valueClass}>{this._value}</span>
+                <span title={this._value} className={valueClass}>{this._value}</span>
             </div>
             <div className={codicon('close', true)} title={nls.localizeByDefault('Remove Expression')} onClick={this.options.remove} />
         </div>;
@@ -93,16 +93,10 @@ export class DebugWatchExpression extends ExpressionItem {
     }
 
     get supportCopyValue(): boolean {
-        return !!this.valueRef && document.queryCommandSupported('copy');
+        return this.available;
     }
-    copyValue(): void {
-        const selection = document.getSelection();
-        if (this.valueRef && selection) {
-            selection.selectAllChildren(this.valueRef);
-            document.execCommand('copy');
-        }
+    async getValueToCopy(): Promise<string> {
+        return this.evaluateForClipboard(this.expression, 'watch', this.value);
     }
-    protected valueRef: HTMLSpanElement | undefined;
-    protected setValueRef = (valueRef: HTMLSpanElement | null): void => { this.valueRef = valueRef || undefined; };
 
 }

package/src/common/debug-preferences.ts

@@ -35,6 +35,12 @@ export const debugPreferencesSchema: PreferenceSchema = {
             default: 'openOnFirstSessionStart',
             description: nls.localizeByDefault('Controls when the internal Debug Console should open.')
         },
+        'debug.console.maximumLines': {
+            type: 'number',
+            default: 10000,
+            minimum: 1,
+            description: nls.localizeByDefault('Controls the maximum number of lines in the Debug Console.')
+        },
         'debug.inlineValues': {
             type: 'boolean',
             default: false,
@@ -92,6 +98,7 @@ export class DebugConfiguration {
     'debug.trace': boolean;
     'debug.openDebug': 'neverOpen' | 'openOnSessionStart' | 'openOnFirstSessionStart' | 'openOnDebugBreak';
     'debug.internalConsoleOptions': 'neverOpen' | 'openOnSessionStart' | 'openOnFirstSessionStart';
+    'debug.console.maximumLines': number;
     'debug.inlineValues': boolean;
     'debug.showInStatusBar': 'never' | 'always' | 'onFirstSessionStart';
     'debug.confirmOnExit': 'never' | 'always';