@theia/remote 1.45.1 → 1.46.0-next.241

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

@@ -16,36 +16,15 @@
 
 import { ApplicationPackage } from '@theia/core/shared/@theia/application-package';
 import { inject, injectable } from '@theia/core/shared/inversify';
+import { RemoteCopyRegistry, RemoteFile, RemoteCopyOptions } from '@theia/core/lib/node/remote/remote-copy-contribution';
 import { glob as globCallback } from 'glob';
 import { promisify } from 'util';
 import * as path from 'path';
-import { MaybePromise } from '@theia/core';
 
 const promiseGlob = promisify(globCallback);
 
-export const RemoteCopyContribution = Symbol('RemoteCopyContribution');
-
-export interface RemoteCopyContribution {
-    copy(registry: RemoteCopyRegistry): MaybePromise<void>
-}
-
-export interface RemoteCopyOptions {
-    /**
-     * The mode that the file should be set to once copied to the remote.
-     *
-     * Only relevant for POSIX-like systems
-     */
-    mode?: number;
-}
-
-export interface RemoteFile {
-    path: string
-    target: string
-    options?: RemoteCopyOptions;
-}
-
 @injectable()
-export class RemoteCopyRegistry {
+export class RemoteCopyRegistryImpl implements RemoteCopyRegistry {
 
     @inject(ApplicationPackage)
     protected readonly applicationPackage: ApplicationPackage;
@@ -57,15 +36,16 @@ export class RemoteCopyRegistry {
     }
 
     async glob(pattern: string, target?: string): Promise<void> {
+        return this.doGlob(pattern, this.applicationPackage.projectPath, target);
+    }
+
+    async doGlob(pattern: string, cwd: string, target?: string): Promise<void> {
         const projectPath = this.applicationPackage.projectPath;
-        const globResult = await promiseGlob(pattern, {
-            cwd: projectPath
-        });
-        const relativeFiles = globResult.map(file => path.relative(projectPath, file));
-        for (const file of relativeFiles) {
+        const globResult = await promiseGlob(pattern, { cwd, nodir: true });
+        for (const file of globResult) {
             const targetFile = this.withTarget(file, target);
             this.files.push({
-                path: file,
+                path: path.relative(projectPath, path.resolve(cwd, file)),
                 target: targetFile
             });
         }
@@ -81,7 +61,11 @@ export class RemoteCopyRegistry {
     }
 
     async directory(dir: string, target?: string): Promise<void> {
-        return this.glob(dir + '/**', target);
+        let absoluteDir = dir;
+        if (!path.isAbsolute(absoluteDir)) {
+            absoluteDir = path.join(this.applicationPackage.projectPath, dir);
+        }
+        return this.doGlob('**/*', absoluteDir, target ?? dir);
     }
 
     protected withTarget(file: string, target?: string): string {

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

@@ -20,10 +20,12 @@ import * as fs from 'fs';
 import * as os from 'os';
 import { ApplicationPackage } from '@theia/core/shared/@theia/application-package';
 import { inject, injectable, named } from '@theia/core/shared/inversify';
-import { RemoteConnection, RemotePlatform } from '../remote-types';
+import { RemoteConnection } from '../remote-types';
+import { RemotePlatform } from '@theia/core/lib/node/remote/remote-cli-contribution';
 import { RemoteNativeDependencyService } from './remote-native-dependency-service';
 import { ContributionProvider } from '@theia/core';
-import { RemoteCopyContribution, RemoteCopyRegistry, RemoteFile } from './remote-copy-contribution';
+import { RemoteCopyRegistryImpl } from './remote-copy-contribution';
+import { RemoteCopyContribution, RemoteFile } from '@theia/core/lib/node/remote/remote-copy-contribution';
 
 @injectable()
 export class RemoteCopyService {
@@ -31,8 +33,8 @@ export class RemoteCopyService {
     @inject(ApplicationPackage)
     protected readonly applicationPackage: ApplicationPackage;
 
-    @inject(RemoteCopyRegistry)
-    protected readonly copyRegistry: RemoteCopyRegistry;
+    @inject(RemoteCopyRegistryImpl)
+    protected readonly copyRegistry: RemoteCopyRegistryImpl;
 
     @inject(RemoteNativeDependencyService)
     protected readonly nativeDependencyService: RemoteNativeDependencyService;

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

@@ -16,7 +16,7 @@
 
 import { isObject } from '@theia/core';
 import { RequestOptions } from '@theia/core/shared/@theia/request';
-import { RemotePlatform } from '../remote-types';
+import { RemotePlatform } from '@theia/core/lib/node/remote/remote-cli-contribution';
 
 export interface FileDependencyResult {
     path: string;

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

@@ -21,7 +21,7 @@ import * as decompress from 'decompress';
 import * as path from 'path';
 import * as fs from 'fs/promises';
 import { DependencyDownload, DirectoryDependencyDownload, RemoteNativeDependencyContribution } from './remote-native-dependency-contribution';
-import { RemotePlatform } from '../remote-types';
+import { RemotePlatform } from '@theia/core/lib/node/remote/remote-cli-contribution';
 
 const decompressTar = require('decompress-tar');
 const decompressTargz = require('decompress-targz');

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

@@ -21,7 +21,7 @@ import * as os from 'os';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { RequestService } from '@theia/core/shared/@theia/request';
 import { RemoteSetupScriptService } from './remote-setup-script-service';
-import { RemotePlatform } from '../remote-types';
+import { RemotePlatform } from '@theia/core/lib/node/remote/remote-cli-contribution';
 import { OS } from '@theia/core';
 
 /**

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

@@ -16,7 +16,7 @@
 
 import { OS } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { RemotePlatform } from '../remote-types';
+import { RemotePlatform } from '@theia/core/lib/node/remote/remote-cli-contribution';
 
 export interface RemoteScriptStrategy {
     exec(): string;

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

@@ -14,12 +14,13 @@
 // 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 { RemoteConnection, RemoteExecResult, RemotePlatform, RemoteStatusReport } from '../remote-types';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
+import { RemoteConnection, RemoteExecResult, RemoteStatusReport } from '../remote-types';
+import { RemoteCliContext, RemoteCliContribution, RemotePlatform } from '@theia/core/lib/node/remote/remote-cli-contribution';
 import { ApplicationPackage } from '@theia/core/shared/@theia/application-package';
 import { RemoteCopyService } from './remote-copy-service';
 import { RemoteNativeDependencyService } from './remote-native-dependency-service';
-import { OS, THEIA_VERSION } from '@theia/core';
+import { ContributionProvider, OS, THEIA_VERSION } from '@theia/core';
 import { RemoteNodeSetupService } from './remote-node-setup-service';
 import { RemoteSetupScriptService } from './remote-setup-script-service';
 
@@ -29,6 +30,11 @@ export interface RemoteSetupOptions {
     nodeDownloadTemplate?: string;
 }
 
+export interface RemoteSetupResult {
+    applicationDirectory: string;
+    nodeDirectory: string;
+}
+
 @injectable()
 export class RemoteSetupService {
 
@@ -47,7 +53,10 @@ export class RemoteSetupService {
     @inject(ApplicationPackage)
     protected readonly applicationPackage: ApplicationPackage;
 
-    async setup(options: RemoteSetupOptions): Promise<void> {
+    @inject(ContributionProvider) @named(RemoteCliContribution)
+    protected readonly cliContributions: ContributionProvider<RemoteCliContribution>;
+
+    async setup(options: RemoteSetupOptions): Promise<RemoteSetupResult> {
         const {
             connection,
             report,
@@ -86,22 +95,36 @@ 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
             prefix = this.scriptService.exec(platform) + ' ';
         }
+        const remoteContext: RemoteCliContext = {
+            platform,
+            directory: remotePath
+        };
+        const args: string[] = ['--hostname=0.0.0.0', `--port=${connection.remotePort ?? 0}`, '--remote'];
+        for (const cli of this.cliContributions.getContributions()) {
+            if (cli.enhanceArgs) {
+                args.push(...await cli.enhanceArgs(remoteContext));
+            }
+        }
         // Change to the remote application path and start a node process with the copied main.js file
         // 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, ...args]);
 
         const match = localAddressRegex.exec(result.stdout);
         if (!match) {
@@ -144,6 +167,8 @@ export class RemoteSetupService {
                 arch = 'x64';
             } else if (archResult.match(/i\d83/)) { // i386, i483, i683
                 arch = 'x86';
+            } else if (archResult.includes('aarch64')) {
+                arch = 'arm64';
             } else {
                 arch = archResult.trim();
             }

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

@@ -27,7 +27,7 @@ import { RemoteConnection, RemoteExecOptions, RemoteExecResult, RemoteExecTester
 import { Deferred, timeout } from '@theia/core/lib/common/promise-util';
 import { SSHIdentityFileCollector, SSHKey } from './ssh-identity-file-collector';
 import { RemoteSetupService } from '../setup/remote-setup-service';
-import { v4 } from 'uuid';
+import { generateUuid } from '@theia/core/lib/common/uuid';
 
 @injectable()
 export class RemoteSSHConnectionProviderImpl implements RemoteSSHConnectionProvider {
@@ -86,13 +86,14 @@ export class RemoteSSHConnectionProviderImpl implements RemoteSSHConnectionProvi
         const deferred = new Deferred<RemoteSSHConnection>();
         const sshClient = new ssh2.Client();
         const identityFiles = await this.identityFileCollector.gatherIdentityFiles();
-        const sshAuthHandler = this.getAuthHandler(user, host, identityFiles);
+        const hostUrl = new URL(`ssh://${host}`);
+        const sshAuthHandler = this.getAuthHandler(user, hostUrl.hostname, identityFiles);
         sshClient
             .on('ready', async () => {
                 const connection = new RemoteSSHConnection({
                     client: sshClient,
-                    id: v4(),
-                    name: host,
+                    id: generateUuid(),
+                    name: hostUrl.hostname,
                     type: 'SSH'
                 });
                 try {
@@ -102,11 +103,12 @@ export class RemoteSSHConnectionProviderImpl implements RemoteSSHConnectionProvi
                     deferred.reject(err);
                 }
             }).on('end', () => {
-                console.log(`Ended remote connection to host '${user}@${host}'`);
+                console.log(`Ended remote connection to host '${user}@${hostUrl.hostname}'`);
             }).on('error', err => {
                 deferred.reject(err);
             }).connect({
-                host: host,
+                host: hostUrl.hostname,
+                port: hostUrl.port ? parseInt(hostUrl.port, 10) : undefined,
                 username: user,
                 authHandler: (methodsLeft, successes, callback) => (sshAuthHandler(methodsLeft, successes, callback), undefined)
             });
@@ -276,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 {