@theia/remote 1.47.1 → 1.48.0

package/src/electron-browser/remote-registry-contribution.ts

@@ -16,8 +16,7 @@
 
 import { Command, CommandHandler, Emitter, Event } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { WindowService } from '@theia/core/lib/browser/window/window-service';
-import { WindowSearchParams } from '@theia/core/lib/common/window';
+import { WindowService, WindowReloadOptions } from '@theia/core/lib/browser/window/window-service';
 
 export const RemoteRegistryContribution = Symbol('RemoteRegistryContribution');
 
@@ -33,15 +32,19 @@ export abstract class AbstractRemoteRegistryContribution implements RemoteRegist
 
     abstract registerRemoteCommands(registry: RemoteRegistry): void;
 
-    protected openRemote(port: string, newWindow: boolean): void {
+    protected openRemote(port: string, newWindow: boolean, workspace?: string): void {
         const searchParams = new URLSearchParams(location.search);
         const localPort = searchParams.get('localPort') || searchParams.get('port');
-        const options: WindowSearchParams = {
-            port
+        const options: WindowReloadOptions = {
+            search: { port }
         };
         if (localPort) {
-            options.localPort = localPort;
+            options.search!.localPort = localPort;
         }
+        if (workspace) {
+            options.hash = workspace;
+        }
+
         if (newWindow) {
             this.windowService.openNewDefaultWindow(options);
         } else {

package/src/electron-browser/style/port-forwarding-widget.css

@@ -0,0 +1,44 @@
+/********************************************************************************
+ * Copyright (C) 2024 TypeFox 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
+ ********************************************************************************/
+
+.port-table {
+  width: 100%;
+  margin: calc(var(--theia-ui-padding) * 2);
+  table-layout: fixed;
+}
+
+.port-table-header {
+  text-align: left;
+}
+
+.forward-port-button {
+  margin-left: 0;
+  width: 100%;
+}
+
+.button-cell {
+  display: flex;
+  padding-right: var(--theia-ui-padding);
+}
+
+.forwarded-address:hover {
+  cursor: pointer;
+  text-decoration: underline;
+}
+
+.port-edit-input-error {
+  outline-color: var(--theia-inputValidation-errorBorder);
+}

package/src/electron-common/remote-port-forwarding-provider.ts

@@ -0,0 +1,29 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox 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
+// *****************************************************************************
+
+export const RemoteRemotePortForwardingProviderPath = '/remote/port-forwarding';
+
+export const RemotePortForwardingProvider = Symbol('RemoteSSHConnectionProvider');
+
+export interface ForwardedPort {
+    port: number;
+    address?: string;
+}
+
+export interface RemotePortForwardingProvider {
+    forwardPort(connectionPort: number, portToForward: ForwardedPort): Promise<void>;
+    portRemoved(port: ForwardedPort): Promise<void>;
+}

package/src/electron-node/remote-backend-module.ts

@@ -37,11 +37,17 @@ import { RemoteCopyContribution, RemoteCopyRegistry } from './setup/remote-copy-
 import { MainCopyContribution } from './setup/main-copy-contribution';
 import { RemoteNativeDependencyContribution } from './setup/remote-native-dependency-contribution';
 import { AppNativeDependencyContribution } from './setup/app-native-dependency-contribution';
+import { RemotePortForwardingProviderImpl } from './remote-port-forwarding-provider';
+import { RemotePortForwardingProvider, RemoteRemotePortForwardingProviderPath } from '../electron-common/remote-port-forwarding-provider';
 
 export const remoteConnectionModule = ConnectionContainerModule.create(({ bind, bindBackendService }) => {
     bind(RemoteSSHConnectionProviderImpl).toSelf().inSingletonScope();
     bind(RemoteSSHConnectionProvider).toService(RemoteSSHConnectionProviderImpl);
     bindBackendService(RemoteSSHConnectionProviderPath, RemoteSSHConnectionProvider);
+
+    bind(RemotePortForwardingProviderImpl).toSelf().inSingletonScope();
+    bind(RemotePortForwardingProvider).toService(RemotePortForwardingProviderImpl);
+    bindBackendService(RemoteRemotePortForwardingProviderPath, RemotePortForwardingProvider);
 });
 
 export default new ContainerModule((bind, _unbind, _isBound, rebind) => {

package/src/electron-node/remote-port-forwarding-provider.ts

@@ -0,0 +1,50 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox 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 { inject, injectable } from '@theia/core/shared/inversify';
+import { ForwardedPort, RemotePortForwardingProvider } from '../electron-common/remote-port-forwarding-provider';
+import { createServer, Server } from 'net';
+import { RemoteConnectionService } from './remote-connection-service';
+
+@injectable()
+export class RemotePortForwardingProviderImpl implements RemotePortForwardingProvider {
+
+    @inject(RemoteConnectionService)
+    protected readonly connectionService: RemoteConnectionService;
+
+    protected forwardedPorts: Map<number, Server> = new Map();
+
+    async forwardPort(connectionPort: number, portToForward: ForwardedPort): Promise<void> {
+        const currentConnection = this.connectionService.getConnectionFromPort(connectionPort);
+        if (!currentConnection) {
+            throw new Error(`No connection found for port ${connectionPort}`);
+        }
+
+        const server = createServer(socket => {
+            currentConnection?.forwardOut(socket, portToForward.port);
+        }).listen(portToForward.port, portToForward.address);
+        this.forwardedPorts.set(portToForward.port, server);
+    }
+
+    async portRemoved(forwardedPort: ForwardedPort): Promise<void> {
+        const proxy = this.forwardedPorts.get(forwardedPort.port);
+        if (proxy) {
+            proxy.close();
+            this.forwardedPorts.delete(forwardedPort.port);
+        }
+    }
+
+}

package/src/electron-node/remote-types.ts

@@ -49,8 +49,21 @@ export interface RemoteConnection extends Disposable {
     localPort: number;
     remotePort: number;
     onDidDisconnect: Event<void>;
-    forwardOut(socket: net.Socket): void;
+    forwardOut(socket: net.Socket, port?: number): void;
+
+    /**
+     * execute a single command on the remote machine
+     */
     exec(cmd: string, args?: string[], options?: RemoteExecOptions): Promise<RemoteExecResult>;
+
+    /**
+     * execute a command on the remote machine and wait for a specific output
+     * @param tester function which returns true if the output is as expected
+     */
     execPartial(cmd: string, tester: RemoteExecTester, args?: string[], options?: RemoteExecOptions): Promise<RemoteExecResult>;
+
+    /**
+     * copy files from local to remote
+     */
     copy(localPath: string | Buffer | NodeJS.ReadableStream, remotePath: string): Promise<void>;
 }

package/src/electron-node/setup/remote-setup-service.ts

@@ -29,6 +29,11 @@ export interface RemoteSetupOptions {
     nodeDownloadTemplate?: string;
 }
 
+export interface RemoteSetupResult {
+    applicationDirectory: string;
+    nodeDirectory: string;
+}
+
 @injectable()
 export class RemoteSetupService {
 
@@ -47,7 +52,7 @@ export class RemoteSetupService {
     @inject(ApplicationPackage)
     protected readonly applicationPackage: ApplicationPackage;
 
-    async setup(options: RemoteSetupOptions): Promise<void> {
+    async setup(options: RemoteSetupOptions): Promise<RemoteSetupResult> {
         const {
             connection,
             report,
@@ -86,12 +91,16 @@ export class RemoteSetupService {
         report('Starting application on remote...');
         const port = await this.startApplication(connection, platform, applicationDirectory, remoteNodeDirectory);
         connection.remotePort = port;
+        return {
+            applicationDirectory: libDir,
+            nodeDirectory: remoteNodeDirectory
+        };
     }
 
     protected async startApplication(connection: RemoteConnection, platform: RemotePlatform, remotePath: string, nodeDir: string): Promise<number> {
         const nodeExecutable = this.scriptService.joinPath(platform, nodeDir, ...(platform.os === OS.Type.Windows ? ['node.exe'] : ['bin', 'node']));
         const mainJsFile = this.scriptService.joinPath(platform, remotePath, 'lib', 'backend', 'main.js');
-        const localAddressRegex = /listening on http:\/\/127.0.0.1:(\d+)/;
+        const localAddressRegex = /listening on http:\/\/0.0.0.0:(\d+)/;
         let prefix = '';
         if (platform.os === OS.Type.Windows) {
             // We might to switch to PowerShell beforehand on Windows
@@ -101,7 +110,7 @@ export class RemoteSetupService {
         // This way, our current working directory is set as expected
         const result = await connection.execPartial(`${prefix}cd "${remotePath}";${nodeExecutable}`,
             stdout => localAddressRegex.test(stdout),
-            [mainJsFile, '--hostname=127.0.0.1', '--port=0', '--remote']);
+            [mainJsFile, '--hostname=0.0.0.0', `--port=${connection.remotePort ?? 0}`, '--remote']);
 
         const match = localAddressRegex.exec(result.stdout);
         if (!match) {

package/src/electron-node/ssh/remote-ssh-connection-provider.ts

@@ -278,8 +278,8 @@ export class RemoteSSHConnection implements RemoteConnection {
         return sftpClient;
     }
 
-    forwardOut(socket: net.Socket): void {
-        this.client.forwardOut(socket.localAddress!, socket.localPort!, '127.0.0.1', this.remotePort, (err, stream) => {
+    forwardOut(socket: net.Socket, port?: number): void {
+        this.client.forwardOut(socket.localAddress!, socket.localPort!, '127.0.0.1', port ?? this.remotePort, (err, stream) => {
             if (err) {
                 console.debug('Proxy message rejected', err);
             } else {