Plugin runtime v2 (#62)

plugin-runtime/src/index.worker.ts

@@ -1,11 +1,13 @@
+import { ImportResponse, InternalEvent, InternalEventPayload } from '@yaakapp/api';
+import interceptStdout from 'intercept-stdout';
+import * as console from 'node:console';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
+import * as util from 'node:util';
 import { parentPort, workerData } from 'node:worker_threads';
-import { ParentToWorkerEvent } from './PluginHandle';
-import { PluginInfo } from './plugins';
 
 new Promise<void>(async (resolve, reject) => {
-  const { pluginDir } = workerData;
+  const { pluginDir /*, pluginRefId*/ } = workerData;
   const pathMod = path.join(pluginDir, 'build/index.js');
   const pathPkg = path.join(pluginDir, 'package.json');
 
@@ -18,59 +20,112 @@ new Promise<void>(async (resolve, reject) => {
     return;
   }
 
-  const mod = (await import(`file://${pathMod}`)).default ?? {};
+  prefixStdout(`[plugin][${pkg.name}] %s`);
 
-  const info: PluginInfo = {
-    capabilities: [],
-    name: pkg['name'] ?? 'n/a',
-    dir: pluginDir,
-  };
+  const mod = (await import(pathMod)).default ?? {};
 
-  if (typeof mod['pluginHookImport'] === 'function') {
-    info.capabilities.push('import');
-  }
+  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');
 
-  if (typeof mod['pluginHookExport'] === 'function') {
-    info.capabilities.push('export');
-  }
+  console.log('Plugin initialized', pkg.name, capabilities, Object.keys(mod));
 
-  if (typeof mod['pluginHookResponseFilter'] === 'function') {
-    info.capabilities.push('filter');
-  }
+  // Message comes into the plugin to be processed
+  parentPort!.on('message', async ({ payload, pluginRefId, id: replyId }: InternalEvent) => {
+    console.log(`Received ${payload.type}`);
 
-  console.log('Loaded plugin', info.name, info.capabilities, info.dir);
-
-  function reply<T>(originalMsg: ParentToWorkerEvent, payload: T) {
-    parentPort!.postMessage({ payload, callbackId: originalMsg.callbackId });
-  }
-
-  function replyErr(originalMsg: ParentToWorkerEvent, error: unknown) {
-    parentPort!.postMessage({
-      error: String(error),
-      callbackId: originalMsg.callbackId,
-    });
-  }
-
-  parentPort!.on('message', async (msg: ParentToWorkerEvent) => {
     try {
-      const ctx = { todo: 'implement me' };
-      if (msg.name === 'run-import') {
-        reply(msg, await mod.pluginHookImport(ctx, msg.payload));
-      } else if (msg.name === 'run-filter') {
-        reply(msg, await mod.pluginHookResponseFilter(ctx, msg.payload));
-      } else if (msg.name === 'run-export') {
-        reply(msg, await mod.pluginHookExport(ctx, msg.payload));
-      } else if (msg.name === 'info') {
-        reply(msg, info);
-      } else {
-        console.log('Unknown message', msg);
+      if (payload.type === 'boot_request') {
+        const payload: InternalEventPayload = {
+          type: 'boot_response',
+          name: pkg.name,
+          version: pkg.version,
+          capabilities,
+        };
+        sendToServer({ id: genId(), pluginRefId, replyId, payload });
+        return;
       }
-    } catch (err: unknown) {
-      replyErr(msg, err);
+
+      if (payload.type === 'import_request' && typeof mod.pluginHookImport === 'function') {
+        const reply: ImportResponse | null = await mod.pluginHookImport({}, payload.content);
+        if (reply != null) {
+          const replyPayload: InternalEventPayload = {
+            type: 'import_response',
+            resources: reply?.resources,
+          };
+          sendToServer({ id: genId(), pluginRefId, replyId, payload: replyPayload });
+          return;
+        } else {
+          // Continue, to send back an empty reply
+        }
+      }
+
+      if (
+        payload.type === 'export_http_request_request' &&
+        typeof mod.pluginHookExport === 'function'
+      ) {
+        const reply: string = await mod.pluginHookExport({}, payload.httpRequest);
+        const replyPayload: InternalEventPayload = {
+          type: 'export_http_request_response',
+          content: reply,
+        };
+        sendToServer({ id: genId(), pluginRefId, replyId, payload: replyPayload });
+        return;
+      }
+
+      if (payload.type === 'filter_request' && typeof mod.pluginHookResponseFilter === 'function') {
+        const reply: string = await mod.pluginHookResponseFilter(
+          {},
+          { filter: payload.filter, body: payload.content },
+        );
+        const replyPayload: InternalEventPayload = {
+          type: 'filter_response',
+          items: JSON.parse(reply),
+        };
+        sendToServer({ id: genId(), pluginRefId, replyId, payload: replyPayload });
+        return;
+      }
+    } catch (err) {
+      console.log('Plugin call threw exception', payload.type, err);
+      // TODO: Return errors to server
     }
+
+    // No matches, so send back an empty response so the caller doesn't block forever
+    const id = genId();
+    console.log('Sending nothing back to', id, { replyId });
+    sendToServer({ id, pluginRefId, replyId, payload: { type: 'empty_response' } });
   });
 
   resolve();
 }).catch((err) => {
   console.log('failed to boot plugin', err);
 });
+
+function sendToServer(e: InternalEvent) {
+  parentPort!.postMessage(e);
+}
+
+function genId(len = 5): string {
+  const alphabet = '01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  let id = '';
+  for (let i = 0; i < len; i++) {
+    id += alphabet[Math.floor(Math.random() * alphabet.length)];
+  }
+  return id;
+}
+
+function prefixStdout(s: string) {
+  if (!s.includes('%s')) {
+    throw new Error('Console prefix must contain a "%s" replacer');
+  }
+  interceptStdout((text) => {
+    const lines = text.split(/\n/);
+    let newText = '';
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i] == '') continue;
+      newText += util.format(s, lines[i]) + '\n';
+    }
+    return newText.trimEnd();
+  });
+}