@theia/core 1.72.0-next.5 → 1.72.0-next.52

package/src/browser/style/index.css

@@ -14,8 +14,36 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
  ********************************************************************************/
 
-@import url("~@lumino/widgets/style/index.css");
-@import url("~font-awesome/css/font-awesome.min.css");
+/*-----------------------------------------------------------------------------
+| Import children style files
+|----------------------------------------------------------------------------*/
+
+@import "./os.css";
+@import "./dockpanel.css";
+@import "./dialog.css";
+@import "./menus.css";
+@import "./sidepanel.css";
+@import "./tabs.css";
+@import "./scrollbars.css";
+@import "./tree.css";
+@import "./status-bar.css";
+@import "./tree-decorators.css";
+@import "./about.css";
+@import "./search-box.css";
+@import "./ansi.css";
+@import "./view-container.css";
+@import "./notification.css";
+@import "./alert-messages.css";
+@import "./icons.css";
+@import "./widget.css";
+@import "./quick-title-bar.css";
+@import "./progress-bar.css";
+@import "./breadcrumbs.css";
+@import "./tooltip.css";
+@import "./split-widget.css";
+@import "./symbol-icon.css";
+@import "./card.css";
+
 
 /*-----------------------------------------------------------------------------
 | General
@@ -160,6 +188,7 @@ blockquote {
     right: 0;
     bottom: 0;
     background: var(--theia-editor-background);
+    height: 100%;
 }
 
 .theia-preload {
@@ -324,33 +353,3 @@ button.secondary[disabled],
 .theia-cursor-no-drop:active {
     cursor: no-drop;
 }
-
-/*-----------------------------------------------------------------------------
-| Import children style files
-|----------------------------------------------------------------------------*/
-
-@import "./os.css";
-@import "./dockpanel.css";
-@import "./dialog.css";
-@import "./menus.css";
-@import "./sidepanel.css";
-@import "./tabs.css";
-@import "./scrollbars.css";
-@import "./tree.css";
-@import "./status-bar.css";
-@import "./tree-decorators.css";
-@import "./about.css";
-@import "./search-box.css";
-@import "./ansi.css";
-@import "./view-container.css";
-@import "./notification.css";
-@import "./alert-messages.css";
-@import "./icons.css";
-@import "./widget.css";
-@import "./quick-title-bar.css";
-@import "./progress-bar.css";
-@import "./breadcrumbs.css";
-@import "./tooltip.css";
-@import "./split-widget.css";
-@import "./symbol-icon.css";
-@import "./card.css";

package/src/browser/style/scrollbars.css

@@ -14,8 +14,6 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
  ********************************************************************************/
 
-@import url("~perfect-scrollbar/css/perfect-scrollbar.css");
-
 ::-webkit-scrollbar {
   height: var(--theia-scrollbar-width);
   width: var(--theia-scrollbar-width);

package/src/browser/style/select-component.css

@@ -15,9 +15,12 @@
  ********************************************************************************/
 
 .theia-select-component-container {
-  /* required to set z-index */
-  position: fixed;
-  /* dialog overlay has a z-index of 5000 */
+  /* position is required for z-index to take effect; top/left at 0 anchors
+     the container so the absolutely-positioned dropdown resolves its
+     viewport-relative coordinates correctly. */
+  position: absolute;
+  top: 0;
+  left: 0;
   z-index: 6000;
 }
 

package/src/browser/widgets/select-component.tsx

@@ -149,7 +149,7 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
         return optimal + 20; // Just to be safe, add another 20 pixels here
     }
 
