@theia/core 1.71.0-next.3 → 1.71.0-next.34

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar.tsx

@@ -16,6 +16,7 @@
 
 import { inject, injectable, postConstruct } from 'inversify';
 import * as React from 'react';
+import { buttonKeyboardProps, isActivationKey } from '../../keyboard/keyboard-utils';
 import { ContextKeyService } from '../../context-key-service';
 import { CommandRegistry, Disposable, DisposableCollection, nls } from '../../../common';
 import { Anchor, ContextMenuAccess, ContextMenuRenderer } from '../../context-menu-renderer';
@@ -150,7 +151,10 @@ export class TabBarToolbar extends ReactWidget {
 
     protected renderMore(): React.ReactNode {
         return !!this.more.size && <div key='__more__' className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled'}>
-            <div id='__more__' className={codicon('ellipsis', true)} onClick={this.showMoreContextMenu}
+            <div id='__more__' className={codicon('ellipsis', true)}
+                {...buttonKeyboardProps(nls.localizeByDefault('More Actions...'))}
+                onClick={this.showMoreContextMenu}
+                onKeyDown={this.handleMoreKeyDown}
                 title={nls.localizeByDefault('More Actions...')} />
         </div>;
     }
@@ -162,6 +166,15 @@ export class TabBarToolbar extends ReactWidget {
         this.renderMoreContextMenu(anchor);
     };
 
+    protected handleMoreKeyDown = (event: React.KeyboardEvent) => {
+        if (isActivationKey(event)) {
+            event.preventDefault();
+            event.stopPropagation();
+            const { left, bottom } = (event.currentTarget as HTMLElement).getBoundingClientRect();
+            this.renderMoreContextMenu({ x: left, y: bottom });
+        }
+    };
+
     renderMoreContextMenu(anchor: Anchor): ContextMenuAccess {
         const toDisposeOnHide = new DisposableCollection();
         this.addClass('menu-open');

package/src/browser/shell/tab-bar-toolbar/tab-toolbar-item.tsx

@@ -23,6 +23,7 @@ import { KeybindingRegistry } from '../../keybinding';
 import { ACTION_ITEM } from '../../widgets';
 import { TabBarToolbar } from './tab-bar-toolbar';
 import * as React from 'react';
+import { buttonKeyboardProps, isActivationKey } from '../../keyboard/keyboard-utils';
 import { ActionMenuNode, GroupImpl, MenuNode } from '../../../common/menu';
 
 export interface TabBarToolbarItem {
@@ -195,16 +196,24 @@ export class RenderedToolbarItemImpl extends AbstractToolbarItemImpl<RenderedToo
     };
 
     protected executeCommand(e: React.MouseEvent<HTMLElement>, widget: Widget): void {
+        this.doExecuteCommand(e, widget);
+    };
+
+    protected doExecuteCommand(e: React.SyntheticEvent<HTMLElement>, widget: Widget): void {
         e.preventDefault();
         e.stopPropagation();
-
         if (!this.isEnabled(widget)) {
             return;
         }
-
         if (this.action.command) {
             this.commandRegistry.executeCommand(this.action.command, widget);
         }
+    }
+
+    protected onKeyDownEvent = (e: React.KeyboardEvent<HTMLElement>, widget: Widget) => {
+        if (isActivationKey(e)) {
+            this.doExecuteCommand(e, widget);
+        }
     };
 
     protected renderItem(widget: Widget): React.ReactNode {
@@ -249,7 +258,9 @@ export class RenderedToolbarItemImpl extends AbstractToolbarItemImpl<RenderedToo
             onMouseUp={this.onMouseUpEvent}
             onMouseOut={this.onMouseUpEvent} >
             <div id={this.action.id} className={classNames.join(' ')}
+                {...buttonKeyboardProps(tooltip)}
                 onClick={e => this.executeCommand(e, widget)}
+                onKeyDown={e => this.onKeyDownEvent(e, widget)}
                 title={tooltip} > {innerText}
             </div>
         </div>;

package/src/browser/style/card.css

@@ -101,11 +101,13 @@
     transition: opacity 0.15s;
 }
 
-.theia-Card:hover .theia-Card-footer-time {
+.theia-Card:hover .theia-Card-footer-time,
+.theia-Card:focus-within .theia-Card-footer-time {
     opacity: 0;
 }
 
-.theia-Card:hover .theia-Card-footer-actions {
+.theia-Card:hover .theia-Card-footer-actions,
+.theia-Card:focus-within .theia-Card-footer-actions {
     opacity: 1;
     pointer-events: auto;
 }

package/src/common/message-rpc/channel.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { injectable } from 'inversify';
 import { Disposable, DisposableCollection } from '../disposable';
 import { Emitter, Event } from '../event';
 import { ReadBuffer, WriteBuffer } from './message-buffer';
@@ -71,6 +72,7 @@ export type MessageProvider = () => ReadBuffer;
  *  Reusable abstract {@link Channel} implementation that sets up
  *  the basic channel event listeners and offers a generic close method.
  */
+@injectable()
 export abstract class AbstractChannel implements Channel {
 
     onCloseEmitter: Emitter<ChannelCloseEvent> = new Emitter();

package/src/common/messaging/index.ts

@@ -17,3 +17,4 @@
 export * from './handler';
 export * from './proxy-factory';
 export * from './connection-error-handler';
+export * from './socket-write-buffer';

package/src/common/messaging/socket-write-buffer.ts

@@ -14,13 +14,19 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { injectable } from 'inversify';
 import { WebSocket } from './web-socket-channel';
 
+@injectable()
 export class SocketWriteBuffer {
-    private static DISCONNECTED_BUFFER_SIZE = 100 * 1024;
+    private static readonly DEFAULT_DISCONNECTED_BUFFER_SIZE = 100 * 1024;
 
-    private disconnectedBuffer: Uint8Array | undefined;
-    private bufferWritePosition = 0;
+    protected disconnectedBuffer: Uint8Array | undefined;
+    protected bufferWritePosition = 0;
+
+    protected get maxBufferSize(): number {
+        return SocketWriteBuffer.DEFAULT_DISCONNECTED_BUFFER_SIZE;
+    }
 
     buffer(data: Uint8Array): void {
         this.ensureWriteBuffer(data.byteLength);
@@ -30,7 +36,7 @@ export class SocketWriteBuffer {
 
     protected ensureWriteBuffer(byteLength: number): void {
         if (!this.disconnectedBuffer) {
-            this.disconnectedBuffer = new Uint8Array(SocketWriteBuffer.DISCONNECTED_BUFFER_SIZE);
+            this.disconnectedBuffer = new Uint8Array(this.maxBufferSize);
             this.bufferWritePosition = 0;
         }
 

package/src/common/preferences/index.ts

@@ -25,3 +25,4 @@ export * from './preference-service';
 export * from './injectable-preference-proxy';
 export * from './preference-proxy';
 export * from './preference-configurations';
+export * from './preference-utils';

package/src/common/preferences/preference-utils.ts

@@ -0,0 +1,28 @@
+// *****************************************************************************
+// 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 { nls } from '../nls';
+import { isOSX, isWindows } from '../os';
+
+/**
+ * Hint appended to API key preference descriptions on Linux, where environment variables
+ * set in `~/.bashrc` are not available to desktop-launched applications.
+ */
+export const LINUX_ENV_HINT = !isWindows && !isOSX
+    ? ' ' + nls.localize('theia/ai-core/preferences/linuxEnvHint',
+        'On Linux, make sure the variable is defined in `~/.profile` (not just `~/.bashrc`) if you launch the application from a desktop shortcut.' +
+        ' See the [documentation](https://theia-ide.org/docs/user_ai/#setting-api-keys) for details.')
+    : '';

package/src/common/resource.ts

@@ -311,13 +311,19 @@ export class InMemoryResources implements ResourceResolver {
 }
 
 export const MEMORY_TEXT = 'mem-txt';
+export const MEMORY_TEXT_READONLY = 'mem-txt-readonly';
 
 /**
  * Resource implementation for 'mem-txt' URI scheme where content is saved in URI query.
  */
 export class InMemoryTextResource implements Resource {
+
     constructor(readonly uri: URI) { }
 
+    get readOnly(): boolean {
+        return this.uri.scheme === MEMORY_TEXT_READONLY;
+    }
+
     async readContents(options?: { encoding?: string | undefined; } | undefined): Promise<string> {
         return this.uri.query;
     }
@@ -330,8 +336,8 @@ export class InMemoryTextResource implements Resource {
 @injectable()
 export class InMemoryTextResourceResolver implements ResourceResolver {
     resolve(uri: URI): MaybePromise<Resource> {
-        if (uri.scheme !== MEMORY_TEXT) {
-            throw new Error(`Expected a URI with ${MEMORY_TEXT} scheme. Was: ${uri}.`);
+        if (uri.scheme !== MEMORY_TEXT && uri.scheme !== MEMORY_TEXT_READONLY) {
+            throw new Error(`Expected a URI with ${MEMORY_TEXT} or ${MEMORY_TEXT_READONLY} scheme. Was: ${uri}.`);
         }
         return new InMemoryTextResource(uri);
     }

package/src/electron-browser/menu/electron-main-menu-factory.ts

@@ -233,7 +233,11 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
                 }
             };
 
-            const role = this.roleFor(menu.id);
+            // Only assign Electron roles when no custom args are present.
+            // Custom args indicate that command handlers have context-dependent
+            // behavior (e.g. chat view copying the whole message when there is
+            // no DOM selection) that would be bypassed by the native role.
+            const role = args.length === 0 ? this.roleFor(menu.id) : undefined;
             if (role) {
                 menuItem.role = role;
                 delete menuItem.execute;

package/src/electron-browser/messaging/electron-messaging-frontend-module.ts

@@ -26,11 +26,14 @@ import { LocalConnectionProvider, RemoteConnectionProvider, ServiceConnectionPro
 import { WebSocketConnectionProvider } from '../../browser/messaging/ws-connection-provider';
 import { ConnectionCloseService, connectionCloseServicePath } from '../../common/messaging/connection-management';
 import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
+import { SocketWriteBuffer } from '../../common/messaging/socket-write-buffer';
 
 const backendServiceProvider = Symbol('backendServiceProvider2');
 const localServiceProvider = Symbol('localServiceProvider');
 
 export const messagingFrontendModule = new ContainerModule(bind => {
+    // Transient: each connection source gets its own private buffer instance.
+    bind(SocketWriteBuffer).toSelf();
     bind(ConnectionCloseService).toDynamicValue(ctx => WebSocketConnectionProvider.createProxy(ctx.container, connectionCloseServicePath)).inSingletonScope();
     bind(ElectronWebSocketConnectionSource).toSelf().inSingletonScope();
     bind(WebSocketConnectionSource).toService(ElectronWebSocketConnectionSource);

package/src/electron-main/electron-api-main.ts

@@ -136,6 +136,8 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
             }
             popup.popup({
                 window: electronWindow,
+                x,
+                y,
                 callback: () => {
                     this.openPopups.delete(menuId);
                     event.sender.send(CHANNEL_ON_CLOSE_POPUP, menuId);
@@ -343,13 +345,13 @@ export namespace TheiaRendererAPI {
         const disposables = new DisposableCollection();
 
         return new Promise<boolean>(resolve => {
-            wc.send(CHANNEL_REQUEST_CLOSE, stopReason, confirmChannel, cancelChannel);
             createDisposableListener(ipcMain, confirmChannel, e => {
                 resolve(true);
             }, disposables);
             createDisposableListener(ipcMain, cancelChannel, e => {
                 resolve(false);
             }, disposables);
+            wc.send(CHANNEL_REQUEST_CLOSE, stopReason, confirmChannel, cancelChannel);
         }).finally(() => disposables.dispose());
     }
 
@@ -360,13 +362,13 @@ export namespace TheiaRendererAPI {
         const disposables = new DisposableCollection();
 
         return new Promise<boolean>(resolve => {
-            mainWindow.send(CHANNEL_REQUEST_SECONDARY_CLOSE, secondaryWindow.mainFrame.name, confirmChannel, cancelChannel);
             createDisposableListener(ipcMain, confirmChannel, e => {
                 resolve(true);
             }, disposables);
             createDisposableListener(ipcMain, cancelChannel, e => {
                 resolve(false);
             }, disposables);
+            mainWindow.send(CHANNEL_REQUEST_SECONDARY_CLOSE, secondaryWindow.mainFrame.name, confirmChannel, cancelChannel);
         }).finally(() => disposables.dispose());
     }
 

package/src/electron-main/theia-electron-window.ts

@@ -140,6 +140,9 @@ export class TheiaElectronWindow {
 
     protected async doCloseWindow(): Promise<void> {
         this.closeIsConfirmed = true;
+        // Hide the window immediately so the user perceives an instant close.
+        // This is done after veto checks have passed to ensure save dialogs remain visible.
+        this._window.hide();
         await TheiaRendererAPI.sendAboutToClose(this._window.webContents);
         this._window.close();
     }

package/src/node/messaging/index.ts

@@ -17,3 +17,4 @@
 export * from './messaging-service';
 export * from './ipc-connection-provider';
 export * from './ipc-channel';
+export * from './websocket-frontend-connection-service';

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

@@ -24,8 +24,9 @@ import { MessagingListener, MessagingListenerContribution } from './messaging-li
 import { FrontendConnectionService } from './frontend-connection-service';
 import { BackendApplicationContribution } from '../backend-application';
 import { connectionCloseServicePath } from '../../common/messaging/connection-management';
-import { WebsocketFrontendConnectionService } from './websocket-frontend-connection-service';
+import { ReconnectableSocketChannel, WebsocketFrontendConnectionService } from './websocket-frontend-connection-service';
 import { WebsocketEndpoint } from './websocket-endpoint';
+import { SocketWriteBuffer } from '../../common/messaging/socket-write-buffer';
 
 export const messagingBackendModule = new ContainerModule(bind => {
     bindRootContributionProvider(bind, ConnectionContainerModule);
@@ -36,6 +37,9 @@ export const messagingBackendModule = new ContainerModule(bind => {
     bind(MessagingContainer).toDynamicValue(({ container }) => container).inSingletonScope();
     bind(WebsocketEndpoint).toSelf().inSingletonScope();
     bind(BackendApplicationContribution).toService(WebsocketEndpoint);
+    // Transient: each connection gets its own private buffer and channel instances.
+    bind(SocketWriteBuffer).toSelf();
+    bind(ReconnectableSocketChannel).toSelf();
     bind(WebsocketFrontendConnectionService).toSelf().inSingletonScope();
     bind(FrontendConnectionService).toService(WebsocketFrontendConnectionService);
     bind(MessagingListener).toSelf().inSingletonScope();

package/src/node/messaging/websocket-frontend-connection-service.ts

@@ -15,9 +15,9 @@
 
 import { Channel, WriteBuffer } from '../../common/message-rpc';
 import { MessagingService } from './messaging-service';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, interfaces } from 'inversify';
 import { Socket } from 'socket.io';
-import { ConnectionHandlers } from './default-messaging-service';
+import { ConnectionHandlers, MessagingContainer } from './default-messaging-service';
 import { SocketWriteBuffer } from '../../common/messaging/socket-write-buffer';
 import { FrontendConnectionService } from './frontend-connection-service';
 import { AbstractChannel } from '../../common/message-rpc/channel';
@@ -33,6 +33,9 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
     @inject(WebsocketEndpoint)
     protected readonly websocketServer: WebsocketEndpoint;
 
+    @inject(MessagingContainer)
+    protected readonly container: interfaces.Container;
+
     protected readonly wsHandlers = new ConnectionHandlers();
     protected readonly connectionsByFrontend = new Map<string, ReconnectableSocketChannel>();
     protected readonly closeTimeouts = new Map<string, NodeJS.Timeout>();
@@ -94,7 +97,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
 
     protected createConnection(socket: Socket, frontEndId: string): ReconnectableSocketChannel {
         console.info(`creating connection for ${frontEndId}`);
-        const channel = new ReconnectableSocketChannel();
+        const channel = this.container.get(ReconnectableSocketChannel);
         channel.connect(socket);
 
         this.connectionsByFrontend.set(frontEndId, channel);
@@ -136,12 +139,17 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
     }
 }
 
-class ReconnectableSocketChannel extends AbstractChannel {
-    private socket: Socket | undefined;
-    private socketBuffer = new SocketWriteBuffer();
-    private disposables = new DisposableCollection();
+@injectable()
+export class ReconnectableSocketChannel extends AbstractChannel {
+    protected socket: Socket | undefined;
+
+    @inject(SocketWriteBuffer)
+    protected socketBuffer: SocketWriteBuffer;
+
+    protected disposables = new DisposableCollection();
 
     connect(socket: Socket): void {
+        this.disposables.dispose();
         this.disposables = new DisposableCollection();
         this.socket = socket;
         const errorHandler = (err: Error) => {

package/src/node/process-utils.ts

@@ -32,7 +32,15 @@ export class ProcessUtils {
     }
 
     protected winTerminateProcessTree(ppid: number): void {
-        this.spawnSync('taskkill.exe', ['/f', '/t', '/pid', ppid.toString(10)]);
+        const result = cp.spawnSync('taskkill.exe', ['/f', '/t', '/pid', ppid.toString(10)], { encoding: 'utf8' });
+        if (result.error) {
+            throw result.error;
+        }
+        // taskkill may exit with a non-zero code when some child processes have already exited.
+        // This is expected during shutdown — log but don't throw.
+        if (result.status !== 0) {
+            console.warn(`taskkill.exe exited with ${result.status} for PID ${ppid}. Output:\n${JSON.stringify(result.output)}`);
+        }
     }
 
     protected unixTerminateProcessTree(ppid: number): void {