@camera.ui/server 0.0.48 → 0.0.50-internal.0

package/src/plugins/runtime/base.ts

@@ -0,0 +1,282 @@
+import { Logger } from '@camera.ui/common';
+import { pathExists } from 'fs-extra';
+import { EventEmitter } from 'node:events';
+import { createWriteStream, ftruncate, read, rmSync } from 'node:fs';
+import { open, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { container } from 'tsyringe';
+
+import { API_EVENT } from '../../api.js';
+
+import type { ChildProcess } from 'node:child_process';
+import type { WriteStream } from 'node:fs';
+import type { CameraUiAPI } from '../../api.js';
+import type { ProcInfo } from '../../api/database/checks.js';
+import type { SocketService } from '../../api/websocket/index.js';
+import type { ProxyServer } from '../../rpc/index.js';
+import type { ConfigService } from '../../services/config/index.js';
+import type { LoggerService } from '../../services/logger/index.js';
+import type { PluginManager } from '../index.js';
+import type { Plugin } from '../plugin.js';
+
+const truncatePromise = promisify(ftruncate);
+const readPromise = promisify(read);
+
+export declare interface BasePluginRuntime {
+  on(event: 'exit', listener: () => void): this;
+  once(event: 'exit', listener: () => void): this;
+  off(event: 'exit', listener: () => void): this;
+  emit(event: 'exit'): boolean;
+  removeListener(event: 'exit', listener: () => void): this;
+}
+
+export abstract class BasePluginRuntime extends EventEmitter {
+  public readonly logger: Logger;
+
+  protected api: CameraUiAPI;
+  protected configService: ConfigService;
+  protected socketService: SocketService;
+  protected pluginManager: PluginManager;
+  protected proxyServer: ProxyServer;
+
+  protected worker?: ChildProcess;
+  protected processInfo?: ProcInfo;
+
+  private loggerService: LoggerService;
+  private processLogger: Logger;
+
+  private logStream?: WriteStream;
+  private truncateInterval?: NodeJS.Timeout;
+  private truncateIntervalMs: number = 1000 * 60 * 60 * 2;
+  private logBuffer = '';
+
+  constructor(protected plugin: Plugin) {
+    super();
+
+    this.api = container.resolve<CameraUiAPI>('api');
+    this.loggerService = container.resolve<LoggerService>('logger');
+    this.configService = container.resolve<ConfigService>('configService');
+    this.socketService = container.resolve<SocketService>('socketService');
+    this.pluginManager = container.resolve<PluginManager>('pluginManager');
+    this.proxyServer = container.resolve<ProxyServer>('proxy');
+
+    this.logger = this.loggerService.createLogger({ prefix: plugin.displayName, logStream: this.logStream });
+    this.processLogger = this.loggerService.createLogger({
+      ...this.configService.loggerOptions,
+      disablePrefix: true,
+      disableTimestamps: true,
+      prefix: undefined,
+      suffix: undefined,
+    });
+
+    this.logStream = createWriteStream(this.plugin.logPath, { flags: 'a' });
+    this.truncateInterval = setInterval(() => this.truncateLog(), this.truncateIntervalMs);
+    this.truncateLog();
+
+    this.api.setMaxListeners(this.api.getMaxListeners() + 1);
+    this.api.once(API_EVENT.SHUTDOWN, () => {
+      this.closeLogStream();
+    });
+  }
+
+  public abstract start(): Promise<void>;
+
+  public stop(): Promise<void> {
+    return new Promise<void>((resolve) => {
+      if (!this.worker || this.worker.killed) {
+        resolve();
+        return;
+      }
+
+      const killTimeout = setTimeout(() => {
+        this.logger.warn(`Plugin ${this.plugin.displayName} did not terminate gracefully. Forcing closure.`);
+        this.worker?.kill('SIGKILL');
+        resolve();
+      }, 3000);
+
+      this.worker.once('close', (code, signal) => {
+        clearTimeout(killTimeout);
+        this.logger.log(`Plugin ${this.plugin.displayName} closed. Code: ${code}, Signal: ${signal}`);
+        this.worker = undefined;
+        resolve();
+      });
+
+      this.worker.kill('SIGTERM');
+    });
+  }
+
+  public kill(): void {
+    this.worker?.kill('SIGKILL');
+  }
+
+  public getPID(): number {
+    return this.worker?.pid ?? 0;
+  }
+
+  public isRunning(): boolean {
+    return !!this.worker && !this.worker?.killed;
+  }
+
+  public writeLog(...args: any[]): void {
+    this.safeWriteLog(args.join(' ').replace(/\r?\n*$/, '\n'));
+  }
+
+  public writeHeader(): void {
+    const date = new Date().toLocaleString('en-US');
+    const pluginInfo = `${this.plugin.pluginName}@${this.plugin.info.installedVersion}`;
+    const content = `${date}: ${pluginInfo}`;
+    const lineLength = content.length + 3;
+    const line = '-'.repeat(lineLength);
+
+    this.safeWriteLog(`\n${line}\n`);
+    this.safeWriteLog(content.padEnd(lineLength));
+    this.safeWriteLog(`\n${line}\n\n`);
+  }
+
+  public cleanup(): void {
+    this.removeLogStream();
+    this.removeAllListeners();
+  }
+
+  protected onSpawn(pid: number, command: string, args: string[], titles: string[], resolve: (value: void | PromiseLike<void>) => void): void {
+    this.logger.log(`Initializing process with PID: ${pid}`);
+
+    this.processInfo = this.configService.addProcess({
+      pid,
+      command,
+      args,
+      titles,
+      startTime: Date.now(),
+    });
+
+    resolve();
+  }
+
+  protected onError(reject: (reason?: any) => void, error: Error): void {
+    this.logger.error(`The plugin process for "${this.plugin.pluginName}" failed to start/stop!`, error);
+    reject(error);
+  }
+
+  protected onExit(): void {
+    this.logger.log(`Plugin ${this.plugin.displayName} exited`);
+    const cameras = this.api.getCameras();
+    cameras.forEach((camera) => camera.removePluginCapabilities(this.plugin.id));
+    this.configService.removeProcessByPID(this.processInfo?.pid);
+    this.worker = undefined;
+    this.processInfo = undefined;
+    this.emit('exit');
+  }
+
+  protected onData(data: Buffer): void {
+    const rawData = data.toString();
+    this.logBuffer += rawData;
+
+    let endIndex: number;
+    while ((endIndex = this.logBuffer.indexOf(Logger.LOGGER_END)) !== -1) {
+      const logEntry = this.logBuffer.slice(0, endIndex);
+      this.processLogEntry(logEntry, true);
+      this.logBuffer = this.logBuffer.slice(endIndex + Logger.LOGGER_END.length);
+    }
+
+    const remainingLines = this.logBuffer.split('\n');
+    this.logBuffer = remainingLines.pop() ?? '';
+    remainingLines.forEach((line) => this.processLogEntry(line, false));
+  }
+
+  protected getEnv(): Record<string, string> {
+    return {
+      WORKER_NAME: this.plugin.displayName,
+      PLUGIN_ID: this.plugin.id,
+      PLUGIN_NAME: this.plugin.pluginName,
+      FORCE_COLOR: '1',
+      PROXY_USER: this.proxyServer.auth.server.user,
+      PROXY_PASSWORD: this.proxyServer.auth.server.password,
+      PROXY_ENDPOINTS: this.proxyServer.server.endpoints.join(','),
+      PROXY_CERT: this.configService.ssl.cert.toString('utf-8'),
+      PROXY_KEY: this.configService.ssl.key.toString('utf-8'),
+      PROXY_CA: this.configService.ssl.ca.toString('utf-8'),
+      LOGGER_LEVEL: this.configService.config.logger.level,
+      LOGGER_DISABLE_TIMESTAMPS: this.configService.config.logger.disableTimestamps ? '1' : '0',
+      MODULE_PATH: join(this.plugin.installPath, this.plugin.main),
+    };
+  }
+
+  private processLogEntry(logEntry: string, hasLoggerId: boolean): void {
+    if (hasLoggerId) {
+      const { loggerId, content } = this.processLogger.extractLoggerIdAndContent(logEntry);
+      if (loggerId) {
+        this.api.writeCameraLog(loggerId, content);
+      }
+      this.writeProcessLog(content);
+    } else {
+      this.writeProcessLog(logEntry);
+    }
+  }
+
+  private writeProcessLog(content: string): void {
+    if (content.trim() && !content.includes('returning true from eof_received')) {
+      this.processLogger.log(content);
+      this.safeWriteLog(content + '\n');
+    }
+  }
+
+  private closeLogStream(): void {
+    clearInterval(this.truncateInterval);
+    this.logStream?.close();
+    this.logStream = undefined;
+    this.logger.logStream = undefined;
+    this.logBuffer = '';
+  }
+
+  private removeLogStream(): void {
+    this.closeLogStream();
+    rmSync(this.plugin.logPath);
+  }
+
+  private async truncateLog(): Promise<void> {
+    if (!(await pathExists(this.plugin.logPath))) {
+      return;
+    }
+
+    const maxSize = 1000000; // ~1 MB
+    const truncateSize = 200000; // ~0.2 MB
+
+    try {
+      const logStats = await stat(this.plugin.logPath);
+
+      if (logStats.size < maxSize) {
+        // this.logger.debug(`Log file size is less than ${maxSize} bytes, skipping truncate`);
+        return;
+      }
+
+      // this.logger.debug(`Truncating log file to ${truncateSize} bytes...`);
+
+      const logStartPosition = logStats.size - truncateSize;
+      const logBuffer = Buffer.alloc(truncateSize);
+      const fileHandle = await open(this.plugin.logPath, 'r+');
+
+      try {
+        await readPromise(fileHandle.fd, logBuffer, 0, truncateSize, logStartPosition);
+        await truncatePromise(fileHandle.fd, 0);
+        await fileHandle.write(logBuffer, 0, truncateSize, 0);
+      } finally {
+        await fileHandle.close();
+      }
+
+      // this.logger.debug('Log file truncated successfully');
+    } catch (e) {
+      this.logger.error(`Failed to truncate log file: ${e.message}`);
+    }
+  }
+
+  private safeWriteLog(message: string): void {
+    if (this.logStream?.writable) {
+      try {
+        this.logStream?.write(message);
+      } catch {
+        // Ignore
+      }
+    }
+  }
+}

package/src/plugins/runtime/index.ts

@@ -0,0 +1,15 @@
+import { NodePluginRuntime } from './node/index.js';
+import { PythonPluginRuntime } from './python/index.js';
+
+import type { Plugin } from '../plugin.js';
+import type { BasePluginRuntime } from './base.js';
+
+export class RuntimeFactory {
+  static createRuntime(plugin: Plugin): BasePluginRuntime {
+    if (plugin.isPython) {
+      return new PythonPluginRuntime(plugin);
+    } else {
+      return new NodePluginRuntime(plugin);
+    }
+  }
+}

package/src/plugins/runtime/node/child.ts

@@ -0,0 +1,193 @@
+import { Logger, SignalHandler, sleep } from '@camera.ui/common';
+import { ClientInstance } from '@camera.ui/rpc-client';
+import { open } from 'lmdb';
+import { fileURLToPath } from 'node:url';
+
+import { API_EVENT } from '../../../api.js';
+import { NamespaceManager } from '../../../rpc/namespaces.js';
+import { PLUGIN_COMMAND, PLUGIN_STATUS } from '../../types.js';
+import { Plugin } from './plugin.js';
+import { PluginAPI } from './pluginApi.js';
+import { CameraDeviceProxy } from './proxy/cameraDevice.js';
+
+import type { LoggerOptions } from '@camera.ui/common';
+import type { SubscriptionWrapper } from '@camera.ui/rpc-common';
+import type { Camera } from '@camera.ui/types';
+import type { RootDatabase } from 'lmdb';
+import type { PluginInfo, ProcessLoadMessage, ProcessMessage, ProcessResponse } from '../../types.js';
+
+const processName = process.argv[3] || process.argv[2] || 'Plugin';
+process.title = `camera.ui - ${processName}`;
+
+export class PluginChild extends ClientInstance {
+  private displayName: string;
+  private api?: PluginAPI;
+  private plugin?: Plugin;
+  private pluginDb?: RootDatabase<Record<string, any>, 'config'>;
+  private signalHandler: SignalHandler;
+
+  private logger: Logger;
+  private loggerOptions: LoggerOptions;
+
+  private subscription?: SubscriptionWrapper;
+
+  private stopped = false;
+
+  constructor() {
+    super('plugin', {
+      endpoints: process.env.PROXY_ENDPOINTS!.split(','),
+      auth: {
+        user: process.env.PROXY_USER!,
+        password: process.env.PROXY_PASSWORD!,
+      },
+      tls: {
+        cert: process.env.PROXY_CERT!,
+        key: process.env.PROXY_KEY!,
+        ca: process.env.PROXY_CA!,
+      },
+      metadata: {
+        id: NamespaceManager.pluginNamespaces(process.env.PLUGIN_ID!).pluginChild,
+        name: process.env.PLUGIN_NAME!,
+      },
+      connect: {
+        waitForServer: true,
+      },
+      reconnect: {
+        enabled: true,
+      },
+      bundledConnection: false,
+    });
+
+    delete process.env.PROXY_USER;
+    delete process.env.PROXY_PASSWORD;
+    delete process.env.PROXY_ENDPOINTS;
+    delete process.env.PROXY_CERT;
+    delete process.env.PROXY_KEY;
+    delete process.env.PROXY_CA;
+
+    this.displayName = processName;
+
+    this.loggerOptions = {
+      prefix: this.displayName,
+      disableTimestamps: process.env.LOGGER_DISABLE_TIMESTAMPS === '1',
+      debugEnabled: process.env.LOGGER_LEVEL === 'debug' || process.env.LOGGER_LEVEL === 'trace',
+      traceEnabled: process.env.LOGGER_LEVEL === 'trace',
+    };
+
+    this.logger = new Logger(this.loggerOptions);
+
+    this.signalHandler = new SignalHandler({
+      displayName: '[Signal]',
+      timeoutDuration: 3000,
+      logger: this.logger,
+      closeFunction: this.stopPlugin.bind(this),
+    });
+
+    this.start();
+  }
+
+  protected async onStart(): Promise<void> {
+    this.subscription = this.onServerMessage<ProcessMessage>(this.onMessage.bind(this));
+    this.sendMessage({ type: PLUGIN_STATUS.READY });
+  }
+
+  protected async onBeforeStop(): Promise<void> {
+    await this.stopPlugin();
+  }
+
+  protected async onStop(): Promise<void> {}
+
+  private async startPlugin(data: ProcessLoadMessage): Promise<void> {
+    try {
+      const storagePath = data.storage.storagePath;
+      const pluginInfo = data.plugin;
+      const cameras = data.cameras;
+
+      this.pluginDb = await this.configurePluginDB(storagePath);
+      this.api = new PluginAPI(this, pluginInfo, storagePath, this.logger, this.pluginDb);
+      this.plugin = new Plugin(this, this.api, pluginInfo, this.logger);
+
+      await this.api.deviceManager.init();
+      await this.api.coreManager.init();
+      await this.plugin.load();
+      await this.configureCameras(this.api, pluginInfo, cameras);
+
+      this.sendMessage({ type: PLUGIN_STATUS.STARTED });
+
+      setImmediate(() => {
+        this.api?.emit(API_EVENT.FINISH_LAUNCHING);
+      });
+    } catch (error: any) {
+      this.sendMessage({ type: PLUGIN_STATUS.ERROR, error: error.message });
+    }
+  }
+
+  private async stopPlugin(): Promise<void> {
+    if (this.stopped) {
+      return;
+    }
+
+    this.stopped = true;
+
+    this.api?.emit(API_EVENT.SHUTDOWN);
+
+    await sleep(500);
+    await this.pluginDb?.close();
+
+    this.subscription?.unsubscribe();
+    this.subscription = undefined;
+
+    await this.stop();
+  }
+
+  private sendMessage(message: ProcessResponse): void {
+    this.sendToServer<ProcessResponse>(message);
+  }
+
+  private async onMessage(message: ProcessMessage): Promise<void> {
+    if (this.stopped) {
+      return;
+    }
+
+    switch (message.type) {
+      case PLUGIN_COMMAND.START:
+        if (!message.data) {
+          this.sendMessage({ type: PLUGIN_STATUS.ERROR, error: 'No data provided' });
+          return;
+        }
+
+        this.startPlugin(message.data);
+        break;
+      case PLUGIN_COMMAND.STOP:
+        this.stopPlugin();
+        break;
+    }
+  }
+
+  private async configurePluginDB(storagePath: string): Promise<RootDatabase<Record<string, any>, 'config'>> {
+    const pluginDb = open(`${storagePath}/volume`, {
+      name: 'plugins',
+    });
+
+    const pluginConfig = pluginDb.get('config');
+    if (!pluginConfig) {
+      await pluginDb.put('config', {});
+    }
+
+    return pluginDb as RootDatabase<Record<string, any>, 'config'>;
+  }
+
+  private async configureCameras(api: PluginAPI, pluginInfo: PluginInfo, cameras: Camera[]): Promise<void> {
+    const cameraDevices = cameras.map((camera) => {
+      const cameraLogger = this.logger.createLogger({ suffix: camera.name, loggerId: camera._id });
+      return new CameraDeviceProxy(this, api, camera, pluginInfo, cameraLogger);
+    });
+
+    await this.api?.deviceManager.configureCameras(cameraDevices);
+    await this.plugin?.configureCameras(cameraDevices);
+  }
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  new PluginChild();
+}

package/src/plugins/runtime/node/index.ts

@@ -0,0 +1,67 @@
+import { fork } from 'child_process';
+import { nodePluginPath } from '../../../utils/path.js';
+
+import { BasePluginRuntime } from '../base.js';
+
+import { IS_DEV } from '@camera.ui/common';
+import type { Plugin } from '../../plugin.js';
+
+export class NodePluginRuntime extends BasePluginRuntime {
+  constructor(plugin: Plugin) {
+    super(plugin);
+  }
+
+  public async start(): Promise<void> {
+    if (this.isRunning()) {
+      return;
+    }
+
+    return new Promise<void>((resolve, reject) => {
+      this.logger.log(`Starting plugin: ${this.plugin.displayName} (${this.plugin.pluginName}.${this.plugin.info.installedVersion})...`);
+
+      const command = process.execPath;
+      const processNames = [this.plugin.pluginName, this.plugin.displayName];
+      const args: string[] = [nodePluginPath, ...processNames];
+
+      this.logger.debug(`Forking plugin: ${this.plugin.pluginName}`);
+
+      this.worker = fork(nodePluginPath, [...processNames], {
+        env: {
+          ...this.cleanedProcessEnv(),
+          ...this.getEnv(),
+        },
+        cwd: this.plugin.mainPath,
+        silent: true,
+        execArgv: IS_DEV ? ['--import=tsx'] : undefined,
+      });
+
+      this.worker.once('spawn', this.onSpawn.bind(this, this.worker.pid!, command, args, processNames, resolve));
+      this.worker.once('error', this.onError.bind(this, reject));
+      this.worker.once('exit', this.onExit.bind(this));
+
+      this.worker.stdout?.on('data', this.onData.bind(this));
+      this.worker.stderr?.on('data', this.onData.bind(this));
+    });
+  }
+
+  private cleanedProcessEnv(): Record<string, string> {
+    const env = { ...process.env } as Record<string, string>;
+
+    delete env.CAMERA_UI_STORAGE_PATH;
+    delete env.CAMERA_UI_DATABASE_PATH;
+    delete env.CAMERA_UI_USERS_STORAGE_PATH;
+    delete env.CAMERA_UI_PLUGINS_STORAGE_PATH;
+    delete env.CAMERA_UI_PLUGINS_INSTALL_PATH;
+    delete env.CAMERA_UI_PLUGINS_PJSON_FILE;
+    delete env.CAMERA_UI_CONFIG_FILE;
+    delete env.CAMERA_UI_SECRETS_FILE;
+    delete env.CAMERA_UI_LOG_FILE;
+    delete env.CAMERA_UI_GO2RTC_CONFIG_FILE;
+    delete env.CAMERA_UI_GO2RTC_BINARY;
+    delete env.CAMERA_UI_DEV_PORT;
+    delete env.CAMERA_UI_DEV_WS_PORT;
+    delete env.CAMERA_UI_DEV_UI_PORT;
+
+    return env;
+  }
+}

package/src/plugins/runtime/node/plugin.ts

@@ -0,0 +1,122 @@
+import { rpc } from '@camera.ui/rpc-common';
+import { pathToFileURL } from 'node:url';
+import { isPromise } from 'node:util/types';
+
+import { NamespaceManager } from '../../../rpc/namespaces.js';
+
+import type { Logger } from '@camera.ui/common';
+import type { ClientInstance } from '@camera.ui/rpc-client';
+import type {
+  AudioDetectionPluginResponse,
+  AudioMetadata,
+  CuiPlugin,
+  CuiPluginCapability,
+  DeviceStorage,
+  ImageMetadata,
+  JsonSchema,
+  MotionDetectionPluginResponse,
+  ObjectDetectionPluginResponse,
+} from '@camera.ui/types';
+import type { PluginNamespaces } from '../../../rpc/namespaces.js';
+import type { PluginInfo } from '../../types.js';
+import type { PluginAPI } from './pluginApi.js';
+import type { CameraDeviceProxy } from './proxy/cameraDevice.js';
+
+export type PluginConstructor = new (logger: Logger, api: PluginAPI, storage: DeviceStorage<Record<string, any>>) => CuiPlugin;
+
+export class Plugin implements CuiPlugin {
+  private plugin?: CuiPlugin;
+  private namespaces: PluginNamespaces;
+
+  constructor(
+    private proxy: ClientInstance,
+    private api: PluginAPI,
+    private pluginInfo: PluginInfo,
+    private logger: Logger,
+  ) {
+    this.namespaces = NamespaceManager.pluginNamespaces(this.pluginInfo.id);
+  }
+
+  public async load(): Promise<void> {
+    const PluginConstructor = await this.loadPlugin();
+    const pluginStorage = await this.api.storageController.createStorage('plugin');
+    this.plugin = new PluginConstructor(this.logger, this.api, pluginStorage);
+    await this.proxy.registerRPCHandler(this.namespaces.pluginChildRpc, this);
+  }
+
+  @rpc({ public: true })
+  public async configureCameras(cameraDevices: CameraDeviceProxy[]): Promise<void> {
+    if (!this.plugin) {
+      throw new Error('Plugin not loaded');
+    }
+
+    await this.plugin.configureCameras(cameraDevices);
+  }
+
+  @rpc({ public: true })
+  public getCapabilities(): Promise<CuiPluginCapability[]> {
+    if (!this.plugin) {
+      throw new Error('Plugin not loaded');
+    }
+
+    return this.plugin.getCapabilities();
+  }
+
+  @rpc({ public: true })
+  public async interfaceSchema(): Promise<JsonSchema[] | undefined> {
+    if (!this.plugin) {
+      throw new Error('Plugin not loaded');
+    }
+
+    return this.plugin.interfaceSchema?.();
+  }
+
+  @rpc({ public: true })
+  public async detectAudio(audioData: Buffer | Uint8Array, metadata: AudioMetadata, config: Record<string, any>): Promise<AudioDetectionPluginResponse | undefined> {
+    if (!this.plugin) {
+      throw new Error('Plugin not loaded');
+    }
+
+    return this.plugin.detectAudio?.(audioData, metadata, config);
+  }
+
+  @rpc({ public: true })
+  public async detectMotion(videoData: Buffer | Uint8Array, config: Record<string, any>): Promise<MotionDetectionPluginResponse | undefined> {
+    if (!this.plugin) {
+      throw new Error('Plugin not loaded');
+    }
+
+    return this.plugin.detectMotion?.(videoData, config);
+  }
+
+  @rpc({ public: true })
+  public async detectObjects(imageData: Buffer | Uint8Array, metadata: ImageMetadata, config: Record<string, any>): Promise<ObjectDetectionPluginResponse | undefined> {
+    if (!this.plugin) {
+      throw new Error('Plugin not loaded');
+    }
+
+    return this.plugin.detectObjects?.(imageData, metadata, config);
+  }
+
+  private async loadPlugin(): Promise<PluginConstructor> {
+    const moduleUrl = pathToFileURL(process.env.MODULE_PATH!).href;
+    const mod = await import(moduleUrl);
+    const isDefaultPromise = isPromise(mod.default);
+
+    let defaultModule: any;
+
+    if (isDefaultPromise) {
+      defaultModule = await mod.default;
+    } else {
+      defaultModule = mod.default;
+    }
+
+    if (defaultModule && typeof defaultModule.default === 'function') {
+      return defaultModule.default;
+    } else if (typeof defaultModule === 'function') {
+      return defaultModule;
+    } else {
+      throw new Error(`Plugin ${process.env.MODULE_PATH} does not export a initializer function from main.`);
+    }
+  }
+}