@theia/remote 1.45.1 → 1.46.0-next.241

package/src/electron-browser/port-forwarding/port-forwarding-widget.tsx

@@ -0,0 +1,140 @@
+// *****************************************************************************
+// 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 * as React from '@theia/core/shared/react';
+import { ReactNode } from '@theia/core/shared/react';
+import { OpenerService, ReactWidget } from '@theia/core/lib/browser';
+import { nls, URI } from '@theia/core';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { ForwardedPort, PortForwardingService } from './port-forwarding-service';
+import { ClipboardService } from '@theia/core/lib/browser/clipboard-service';
+
+export const PORT_FORWARDING_WIDGET_ID = 'port-forwarding-widget';
+
+@injectable()
+export class PortForwardingWidget extends ReactWidget {
+
+    @inject(PortForwardingService)
+    protected readonly portForwardingService: PortForwardingService;
+
+    @inject(OpenerService)
+    protected readonly openerService: OpenerService;
+
+    @inject(ClipboardService)
+    protected readonly clipboardService: ClipboardService;
+
+    @postConstruct()
+    protected init(): void {
+        this.id = PORT_FORWARDING_WIDGET_ID;
+        this.node.tabIndex = -1;
+        this.title.label = nls.localizeByDefault('Ports');
+        this.title.caption = this.title.label;
+        this.title.closable = true;
+        this.update();
+
+        this.portForwardingService.onDidChangePorts(() => this.update());
+    }
+
+    protected render(): ReactNode {
+        if (this.portForwardingService.forwardedPorts.length === 0) {
+            return <div>
+                <p style={{ marginLeft: 'calc(var(--theia-ui-padding) * 2)' }}>
+                    {nls.localizeByDefault('No forwarded ports. Forward a port to access your locally running services over the internet.\n[Forward a Port]({0})').split('\n')[0]}
+                </p>
+                {this.renderForwardPortButton()}
+            </div>;
+        }
+
+        return <div>
+            <table className='port-table'>
+                <thead>
+                    <tr>
+                        <th className='port-table-header'>{nls.localizeByDefault('Port')}</th>
+                        <th className='port-table-header'>{nls.localizeByDefault('Address')}</th>
+                        <th className='port-table-header'>{nls.localizeByDefault('Running Process')}</th>
+                        <th className='port-table-header'>{nls.localizeByDefault('Origin')}</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {this.portForwardingService.forwardedPorts.map(port => (
+                        <tr key={port.localPort ?? 'editing'}>
+                            {this.renderPortColumn(port)}
+                            {this.renderAddressColumn(port)}
+                            <td></td>
+                            <td>{port.origin ? nls.localizeByDefault(port.origin) : ''}</td>
+                        </tr>
+                    ))}
+                    {!this.portForwardingService.forwardedPorts.some(port => port.editing) && <tr><td>{this.renderForwardPortButton()}</td></tr>}
+                </tbody>
+            </table>
+        </div>;
+    }
+
+    protected renderForwardPortButton(): ReactNode {
+        return <button className='theia-button' onClick={() => {
+            this.portForwardingService.forwardNewPort('User Forwarded');
+            this.update();
+        }
+        }>{nls.localizeByDefault('Forward a Port')}</button>;
+    }
+
+    protected renderAddressColumn(port: ForwardedPort): ReactNode {
+        const address = `${port.address ?? '0.0.0.0'}:${port.localPort}`;
+        return <td>
+            <div className='button-cell'>
+                <span style={{ flexGrow: 1 }} className='forwarded-address' onClick={async e => {
+                    if (e.ctrlKey) {
+                        const uri = new URI(`http://${address}`);
+                        (await this.openerService.getOpener(uri)).open(uri);
+                    }
+                }} title={nls.localizeByDefault('Follow link') + ' (ctrl/cmd + click)'}>
+                    {port.localPort ? address : ''}
+                </span>
+                {
+                    port.localPort &&
+                    <span className='codicon codicon-clippy action-label' title={nls.localizeByDefault('Copy Local Address')} onClick={() => {
+                        this.clipboardService.writeText(address);
+                    }}></span>
+                }
+            </div>
+        </td>;
+    }
+
+    protected renderPortColumn(port: ForwardedPort): ReactNode {
+        return port.editing ?
+            <td><PortEditingInput port={port} service={this.portForwardingService} /></td> :
+            <td>
+                <div className='button-cell'>
+                    <span style={{ flexGrow: 1 }}>{port.localPort}</span>
+                    <span className='codicon codicon-close action-label' title={nls.localizeByDefault('Stop Forwarding Port')} onClick={() => {
+                        this.portForwardingService.removePort(port);
+                        this.update();
+                    }}></span>
+                </div>
+            </td>;
+    }
+
+}
+
+function PortEditingInput({ port, service }: { port: ForwardedPort, service: PortForwardingService }): React.JSX.Element {
+    const [error, setError] = React.useState(false);
+    return <input className={`theia-input forward-port-button${error ? ' port-edit-input-error' : ''}`} port-edit-input-error={error}
+        autoFocus defaultValue={port.address ? `${port.address}:${port.localPort}` : port.localPort ?? ''}
+        placeholder={nls.localizeByDefault('Port number or address (eg. 3000 or 10.10.10.10:2000).')}
+        onKeyDown={e => e.key === 'Enter' && !error && service.updatePort(port, e.currentTarget.value)}
+        onKeyUp={e => setError(!service.isValidAddress(e.currentTarget.value))}></input>;
+
+}

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

