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

package/src/plugins/index.ts

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

@@ -1,177 +0,0 @@
-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';
-  }
-}