@theia/plugin-ext 1.13.0-next.df062f62 → 1.13.0

package/src/common/plugin-api-rpc.ts

@@ -1354,6 +1354,8 @@ export interface CommandProperties {
 
 export interface TaskDto {
     type: string;
+    taskType?: 'shell' | 'process' | 'customExecution'; // the task execution type
+    executionId?: string,
     label: string;
     source?: string;
     scope: string | number;

package/src/common/plugin-protocol.ts

@@ -154,6 +154,8 @@ export interface PluginPackageKeybinding {
     mac?: string;
     linux?: string;
     win?: string;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    args?: any;
 }
 
 export interface PluginPackageGrammarsContribution {
@@ -706,6 +708,8 @@ export interface Keybinding {
     mac?: string;
     linux?: string;
     win?: string;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    args?: any;
 }
 
 /**
@@ -768,7 +772,7 @@ export function buildFrontendModuleName(plugin: PluginPackage | PluginModel): st
 
 export const HostedPluginClient = Symbol('HostedPluginClient');
 export interface HostedPluginClient {
-    postMessage(message: string): Promise<void>;
+    postMessage(pluginHost: string, message: string): Promise<void>;
 
     log(logPart: LogPart): void;
 
@@ -812,10 +816,12 @@ export interface HostedPluginServer extends JsonRpcServer<HostedPluginClient> {
 
     getExtPluginAPI(): Promise<ExtPluginApi[]>;
 
-    onMessage(message: string): Promise<void>;
+    onMessage(targetHost: string, message: string): Promise<void>;
 
 }
 
+export const PLUGIN_HOST_BACKEND = 'main';
+
 export interface WorkspaceStorageKind {
     workspace?: string | undefined;
     roots: string[];
@@ -847,9 +853,9 @@ export interface PluginServer {
 export const ServerPluginRunner = Symbol('ServerPluginRunner');
 export interface ServerPluginRunner {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    acceptMessage(jsonMessage: any): boolean;
+    acceptMessage(pluginHostId: string, jsonMessage: string): boolean;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    onMessage(jsonMessage: any): void;
+    onMessage(pluginHostId: string, jsonMessage: string): void;
     setClient(client: HostedPluginClient): void;
     setDefault(defaultRunner: ServerPluginRunner): void;
     clientClosed(): void;

package/src/common/rpc-protocol.ts

@@ -22,7 +22,7 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { Event } from '@theia/core/lib/common/event';
+import { Emitter, Event } from '@theia/core/lib/common/event';
 import { DisposableCollection, Disposable } from '@theia/core/lib/common/disposable';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { URI as VSCodeURI } from '@theia/core/shared/vscode-uri';
@@ -32,8 +32,8 @@ import { Range, Position } from '../plugin/types-impl';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
 
 export interface MessageConnection {
-    send(msg: {}): void;
-    onMessage: Event<{}>;
+    send(msg: string): void;
+    onMessage: Event<string>;
 }
 
 export const RPCProtocol = Symbol('RPCProtocol');
@@ -83,17 +83,17 @@ export class RPCProtocolImpl implements RPCProtocol {
     private lastMessageId = 0;
     private readonly cancellationTokenSources = new Map<string, CancellationTokenSource>();
     private readonly pendingRPCReplies = new Map<string, Deferred<any>>();
-    private readonly multiplexor: RPCMultiplexer;
-    private messageToSendHostId: string | undefined;
+    private readonly multiplexer: RPCMultiplexer;
 
     private readonly toDispose = new DisposableCollection(
         Disposable.create(() => { /* mark as no disposed */ })
     );
 
