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

package/src/plugins/index.ts

@@ -0,0 +1,443 @@
+import 'reflect-metadata';
+
+import AdmZip from 'adm-zip';
+import { pathExists, readJson, remove } from 'fs-extra/esm';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import semver from 'semver';
+import { container } from 'tsyringe';
+import { DEFAULT_PY_VERSION, PythonInstaller } from '../utils/pythonInstaller.js';
+
+import { API_EVENT } from '../api.js';
+import { PluginsService } from '../api/services/plugins.service.js';
+import { Plugin } from './plugin.js';
+import { CAMERA_EXTENSIONS, PLUGIN_IDENTIFIER_PATTERN } from './types.js';
+
+import type { CameraUiAPI } from '../api.js';
+import type { BackupInfo, IPackageJson } from '../api/types/index.js';
+import type { ConfigService } from '../services/config/index.js';
+import type { LoggerService } from '../services/logger/index.js';
+import type { PluginContract } from './types.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export class PluginManager {
+  private logger: LoggerService;
+  private api: CameraUiAPI;
+  private configService: ConfigService;
+
+  public installedPythonVersions = new Set<string>();
+  public searchPaths = new Set<string>();
+
+  public plugins = new Map<string, Plugin>();
+  public pluginIdentifiers = new Set<string>();
+
+  constructor() {
+    container.registerInstance('pluginManager', this);
+
+    this.api = container.resolve<CameraUiAPI>('api');
+    this.logger = container.resolve<LoggerService>('logger');
+    this.configService = container.resolve<ConfigService>('configService');
+
+    this.api.setMaxListeners(this.api.getMaxListeners() + 1);
+    this.api.once(API_EVENT.SHUTDOWN, () => {
+      this.plugins.forEach((plugin) => plugin.worker.teardown());
+    });
+  }
+
+  public static isQualifiedPluginIdentifier(pluginName: string): boolean {
+    const normalizedName = pluginName.replace(/\\/g, '/');
+    return PLUGIN_IDENTIFIER_PATTERN.test(normalizedName);
+  }
+
+  public static isQualifiedPluginContract(contract?: Partial<PluginContract>): boolean {
+    if (contract) {
+      if (!contract.extensions || !Array.isArray(contract.extensions) || contract.extensions.length === 0) {
+        return false;
+      }
+
+      if (contract.extensions.some((extension) => !CAMERA_EXTENSIONS.includes(extension))) {
+        return false;
+      }
+
+      return true;
+    }
+
+    return false;
+  }
+
+  public static extractPluginScope(pluginName: string): string | undefined {
+    return pluginName.match(PLUGIN_IDENTIFIER_PATTERN)![2];
+  }
+
+  public static extractPluginName(pluginName: string): string {
+    return pluginName.match(PLUGIN_IDENTIFIER_PATTERN)![3];
+  }
+
+  public static transformDisplaName(pluginName: string): string {
+    const extractedPkgName = this.extractPluginName(pluginName).replace('camera-ui-', '').replaceAll('-', ' ');
+
+    return extractedPkgName
+      .toLowerCase()
+      .split(' ')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  public static loadPackageJSON(installPath: string): IPackageJson {
+    const packageJsonPath = join(installPath, 'package.json');
+    let packageJson;
+
+    if (!existsSync(packageJsonPath)) {
+      throw new Error(`Plugin ${installPath} does not contain a package.json.`);
+    }
+
+    try {
+      packageJson = JSON.parse(readFileSync(packageJsonPath, { encoding: 'utf8' }));
+    } catch (error: any) {
+      throw new Error(`Plugin ${installPath} contains an invalid package.json. Error: ${error}`);
+    }
+
+    if (!PluginManager.isQualifiedPluginIdentifier(packageJson.name)) {
+      throw new Error(`Plugin "${packageJson.name}" does not have a package name that begins with 'camera-ui-' or '@scope/camera-ui-.`);
+    }
+
+    if (!PluginManager.isQualifiedPluginContract(packageJson['camera.ui'])) {
+      throw new Error(`Plugin "${packageJson.name}" does not contain a valid contract.`);
+    }
+
+    // verify that it's tagged with the correct keyword
+    if (!packageJson.keywords?.includes('camera-ui-plugin')) {
+      throw new Error(`Plugin "${packageJson.name}" does not contain the keyword 'camera-ui-plugin'.`);
+    }
+
+    return packageJson;
+  }
+
+  public static parseContract(pjson: IPackageJson): PluginContract {
+    const contract = pjson['camera.ui'];
+
+    if (contract?.pythonVersion) {
+      const validPythonVersions = PythonInstaller.versions;
+      const minValidPythonVersion = validPythonVersions[validPythonVersions.length - 1];
+      const maxValidPythonVersion = validPythonVersions[0];
+      const pluginPythonVersion = semver.clean(contract.pythonVersion);
+
+      if (!pluginPythonVersion || !semver.satisfies(pluginPythonVersion, `>=${minValidPythonVersion} <=${maxValidPythonVersion}`)) {
+        contract.pythonVersion = DEFAULT_PY_VERSION;
+      }
+    }
+
+    if (contract?.dependencies) {
+      const invalidDependencies = contract.dependencies.filter((dep) => !PluginManager.isQualifiedPluginIdentifier(dep));
+      if (invalidDependencies.length) {
+        contract.dependencies = contract.dependencies.filter((dep) => PluginManager.isQualifiedPluginIdentifier(dep));
+      }
+    }
+
+    const extensions = contract?.extensions ?? [];
+    const dependencies = contract?.dependencies ? Array.from(new Set(contract.dependencies)) : [];
+    const pythonVersion = contract?.pythonVersion;
+    const bundled = contract?.bundled ?? false;
+
+    return {
+      extensions,
+      dependencies,
+      pythonVersion,
+      bundled,
+    };
+  }
+
+  public static async checkBundeledPlugin(packageDir: string): Promise<string | undefined> {
+    const bundleRootPath = join(packageDir, 'bundle.zip');
+    const bundlePath = join(packageDir, 'bundle', 'bundle.zip');
+
+    if (await pathExists(bundleRootPath)) {
+      return bundleRootPath;
+    }
+
+    if (await pathExists(bundlePath)) {
+      return bundlePath;
+    }
+  }
+
+  public static async extrackBundeledPlugin(packageDir: string, bundlePath?: string): Promise<void> {
+    bundlePath = bundlePath ?? (await this.checkBundeledPlugin(packageDir));
+    if (!bundlePath) {
+      return;
+    }
+
+    const bundleDir = dirname(bundlePath);
+    const zip = new AdmZip(bundlePath);
+    zip.extractAllTo(bundleDir, true);
+
+    await remove(bundlePath);
+  }
+
+  public async initializeInstalledPlugins(): Promise<void> {
+    if (this.plugins.size === 0) {
+      this.logger.warn('No plugins found. See the README for information on installing plugins.');
+      return;
+    }
+
+    await Promise.all(Array.from(this.plugins).map(([, plugin]) => this.initializeInstalledPlugin(plugin)));
+    // for (const [, plugin] of this.plugins) {
+    //   await this.initializeInstalledPlugin(plugin);
+    // }
+  }
+
+  public async initializeInstalledPlugin(plugin: Plugin): Promise<void> {
+    if (plugin.disabled) {
+      this.logger.warn(`Disabled plugin: ${plugin.displayName} (${plugin.pluginName}@${plugin.info.installedVersion})`);
+    } else {
+      this.logger.log(`Initializing plugin: ${plugin.displayName} (${plugin.pluginName}@${plugin.info.installedVersion})`);
+    }
+
+    try {
+      await this.startPluginChild(plugin.pluginName);
+    } catch (error: any) {
+      this.logger.error(`Error loading plugin: ${plugin.pluginName}:`, error);
+      this.plugins.delete(plugin.pluginName);
+    }
+  }
+
+  public async loadPlugin(absolutePath: string, oldId?: string): Promise<Plugin> {
+    const pluginsService = new PluginsService();
+
+    const packageJson = PluginManager.loadPackageJSON(absolutePath);
+    const pluginName = packageJson.name;
+    const scope = PluginManager.extractPluginScope(pluginName);
+    const alreadyInstalled = this.plugins.get(pluginName);
+
+    if (alreadyInstalled) {
+      throw new Error(`Warning: skipping plugin found at '${absolutePath}' since we already loaded the same plugin from '${alreadyInstalled.installPath}'.`);
+    }
+
+    const dbPlugin = await pluginsService.insertPluginDb(pluginName, oldId);
+    const plugin = new Plugin(pluginName, absolutePath, packageJson, dbPlugin._id, scope);
+
+    const bundlePath = await PluginManager.checkBundeledPlugin(plugin.installPath);
+    if (bundlePath) {
+      this.logger.debug(`Extracting bundled plugin: ${pluginName}`);
+      await PluginManager.extrackBundeledPlugin(plugin.installPath, bundlePath);
+    }
+
+    this.plugins.set(pluginName, plugin);
+
+    return plugin;
+  }
+
+  public async removePlugin(plugin: Plugin, removeStorage?: boolean): Promise<void> {
+    await plugin.worker.cleanup();
+
+    const pluginsService = new PluginsService();
+    await pluginsService.removePluginDbById(plugin.id);
+
+    if (removeStorage) {
+      await remove(plugin.storagePath);
+    }
+
+    this.plugins.delete(plugin.pluginName);
+  }
+
+  public async startPluginChild(pluginName: string): Promise<void> {
+    try {
+      const plugin = this.plugins.get(pluginName);
+
+      if (!plugin || plugin.disabled || plugin.worker?.isRunning()) {
+        return;
+      }
+
+      await plugin.load();
+
+      for (const depName of plugin.contract.dependencies ?? []) {
+        if (!PluginManager.isQualifiedPluginIdentifier(depName)) {
+          continue;
+        }
+
+        const depPlugin = this.plugins.get(depName);
+
+        if (!depPlugin) {
+          this.logger.attention(`Plugin ${pluginName} requires ${depName} which is not installed!`);
+        }
+
+        if (depPlugin?.disabled) {
+          this.logger.attention(`Reactivation and start of dependency ${depPlugin.displayName} for ${plugin.displayName}`);
+          depPlugin.disabled = false;
+          this.startPluginChild(depName);
+        }
+      }
+
+      await plugin.worker.start();
+    } catch (error: any) {
+      if (error.message === 'NOT_COMPATIBLE') {
+        return;
+      }
+
+      this.logger.error(`Error starting plugin ${pluginName}:`, error);
+    }
+  }
+
+  public async stopPluginChild(pluginName: string): Promise<void> {
+    const plugin = this.plugins.get(pluginName);
+    await plugin?.worker.teardown();
+  }
+
+  public async initializePlugins(): Promise<void> {
+    await this.loadInstalledPlugins();
+    await this.removeOrphanedPlugins();
+
+    for (const [, plugin] of this.plugins) {
+      if (this.configService.config.plugins.disabledPlugins.includes(plugin.pluginName)) {
+        plugin.disabled = true;
+      }
+    }
+
+    await this.handleDisabledPlugins();
+    await this.restorePlugins();
+    await this.installRequiredPythonEnvs();
+  }
+
+  private async installRequiredPythonEnvs(): Promise<void> {
+    this.installedPythonVersions.clear();
+
+    const pythonVersionsToInstall = new Set<string>();
+    pythonVersionsToInstall.add(DEFAULT_PY_VERSION);
+
+    for (const [, plugin] of this.plugins) {
+      if (plugin.isPython && !plugin.disabled) {
+        pythonVersionsToInstall.add(plugin.contract.pythonVersion ?? DEFAULT_PY_VERSION);
+      }
+    }
+
+    if (pythonVersionsToInstall.size > 0) {
+      const promises: Promise<any>[] = [];
+
+      for (const version of pythonVersionsToInstall) {
+        const requirementsPath = resolve(join(__dirname, '..', '..', 'requirements.txt')).replace('app.asar', 'app.asar.unpacked');
+        const py = new PythonInstaller(this.configService.HOME_PATH, this.logger, undefined, version);
+
+        promises.push(
+          py
+            .install('server', requirementsPath)
+            .then(() => this.installedPythonVersions.add(version))
+            .catch((error) => this.logger.error(`Error installing Python ${version}:`, error)),
+        );
+      }
+
+      const { logger } = new PythonInstaller(this.configService.HOME_PATH, this.logger, undefined, DEFAULT_PY_VERSION);
+
+      if (promises.length > 0) {
+        logger.log(`Installing required Python versions: ${Array.from(pythonVersionsToInstall).join(', ')} ...`);
+        await Promise.all(promises);
+        logger.log('Python installation complete.');
+      } else if (pythonVersionsToInstall.size > 0) {
+        logger.log(`Required Python versions already installed: ${Array.from(pythonVersionsToInstall).join(', ')}`);
+      }
+    }
+  }
+
+  private async loadInstalledPlugins(): Promise<void> {
+    const searchPath = this.configService.PLUGINS_INSTALL_PATH;
+
+    const relativeinstallPaths = readdirSync(searchPath).filter((relativePath) => {
+      try {
+        return statSync(join(searchPath, relativePath)).isDirectory();
+      } catch (error: any) {
+        this.logger.debug(`Ignoring path ${resolve(searchPath, relativePath)}`, error);
+        return false;
+      }
+    });
+
+    // expand out @scoped plugins
+    for (const scopeDirectory of [...relativeinstallPaths].filter((path) => path.startsWith('@'))) {
+      const index = relativeinstallPaths.indexOf(scopeDirectory);
+      relativeinstallPaths.splice(index, 1);
+      const absolutePath = resolve(searchPath, scopeDirectory);
+
+      for (const name of readdirSync(absolutePath)
+        .filter((name) => PluginManager.isQualifiedPluginIdentifier(name))
+        .filter((name) => {
+          try {
+            return statSync(join(absolutePath, name)).isDirectory();
+          } catch (error: any) {
+            this.logger.debug(`Ignoring path ${resolve(absolutePath, name)} - ${error.message}`);
+            return false;
+          }
+        }))
+        relativeinstallPaths.push(join(scopeDirectory, name));
+    }
+
+    relativeinstallPaths.forEach((pluginIdentifier) => {
+      if (PluginManager.isQualifiedPluginIdentifier(pluginIdentifier)) {
+        this.pluginIdentifiers.add(pluginIdentifier);
+      }
+    });
+
+    for (const pluginIdentifier of this.pluginIdentifiers) {
+      try {
+        const absolutePath = join(searchPath, pluginIdentifier);
+        await this.loadPlugin(absolutePath);
+      } catch (error: any) {
+        this.logger.warn(error.message);
+        continue;
+      }
+    }
+  }
+
+  private async restorePlugins(): Promise<void> {
+    try {
+      const backupInfo: BackupInfo = await readJson(this.configService.BACKUP_INFO_FILE);
+      const notInstalledPlugins = backupInfo.plugins.filter((plugin) => !this.plugins.has(plugin.name));
+
+      const restorePromises: Promise<void>[] = [];
+
+      if (notInstalledPlugins.length > 0) {
+        this.logger.log('Restoring missing plugins...');
+
+        const restore = async () => {
+          const pluginsService = new PluginsService();
+
+          for (const pluginInfo of notInstalledPlugins) {
+            try {
+              this.logger.log(`Installing plugin: ${pluginInfo.name}@${pluginInfo.version}`);
+
+              const installPath = await pluginsService.manage(pluginInfo.name, 'install', pluginInfo.version);
+              const plugin = await this.loadPlugin(installPath, pluginInfo.id);
+
+              if (this.configService.config.plugins.disabledPlugins.includes(plugin.pluginName)) {
+                plugin.disabled = true;
+              }
+
+              this.logger.log(`Plugin installed: ${plugin.pluginName}.${plugin.displayName} (${plugin.info.installedVersion})`);
+            } catch (error: any) {
+              this.logger.error(`Error restoring plugin ${pluginInfo.name}:`, error);
+            }
+          }
+        };
+
+        restorePromises.push(restore());
+
+        await Promise.all(restorePromises);
+
+        this.logger.log('Plugins restored');
+
+        await remove(this.configService.BACKUP_INFO_FILE);
+      }
+    } catch {
+      //
+    }
+  }
+
+  private async removeOrphanedPlugins(): Promise<void> {
+    const pluginsService = new PluginsService();
+    await pluginsService.removeOrphanPluginsDb();
+  }
+
+  private async handleDisabledPlugins(): Promise<void> {
+    const pluginsService = new PluginsService();
+    await pluginsService.handleDisabledPlugins();
+  }
+}

