refactor plugin + worker interface

packages/controllers/src/index.ts

@@ -1,3 +1,3 @@
-export * from './workers/WorkerController';
+export * from './services/WorkerExecutionEnvironment';
 export * from './plugins/PluginController';
 export * from './resource/ExternalResourceController';

packages/controllers/src/plugins/PluginController.test.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import { ControllerMessenger } from '@metamask/controllers/dist/ControllerMessenger';
-import { WorkerController } from '../workers/WorkerController';
+import { WorkerExecutionEnvironment } from '../services/WorkerExecutionEnvironment';
 import { PluginController } from './PluginController';
 
 const workerCode = fs.readFileSync(
@@ -10,20 +10,26 @@ const workerCode = fs.readFileSync(
 
 describe('PluginController Controller', () => {
   it('can create a worker and plugin controller', async () => {
-    const workerController = new WorkerController({
+    const workerExecutionEnvironment = new WorkerExecutionEnvironment({
       setupWorkerConnection: jest.fn(),
       workerUrl: new URL(URL.createObjectURL(new Blob([workerCode]))),
     });
     const pluginController = new PluginController({
-      command: workerController.command.bind(workerController),
-      createPluginWorker: workerController.createPluginWorker.bind(
-        workerController,
+      command: workerExecutionEnvironment.command.bind(
+        workerExecutionEnvironment,
       ),
-      terminateAll: workerController.terminateAll.bind(workerController),
-      terminateWorkerOf: workerController.terminateWorkerOf.bind(
-        workerController,
+      createPluginEnvironment: workerExecutionEnvironment.createPluginEnvironment.bind(
+        workerExecutionEnvironment,
+      ),
+      terminateAll: workerExecutionEnvironment.terminateAllPlugins.bind(
+        workerExecutionEnvironment,
+      ),
+      terminatePlugin: workerExecutionEnvironment.terminatePlugin.bind(
+        workerExecutionEnvironment,
+      ),
+      startPlugin: workerExecutionEnvironment.startPlugin.bind(
+        workerExecutionEnvironment,
       ),
-      startPlugin: workerController.startPlugin.bind(workerController),
       removeAllPermissionsFor: jest.fn(),
       getPermissions: jest.fn(),
       hasPermission: jest.fn(),
@@ -42,20 +48,26 @@ describe('PluginController Controller', () => {
   });
 
   it('can add a plugin and use its JSON-RPC api', async () => {
-    const workerController = new WorkerController({
+    const workerExecutionEnvironment = new WorkerExecutionEnvironment({
       setupWorkerConnection: jest.fn(),
       workerUrl: new URL(URL.createObjectURL(new Blob([workerCode]))),
     });
     const pluginController = new PluginController({
-      command: workerController.command.bind(workerController),
-      createPluginWorker: workerController.createPluginWorker.bind(
-        workerController,
+      command: workerExecutionEnvironment.command.bind(
+        workerExecutionEnvironment,
+      ),
+      createPluginEnvironment: workerExecutionEnvironment.createPluginEnvironment.bind(
+        workerExecutionEnvironment,
+      ),
+      terminateAll: workerExecutionEnvironment.terminateAllPlugins.bind(
+        workerExecutionEnvironment,
+      ),
+      terminatePlugin: workerExecutionEnvironment.terminatePlugin.bind(
+        workerExecutionEnvironment,
       ),
-      terminateAll: workerController.terminateAll.bind(workerController),
-      terminateWorkerOf: workerController.terminateWorkerOf.bind(
-        workerController,
+      startPlugin: workerExecutionEnvironment.startPlugin.bind(
+        workerExecutionEnvironment,
       ),
-      startPlugin: workerController.startPlugin.bind(workerController),
       removeAllPermissionsFor: jest.fn(),
       getPermissions: jest.fn(),
       hasPermission: jest.fn(),

packages/controllers/src/plugins/PluginController.ts

@@ -5,9 +5,14 @@ import {
   BaseControllerV2 as BaseController,
   RestrictedControllerMessenger,
 } from '@metamask/controllers';
-import { Json, JsonRpcRequest } from 'json-rpc-engine';
-import { PluginData } from '@mm-snap/types';
-import { PluginWorkerMetadata } from '../workers/WorkerController';
+import { Json } from 'json-rpc-engine';
+import {
+  Command,
+  CreatePluginEnvironment,
+  StartPlugin,
+  TerminateAll,
+  TerminatePlugin,
+} from '../services/PluginExecutionEnvironmentService';
 import { INLINE_PLUGINS } from './inlinePlugins';
 
 export const PLUGIN_PREFIX = 'wallet_plugin_';
@@ -59,18 +64,6 @@ type HasPermissionFunction = (
   permissionName: string,
 ) => boolean;
 type GetPermissionsFunction = (domain: string) => IOcapLdCapability[];
-type TerminateWorkerOf = (pluginName: string) => void;
-type Command = (
-  workerId: string,
-  message: JsonRpcRequest<unknown>,
-) => Promise<unknown>;
-type TerminateAll = () => void;
-type CreatePluginWorker = (metadate: PluginWorkerMetadata) => Promise<string>;
-type StartPlugin = (
-  workerId: string,
-  pluginData: PluginData,
-) => Promise<unknown>;
-
 type PluginId = string;
 type StoredPlugins = Record<PluginId, Plugin>;
 
@@ -90,10 +83,10 @@ interface PluginControllerArgs {
   requestPermissions: RequestPermissionsFunction;
   getPermissions: GetPermissionsFunction;
   hasPermission: HasPermissionFunction;
-  terminateWorkerOf: TerminateWorkerOf;
+  terminatePlugin: TerminatePlugin;
   command: Command;
   terminateAll: TerminateAll;
-  createPluginWorker: CreatePluginWorker;
+  createPluginEnvironment: CreatePluginEnvironment;
   startPlugin: StartPlugin;
 }
 
@@ -149,13 +142,13 @@ export class PluginController extends BaseController<
 
   private _hasPermission: HasPermissionFunction;
 
-  private _terminateWorkerOf: TerminateWorkerOf;
+  private _terminatePlugin: TerminatePlugin;
 
   private _command: Command;
 
   private _terminateAll: TerminateAll;
 
-  private _createPluginWorker: CreatePluginWorker;
+  private _createPluginEnvironment: CreatePluginEnvironment;
 
   private _startPlugin: StartPlugin;
 
@@ -166,10 +159,10 @@ export class PluginController extends BaseController<
     closeAllConnections,
     requestPermissions,
     getPermissions,
-    terminateWorkerOf,
+    terminatePlugin,
     terminateAll,
     hasPermission,
-    createPluginWorker,
+    createPluginEnvironment,
     startPlugin,
     command,
     messenger,
@@ -207,9 +200,9 @@ export class PluginController extends BaseController<
     this._getPermissions = getPermissions;
     this._hasPermission = hasPermission;
 
-    this._terminateWorkerOf = terminateWorkerOf;
+    this._terminatePlugin = terminatePlugin;
     this._terminateAll = terminateAll;
-    this._createPluginWorker = createPluginWorker;
+    this._createPluginEnvironment = createPluginEnvironment;
     this._startPlugin = startPlugin;
     this._command = command;
 
@@ -236,7 +229,7 @@ export class PluginController extends BaseController<
         console.log(`Starting: ${pluginName}`);
 
         try {
-          await this._startPluginInWorker(pluginName, sourceCode);
+          await this._startPluginInExecutionEnvironment(pluginName, sourceCode);
         } catch (err) {
           console.warn(`Failed to start "${pluginName}", deleting it.`, err);
           // Clean up failed plugins:
@@ -262,7 +255,10 @@ export class PluginController extends BaseController<
     }
 
     try {
-      await this._startPluginInWorker(pluginName, plugin.sourceCode);
+      await this._startPluginInExecutionEnvironment(
+        pluginName,
+        plugin.sourceCode,
+      );
     } catch (err) {
       console.error(`Failed to start "${pluginName}".`, err);
     }
@@ -298,7 +294,7 @@ export class PluginController extends BaseController<
   private _stopPlugin(pluginName: string, setNotRunning = true): void {
     this._removePluginHooks(pluginName);
     this._closeAllConnections(pluginName);
-    this._terminateWorkerOf(pluginName);
+    this._terminatePlugin(pluginName);
     if (setNotRunning) {
       this._setPluginToNotRunning(pluginName);
     }
@@ -525,7 +521,7 @@ export class PluginController extends BaseController<
 
       await this.authorize(pluginName);
 
-      await this._startPluginInWorker(pluginName, sourceCode);
+      await this._startPluginInExecutionEnvironment(pluginName, sourceCode);
 
       return this.getSerializable(pluginName) as SerializablePlugin;
     } catch (err) {
@@ -691,7 +687,10 @@ export class PluginController extends BaseController<
    * Test method.
    */
   runInlinePlugin(inlinePluginName: keyof typeof INLINE_PLUGINS = 'IDLE') {
-    this._startPluginInWorker('inlinePlugin', INLINE_PLUGINS[inlinePluginName]);
+    this._startPluginInExecutionEnvironment(
+      'inlinePlugin',
+      INLINE_PLUGINS[inlinePluginName],
+    );
     this.update((state: any) => {
       state.inlinePluginIsRunning = true;
     });
@@ -707,12 +706,15 @@ export class PluginController extends BaseController<
     this.removePlugin('inlinePlugin');
   }
 
-  private async _startPluginInWorker(pluginName: string, sourceCode: string) {
-    const workerId = await this._createPluginWorker({
+  private async _startPluginInExecutionEnvironment(
+    pluginName: string,
+    sourceCode: string,
+  ) {
+    await this._createPluginEnvironment({
       hostname: pluginName,
     });
-    this._createPluginHooks(pluginName, workerId);
-    await this._startPlugin(workerId, {
+    this._createPluginHooks(pluginName);
+    await this._startPlugin({
       pluginName,
       sourceCode,
     });
@@ -728,12 +730,12 @@ export class PluginController extends BaseController<
     return this._pluginRpcHooks.get(pluginName);
   }
 
-  private _createPluginHooks(pluginName: string, workerId: string) {
+  private _createPluginHooks(pluginName: string) {
     const rpcHook = async (
       origin: string,
       request: Record<string, unknown>,
     ) => {
-      return await this._command(workerId, {
+      return await this._command(pluginName, {
         id: nanoid(),
         jsonrpc: '2.0',
         method: 'pluginRpc',

packages/controllers/src/services/PluginExecutionEnvironmentService.ts

@@ -0,0 +1,25 @@
+import { JsonRpcRequest } from 'json-rpc-engine';
+import { PluginData } from '@mm-snap/types';
+
+export interface PluginMetadata {
+  hostname: string;
+}
+
+export type TerminatePlugin = (pluginName: string) => void;
+export type Command = (
+  pluginName: string,
+  message: JsonRpcRequest<unknown>,
+) => Promise<unknown>;
+export type TerminateAll = () => void;
+export type CreatePluginEnvironment = (
+  metadata: PluginMetadata,
+) => Promise<string>;
+export type StartPlugin = (pluginData: PluginData) => Promise<unknown>;
+
+export interface PluginExecutionEnvironmentService {
+  terminatePlugin: TerminatePlugin;
+  terminateAllPlugins: TerminateAll;
+  createPluginEnvironment: CreatePluginEnvironment;
+  command: Command;
+  startPlugin: StartPlugin;
+}

packages/controllers/src/workers/WorkerController.test.ts → packages/controllers/src/services/WorkerExecutionEnvironment.test.ts

@@ -1,5 +1,5 @@
 import fs from 'fs';
-import { WorkerController } from './WorkerController';
+import { WorkerExecutionEnvironment } from './WorkerExecutionEnvironment';
 
 const workerCode = fs.readFileSync(
   require.resolve('@mm-snap/workers/dist/PluginWorker.js'),
@@ -8,7 +8,7 @@ const workerCode = fs.readFileSync(
 
 describe('Worker Controller', () => {
   it('can boot', async () => {
-    const workerController = new WorkerController({
+    const workerController = new WorkerExecutionEnvironment({
       setupWorkerConnection: () => {
         // do nothing
       },
@@ -17,30 +17,30 @@ describe('Worker Controller', () => {
     expect(workerController).toBeDefined();
   });
   it('can create a plugin worker and get the workerId back', async () => {
-    const workerController = new WorkerController({
+    const workerController = new WorkerExecutionEnvironment({
       setupWorkerConnection: () => {
         // do nothing
       },
       workerUrl: new URL(URL.createObjectURL(new Blob([workerCode]))),
     });
     expect(
-      typeof (await workerController.createPluginWorker({
+      typeof (await workerController.createPluginEnvironment({
         hostname: 'foobarbaz',
       })),
     ).toEqual('string');
   });
   it('can create a plugin worker and start the plugin', async () => {
-    const workerController = new WorkerController({
+    const workerController = new WorkerExecutionEnvironment({
       setupWorkerConnection: () => {
         // do nothing
       },
       workerUrl: new URL(URL.createObjectURL(new Blob([workerCode]))),
     });
     const pluginName = 'foo.bar.baz';
-    const workerId = await workerController.createPluginWorker({
+    await workerController.createPluginEnvironment({
       hostname: pluginName,
     });
-    const response = await workerController.startPlugin(workerId, {
+    const response = await workerController.startPlugin({
       pluginName,
       sourceCode: `
         console.log('foo');