@@ -21,6 +21,7 @@ import { RemoteStatus, RemoteStatusService } from '../electron-common/remote-sta
 import { RemoteRegistry, RemoteRegistryContribution } from './remote-registry-contribution';
 import { RemoteService } from './remote-service';
 import { WindowService } from '@theia/core/lib/browser/window/window-service';
+import { getLocalPort, getCurrentPort } from '@theia/core/lib/electron-browser/messaging/electron-local-ws-connection-source';
 
 export namespace RemoteCommands {
     export const REMOTE_SELECT: Command = {
@@ -59,7 +60,7 @@ export class RemoteFrontendContribution implements CommandContribution, Frontend
     protected remoteRegistry = new RemoteRegistry();
 
     async configure(): Promise<void> {
-        const port = new URLSearchParams(location.search).get('port');
+        const port = getCurrentPort();
         if (port) {
             const status = await this.remoteStatusService.getStatus(Number(port));
             await this.setStatusBar(status);
@@ -105,12 +106,13 @@ export class RemoteFrontendContribution implements CommandContribution, Frontend
         });
     }
 
-    protected disconnectRemote(): void {
-        const port = new URLSearchParams(location.search).get('localPort');
-        if (port) {
-            this.windowService.reload({
-                port
-            });
+    protected async disconnectRemote(): Promise<void> {
+        const localPort = getLocalPort();
+        if (localPort) {
+            const searchParams = new URLSearchParams(location.search);
+            const currentPort = searchParams.get('port');
+            this.remoteStatusService.connectionClosed(parseInt(currentPort ?? '0'));
+            this.windowService.reload({ search: { port: localPort } });
         }
     }
 

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

@@ -16,7 +16,7 @@
 
 import { bindContributionProvider, CommandContribution } from '@theia/core';
 import { ContainerModule } from '@theia/core/shared/inversify';
-import { FrontendApplicationContribution, WebSocketConnectionProvider } from '@theia/core/lib/browser';
+import { bindViewContribution, FrontendApplicationContribution, isRemote, WidgetFactory } from '@theia/core/lib/browser';
 import { RemoteSSHContribution } from './remote-ssh-contribution';
 import { RemoteSSHConnectionProvider, RemoteSSHConnectionProviderPath } from '../electron-common/remote-ssh-connection-provider';
 import { RemoteFrontendContribution } from './remote-frontend-contribution';
@@ -26,6 +26,17 @@ import { RemoteStatusService, RemoteStatusServicePath } from '../electron-common
 import { ElectronFileDialogService } from '@theia/filesystem/lib/electron-browser/file-dialog/electron-file-dialog-service';
 import { RemoteElectronFileDialogService } from './remote-electron-file-dialog-service';
 import { bindRemotePreferences } from './remote-preferences';
+import { PortForwardingWidget, PORT_FORWARDING_WIDGET_ID } from './port-forwarding/port-forwarding-widget';
+import { PortForwardingContribution } from './port-forwarding/port-forwading-contribution';
+import { PortForwardingService } from './port-forwarding/port-forwarding-service';
+import { RemotePortForwardingProvider, RemoteRemotePortForwardingProviderPath } from '../electron-common/remote-port-forwarding-provider';
+import { ServiceConnectionProvider } from '@theia/core/lib/browser/messaging/service-connection-provider';
+import '../../src/electron-browser/style/port-forwarding-widget.css';
+import { UserStorageContribution } from '@theia/userstorage/lib/browser/user-storage-contribution';
+import { RemoteUserStorageContribution } from './remote-user-storage-provider';
+import { remoteFileSystemPath, RemoteFileSystemProxyFactory, RemoteFileSystemServer } from '@theia/filesystem/lib/common/remote-file-system-provider';
+import { LocalEnvVariablesServer, LocalRemoteFileSystemProvider, LocalRemoteFileSytemServer } from './local-backend-services';
+import { envVariablesPath, EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 
 export default new ContainerModule((bind, _, __, rebind) => {
     bind(RemoteFrontendContribution).toSelf().inSingletonScope();
@@ -42,8 +53,33 @@ export default new ContainerModule((bind, _, __, rebind) => {
 
     bind(RemoteService).toSelf().inSingletonScope();
 
+    bind(PortForwardingWidget).toSelf();
+    bind(WidgetFactory).toDynamicValue(context => ({
+        id: PORT_FORWARDING_WIDGET_ID,
+        createWidget: () => context.container.get<PortForwardingWidget>(PortForwardingWidget)
+    }));
+
+    bindViewContribution(bind, PortForwardingContribution);
+    bind(PortForwardingService).toSelf().inSingletonScope();
+
     bind(RemoteSSHConnectionProvider).toDynamicValue(ctx =>
-        WebSocketConnectionProvider.createLocalProxy<RemoteSSHConnectionProvider>(ctx.container, RemoteSSHConnectionProviderPath)).inSingletonScope();
+        ServiceConnectionProvider.createLocalProxy<RemoteSSHConnectionProvider>(ctx.container, RemoteSSHConnectionProviderPath)).inSingletonScope();
     bind(RemoteStatusService).toDynamicValue(ctx =>
-        WebSocketConnectionProvider.createLocalProxy<RemoteStatusService>(ctx.container, RemoteStatusServicePath)).inSingletonScope();
+        ServiceConnectionProvider.createLocalProxy<RemoteStatusService>(ctx.container, RemoteStatusServicePath)).inSingletonScope();
+
+    bind(RemotePortForwardingProvider).toDynamicValue(ctx =>
+        ServiceConnectionProvider.createLocalProxy<RemotePortForwardingProvider>(ctx.container, RemoteRemotePortForwardingProviderPath)).inSingletonScope();
+
+    bind(LocalRemoteFileSytemServer).toDynamicValue(ctx =>
+        isRemote ?
+            ServiceConnectionProvider.createLocalProxy(ctx.container, remoteFileSystemPath, new RemoteFileSystemProxyFactory()) :
+            ctx.container.get(RemoteFileSystemServer));
+    bind(LocalEnvVariablesServer).toDynamicValue(ctx =>
+        isRemote ?
+            ServiceConnectionProvider.createLocalProxy<EnvVariablesServer>(ctx.container, envVariablesPath) :
+            ctx.container.get(EnvVariablesServer));
+    bind(LocalRemoteFileSystemProvider).toSelf().inSingletonScope();
+    rebind(UserStorageContribution).to(RemoteUserStorageContribution);
+
 });
+

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/remote-user-storage-provider.ts

@@ -0,0 +1,64 @@
+// *****************************************************************************
+// 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 { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { FileSystemProvider } from '@theia/filesystem/lib/common/files';
+import { UserStorageContribution } from '@theia/userstorage/lib/browser/user-storage-contribution';
+import { RemoteStatusService } from '../electron-common/remote-status-service';
+import { LocalEnvVariablesServer, LocalRemoteFileSystemProvider } from './local-backend-services';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import { URI } from '@theia/core';
+import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
+import { getCurrentPort } from '@theia/core/lib/electron-browser/messaging/electron-local-ws-connection-source';
+
+/**
+ * This overide is to have remote connections still use settings, keymaps, etc. from the local machine.
+ */
+@injectable()
+export class RemoteUserStorageContribution extends UserStorageContribution {
+    @inject(RemoteStatusService)
+    protected readonly remoteStatusService: RemoteStatusService;
+
+    @inject(LocalRemoteFileSystemProvider)
+    protected readonly localRemoteFileSystemProvider: LocalRemoteFileSystemProvider;
+
+    @inject(LocalEnvVariablesServer)
+    protected readonly localEnvironments: EnvVariablesServer;
+
+    isRemoteConnection: Deferred<boolean> = new Deferred();
+
+    @postConstruct()
+    protected init(): void {
+        const port = getCurrentPort();
+        if (port) {
+            this.remoteStatusService.getStatus(Number(port)).then(status => this.isRemoteConnection.resolve(status.alive));
+        }
+    }
+
+    protected override async getDelegate(service: FileService): Promise<FileSystemProvider> {
+        return await this.isRemoteConnection.promise ?
+            this.localRemoteFileSystemProvider
+            : service.activateProvider('file');
+    }
+
+    protected override async getCongigDirUri(): Promise<URI> {
+        return await this.isRemoteConnection.promise ?
+            new URI(await this.localEnvironments.getConfigDirUri())
+            : super.getCongigDirUri();
+    }
+
+}

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,30 @@
+// *****************************************************************************
+// 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>;
+    getForwardedPorts(): Promise<ForwardedPort[]>
+}

package/src/electron-common/remote-status-service.ts

@@ -31,5 +31,7 @@ export const RemoteStatusServicePath = '/remote/status';
 export const RemoteStatusService = Symbol('RemoteStatusService');
 
 export interface RemoteStatusService {
-    getStatus(localPort: number): Promise<RemoteStatus>
+    getStatus(localPort: number): Promise<RemoteStatus>;
+
+    connectionClosed(localPort: number): Promise<void>;
 }

package/src/electron-node/backend-remote-service-impl.ts

@@ -17,7 +17,7 @@
 import { CliContribution } from '@theia/core/lib/node';
 import { injectable } from '@theia/core/shared/inversify';
 import { Arguments, Argv } from '@theia/core/shared/yargs';
-import { BackendRemoteService } from '@theia/core/lib/node/backend-remote-service';
+import { BackendRemoteService } from '@theia/core/lib/node/remote/backend-remote-service';
 
 export const REMOTE_START = 'remote';
 

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

@@ -27,21 +27,28 @@ import { RemoteCopyService } from './setup/remote-copy-service';
 import { RemoteSetupService } from './setup/remote-setup-service';
 import { RemoteNativeDependencyService } from './setup/remote-native-dependency-service';
 import { BackendRemoteServiceImpl } from './backend-remote-service-impl';
-import { BackendRemoteService } from '@theia/core/lib/node/backend-remote-service';
+import { BackendRemoteService } from '@theia/core/lib/node/remote/backend-remote-service';
 import { RemoteNodeSetupService } from './setup/remote-node-setup-service';
 import { RemotePosixScriptStrategy, RemoteSetupScriptService, RemoteWindowsScriptStrategy } from './setup/remote-setup-script-service';
 import { RemoteStatusService, RemoteStatusServicePath } from '../electron-common/remote-status-service';
 import { RemoteStatusServiceImpl } from './remote-status-service';
 import { ConnectionHandler, RpcConnectionHandler, bindContributionProvider } from '@theia/core';
-import { RemoteCopyContribution, RemoteCopyRegistry } from './setup/remote-copy-contribution';
+import { RemoteCopyRegistryImpl } from './setup/remote-copy-contribution';
+import { RemoteCopyContribution } from '@theia/core/lib/node/remote/remote-copy-contribution';
 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) => {
@@ -62,7 +69,7 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bind(RemotePosixScriptStrategy).toSelf().inSingletonScope();
     bind(RemoteSetupScriptService).toSelf().inSingletonScope();
     bind(RemoteNativeDependencyService).toSelf().inSingletonScope();
-    bind(RemoteCopyRegistry).toSelf().inSingletonScope();
+    bind(RemoteCopyRegistryImpl).toSelf().inSingletonScope();
     bindContributionProvider(bind, RemoteCopyContribution);
     bindContributionProvider(bind, RemoteNativeDependencyContribution);
     bind(MainCopyContribution).toSelf().inSingletonScope();

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

@@ -18,8 +18,8 @@ import { inject, injectable } from '@theia/core/shared/inversify';
 import { RemoteConnection } from './remote-types';
 import { Disposable } from '@theia/core';
 import { RemoteCopyService } from './setup/remote-copy-service';
-import { RemoteNativeDependencyService } from './setup/remote-native-dependency-service';
 import { BackendApplicationContribution } from '@theia/core/lib/node';
+import { RemoteSetupService } from './setup/remote-setup-service';
 
 @injectable()
 export class RemoteConnectionService implements BackendApplicationContribution {
@@ -27,8 +27,9 @@ export class RemoteConnectionService implements BackendApplicationContribution {
     @inject(RemoteCopyService)
     protected readonly copyService: RemoteCopyService;
 
-    @inject(RemoteNativeDependencyService)
-    protected readonly nativeDependencyService: RemoteNativeDependencyService;
+    // Workaround for the fact that connection scoped services cannot directly inject these services.
+    @inject(RemoteSetupService)
+    protected readonly remoteSetupService: RemoteSetupService;
 
     protected readonly connections = new Map<string, RemoteConnection>();
 
@@ -49,7 +50,11 @@ export class RemoteConnectionService implements BackendApplicationContribution {
 
     onStop(): void {
         for (const connection of this.connections.values()) {
-            connection.dispose();
+            if (connection.disposeSync) {
+                connection.disposeSync();
+            } else {
+                connection.dispose();
+            };
         }
     }
 }

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

@@ -0,0 +1,66 @@
+// *****************************************************************************
+// 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';
+import { RemoteConnection } from './remote-types';
+
+interface ForwardInfo {
+    connection: RemoteConnection
+    port: ForwardedPort
+    server: Server
+}
+
+@injectable()
+export class RemotePortForwardingProviderImpl implements RemotePortForwardingProvider {
+
+    @inject(RemoteConnectionService)
+    protected readonly connectionService: RemoteConnectionService;
+
+    protected static forwardedPorts: ForwardInfo[] = [];
+
+    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);
+
+        currentConnection.onDidDisconnect(() => {
+            this.portRemoved(portToForward);
+        });
+
+        RemotePortForwardingProviderImpl.forwardedPorts.push({ connection: currentConnection, port: portToForward, server });
+    }
+
+    async portRemoved(forwardedPort: ForwardedPort): Promise<void> {
+        const forwardInfo = RemotePortForwardingProviderImpl.forwardedPorts.find(info => info.port.port === forwardedPort.port);
+        if (forwardInfo) {
+            forwardInfo.server.close();
+            RemotePortForwardingProviderImpl.forwardedPorts.splice(RemotePortForwardingProviderImpl.forwardedPorts.indexOf(forwardInfo), 1);
+        }
+    }
+
+    async getForwardedPorts(): Promise<ForwardedPort[]> {
+        return Array.from(RemotePortForwardingProviderImpl.forwardedPorts)
+            .map(forwardInfo => ({ ...forwardInfo.port, editing: false }));
+    }
+}

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

@@ -38,4 +38,11 @@ export class RemoteStatusServiceImpl implements RemoteStatusService {
             };
         }
     }
+
+    async connectionClosed(localPort: number): Promise<void> {
+        const connection = this.remoteConnectionService.getConnectionFromPort(localPort);
+        if (connection) {
+            connection.dispose();
+        }
+    }
 }

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