package/src/plugins/plugin.ts

@@ -0,0 +1,177 @@
+import { lstatSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import semver from 'semver';
+import { container } from 'tsyringe';
+
+import { ConfigService } from '../services/config/index.js';
+import { PluginManager } from './index.js';
+import { PluginWorker } from './worker.js';
+
+import type { CameraExtension } from '@camera.ui/types';
+import type { CameraUiPlugin, IPackageJson } from '../api/types/index.js';
+import type { LoggerService } from '../services/logger/index.js';
+import type { Context, PluginContract } from './types.js';
+
+export class Plugin {
+  private logger: LoggerService;
+  private configService: ConfigService;
+
+  private _disabled = false;
+  private _info: CameraUiPlugin;
+  private _contract: PluginContract;
+  private loadContext: Context;
+
+  readonly id: string;
+  readonly main: string;
+  readonly pluginName: string;
+  readonly displayName: string;
+  readonly scope?: string;
+  readonly isPython: boolean;
+  readonly isSymLink: boolean;
+  readonly installPath: string;
+  readonly mainPath: string;
+  readonly storagePath: string;
+  readonly logPath: string;
+  readonly worker: PluginWorker;
+
+  public get contract(): PluginContract {
+    return this._contract;
+  }
+
+  public get info(): CameraUiPlugin {
+    this._info.disabled = this.disabled;
+    return this._info;
+  }
+
+  public set info(value: CameraUiPlugin) {
+    this._info = value;
+    this._info.disabled = this.disabled;
+  }
+
+  public get disabled(): boolean {
+    return this._disabled;
+  }
+
+  public set disabled(disabled: boolean) {
+    this._disabled = disabled;
+    this._info.disabled = disabled;
+
+    if (disabled) {
+      this.worker.disable();
+    }
+  }
+
+  public get type(): CameraExtension[] {
+    return [...this.contract.extensions];
+  }
+
+  constructor(pluginName: string, installPath: string, packageJSON: IPackageJson, pluginId: string, scope?: string) {
+    this.logger = container.resolve<LoggerService>('logger');
+    this.configService = container.resolve<ConfigService>('configService');
+
+    this.scope = scope;
+    this.installPath = join(installPath);
+    this.id = pluginId;
+    this.pluginName = pluginName;
+    this.storagePath = join(this.configService.PLUGINS_STORAGE_PATH, this.pluginName);
+    this.logPath = join(this.configService.LOGS_PATH, `plugin-${this.id}.log`);
+
+    this.main = this.getMainFile(packageJSON);
+    this.mainPath = join(this.installPath, dirname(this.main));
+    this.isPython = this.main.endsWith('.py');
+    this.isSymLink = lstatSync(this.installPath).isSymbolicLink();
+
+    this._info = this.parsePackageJson(packageJSON, installPath);
+    this._contract = PluginManager.parseContract(packageJSON);
+
+    this.displayName = this.info.displayName;
+
+    this.loadContext = {
+      engines: packageJSON.engines,
+      dependencies: packageJSON.dependencies,
+    };
+
+    this.worker = new PluginWorker(this);
+
+    this.disabled = this.configService.config.plugins.disabledPlugins.includes(pluginName);
+  }
+
+  public async load(): Promise<void> {
+    if (!this.loadContext.engines?.['camera.ui']) {
+      throw new Error(`Plugin ${this.installPath} does not contain the 'camera.ui' package in 'engines'.`);
+    }
+
+    const serverVersion = semver.clean(ConfigService.VERSION);
+    const versionRequired = semver.clean(this.loadContext.engines['camera.ui']);
+    const processVersion = semver.clean(process.version.replace('v', ''));
+    const nodeVersionRequired = semver.clean(this.loadContext.engines.node);
+
+    if (serverVersion && versionRequired && !semver.gte(serverVersion, versionRequired)) {
+      this.logger.warn(`The plugin "${this.pluginName}" requires a camera.ui version of ${versionRequired} which does \
+not satisfy the current camera.ui version of ${ConfigService.VERSION}. Please update camera.ui to the required version.`);
+      throw new Error('NOT_COMPATIBLE');
+    }
+
+    if (processVersion && nodeVersionRequired && !semver.gte(processVersion, nodeVersionRequired)) {
+      this.logger.warn(`The plugin "${this.pluginName}" requires Node.js version of ${nodeVersionRequired} which does \
+not satisfy the current Node.js version of ${process.version}. You may need to upgrade your installation of Node.js`);
+    }
+  }
+
+  public reparsePackageJson(): void {
+    const pjson = PluginManager.loadPackageJSON(this.installPath);
+    this._info = this.parsePackageJson(pjson, this.installPath);
+    this._contract = PluginManager.parseContract(pjson);
+  }
+
+  private parsePackageJson(pjson: IPackageJson, installPath: string): CameraUiPlugin {
+    const pluginPackageJson: CameraUiPlugin = {
+      id: this.id,
+      disabled: this.configService.config.plugins.disabledPlugins.includes(this.pluginName),
+      private: pjson.private ?? false,
+      pluginName: pjson.name,
+      displayName: pjson.displayName ?? PluginManager.transformDisplaName(pjson.name),
+      author: pjson.author ? (typeof pjson.author === 'string' ? pjson.author : pjson.author.name) : undefined,
+      description: pjson.description ? pjson.description.replace(/(?:https?|ftp):\/\/[\n\S]+/g, '').trim() : pjson.name,
+      installedVersion: pjson.version,
+      latestVersion: pjson.version,
+      globalInstall: false,
+      publicPackage: pjson.private ?? false,
+      engines: pjson.engines,
+      installPath,
+      links: {
+        npm: `https://www.npmjs.com/package/${this.pluginName}`,
+        homepage: pjson.homepage,
+      },
+      isPython: this.isPython,
+      isNode: !this.isPython,
+      'camera.ui': PluginManager.parseContract(pjson),
+    };
+
+    return pluginPackageJson;
+  }
+
+  private getMainFile(packageJSON: IPackageJson): string {
+    let main: string | undefined;
+
+    if (packageJSON.exports) {
+      if (typeof packageJSON.exports === 'string') {
+        main = packageJSON.exports;
+      } else {
+        const exports = packageJSON.exports.import ?? packageJSON.exports.require ?? packageJSON.exports.node ?? packageJSON.exports.default ?? packageJSON.exports['.'];
+
+        if (typeof exports !== 'string') {
+          if (exports.import) {
+            main = exports.import;
+          } else {
+            main = exports.require ?? exports.node ?? exports.default;
+          }
+        } else {
+          main = exports;
+        }
+      }
+    }
+
+    return main ?? packageJSON.main ?? './index.js';
+  }
+}