-   protected attachListeners(): void {
+    protected attachListeners(): void {
         const hide = (event: Event) => {
             if (!this.dropdownRef.current?.contains(event.target as Node)) {
                 this.hide();

package/src/common/markdown-rendering/markdown-string.spec.ts

@@ -0,0 +1,50 @@
+// *****************************************************************************
+// 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 { expect } from 'chai';
+import { MarkdownStringImpl } from './markdown-string';
+
+describe('MarkdownStringImpl#appendCodeblock', () => {
+
+    it('uses a triple-backtick fence for code without backticks', () => {
+        const md = new MarkdownStringImpl();
+        md.appendCodeblock('json', '{ "type": "adaptive" }');
+        expect(md.value).to.equal('\n```json\n{ "type": "adaptive" }\n```\n');
+    });
+
+    it('uses a longer fence when the code contains a triple-backtick run', () => {
+        const md = new MarkdownStringImpl();
+        const code = 'before\n```json\n{ "x": 1 }\n```\nafter';
+        md.appendCodeblock('', code);
+        // The fence must be at least 4 backticks so the inner ``` cannot close it.
+        expect(md.value).to.equal('\n````\n' + code + '\n````\n');
+    });
+
+    it('grows the fence to be longer than the longest backtick run inside the code', () => {
+        const md = new MarkdownStringImpl();
+        const code = 'a ```` b ``` c';
+        md.appendCodeblock('', code);
+        // Longest run is 4, so fence must be 5.
+        expect(md.value).to.equal('\n`````\n' + code + '\n`````\n');
+    });
+
+    it('still uses a triple-backtick fence when only single/double backticks appear', () => {
+        const md = new MarkdownStringImpl();
+        const code = 'inline `code` and ``double`` only';
+        md.appendCodeblock('', code);
+        expect(md.value).to.equal('\n```\n' + code + '\n```\n');
+    });
+});

package/src/common/markdown-rendering/markdown-string.ts

@@ -44,6 +44,16 @@ export namespace MarkdownString {
     export function is(candidate: unknown): candidate is MarkdownString {
         return isObject<MarkdownString>(candidate) && isString(candidate.value);
     }
+
+    /**
+     * @returns whether `commandId` is allowed to execute given the markdown string's
+     * {@link MarkdownString.isTrusted} setting. Fully trusted strings allow any command;
+     * partially trusted strings restrict execution to their `enabledCommands` list.
+     */
+    export function isCommandAllowed(isTrusted: MarkdownString['isTrusted'], commandId: string): boolean {
+        return isTrusted === true
+            || (typeof isTrusted === 'object' && isTrusted.enabledCommands.includes(commandId));
+    }
 }
 
 // Copied from https://github.com/microsoft/vscode/blob/7d9b1c37f8e5ae3772782ba3b09d827eb3fdd833/src/vs/base/common/htmlContent.ts
@@ -90,14 +100,36 @@ export class MarkdownStringImpl implements MarkdownString {
     }
 
     appendCodeblock(langId: string, code: string): MarkdownStringImpl {
-        this.value += '\n```';
+        // Use a fence longer than any run of backticks in the code so that triple-backtick
+        // sequences inside `code` cannot prematurely close the surrounding fenced block.
+        const fence = '`'.repeat(Math.max(3, MarkdownStringImpl.longestBacktickRun(code) + 1));
+        this.value += '\n';
+        this.value += fence;
         this.value += langId;
         this.value += '\n';
         this.value += code;
-        this.value += '\n```\n';
+        this.value += '\n';
+        this.value += fence;
+        this.value += '\n';
         return this;
     }
 
+    private static longestBacktickRun(value: string): number {
+        let longest = 0;
+        let current = 0;
+        for (let i = 0; i < value.length; i++) {
+            if (value.charCodeAt(i) === 96 /* ` */) {
+                current++;
+                if (current > longest) {
+                    longest = current;
+                }
+            } else {
+                current = 0;
+            }
+        }
+        return longest;
+    }
+
     appendLink(target: UriComponents | string, label: string, title?: string): MarkdownStringImpl {
         this.value += '[';
         this.value += this._escape(label, ']');

package/src/node/backend-application-module.ts

@@ -34,7 +34,10 @@ import {
     PreferenceProviderProvider,
     PreferenceProvider
 } from '../common';
-import { BackendApplication, BackendApplicationContribution, BackendApplicationCliContribution, BackendApplicationServer, BackendApplicationPath } from './backend-application';
+import {
+    BackendApplication, BackendApplicationContribution, BackendApplicationCliContribution,
+    BackendApplicationServer, BackendApplicationPath, RootContainer
+} from './backend-application';
 import { CliManager, CliContribution } from './cli';
 import { IPCConnectionProvider } from './messaging';
 import { ApplicationServerImpl } from './application-server';
@@ -87,6 +90,13 @@ export const backendApplicationModule = new ContainerModule(bind => {
     bind(CliContribution).toService(BackendApplicationCliContribution);
 
     bind(BackendApplication).toSelf().inSingletonScope();
+    bind(RootContainer).toDynamicValue(({ container }) => {
+        let root = container;
+        while (root.parent) {
+            root = root.parent;
+        }
+        return root;
+    }).inSingletonScope();
     bindRootContributionProvider(bind, BackendApplicationContribution);
     // Bind the BackendApplicationServer as a BackendApplicationContribution
     // and fallback to an empty contribution if never bound.

package/src/node/backend-application.spec.ts

@@ -0,0 +1,310 @@
+// *****************************************************************************
+// 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 { expect } from 'chai';
+import * as sinon from 'sinon';
+import { Container, ContainerModule, injectable, preDestroy } from 'inversify';
+import { bindContributionProvider, ILogger, Stopwatch } from '../common';
+import { Deferred } from '../common/promise-util';
+import { MockLogger } from '../common/test/mock-logger';
+import { NodeStopwatch } from './performance/node-stopwatch';
+import { ProcessUtils } from './process-utils';
+import {
+    BackendApplication,
+    BackendApplicationCliContribution,
+    BackendApplicationContribution,
+    RootContainer
+} from './backend-application';
+import { CliContribution } from './cli';
+
+/**
+ * Test subclass that exposes the protected `gracefulShutdown` for direct testing.
+ */
+@injectable()
+class TestBackendApplication extends BackendApplication {
+    public invokeGracefulShutdown(): Promise<void> {
+        return this.gracefulShutdown();
+    }
+}
+
+// All process events on which `BackendApplication` installs listeners in its
+// constructor. We snapshot and restore them around each test to avoid leaking
+// listeners across tests (and triggering `MaxListenersExceededWarning`).
+const PROCESS_EVENTS = ['SIGINT', 'SIGTERM', 'SIGPIPE', 'exit', 'uncaughtException'] as const;
+type ProcessEventName = typeof PROCESS_EVENTS[number];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyListener = (...args: any[]) => void;
+
+describe('BackendApplication', () => {
+    let sandbox: sinon.SinonSandbox;
+    let exitStub: sinon.SinonStub;
+    let savedListeners: Partial<Record<ProcessEventName, AnyListener[]>>;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+
+        // Snapshot any existing listeners so we can restore after each test
+        // (BackendApplication installs its own as part of construction).
+        savedListeners = {};
+        for (const evt of PROCESS_EVENTS) {
+            savedListeners[evt] = [...process.listeners(evt as NodeJS.Signals)] as AnyListener[];
+            process.removeAllListeners(evt);
+        }
+
+        exitStub = sandbox.stub(process, 'exit');
+    });
+
+    afterEach(() => {
+        for (const evt of PROCESS_EVENTS) {
+            process.removeAllListeners(evt);
+            for (const listener of savedListeners[evt] ?? []) {
+                process.on(evt, listener);
+            }
+        }
+
+        sandbox.restore();
+    });
+
+    function createTestContainer(): Container {
+        const container = new Container();
+
+        container.bind(RootContainer).toConstantValue(container);
+
+        container.bind(ILogger).to(MockLogger).inSingletonScope();
+        container.bind(Stopwatch).to(NodeStopwatch).inSingletonScope();
+        container.bind(ProcessUtils).toSelf().inSingletonScope();
+        container.bind(BackendApplicationCliContribution).toSelf().inSingletonScope();
+        container.bind(CliContribution).toService(BackendApplicationCliContribution);
+        bindContributionProvider(container, BackendApplicationContribution);
+
+        container.bind(TestBackendApplication).toSelf().inSingletonScope();
+        container.bind(BackendApplication).toService(TestBackendApplication);
+
+        return container;
+    }
+
+    describe('graceful shutdown', () => {
+
+        it('runs @preDestroy on root-scoped singletons before exiting with code 1', async () => {
+            let canaryDisposed = false;
+
+            @injectable()
+            class Canary {
+                @preDestroy()
+                protected onPreDestroy(): void {
+                    canaryDisposed = true;
+                }
+            }
+
+            const container = createTestContainer();
+            const canaryModule = new ContainerModule(bind => {
+                bind(Canary).toSelf().inSingletonScope();
+            });
+            container.load(canaryModule);
+            container.get(Canary);
+
+            const app = container.get(TestBackendApplication);
+
+            await app.invokeGracefulShutdown();
+
+            expect(canaryDisposed, '@preDestroy was not invoked on root-scoped singleton').to.be.true;
+            expect(exitStub.calledOnceWith(1), 'process.exit(1) was not called exactly once').to.be.true;
+        });
+
+        it('is idempotent: a second invocation does not unbind the container twice', async () => {
+            const container = createTestContainer();
+            const unbindSpy = sandbox.spy(container, 'unbindAllAsync');
+
+            const app = container.get(TestBackendApplication);
+
+            await app.invokeGracefulShutdown();
+            await app.invokeGracefulShutdown();
+
+            expect(unbindSpy.callCount, 'unbindAllAsync should be called only once').to.equal(1);
+            expect(exitStub.callCount, 'process.exit should be called only once').to.equal(1);
+        });
+
+        it('still exits if container cleanup rejects', async () => {
+            const container = createTestContainer();
+            const cleanupError = new Error('cleanup boom');
+            sandbox.stub(container, 'unbindAllAsync').rejects(cleanupError);
+            const warnStub = sandbox.stub(console, 'warn');
+
+            const app = container.get(TestBackendApplication);
+
+            await app.invokeGracefulShutdown();
+
+            expect(exitStub.calledOnceWith(1), 'process.exit(1) was not called').to.be.true;
+            expect(warnStub.calledOnce, 'a warning should be logged when cleanup rejects').to.be.true;
+            expect(warnStub.firstCall.args[0]).to.match(/cleanup boom/);
+        });
+
+        it('exits even when container cleanup hangs past the timeout', async () => {
+            const clock = sandbox.useFakeTimers();
+            const container = createTestContainer();
+            sandbox.stub(container, 'unbindAllAsync').returns(new Promise<void>(() => { /* never */ }));
+            const warnStub = sandbox.stub(console, 'warn');
+
+            const app = container.get(TestBackendApplication);
+
+            const shutdownPromise = app.invokeGracefulShutdown();
+
+            await clock.tickAsync(5001);
+            await shutdownPromise;
+
+            expect(exitStub.calledOnceWith(1), 'process.exit(1) was not called after timeout').to.be.true;
+            expect(warnStub.calledOnce, 'a warning should be logged on timeout').to.be.true;
+            expect(warnStub.firstCall.args[0]).to.match(/timed out/);
+        });
+
+        it('awaits async onStop contributions before unbinding the container', async () => {
+            const container = createTestContainer();
+            const onStopDeferred = new Deferred<void>();
+            container.bind(BackendApplicationContribution).toConstantValue({
+                onStop: () => onStopDeferred.promise
+            });
+            const unbindSpy = sandbox.spy(container, 'unbindAllAsync');
+
+            const app = container.get(TestBackendApplication);
+            const shutdownPromise = app.invokeGracefulShutdown();
+
+            expect(unbindSpy.called, 'unbindAllAsync should not run before onStop resolves').to.be.false;
+
+            onStopDeferred.resolve();
+            await shutdownPromise;
+
+            expect(unbindSpy.calledOnce, 'unbindAllAsync should run once onStop completes').to.be.true;
+            expect(exitStub.calledOnceWith(1)).to.be.true;
+        });
+
+        it('invokes onStop hooks while injected services are still resolvable', async () => {
+            @injectable()
+            class Helper {
+                readonly value = 'still-bound';
+            }
+
+            const container = createTestContainer();
+            container.bind(Helper).toSelf().inSingletonScope();
+
+            let observed: string | undefined;
+            container.bind(BackendApplicationContribution).toConstantValue({
+                onStop: () => {
+                    observed = container.get(Helper).value;
+                }
+            });
+
+            const app = container.get(TestBackendApplication);
+            await app.invokeGracefulShutdown();
+
+            expect(observed, 'onStop should observe injected services that are still bound').to.equal('still-bound');
+        });
+
+        it('proceeds with shutdown when onStop hooks exceed the timeout', async () => {
+            const clock = sandbox.useFakeTimers();
+            const container = createTestContainer();
+            container.bind(BackendApplicationContribution).toConstantValue({
+                onStop: () => new Promise<void>(() => { /* never */ })
+            });
+            const unbindSpy = sandbox.spy(container, 'unbindAllAsync');
+            const warnStub = sandbox.stub(console, 'warn');
+
+            const app = container.get(TestBackendApplication);
+            const shutdownPromise = app.invokeGracefulShutdown();
+
+            await clock.tickAsync(5001);
+            await shutdownPromise;
+
+            expect(warnStub.calledOnce, 'a warning should be logged on onStop timeout').to.be.true;
+            expect(warnStub.firstCall.args[0]).to.match(/Stopping backend contributions/);
+            expect(unbindSpy.calledOnce, 'unbind should still run after onStop times out').to.be.true;
+            expect(exitStub.calledOnceWith(1)).to.be.true;
+        });
+
+        it('runs all contributions even when one onStop rejects', async () => {
+            const container = createTestContainer();
+            let secondRan = false;
+            container.bind(BackendApplicationContribution).toConstantValue({
+                onStop: async () => { throw new Error('boom'); }
+            });
+            container.bind(BackendApplicationContribution).toConstantValue({
+                onStop: () => { secondRan = true; }
+            });
+            const errorStub = sandbox.stub(console, 'error');
+
+            const app = container.get(TestBackendApplication);
+            await app.invokeGracefulShutdown();
+
+            expect(secondRan, 'second contribution should still be stopped after first rejects').to.be.true;
+            expect(errorStub.calledWithMatch('Could not stop contribution')).to.be.true;
+        });
+
+        it('is idempotent when a contribution re-enters graceful shutdown', async () => {
+            const container = createTestContainer();
+            // Indirected through a holder so the contribution closure can refer to the
+            // application instance that is constructed after the binding is recorded.
+            const appHolder: { current?: TestBackendApplication } = {};
+            container.bind(BackendApplicationContribution).toConstantValue({
+                onStop: () => appHolder.current!.invokeGracefulShutdown()
+            });
+            const unbindSpy = sandbox.spy(container, 'unbindAllAsync');
+
+            appHolder.current = container.get(TestBackendApplication);
+            await appHolder.current.invokeGracefulShutdown();
+
+            expect(unbindSpy.callCount, 'unbindAllAsync should be called only once').to.equal(1);
+            expect(exitStub.callCount, 'process.exit should be called only once').to.equal(1);
+        });
+
+    });
+
+    describe('process exit handler', () => {
+
+        it('does not re-invoke contributions after graceful shutdown ran them', async () => {
+            const container = createTestContainer();
+            const onStopSpy = sandbox.spy();
+            container.bind(BackendApplicationContribution).toConstantValue({ onStop: onStopSpy });
+            const terminateStub = sandbox.stub(ProcessUtils.prototype, 'terminateProcessTree');
+
+            const app = container.get(TestBackendApplication);
+            const exitListener = process.listeners('exit')[0] as () => void;
+
+            await app.invokeGracefulShutdown();
+            expect(onStopSpy.callCount, 'contribution onStop should fire from gracefulShutdown').to.equal(1);
+
+            exitListener();
+
+            expect(onStopSpy.callCount, 'contribution onStop should not be invoked a second time').to.equal(1);
+            expect(terminateStub.called, 'terminateProcessTree should be invoked by the exit handler').to.be.true;
+        });
+
+        it('invokes contributions synchronously when graceful shutdown was bypassed', () => {
+            const container = createTestContainer();
+            const onStopSpy = sandbox.spy();
+            container.bind(BackendApplicationContribution).toConstantValue({ onStop: onStopSpy });
+            const terminateStub = sandbox.stub(ProcessUtils.prototype, 'terminateProcessTree');
+
+            container.get(TestBackendApplication);
+            const exitListener = process.listeners('exit')[0] as () => void;
+
+            exitListener();
+
+            expect(onStopSpy.calledOnce, 'sync exit path should still invoke contributions').to.be.true;
+            expect(terminateStub.called, 'terminateProcessTree should be invoked').to.be.true;
+        });
+
+    });
+
+});