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

package/src/plugins/runtime/base.ts

@@ -1,282 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,193 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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.`);
-    }
-  }
-}