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

package/src/utils/pythonInstaller.ts

@@ -1,597 +0,0 @@
-import { PortablePython } from '@bjia56/portable-python';
-import { compareVersions } from 'compare-versions';
-import { copy, ensureDir, remove } from 'fs-extra/esm';
-import { exec } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { readdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { platform } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { createInterface } from 'readline';
-
-import { IS_ELECTRON } from '@camera.ui/common';
-
-import type { Logger } from '@camera.ui/common';
-
-export const DEFAULT_PY_VERSION = '3.11';
-
-export class PythonInstaller {
-  static readonly versions = ['3.12', '3.11', '3.10', '3.9'];
-
-  public logger: Logger;
-
-  readonly python: PortablePython;
-  readonly venvPath?: string;
-  readonly installPath: string;
-
-  private needsUpdate = false;
-
-  get isInstalled(): boolean {
-    return this.python.isInstalled();
-  }
-
-  get pluginPythonPath(): string {
-    if (!this.venvPath) {
-      throw new Error('Venv path is not defined');
-    }
-
-    const binPath = platform() === 'win32' ? 'Scripts' : 'bin';
-    return join(this.venvPath, binPath, 'python');
-  }
-
-  get serverPythonPath(): string {
-    return this.python.executablePath;
-  }
-
-  get pluginPackagesPath(): string {
-    if (!this.venvPath) {
-      throw new Error('Venv path is not defined');
-    }
-
-    if (platform() === 'win32') {
-      return join(this.venvPath, 'Lib', 'site-packages');
-    } else {
-      return join(this.venvPath, 'lib', `python${this.getMajorMinorVersion(this.version)}`, 'site-packages');
-    }
-  }
-
-  get serverPackagesPath(): string {
-    if (platform() === 'win32') {
-      return join(this.python.extractPath, 'Lib', 'site-packages');
-    } else {
-      return join(this.python.extractPath, 'lib', `python${this.getMajorMinorVersion(this.version)}`, 'site-packages');
-    }
-  }
-
-  get version(): string {
-    return this.python.version;
-  }
-
-  constructor(homePath: string, logger: Logger, venvDir?: string, version: string = DEFAULT_PY_VERSION) {
-    this.logger = logger;
-
-    if (!PythonInstaller.versions.includes(version)) {
-      version = DEFAULT_PY_VERSION;
-    }
-
-    const pythonDir = IS_ELECTRON ? 'python-electron' : 'python';
-    this.installPath = `${homePath}/${pythonDir}`;
-    this.python = new PortablePython(version, this.installPath);
-
-    if (venvDir) {
-      this.venvPath = join(venvDir, `${pythonDir}-${this.getMajorMinorVersion(this.version)}`);
-    }
-  }
-
-  public async install(type: 'plugin' | 'server', requirementsPath?: string): Promise<void> {
-    if (!this.isInstalled) {
-      this.logger.trace(`Installing Python v${this.version} to ${this.installPath}...`);
-
-      await ensureDir(this.installPath);
-      await this.removeOldVersions();
-      await this.python.install();
-    }
-
-    if (type === 'server') {
-      if (!requirementsPath) {
-        throw new Error('Requirements path is not defined');
-      }
-
-      await this.updateServerDependencies(requirementsPath);
-
-      if (platform() === 'win32') {
-        const binPath = dirname(this.serverPythonPath);
-        const pythonwPath = join(binPath, 'pythonw.exe');
-
-        if (!existsSync(pythonwPath)) {
-          await copy(this.serverPythonPath, pythonwPath);
-        }
-      }
-    }
-  }
-
-  public async installPluginPython(): Promise<void> {
-    await this.install('plugin');
-    await this.createVenv();
-  }
-
-  public async uninstall(): Promise<void> {
-    if (this.isInstalled) {
-      await this.python.uninstall();
-    }
-
-    await this.removeVenv();
-  }
-
-  public async updatePluginDependencies(requirementsPath: string): Promise<void> {
-    await this.ensureVenv();
-
-    const { needsUpdate, requirementsLockPath, requirementsContent, lockContent, updatedLockContent } = await this.updateRequirements(requirementsPath);
-    const { reInstall, uninstall } = await this.analyzeDependencies(requirementsContent, lockContent, needsUpdate);
-
-    await this.updateDependencies('plugin', requirementsPath, requirementsContent, reInstall, uninstall);
-
-    if (updatedLockContent) {
-      await writeFile(requirementsLockPath, updatedLockContent);
-    }
-  }
-
-  public async updateServerDependencies(requirementsPath: string): Promise<void> {
-    const requirementsLockPath = resolve(join(this.installPath, `requirements-lock-${this.version}.txt`));
-
-    const { needsUpdate, requirementsContent, lockContent, updatedLockContent } = await this.updateRequirements(requirementsPath, requirementsLockPath);
-    const { reInstall, uninstall } = await this.analyzeDependencies(requirementsContent, lockContent, needsUpdate);
-
-    await this.updateDependencies('server', requirementsPath, requirementsContent, reInstall, uninstall);
-
-    if (updatedLockContent) {
-      await writeFile(requirementsLockPath, updatedLockContent);
-    }
-  }
-
-  public async installPluginPackages(pkgs: string[]): Promise<string> {
-    await this.ensureVenv();
-    return this.installPackages(this.pluginPythonPath, pkgs);
-  }
-
-  public async installServerPackages(pkgs: string[]): Promise<string> {
-    return this.installPackages(this.serverPythonPath, pkgs);
-  }
-
-  public async reinstallPluginPackes(pkgs: string[]): Promise<string> {
-    await this.ensureVenv();
-    return this.reinstallPackages(this.pluginPythonPath, pkgs);
-  }
-
-  public async reinstallServerPackages(pkgs: string[]): Promise<string> {
-    return this.reinstallPackages(this.serverPythonPath, pkgs);
-  }
-
-  public async uninstallPluginPackages(pkgs: string[]): Promise<string> {
-    await this.ensureVenv();
-    return this.uninstallPackages(this.pluginPythonPath, pkgs);
-  }
-
-  public async uninstallServerPackages(pkgs: string[]): Promise<string> {
-    return this.uninstallPackages(this.serverPythonPath, pkgs);
-  }
-
-  private async installPluginRequirements(requirementsPath: string): Promise<string> {
-    return this.installRequirements(this.pluginPythonPath, requirementsPath);
-  }
-
-  private async installServerRequirements(requirementsPath: string): Promise<string> {
-    return this.installRequirements(this.serverPythonPath, requirementsPath);
-  }
-
-  private async updateRequirements(
-    requirementsPath: string,
-    requirementsLockPath?: string,
-  ): Promise<{ needsUpdate: boolean; requirementsLockPath: string; requirementsContent: string; lockContent?: string; updatedLockContent?: string }> {
-    requirementsLockPath = requirementsLockPath ?? join(dirname(requirementsPath), 'requirements-lock.txt');
-    const requirementsContent = await readFile(requirementsPath, 'utf8');
-
-    let lockContent: string | undefined;
-    let updatedLockContent: string | undefined;
-
-    let requirementsLockContent = '';
-    let lockPythonVersion = '';
-
-    try {
-      lockContent = await readFile(requirementsLockPath, 'utf8');
-      const lockLines = lockContent.split('\n');
-      lockPythonVersion = lockLines[0].replace('# Python version: ', '').trim();
-      requirementsLockContent = lockLines.slice(1).join('\n');
-    } catch {
-      //
-    }
-
-    const currentPythonVersion = this.version;
-
-    const needsUpdate = requirementsContent !== requirementsLockContent || currentPythonVersion !== lockPythonVersion;
-
-    if (needsUpdate) {
-      updatedLockContent = `# Python version: ${currentPythonVersion}\n${requirementsContent}`;
-    }
-
-    return { needsUpdate, requirementsLockPath, requirementsContent, lockContent, updatedLockContent };
-  }
-
-  private async analyzeDependencies(reqContent: string, reqLockContent?: string, needsUpdate?: boolean): Promise<{ reInstall: string[]; uninstall: string[] }> {
-    const requiredPackages = new Set<string>(
-      reqContent
-        .split('\n')
-        .filter((line) => /^[a-zA-Z]/.test(line))
-        .map((line) => this.cleanPackageName(line))
-        .filter((line) => line !== ''),
-    );
-
-    let oldPackeges = new Set<string>();
-    if (reqLockContent) {
-      oldPackeges = new Set<string>(
-        reqLockContent
-          .split('\n')
-          .filter((line) => /^[a-zA-Z]/.test(line))
-          .map((line) => this.cleanPackageName(line))
-          .filter((line) => line !== ''),
-      );
-    }
-
-    const toReinstall: string[] = [];
-    const toUninstall: string[] = [...this.difference(oldPackeges, requiredPackages)];
-
-    if (needsUpdate || this.needsUpdate) {
-      toReinstall.push(...requiredPackages);
-    } else {
-      toReinstall.push(...this.difference(requiredPackages, oldPackeges));
-    }
-
-    return { reInstall: toReinstall, uninstall: toUninstall };
-  }
-
-  private async updateDependencies(
-    type: 'server' | 'plugin',
-    requirementsPath: string,
-    requirementsContent: string,
-    reInstall: string[] = [],
-    uninstall: string[] = [],
-  ): Promise<void> {
-    if (uninstall.length > 0) {
-      this.logger.trace(`Uninstalling ${type} packages: ${uninstall.join(', ')}`);
-
-      if (type === 'plugin') {
-        await this.uninstallPluginPackages(uninstall);
-      } else {
-        await this.uninstallServerPackages(uninstall);
-      }
-    }
-
-    if (reInstall.length > 0) {
-      this.logger.trace(`Installing ${type} requirements...`);
-
-      if (type === 'plugin') {
-        await this.installPluginRequirements(requirementsPath);
-      } else {
-        await this.installServerRequirements(requirementsPath);
-      }
-    } else {
-      this.logger.trace(`Dependencies for ${type} are up to date`);
-    }
-  }
-
-  private async installRequirements(pythonPath: string, requirementsPath: string): Promise<string> {
-    const args = [this.quotePath(pythonPath), '-m', 'pip', 'install', '--upgrade', 'pip', '-r', this.quotePath(requirementsPath)];
-
-    if ((process.env.SUDO_UID && process.env.SUDO_GID) || process.getuid?.() === 0) {
-      args.push('--root-user-action=ignore');
-    }
-
-    args.push('--use-pep517');
-
-    const command = args.join(' ');
-    this.logger.trace(`Installing requirements command: ${command}`);
-
-    const child = exec(command, { env: { ...process.env, PIP_DISABLE_PIP_VERSION_CHECK: '1' } });
-
-    const stdoutLine = createInterface({
-      input: child.stdout!,
-      terminal: false,
-    });
-
-    const stderrLine = createInterface({
-      input: child.stderr!,
-      terminal: false,
-    });
-
-    stdoutLine.on('line', (line: string) => {
-      this.logger.trace(line);
-    });
-
-    stderrLine.on('line', (line: string) => {
-      this.logger.error(line);
-    });
-
-    return new Promise((_resolve, _reject) => {
-      child.on('close', (code) => {
-        stdoutLine.close();
-        stderrLine.close();
-
-        if (code === 0) {
-          _resolve('Requirements installed');
-        } else {
-          _reject(new Error(`Installation process exited with code ${code}`));
-        }
-      });
-    });
-  }
-
-  private async installPackages(pythonPath: string, pkgs: string[]): Promise<string> {
-    if (pkgs.length === 0) return Promise.resolve('');
-
-    const args = [this.quotePath(pythonPath), '-m', 'pip', 'install', '--upgrade', 'pip'];
-    args.push(...pkgs.map((pkg) => (pkg.includes(' ') ? this.quotePath(pkg) : pkg)));
-
-    if ((process.env.SUDO_UID && process.env.SUDO_GID) || process.getuid?.() === 0) {
-      args.push('--root-user-action=ignore');
-    }
-
-    args.push('--use-pep517');
-
-    const command = args.join(' ');
-    this.logger.trace(`Installing packages command: ${command}`);
-
-    const child = exec(command, { env: { ...process.env, PIP_DISABLE_PIP_VERSION_CHECK: '1' } });
-
-    const stdoutLine = createInterface({
-      input: child.stdout!,
-      terminal: false,
-    });
-
-    const stderrLine = createInterface({
-      input: child.stderr!,
-      terminal: false,
-    });
-
-    stdoutLine.on('line', (line: string) => {
-      this.logger.trace(line);
-    });
-
-    stderrLine.on('line', (line: string) => {
-      this.logger.error(line);
-    });
-
-    return new Promise((_resolve, _reject) => {
-      child.on('close', (code) => {
-        stdoutLine.close();
-        stderrLine.close();
-
-        if (code === 0) {
-          _resolve('Packages installed');
-        } else {
-          _reject(new Error(`Installation process exited with code ${code}`));
-        }
-      });
-    });
-  }
-
-  private async uninstallPackages(pythonPath: string, pkgs: string[]): Promise<string> {
-    if (pkgs.length === 0) return Promise.resolve('');
-
-    const args = [this.quotePath(pythonPath), '-m', 'pip', 'uninstall', '-y'];
-    args.push(...pkgs.map((pkg) => (pkg.includes(' ') ? this.quotePath(pkg) : pkg)));
-
-    if ((process.env.SUDO_UID && process.env.SUDO_GID) || process.getuid?.() === 0) {
-      args.unshift('sudo', '-H');
-      args.push('--root-user-action=ignore');
-    }
-
-    const command = args.join(' ');
-    this.logger.trace(`Uninstalling packages command: ${command}`);
-
-    const child = exec(command, { env: { ...process.env, PIP_DISABLE_PIP_VERSION_CHECK: '1' } });
-
-    const stdoutLine = createInterface({
-      input: child.stdout!,
-      terminal: false,
-    });
-
-    const stderrLine = createInterface({
-      input: child.stderr!,
-      terminal: false,
-    });
-
-    stdoutLine.on('line', (line: string) => {
-      this.logger.trace(line);
-    });
-
-    stderrLine.on('line', (line: string) => {
-      this.logger.error(line);
-    });
-
-    return new Promise((_resolve, _reject) => {
-      child.on('close', (code) => {
-        stdoutLine.close();
-        stderrLine.close();
-
-        if (code === 0) {
-          _resolve('Packages uninstalled');
-        } else {
-          _reject(new Error(`Installation process exited with code ${code}`));
-        }
-      });
-    });
-  }
-
-  private async reinstallPackages(pythonPath: string, pkgs: string[]): Promise<string> {
-    if (pkgs.length === 0) return Promise.resolve('');
-
-    const args = [this.quotePath(pythonPath), '-m', 'pip', 'install', '--force-reinstall'];
-    args.push(...pkgs.map((pkg) => (pkg.includes(' ') ? this.quotePath(pkg) : pkg)));
-
-    if ((process.env.SUDO_UID && process.env.SUDO_GID) || process.getuid?.() === 0) {
-      args.push('--root-user-action=ignore');
-    }
-
-    args.push('--use-pep517');
-
-    const command = args.join(' ');
-    this.logger.trace(`Reinstalling packages command: ${command}`);
-
-    const child = exec(command, { env: { ...process.env, PIP_DISABLE_PIP_VERSION_CHECK: '1' } });
-
-    const stdoutLine = createInterface({
-      input: child.stdout!,
-      terminal: false,
-    });
-
-    const stderrLine = createInterface({
-      input: child.stderr!,
-      terminal: false,
-    });
-
-    stdoutLine.on('line', (line: string) => {
-      this.logger.trace(line);
-    });
-
-    stderrLine.on('line', (line: string) => {
-      this.logger.error(line);
-    });
-
-    return new Promise((_resolve, _reject) => {
-      child.on('close', (code) => {
-        stdoutLine.close();
-        stderrLine.close();
-
-        if (code === 0) {
-          _resolve('Packages reinstalled');
-        } else {
-          _reject(new Error(`Installation process exited with code ${code}`));
-        }
-      });
-    });
-  }
-
-  private async ensureVenv(): Promise<void> {
-    if (!this.venvPath) {
-      throw new Error('Venv path is not defined');
-    }
-
-    if (!existsSync(this.venvPath)) {
-      await this.createVenv();
-    }
-  }
-
-  private async createVenv(): Promise<void> {
-    if (!this.venvPath) {
-      throw new Error('Venv path is not defined');
-    }
-
-    if (existsSync(this.venvPath)) {
-      return;
-    }
-
-    this.needsUpdate = true;
-
-    const args = [this.quotePath(this.serverPythonPath), '-m', 'virtualenv', this.quotePath(this.venvPath)];
-
-    const command = args.join(' ');
-    this.logger.trace(`Creating venv using virtualenv: ${command}`);
-
-    const child = exec(command, { env: { ...process.env, VIRTUALENV_PYTHON: this.serverPythonPath } });
-
-    const stdoutLine = createInterface({
-      input: child.stdout!,
-      terminal: false,
-    });
-
-    const stderrLine = createInterface({
-      input: child.stderr!,
-      terminal: false,
-    });
-
-    stdoutLine.on('line', (line: string) => {
-      this.logger.trace(line);
-    });
-
-    stderrLine.on('line', (line: string) => {
-      this.logger.error(line);
-    });
-
-    return new Promise((_resolve, _reject) => {
-      child.on('close', (code) => {
-        stdoutLine.close();
-        stderrLine.close();
-
-        if (code === 0) {
-          _resolve();
-        } else {
-          _reject(new Error(`Virtualenv creation process exited with code ${code}`));
-        }
-      });
-    });
-  }
-
-  private async removeVenv(): Promise<void> {
-    if (!this.venvPath) {
-      throw new Error('Venv path is not defined');
-    }
-
-    await rm(this.venvPath, { recursive: true, force: true });
-
-    const parentDirectory = dirname(this.venvPath);
-    const directories = await readdir(parentDirectory, { withFileTypes: true });
-
-    const pythonDirs = directories.filter((dirent) => dirent.isDirectory() && dirent.name.startsWith('python-')).map((dirent) => join(parentDirectory, dirent.name));
-
-    for (const dir of pythonDirs) {
-      await rm(dir, { recursive: true, force: true });
-    }
-  }
-
-  private async removeOldVersions(): Promise<void> {
-    const currentVersion = this.version;
-    const pythonDirs = await readdir(this.installPath);
-
-    for (const dir of pythonDirs) {
-      const match = /^python-(\d+\.\d+(?:\.\d+)?)(.*)$/.exec(dir);
-
-      if (match) {
-        const version = match[1];
-        const platformSuffix = match[2];
-
-        if (compareVersions(version, currentVersion) === -1) {
-          const fullPath = join(this.installPath, `python-${version}${platformSuffix}`);
-          const requirementsLockPath = join(this.installPath, `requirements-lock-${version}.txt`);
-
-          this.logger.trace(`Removing old Python version: ${version}`);
-
-          await remove(fullPath);
-          await remove(requirementsLockPath);
-        }
-      }
-    }
-  }
-
-  private getMajorMinorVersion(version: string): string {
-    const match = /^(\d+)(?:\.(\d+))?/.exec(version);
-    if (match) {
-      const major = match[1];
-      const minor = match[2] || '';
-      return minor ? `${major}.${minor}` : major;
-    }
-    return '';
-  }
-
-  private cleanPackageName(line: string): string {
-    const regex = /^([a-zA-Z0-9_-]+)/;
-    const match = regex.exec(line);
-    return match ? match[1] : '';
-  }
-
-  private difference(setA: Set<string>, setB: Set<string>): Set<string> {
-    return new Set([...setA].filter((x) => !setB.has(x)));
-  }
-
-  private quotePath(path: string): string {
-    return platform() === 'win32' ? `"${path.replace(/"/g, '\\"')}"` : `'${path.replace(/'/g, "\\'")}'`;
-  }
-}

package/tsconfig.json

@@ -1,37 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "./dist/server",
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": [
-      "ES2022",
-      "DOM"
-    ],
-    "declaration": true,
-    "sourceMap": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "preserveConstEnums": true,
-    "skipLibCheck": true,
-    "useUnknownInCatchVariables": false,
-    "allowSyntheticDefaultImports": true,
-    "resolveJsonModule": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "verbatimModuleSyntax": true,
-    "noImplicitAny": true,
-  },
-  "include": [
-    "*.d.ts",
-    "src",
-    "bin",
-    "types",
-    "install"
-  ],
-  "exclude": [
-    "node_modules",
-    "**/test/**",
-    "**/wasm/**"
-  ]
-}

package/types/fastify.d.ts

@@ -1,14 +0,0 @@
-import type { DBUser } from '../src/api/database/types.ts';
-import type { JwtTokenDecoded } from '../src/api/types/index.ts';
-
-export interface CustomLocals {
-  user?: DBUser;
-  items?: any[];
-  jwt?: JwtTokenDecoded;
-}
-
-declare module 'fastify' {
-  interface FastifyRequest {
-    locals: CustomLocals;
-  }
-}

package/updates.config.js

@@ -1,3 +0,0 @@
-export default {
-  exclude: ['@scrypted/node-pty', 'fix-path'],
-};