@theia/remote-wsl 1.62.0

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

@@ -0,0 +1,123 @@
+// *****************************************************************************
+// Copyright (C) 2025 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 { RemoteWslConnectionProvider, WslDistribution, WslConnectionOptions, WslConnectionResult } from '../electron-common/remote-wsl-connection-provider';
+import { RemoteConnectionService } from '@theia/remote/lib/electron-node/remote-connection-service';
+import { RemoteSetupService } from '@theia/remote/lib/electron-node/setup/remote-setup-service';
+import { exec } from 'child_process';
+import { MessageService, generateUuid } from '@theia/core';
+import { RemoteWslConnection } from './remote-wsl-connection';
+
+@injectable()
+export class RemoteWslConnectionProviderImpl implements RemoteWslConnectionProvider {
+
+    @inject(RemoteConnectionService)
+    protected readonly remoteConnectionService: RemoteConnectionService;
+
+    @inject(RemoteSetupService)
+    protected readonly remoteSetup: RemoteSetupService;
+
+    @inject(MessageService)
+    protected readonly messageService: MessageService;
+
+    dispose(): void {
+    }
+
+    /**
+     * executes `wsl.exe --list` to get the list of WSL distributions.
+     * The Output format look like this:
+     * ```
+     *   NAME                    STATE           VERSION
+     * * Ubuntu                  Stopped         2
+     *   Other Distro            Stopped         2
+     * ```
+     * so we split the output by lines and then by whitespace. The * indicates the default distribution so this has to be handled slightly different.
+     *
+     * @returns a list of WslDistribution objects, each containing the name, default status, and version.
+     */
+    async getWslDistributions(): Promise<WslDistribution[]> {
+        return new Promise<WslDistribution[]>((resolve, reject) => {
+            exec('wsl.exe --list --verbose --all', (error, stdout, stderr) => {
+                if (error) {
+                    const errorMessage = `Error executing wsl.exe: ${error} \n ${stderr}`;
+                    console.error(errorMessage);
+                    reject(errorMessage);
+                    return;
+                }
+
+                const lines = stdout
+                    .replace(/\0/g, '')
+                    .split('\n')
+                    .map(line => line.replace('\r', '').trim())
+                    .filter(line => line.length > 0)
+                    .slice(1); // Skip header line
+
+                resolve(lines.map(line => {
+                    const parts = line.split(/\s+/);
+                    const isDefault = parts[0] === '*';
+                    const name = isDefault ? parts[1] : parts[0];
+                    const version = isDefault ? parts[3] : parts[2];
+                    return {
+                        name,
+                        default: isDefault,
+                        version
+                    };
+                }));
+            });
+        });
+    }
+
+    async connectToWsl(options: WslConnectionOptions): Promise<WslConnectionResult> {
+        const progress = await this.messageService.showProgress({
+            text: 'Connecting to WSL'
+        });
+
+        try {
+            const connection = new RemoteWslConnection({
+                id: generateUuid(),
+                name: options.distribution,
+                type: 'WSL',
+                distribution: options.distribution,
+            });
+
+            const report: (message: string) => void = message => progress.report({ message });
+            report('Setting up remote environment...');
+
+            await this.remoteSetup.setup({
+                connection,
+                report,
+                nodeDownloadTemplate: options.nodeDownloadTemplate
+            });
+
+            const registration = this.remoteConnectionService.register(connection);
+
+            connection.onDidDisconnect(() => {
+                registration.dispose();
+            });
+
+            return {
+                port: connection.remotePort,
+            };
+        } catch (e) {
+            this.messageService.error(`Failed to connect to WSL: ${e.message}`);
+            throw e;
+        } finally {
+            progress.cancel();
+        }
+    }
+}
+

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

