Websockets for plugin runtime communication (#156)

packages/plugin-runtime/src/index.worker.ts

@@ -1,27 +1,25 @@
 import type {
   BootRequest,
+  Context,
   FindHttpResponsesResponse,
   GetHttpRequestByIdResponse,
   HttpRequestAction,
-  ImportResponse,
   InternalEvent,
   InternalEventPayload,
+  PluginDefinition,
   PromptTextResponse,
   RenderHttpRequestResponse,
   SendHttpRequestResponse,
   TemplateFunction,
   TemplateRenderResponse,
   WindowContext,
-} from '@yaakapp-internal/plugins';
-import type { Context } from '@yaakapp/api';
-import type { HttpRequestActionPlugin } from '@yaakapp/api/lib/plugins/HttpRequestActionPlugin';
-import type { TemplateFunctionPlugin } from '@yaakapp/api/lib/plugins/TemplateFunctionPlugin';
-import interceptStdout from 'intercept-stdout';
+} from '@yaakapp/api';
 import * as console from 'node:console';
 import type { Stats } from 'node:fs';
 import { readFileSync, statSync, watch } from 'node:fs';
 import path from 'node:path';
 import * as util from 'node:util';
+import { interceptStdout } from './interceptStdout';
 import { parentPort, workerData } from 'node:worker_threads';
 
 export interface PluginWorkerData {
@@ -29,40 +27,32 @@ export interface PluginWorkerData {
   pluginRefId: string;
 }
 
-async function initialize() {
+function initialize(workerData: PluginWorkerData) {
   const {
     bootRequest: { dir: pluginDir, watch: enableWatch },
     pluginRefId,
   }: PluginWorkerData = workerData;
+
   const pathPkg = path.join(pluginDir, 'package.json');
-
   const pathMod = path.posix.join(pluginDir, 'build', 'index.js');
 
-  async function importModule() {
-    const id = require.resolve(pathMod);
-    delete require.cache[id];
-    return require(id);
-  }
-
   const pkg = JSON.parse(readFileSync(pathPkg, 'utf8'));
 
   prefixStdout(`[plugin][${pkg.name}] %s`);
 
-  let mod = await importModule();
-
-  const capabilities: string[] = [];
-  if (typeof mod.pluginHookExport === 'function') capabilities.push('export');
-  if (typeof mod.pluginHookImport === 'function') capabilities.push('import');
-  if (typeof mod.pluginHookResponseFilter === 'function') capabilities.push('filter');
-
-  console.log('Plugin initialized', pkg.name, { capabilities, enableWatch });
-
   function buildEventToSend(
     windowContext: WindowContext,
     payload: InternalEventPayload,
     replyId: string | null = null,
   ): InternalEvent {
-    return { pluginRefId, id: genId(), replyId, payload, windowContext };
+    return {
+      pluginRefId,
+      pluginName: path.basename(pluginDir),
+      id: genId(),
+      replyId,
+      payload,
+      windowContext,
+    };
   }
 
   function sendEmpty(windowContext: WindowContext, replyId: string | null = null): string {
@@ -86,7 +76,7 @@ async function initialize() {
     parentPort!.postMessage(event);
   }
 
-  async function sendAndWaitForReply<T extends Omit<InternalEventPayload, 'type'>>(
+  function sendAndWaitForReply<T extends Omit<InternalEventPayload, 'type'>>(
     windowContext: WindowContext,
     payload: InternalEventPayload,
   ): Promise<T> {
@@ -94,7 +84,7 @@ async function initialize() {
     const eventToSend = buildEventToSend(windowContext, payload, null);
 
     // 2. Spawn listener in background
-    const promise = new Promise<InternalEventPayload>(async (resolve) => {
+    const promise = new Promise<InternalEventPayload>((resolve) => {
       const cb = (event: InternalEvent) => {
         if (event.replyId === eventToSend.id) {
           parentPort!.off('message', cb); // Unlisten, now that we're done
@@ -111,31 +101,33 @@ async function initialize() {
     return promise as unknown as Promise<T>;
   }
 
-  async function reloadModule() {
-    mod = await importModule();
-  }
-
-  // Reload plugin if JS or package.json changes
+  // Reload plugin if the JS or package.json changes
   const windowContextNone: WindowContext = { type: 'none' };
-  const cb = async () => {
-    await reloadModule();
+  const fileChangeCallback = async () => {
+    await importModule();
     return sendPayload(windowContextNone, { type: 'reload_response' }, null);
   };
 
   if (enableWatch) {
-    watchFile(pathMod, cb);
-    watchFile(pathPkg, cb);
+    watchFile(pathMod, fileChangeCallback);
+    watchFile(pathPkg, fileChangeCallback);
   }
 
   const newCtx = (event: InternalEvent): Context => ({
     clipboard: {
       async copyText(text) {
-        await sendAndWaitForReply(event.windowContext, { type: 'copy_text_request', text });
+        await sendAndWaitForReply(event.windowContext, {
+          type: 'copy_text_request',
+          text,
+        });
       },
     },
     toast: {
       async show(args) {
-        await sendAndWaitForReply(event.windowContext, { type: 'show_toast_request', ...args });
+        await sendAndWaitForReply(event.windowContext, {
+          type: 'show_toast_request',
+          ...args,
+        });
       },
     },
     prompt: {
@@ -149,7 +141,10 @@ async function initialize() {
     },
     httpResponse: {
       async find(args) {
-        const payload = { type: 'find_http_responses_request', ...args } as const;
+        const payload = {
+          type: 'find_http_responses_request',
+          ...args,
+        } as const;
         const { httpResponses } = await sendAndWaitForReply<FindHttpResponsesResponse>(
           event.windowContext,
           payload,
@@ -159,7 +154,10 @@ async function initialize() {
     },
     httpRequest: {
       async getById(args) {
-        const payload = { type: 'get_http_request_by_id_request', ...args } as const;
+        const payload = {
+          type: 'get_http_request_by_id_request',
+          ...args,
+        } as const;
         const { httpRequest } = await sendAndWaitForReply<GetHttpRequestByIdResponse>(
           event.windowContext,
           payload,
@@ -167,7 +165,10 @@ async function initialize() {
         return httpRequest;
       },
       async send(args) {
-        const payload = { type: 'send_http_request_request', ...args } as const;
+        const payload = {
+          type: 'send_http_request_request',
+          ...args,
+        } as const;
         const { httpResponse } = await sendAndWaitForReply<SendHttpRequestResponse>(
           event.windowContext,
           payload,
@@ -175,7 +176,10 @@ async function initialize() {
         return httpResponse;
       },
       async render(args) {
-        const payload = { type: 'render_http_request_request', ...args } as const;
+        const payload = {
+          type: 'render_http_request_request',
+          ...args,
+        } as const;
         const { httpRequest } = await sendAndWaitForReply<RenderHttpRequestResponse>(
           event.windowContext,
           payload,
@@ -187,7 +191,7 @@ async function initialize() {
       /**
        * Invoke Yaak's template engine to render a value. If the value is a nested type
        * (eg. object), it will be recursively rendered.
-       * */
+       */
       async render(args) {
         const payload = { type: 'template_render_request', ...args } as const;
         const result = await sendAndWaitForReply<TemplateRenderResponse>(
@@ -199,17 +203,35 @@ async function initialize() {
     },
   });
 
+  let plug: PluginDefinition | null = null;
+
+  function importModule() {
+    const id = require.resolve(pathMod);
+    delete require.cache[id];
+    plug = require(id).plugin;
+  }
+  importModule();
+
+  if (pkg.name?.includes('yaak-faker')) {
+    sendPayload(
+      { type: 'none' },
+      { type: 'error_response', error: 'Failed to initialize Faker plugin' },
+      null,
+    );
+    return;
+  }
+
   // Message comes into the plugin to be processed
   parentPort!.on('message', async (event: InternalEvent) => {
-    const { windowContext, payload, id: replyId } = event;
     const ctx = newCtx(event);
+    const { windowContext, payload, id: replyId } = event;
     try {
       if (payload.type === 'boot_request') {
+        // console.log('Plugin initialized', pkg.name, { capabilities, enableWatch });
         const payload: InternalEventPayload = {
           type: 'boot_response',
           name: pkg.name,
           version: pkg.version,
-          capabilities,
         };
         sendPayload(windowContext, payload, replyId);
         return;
@@ -223,12 +245,15 @@ async function initialize() {
         return;
       }
 
-      if (payload.type === 'import_request' && typeof mod.pluginHookImport === 'function') {
-        const reply: ImportResponse | null = await mod.pluginHookImport(ctx, payload.content);
+      if (payload.type === 'import_request' && typeof plug?.importer?.onImport === 'function') {
+        const reply = await plug.importer.onImport(ctx, {
+          text: payload.content,
+        });
         if (reply != null) {
           const replyPayload: InternalEventPayload = {
             type: 'import_response',
-            resources: reply?.resources,
+            // deno-lint-ignore no-explicit-any
+            resources: reply.resources as any,
           };
           sendPayload(windowContext, replyPayload, replyId);
           return;
@@ -237,27 +262,15 @@ async function initialize() {
         }
       }
 
-      if (
-        payload.type === 'export_http_request_request' &&
-        typeof mod.pluginHookExport === 'function'
-      ) {
-        const reply: string = await mod.pluginHookExport(ctx, payload.httpRequest);
-        const replyPayload: InternalEventPayload = {
-          type: 'export_http_request_response',
-          content: reply,
-        };
-        sendPayload(windowContext, replyPayload, replyId);
-        return;
-      }
-
-      if (payload.type === 'filter_request' && typeof mod.pluginHookResponseFilter === 'function') {
-        const reply: string = await mod.pluginHookResponseFilter(ctx, {
+      if (payload.type === 'filter_request' && typeof plug?.filter?.onFilter === 'function') {
+        const reply = await plug.filter.onFilter(ctx, {
           filter: payload.filter,
-          body: payload.content,
+          payload: payload.content,
+          mimeType: payload.type,
         });
         const replyPayload: InternalEventPayload = {
           type: 'filter_response',
-          content: reply,
+          content: reply.filtered,
         };
         sendPayload(windowContext, replyPayload, replyId);
         return;
@@ -265,15 +278,13 @@ async function initialize() {
 
       if (
         payload.type === 'get_http_request_actions_request' &&
-        Array.isArray(mod.plugin?.httpRequestActions)
+        Array.isArray(plug?.httpRequestActions)
       ) {
-        const reply: HttpRequestAction[] = mod.plugin.httpRequestActions.map(
-          (a: HttpRequestActionPlugin) => ({
-            ...a,
-            // Add everything except onSelect
-            onSelect: undefined,
-          }),
-        );
+        const reply: HttpRequestAction[] = plug.httpRequestActions.map((a) => ({
+          ...a,
+          // Add everything except onSelect
+          onSelect: undefined,
+        }));
         const replyPayload: InternalEventPayload = {
           type: 'get_http_request_actions_response',
           pluginRefId,
@@ -285,15 +296,13 @@ async function initialize() {
 
       if (
         payload.type === 'get_template_functions_request' &&
-        Array.isArray(mod.plugin?.templateFunctions)
+        Array.isArray(plug?.templateFunctions)
       ) {
-        const reply: TemplateFunction[] = mod.plugin.templateFunctions.map(
-          (a: TemplateFunctionPlugin) => ({
-            ...a,
-            // Add everything except render
-            onRender: undefined,
-          }),
-        );
+        const reply: TemplateFunction[] = plug.templateFunctions.map((a) => ({
+          ...a,
+          // Add everything except render
+          onRender: undefined,
+        }));
         const replyPayload: InternalEventPayload = {
           type: 'get_template_functions_response',
           pluginRefId,
@@ -303,21 +312,19 @@ async function initialize() {
         return;
       }
 
-      if (payload.type === 'get_http_authentication_request' && mod.plugin?.authentication) {
-        const auth = mod.plugin.authentication;
+      if (payload.type === 'get_http_authentication_request' && plug?.authentication) {
+        const { onApply: _, ...auth } = plug.authentication;
         const replyPayload: InternalEventPayload = {
           ...auth,
           type: 'get_http_authentication_response',
-
-          // Remove unneeded attrs
-          onApply: undefined,
         };
+
         sendPayload(windowContext, replyPayload, replyId);
         return;
       }
 
-      if (payload.type === 'call_http_authentication_request' && mod.plugin?.authentication) {
-        const auth = mod.plugin.authentication;
+      if (payload.type === 'call_http_authentication_request' && plug?.authentication) {
+        const auth = plug.authentication;
         if (typeof auth?.onApply === 'function') {
           const result = await auth.onApply(ctx, payload);
           sendPayload(
@@ -334,11 +341,9 @@ async function initialize() {
 
       if (
         payload.type === 'call_http_request_action_request' &&
-        Array.isArray(mod.plugin?.httpRequestActions)
+        Array.isArray(plug?.httpRequestActions)
       ) {
-        const action = mod.plugin.httpRequestActions.find(
-          (a: HttpRequestActionPlugin) => a.key === payload.key,
-        );
+        const action = plug.httpRequestActions.find((a) => a.key === payload.key);
         if (typeof action?.onSelect === 'function') {
           await action.onSelect(ctx, payload.args);
           sendEmpty(windowContext, replyId);
@@ -348,11 +353,9 @@ async function initialize() {
 
       if (
         payload.type === 'call_template_function_request' &&
-        Array.isArray(mod.plugin?.templateFunctions)
+        Array.isArray(plug?.templateFunctions)
       ) {
-        const action = mod.plugin.templateFunctions.find(
-          (a: TemplateFunctionPlugin) => a.name === payload.name,
-        );
+        const action = plug.templateFunctions.find((a) => a.name === payload.name);
         if (typeof action?.onRender === 'function') {
           const result = await action.onRender(ctx, payload.args);
           sendPayload(
@@ -368,10 +371,18 @@ async function initialize() {
       }
 
       if (payload.type === 'reload_request') {
-        await reloadModule();
+        await importModule();
       }
     } catch (err) {
       console.log('Plugin call threw exception', payload.type, err);
+      sendPayload(
+        windowContext,
+        {
+          type: 'error_response',
+          error: `${err}`,
+        },
+        replyId,
+      );
       // TODO: Return errors to server
     }
 
@@ -380,9 +391,7 @@ async function initialize() {
   });
 }
 
-initialize().catch((err) => {
-  console.log('failed to boot plugin', err);
-});
+initialize(workerData);
 
 function genId(len = 5): string {
   const alphabet = '01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
@@ -397,7 +406,7 @@ function prefixStdout(s: string) {
   if (!s.includes('%s')) {
     throw new Error('Console prefix must contain a "%s" replacer');
   }
-  interceptStdout((text) => {
+  interceptStdout((text: string) => {
     const lines = text.split(/\n/);
     let newText = '';
     for (let i = 0; i < lines.length; i++) {
@@ -413,11 +422,11 @@ const watchedFiles: Record<string, Stats> = {};
 /**
  * Watch a file and trigger callback on change.
  *
- * We also track the stat for each file because fs.watch will
+ * We also track the stat for each file because fs.watch() will
  * trigger a "change" event when the access date changes
  */
 function watchFile(filepath: string, cb: (filepath: string) => void) {
-  watch(filepath, (_event, _name) => {
+  watch(filepath, () => {
     const stat = statSync(filepath);
     if (stat.mtimeMs !== watchedFiles[filepath]?.mtimeMs) {
       cb(filepath);