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

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/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 {