@@ -0,0 +1,161 @@
+// *****************************************************************************
+// Copyright (C) 2025 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 { Emitter, Event } from '@theia/core';
+import { RemoteConnection, RemoteExecOptions, RemoteExecResult, RemoteExecTester } from '@theia/remote/lib/electron-node/remote-types';
+import { Socket } from 'net';
+import { exec, spawn } from 'child_process';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import * as fs from 'fs';
+
+export interface RemoteWslConnectionOptions {
+    id: string;
+    name: string;
+    type: string;
+    distribution: string;
+}
+
+export class RemoteWslConnection implements RemoteConnection {
+    id: string;
+    name: string;
+    type: string;
+    remotePort: number;
+    distribution: string;
+
+    get localPort(): number {
+        return this.remotePort;
+    }
+
+    protected readonly onDidDisconnectEmitter = new Emitter<void>();
+    onDidDisconnect: Event<void> = this.onDidDisconnectEmitter.event;
+
+    constructor(options: RemoteWslConnectionOptions) {
+        this.id = options.id;
+        this.name = options.name;
+        this.type = options.type;
+        this.distribution = options.distribution;
+    }
+
+    async forwardOut(socket: Socket, port: number): Promise<void> {
+        new Socket().connect(port, 'localhost', () => {
+            socket.pipe(new Socket().connect(port, 'localhost'));
+        });
+    }
+
+    async exec(cmd: string, args?: string[], options?: RemoteExecOptions): Promise<RemoteExecResult> {
+        const deferred = new Deferred<RemoteExecResult>();
+        const fullCommand = `wsl -d ${this.distribution} ${cmd} ${args?.join(' ') ?? ''}`;
+
+        try {
+            exec(fullCommand, { env: options?.env }, (error, stdout, stderr) => {
+                deferred.resolve({ stdout, stderr });
+            });
+        } catch (e) {
+            deferred.reject(e);
+        }
+
+        return deferred.promise;
+    }
+
+    async execPartial(cmd: string, tester: RemoteExecTester, args?: string[], options?: RemoteExecOptions): Promise<RemoteExecResult> {
+        const deferred = new Deferred<RemoteExecResult>();
+
+        try {
+            let cdPath = undefined;
+            if (cmd.startsWith('cd') && cmd.includes(';')) {
+                const parts = cmd.split(';');
+                cdPath = parts[0].replace('cd', '').trim();
+                cmd = parts[1];
+            }
+            const fullCommand = `wsl -d ${this.distribution} ${cdPath ? `--cd ${cdPath} ${cmd}` : cmd} ${args?.join(' ') ?? ''}`;
+
+            const process = spawn(fullCommand, { env: options?.env, shell: 'powershell' });
+
+            let stdoutBuffer = '';
+            let stderrBuffer = '';
+
+            process.stdout.on('data', (data: Buffer) => {
+                if (deferred.state === 'unresolved') {
+                    stdoutBuffer += data.toString();
+                    if (tester(stdoutBuffer, stderrBuffer)) {
+                        deferred.resolve({ stdout: stdoutBuffer, stderr: stderrBuffer });
+                    }
+                }
+            });
+
+            process.stderr.on('data', (data: Buffer) => {
+                if (deferred.state === 'unresolved') {
+                    stderrBuffer += data.toString();
+                    if (tester(stdoutBuffer, stderrBuffer)) {
+                        deferred.resolve({ stdout: stdoutBuffer, stderr: stderrBuffer });
+                    }
+                }
+            });
+
+            process.on('close', () => {
+                if (deferred.state === 'unresolved') {
+                    deferred.resolve({ stdout: stdoutBuffer, stderr: stderrBuffer });
+                }
+            });
+
+            process.on('error', error => {
+                deferred.reject(error);
+            });
+        } catch (e) {
+            deferred.reject(e);
+        }
+
+        return deferred.promise;
+    }
+
+    async copy(localPath: string | Buffer | NodeJS.ReadableStream, remotePath: string): Promise<void> {
+        const deferred = new Deferred<void>();
+        const wslPath = `\\\\wsl$\\${this.distribution}\\${remotePath}`;
+
+        if (typeof localPath === 'string') {
+            exec(`copy "${localPath}" "${wslPath}"`, error => {
+                if (error) {
+                    deferred.reject(error);
+                } else {
+                    deferred.resolve();
+                }
+            });
+        } else if (Buffer.isBuffer(localPath)) {
+            fs.writeFile(wslPath, localPath, (error: Error) => {
+                if (error) {
+                    deferred.reject(error);
+                } else {
+                    deferred.resolve();
+                }
+            });
+        } else {
+            const writeStream = fs.createWriteStream(wslPath);
+            localPath.pipe(writeStream);
+            writeStream.on('finish', () => deferred.resolve());
+            writeStream.on('error', (error: Error) => deferred.reject(error));
+        }
+
+        return deferred.promise;
+    }
+
+    dispose(): void {
+        this.onDidDisconnectEmitter.dispose();
+    }
+
+    disposeSync(): void {
+        // No special cleanup needed for WSL
+    }
+}

package/src/electron-node/wsl-workspace-handler.ts

@@ -0,0 +1,38 @@
+// *****************************************************************************
+// Copyright (C) 2025 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 { URI } from '@theia/core';
+import * as fs from '@theia/core/shared/fs-extra';
+import { WorkspaceHandlerContribution } from '@theia/workspace/lib/node/default-workspace-server';
+
+export class WslWorkspaceHandler implements WorkspaceHandlerContribution {
+    canHandle(uri: URI): boolean {
+        return uri.scheme === 'wsl';
+    }
+    workspaceStillExists(uri: URI): Promise<boolean> {
+        return fs.pathExists(this.toWindowsPath(uri.path.toString()));
+    }
+
+    private toWindowsPath(path: string): string {
+        const match = path.match(/^\/mnt\/([a-z])\/(.*)/i);
+        if (match) {
+            const driveLetter = match[1].toUpperCase();
+            const windowsPath = match[2].replace(/\//g, '\\');
+            return `${driveLetter}:\\${windowsPath}`;
+        }
+        return path;
+    }
+
+}

package/src/package.spec.ts

@@ -0,0 +1,29 @@
+// *****************************************************************************
+// Copyright (C) 2023 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
+// *****************************************************************************
+
+/* note: this bogus test file is required so that
+   we are able to run mocha unit tests on this
+   package, without having any actual unit tests in it.
+   This way a coverage report will be generated,
+   showing 0% coverage, instead of no report.
+   This file can be removed once we have real unit
+   tests in place. */
+
+describe('remote-wsl package', () => {
+
+    it('support code coverage statistics', () => true);
+
+});