-    constructor(connection: MessageConnection, readonly remoteHostID?: string) {
+    constructor(connection: MessageConnection) {
         this.toDispose.push(
-            this.multiplexor = new RPCMultiplexer(connection, msg => this.receiveOneMessage(msg), remoteHostID)
+            this.multiplexer = new RPCMultiplexer(connection)
         );
+        this.multiplexer.onMessage(msg => this.receiveOneMessage(msg));
         this.toDispose.push(Disposable.create(() => {
             this.proxies.clear();
             for (const reply of this.pendingRPCReplies.values()) {
@@ -163,12 +163,12 @@ export class RPCProtocolImpl implements RPCProtocol {
         if (cancellationToken) {
             args.push('add.cancellation.token');
             cancellationToken.onCancellationRequested(() =>
-                this.multiplexor.send(MessageFactory.cancel(callId, this.messageToSendHostId))
+                this.multiplexer.send(MessageFactory.cancel(callId))
             );
         }
 
         this.pendingRPCReplies.set(callId, result);
-        this.multiplexor.send(MessageFactory.request(callId, proxyId, methodName, args, this.messageToSendHostId));
+        this.multiplexer.send(MessageFactory.request(callId, proxyId, methodName, args));
         return result.promise;
     }
 
@@ -176,34 +176,29 @@ export class RPCProtocolImpl implements RPCProtocol {
         if (this.isDisposed) {
             return;
         }
-
-        const msg = <RPCMessage>JSON.parse(rawmsg, ObjectsTransferrer.reviver);
-
-        // handle message that sets the Host ID
-        if ((<any>msg).setHostID) {
-            this.messageToSendHostId = (<any>msg).setHostID;
-            return;
-        }
-
-        // skip message if not matching host
-        if (this.remoteHostID && (<any>msg).hostID && this.remoteHostID !== (<any>msg).hostID) {
-            return;
+        try {
+            const msg = <RPCMessage>JSON.parse(rawmsg, ObjectsTransferrer.reviver);
+
+            switch (msg.type) {
+                case MessageType.Request:
+                    this.receiveRequest(msg);
+                    break;
+                case MessageType.Reply:
+                    this.receiveReply(msg);
+                    break;
+                case MessageType.ReplyErr:
+                    this.receiveReplyErr(msg);
+                    break;
+                case MessageType.Cancel:
+                    this.receiveCancel(msg);
+                    break;
+            }
+        } catch (e) {
+            // exception does not show problematic content: log it!
+            console.log('failed to parse message: ' + rawmsg);
+            throw e;
         }
 
-        switch (msg.type) {
-            case MessageType.Request:
-                this.receiveRequest(msg);
-                break;
-            case MessageType.Reply:
-                this.receiveReply(msg);
-                break;
-            case MessageType.ReplyErr:
-                this.receiveReplyErr(msg);
-                break;
-            case MessageType.Cancel:
-                this.receiveCancel(msg);
-                break;
-        }
     }
 
     private receiveCancel(msg: CancelMessage): void {
@@ -229,10 +224,10 @@ export class RPCProtocolImpl implements RPCProtocol {
 
         invocation.then(result => {
             this.cancellationTokenSources.delete(callId);
-            this.multiplexor.send(MessageFactory.replyOK(callId, result, this.messageToSendHostId));
+            this.multiplexer.send(MessageFactory.replyOK(callId, result));
         }, error => {
             this.cancellationTokenSources.delete(callId);
-            this.multiplexor.send(MessageFactory.replyErr(callId, error, this.messageToSendHostId));
+            this.multiplexer.send(MessageFactory.replyErr(callId, error));
         });
     }
 
@@ -296,41 +291,44 @@ function canceled(): Error {
  *  - multiple messages to be sent from one stack get sent in bulk at `process.nextTick`.
  *  - each incoming message is handled in a separate `process.nextTick`.
  */
-class RPCMultiplexer implements Disposable {
+class RPCMultiplexer implements Disposable, MessageConnection {
 
     private readonly connection: MessageConnection;
     private readonly sendAccumulatedBound: () => void;
 
     private messagesToSend: string[];
 
+    private readonly messageEmitter = new Emitter<string>();
     private readonly toDispose = new DisposableCollection();
 
-    constructor(connection: MessageConnection, onMessage: (msg: string) => void, remoteHostId?: string) {
+    constructor(connection: MessageConnection) {
         this.connection = connection;
         this.sendAccumulatedBound = this.sendAccumulated.bind(this);
 
         this.toDispose.push(Disposable.create(() => this.messagesToSend = []));
-        this.toDispose.push(this.connection.onMessage((data: string[]) => {
-            const len = data.length;
-            for (let i = 0; i < len; i++) {
-                onMessage(data[i]);
+        this.toDispose.push(this.connection.onMessage((msg: string) => {
+            const messages = JSON.parse(msg);
+            for (const message of messages) {
+                this.messageEmitter.fire(message);
             }
         }));
+        this.toDispose.push(this.messageEmitter);
 
         this.messagesToSend = [];
-        if (remoteHostId) {
-            this.send(`{"setHostID":"${remoteHostId}"}`);
-        }
     }
 
     dispose(): void {
         this.toDispose.dispose();
     }
 
+    get onMessage(): Event<string> {
+        return this.messageEmitter.event;
+    }
+
     private sendAccumulated(): void {
         const tmp = this.messagesToSend;
         this.messagesToSend = [];
-        this.connection.send(tmp);
+        this.connection.send(JSON.stringify(tmp));
     }
 
     public send(msg: string): void {
@@ -350,43 +348,27 @@ class RPCMultiplexer implements Disposable {
 
 class MessageFactory {
 
-    static cancel(req: string, messageToSendHostId?: string): string {
-        let prefix = '';
-        if (messageToSendHostId) {
-            prefix = `"hostID":"${messageToSendHostId}",`;
-        }
-        return `{${prefix}"type":${MessageType.Cancel},"id":"${req}"}`;
+    static cancel(req: string): string {
+        return `{"type":${MessageType.Cancel},"id":"${req}"}`;
     }
 
-    public static request(req: string, rpcId: string, method: string, args: any[], messageToSendHostId?: string): string {
-        let prefix = '';
-        if (messageToSendHostId) {
-            prefix = `"hostID":"${messageToSendHostId}",`;
-        }
-        return `{${prefix}"type":${MessageType.Request},"id":"${req}","proxyId":"${rpcId}","method":"${method}","args":${JSON.stringify(args, ObjectsTransferrer.replacer)}}`;
+    public static request(req: string, rpcId: string, method: string, args: any[]): string {
+        return `{"type":${MessageType.Request},"id":"${req}","proxyId":"${rpcId}","method":"${method}","args":${JSON.stringify(args, ObjectsTransferrer.replacer)}}`;
     }
 
-    public static replyOK(req: string, res: any, messageToSendHostId?: string): string {
-        let prefix = '';
-        if (messageToSendHostId) {
-            prefix = `"hostID":"${messageToSendHostId}",`;
-        }
+    public static replyOK(req: string, res: any): string {
         if (typeof res === 'undefined') {
-            return `{${prefix}"type":${MessageType.Reply},"id":"${req}"}`;
+            return `{"type":${MessageType.Reply},"id":"${req}"}`;
         }
-        return `{${prefix}"type":${MessageType.Reply},"id":"${req}","res":${safeStringify(res, ObjectsTransferrer.replacer)}}`;
+        return `{"type":${MessageType.Reply},"id":"${req}","res":${safeStringify(res, ObjectsTransferrer.replacer)}}`;
     }
 
-    public static replyErr(req: string, err: any, messageToSendHostId?: string): string {
-        let prefix = '';
-        if (messageToSendHostId) {
-            prefix = `"hostID":"${messageToSendHostId}",`;
-        }
+    public static replyErr(req: string, err: any): string {
         err = typeof err === 'string' ? new Error(err) : err;
         if (err instanceof Error) {
-            return `{${prefix}"type":${MessageType.ReplyErr},"id":"${req}","err":${safeStringify(transformErrorForSerialization(err))}}`;
+            return `{"type":${MessageType.ReplyErr},"id":"${req}","err":${safeStringify(transformErrorForSerialization(err))}}`;
         }
-        return `{${prefix}"type":${MessageType.ReplyErr},"id":"${req}","err":null}`;
+        return `{"type":${MessageType.ReplyErr},"id":"${req}","err":null}`;
     }
 }
 

package/src/hosted/browser/hosted-plugin-watcher.ts

@@ -21,7 +21,7 @@ import { LogPart } from '../../common/types';
 
 @injectable()
 export class HostedPluginWatcher {
-    private onPostMessage = new Emitter<string[]>();
+    private onPostMessage = new Emitter<{ pluginHostId: string, message: string }>();
     private onLogMessage = new Emitter<LogPart>();
 
     private readonly onDidDeployEmitter = new Emitter<void>();
@@ -31,8 +31,8 @@ export class HostedPluginWatcher {
         const messageEmitter = this.onPostMessage;
         const logEmitter = this.onLogMessage;
         return {
-            postMessage(message: string): Promise<void> {
-                messageEmitter.fire(JSON.parse(message));
+            postMessage(pluginHostId, message: string): Promise<void> {
+                messageEmitter.fire({ pluginHostId, message });
                 return Promise.resolve();
             },
             log(logPart: LogPart): Promise<void> {
@@ -43,7 +43,7 @@ export class HostedPluginWatcher {
         };
     }
 
-    get onPostMessageEvent(): Event<string[]> {
+    get onPostMessageEvent(): Event<{ pluginHostId: string, message: string }> {
         return this.onPostMessage.event;
     }
 

package/src/hosted/browser/hosted-plugin.ts

@@ -489,22 +489,25 @@ export class HostedPluginSupport {
     }
 
     protected initRpc(host: PluginHost, pluginId: string): RPCProtocol {
-        const rpc = host === 'frontend' ? new PluginWorker().rpc : this.createServerRpc(pluginId, host);
+        const rpc = host === 'frontend' ? new PluginWorker().rpc : this.createServerRpc(host);
         setUpPluginApi(rpc, this.container);
         this.mainPluginApiProviders.getContributions().forEach(p => p.initialize(rpc, this.container));
         return rpc;
     }
 
-    private createServerRpc(pluginID: string, hostID: string): RPCProtocol {
+    private createServerRpc(pluginHostId: string): RPCProtocol {
+        const emitter = new Emitter<string>();
+        this.watcher.onPostMessageEvent(received => {
+            if (pluginHostId === received.pluginHostId) {
+                emitter.fire(received.message);
+            }
+        });
         return new RPCProtocolImpl({
-            onMessage: this.watcher.onPostMessageEvent,
+            onMessage: emitter.event,
             send: message => {
-                const wrappedMessage: any = {};
-                wrappedMessage['pluginID'] = pluginID;
-                wrappedMessage['content'] = message;
-                this.server.onMessage(JSON.stringify(wrappedMessage));
+                this.server.onMessage(pluginHostId, message);
             }
-        }, hostID);
+        });
     }
 
     private async updateStoragePath(): Promise<void> {

package/src/hosted/browser/worker/worker-main.ts

@@ -40,10 +40,10 @@ const ctx = self as any;
 const pluginsApiImpl = new Map<string, typeof theia>();
 const pluginsModulesNames = new Map<string, Plugin>();
 
-const emitter = new Emitter();
+const emitter = new Emitter<string>();
 const rpc = new RPCProtocolImpl({
     onMessage: emitter.event,
-    send: (m: {}) => {
+    send: (m: string) => {
         ctx.postMessage(m);
     }
 });

package/src/hosted/node/hosted-plugin-process.ts

@@ -18,7 +18,7 @@ import * as cp from 'child_process';
 import { injectable, inject, named } from '@theia/core/shared/inversify';
 import { ILogger, ConnectionErrorHandler, ContributionProvider, MessageService } from '@theia/core/lib/common';
 import { createIpcEnv } from '@theia/core/lib/node/messaging/ipc-protocol';
-import { HostedPluginClient, ServerPluginRunner, PluginHostEnvironmentVariable, DeployedPlugin } from '../../common/plugin-protocol';
+import { HostedPluginClient, ServerPluginRunner, PluginHostEnvironmentVariable, DeployedPlugin, PLUGIN_HOST_BACKEND } from '../../common/plugin-protocol';
 import { MessageType } from '../../common/rpc-protocol';
 import { HostedPluginCliContribution } from './hosted-plugin-cli-contribution';
 import * as psTree from 'ps-tree';
@@ -78,14 +78,14 @@ export class HostedPluginProcess implements ServerPluginRunner {
     }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    public acceptMessage(jsonMessage: any): boolean {
-        return jsonMessage.type !== undefined && jsonMessage.id;
+    public acceptMessage(pluginHostId: string, message: string): boolean {
+        return pluginHostId === 'main';
     }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    public onMessage(jsonMessage: any): void {
+    public onMessage(pluginHostId: string, jsonMessage: string): void {
         if (this.childProcess) {
-            this.childProcess.send(JSON.stringify(jsonMessage));
+            this.childProcess.send(jsonMessage);
         }
     }
 
@@ -154,7 +154,7 @@ export class HostedPluginProcess implements ServerPluginRunner {
         });
         this.childProcess.on('message', message => {
             if (this.client) {
-                this.client.postMessage(message);
+                this.client.postMessage(PLUGIN_HOST_BACKEND, message);
             }
         });
     }

package/src/hosted/node/hosted-plugin.ts

@@ -71,18 +71,17 @@ export class HostedPluginSupport {
         }
     }
 
-    onMessage(message: string): void {
+    onMessage(pluginHostId: string, message: string): void {
         // need to perform routing
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const jsonMessage: any = JSON.parse(message);
         if (this.pluginRunners.length > 0) {
             this.pluginRunners.forEach(runner => {
-                if (runner.acceptMessage(jsonMessage)) {
-                    runner.onMessage(jsonMessage);
+                if (runner.acceptMessage(pluginHostId, message)) {
+                    runner.onMessage(pluginHostId, message);
                 }
             });
         } else {
-            this.hostedPluginProcess.onMessage(jsonMessage.content);
+            this.hostedPluginProcess.onMessage(pluginHostId, message);
         }
     }
 

package/src/hosted/node/metadata-scanner.ts

@@ -15,8 +15,7 @@
  ********************************************************************************/
 
 import { injectable, multiInject } from '@theia/core/shared/inversify';
-import { PluginPackage, PluginScanner, PluginMetadata } from '../../common/plugin-protocol';
-
+import { PluginPackage, PluginScanner, PluginMetadata, PLUGIN_HOST_BACKEND } from '../../common/plugin-protocol';
 @injectable()
 export class MetadataScanner {
     private scanners: Map<string, PluginScanner> = new Map();
@@ -32,7 +31,7 @@ export class MetadataScanner {
     getPluginMetadata(plugin: PluginPackage): PluginMetadata {
         const scanner = this.getScanner(plugin);
         return {
-            host: 'main',
+            host: PLUGIN_HOST_BACKEND,
             model: scanner.getModel(plugin),
             lifecycle: scanner.getLifecycle(plugin)
         };

package/src/hosted/node/plugin-host.ts

@@ -72,12 +72,12 @@ process.on('rejectionHandled', (promise: Promise<any>) => {
 });
 
 let terminating = false;
-const emitter = new Emitter();
+const emitter = new Emitter<string>();
 const rpc = new RPCProtocolImpl({
     onMessage: emitter.event,
-    send: (m: {}) => {
+    send: (m: string) => {
         if (process.send && !terminating) {
-            process.send(JSON.stringify(m));
+            process.send(m);
         }
     }
 });
@@ -104,7 +104,7 @@ process.on('message', async (message: string) => {
                 process.send(JSON.stringify({ type: MessageType.Terminated }));
             }
         } else {
-            emitter.fire(msg);
+            emitter.fire(message);
         }
     } catch (e) {
         console.error(e);

package/src/hosted/node/plugin-service.ts

@@ -105,8 +105,8 @@ export class HostedPluginServerImpl implements HostedPluginServer {
         return plugins;
     }
 
-    onMessage(message: string): Promise<void> {
-        this.hostedPlugin.onMessage(message);
+    onMessage(pluginHostId: string, message: string): Promise<void> {
+        this.hostedPlugin.onMessage(pluginHostId, message);
         return Promise.resolve();
     }
 

package/src/hosted/node/scanners/scanner-theia.ts

@@ -492,7 +492,8 @@ export class TheiaPluginScanner implements PluginScanner {
             when: rawKeybinding.when,
             mac: rawKeybinding.mac,
             linux: rawKeybinding.linux,
-            win: rawKeybinding.win
+            win: rawKeybinding.win,
+            args: rawKeybinding.args
         };
     }
 

package/src/main/browser/keybindings/keybindings-contribution-handler.ts

@@ -47,8 +47,8 @@ export class KeybindingsContributionPointHandler {
         if (!keybinding) {
             return undefined;
         }
-        const { command, when } = pluginKeybinding;
-        return { keybinding, command, when };
+        const { command, when, args } = pluginKeybinding;
+        return { keybinding, command, when, args };
     }
 
     protected toOSKeybinding(pluginKeybinding: PluginKeybinding): string | undefined {

package/src/main/browser/plugin-worker.ts

@@ -23,7 +23,7 @@ export class PluginWorker {
     private worker: Worker;
     public readonly rpc: RPCProtocol;
     constructor() {
-        const emitter = new Emitter();
+        const emitter = new Emitter<string>();
         this.worker = new (require('../../hosted/browser/worker/worker-main'));
         this.worker.onmessage = message => {
             emitter.fire(message.data);
@@ -32,7 +32,7 @@ export class PluginWorker {
 
         this.rpc = new RPCProtocolImpl({
             onMessage: emitter.event,
-            send: (m: {}) => {
+            send: (m: string) => {
                 this.worker.postMessage(m);
             }
         });

package/src/main/browser/tasks-main.ts

@@ -109,7 +109,7 @@ export class TasksMainImpl implements TasksMain, Disposable {
 
         const toDispose = new DisposableCollection(
             this.taskProviderRegistry.register(type, taskProvider, handle),
-            this.taskResolverRegistry.register(type, taskResolver),
+            this.taskResolverRegistry.registerTaskResolver(type, taskResolver),
             Disposable.create(() => this.taskProviders.delete(handle))
         );
         this.taskProviders.set(handle, toDispose);

package/src/plugin/plugin-context.ts

@@ -82,6 +82,7 @@ import {
     CodeLens,
     CodeActionKind,
     CodeActionTrigger,
+    CodeActionTriggerKind,
     TextDocumentSaveReason,
     CodeAction,
     TreeItem,
@@ -896,6 +897,7 @@ export function createAPIFactory(
             CodeLens,
             CodeActionKind,
             CodeActionTrigger,
+            CodeActionTriggerKind,
             TextDocumentSaveReason,
             CodeAction,
             TreeItem,