@@ -14,14 +14,9 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Disposable, Event, OS } from '@theia/core';
+import { Disposable, Event } from '@theia/core';
 import * as net from 'net';
 
-export interface RemotePlatform {
-    os: OS.Type
-    arch: string
-}
-
 export type RemoteStatusReport = (message: string) => void;
 
 export interface ExpressLayer {
@@ -49,8 +44,26 @@ 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>;
+
+    /**
+     * used for disposing when theia is shutting down
+     */
+    disposeSync?(): void;
 }

package/src/electron-node/setup/app-native-dependency-contribution.ts

@@ -16,7 +16,7 @@
 
 import { injectable } from '@theia/core/shared/inversify';
 import { RemoteNativeDependencyContribution, DownloadOptions, DependencyDownload } from './remote-native-dependency-contribution';
-import { RemotePlatform } from '../remote-types';
+import { RemotePlatform } from '@theia/core/lib/node/remote/remote-cli-contribution';
 import { OS } from '@theia/core';
 
 @injectable()

package/src/electron-node/setup/main-copy-contribution.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { injectable } from '@theia/core/shared/inversify';
-import { RemoteCopyContribution, RemoteCopyRegistry } from './remote-copy-contribution';
+import { RemoteCopyContribution, RemoteCopyRegistry } from '@theia/core/lib/node/remote/remote-copy-contribution';
 
 @injectable()
 export class MainCopyContribution implements RemoteCopyContribution {