@camera.ui/common 0.0.5 → 0.0.7

package/dist/npm/index.js

@@ -0,0 +1,128 @@
+import fixPath from '@seydx/fix-path';
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { basename, dirname, join, sep } from 'node:path';
+function isModuleRootDirectory(dir) {
+    const packageJsonPath = join(dir, 'package.json');
+    if (!existsSync(packageJsonPath)) {
+        return false;
+    }
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        return isExpectedPackage(packageJson, dir);
+    }
+    catch {
+        return false;
+    }
+}
+function isExpectedPackage(packageJson, dir) {
+    const dirName = basename(dir);
+    const parentDirName = basename(dirname(dir));
+    if (parentDirName.startsWith('@')) {
+        return packageJson.name === `${parentDirName}/${dirName}`;
+    }
+    else {
+        return packageJson.name === dirName;
+    }
+}
+export function getNpmPath() {
+    fixPath();
+    if (platform() === 'win32') {
+        // if running on windows find the full path to npm
+        const windowsNpmPath = [
+            join(process.env.APPDATA, 'npm/npm.cmd'),
+            join(process.env.ProgramFiles, 'nodejs/npm.cmd'),
+            join(process.env.NVM_SYMLINK || process.env.ProgramFiles + '/nodejs', 'npm.cmd'),
+        ].filter(existsSync);
+        if (windowsNpmPath.length) {
+            return [windowsNpmPath[0]];
+        }
+    }
+    else {
+        try {
+            const npmPath = execSync('which npm').toString().trim();
+            return [npmPath];
+        }
+        catch {
+            //
+        }
+        if (existsSync('/opt/homebridge/bin/npm')) {
+            return ['/opt/homebridge/bin/npm'];
+        }
+    }
+    return ['npm'];
+}
+export function getNpmGlobalModulesDirectory() {
+    try {
+        const npmPath = getNpmPath().join(' ');
+        const npmPrefix = execSync(`${npmPath} -g prefix`, {
+            env: Object.assign({
+                npm_config_loglevel: 'silent',
+                npm_update_notifier: 'false',
+            }, process.env),
+        })
+            .toString('utf8')
+            .trim();
+        return platform() === 'win32' ? join(npmPrefix, 'node_modules') : join(npmPrefix, 'lib', 'node_modules');
+    }
+    catch {
+        return null;
+    }
+}
+export function getInstallDir(currentDir, moduleName) {
+    const rootDir = dirname(currentDir) === currentDir ? currentDir : sep;
+    while (currentDir !== rootDir) {
+        if (isModuleRootDirectory(currentDir)) {
+            return currentDir;
+        }
+        currentDir = dirname(currentDir);
+    }
+    const npmPath = getNpmPath().join(' ');
+    const isWindows = platform() === 'win32';
+    const isSudo = !isWindows && process.getuid?.() === 0;
+    const npmEnv = Object.assign({
+        npm_config_loglevel: 'silent',
+        npm_update_notifier: 'false',
+    }, process.env);
+    if (isWindows) {
+        const npmPrefix = execSync(`"${npmPath}" -g prefix`, {
+            encoding: 'utf8',
+            env: npmEnv,
+        }).trim();
+        return join(npmPrefix, 'node_modules', moduleName);
+    }
+    else {
+        return (execSync(`${isSudo ? 'sudo ' : ''}${npmPath} -g prefix`, {
+            encoding: 'utf8',
+            env: npmEnv,
+        }).trim() + `/lib/node_modules/${moduleName}`);
+    }
+}
+export function getUserHomeDir(asUser) {
+    const isWindows = platform() === 'win32';
+    const user = asUser || process.env.SUDO_USER || process.env.USER;
+    if (isWindows) {
+        return process.env.USERPROFILE || homedir();
+    }
+    try {
+        if (process.getuid?.() === 0) {
+            if (user) {
+                const homeDir = execSync(`eval echo ~${user}`, { encoding: 'utf8' }).trim();
+                if (homeDir.charAt(0) === '~') {
+                    throw new Error('Could not resolve user home directory');
+                }
+                return homeDir;
+            }
+        }
+        else {
+            return process.env.HOME || homedir();
+        }
+    }
+    catch {
+        // Fallback
+    }
+    // Fallback
+    return homedir();
+}
+//# sourceMappingURL=index.js.map

package/dist/npm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/npm/index.ts"],"names":[],"mappings":"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"}

package/dist/packer/index.d.ts

@@ -0,0 +1,2 @@
+export declare const pack: (message: any) => Buffer;
+export declare const unpack: <T = any>(message: Buffer | Uint8Array) => T;

package/dist/packer/index.js

@@ -0,0 +1,17 @@
+import { Packr, Unpackr } from 'msgpackr';
+const packr = new Packr({
+    useRecords: false,
+    encodeUndefinedAsNil: true,
+    int64AsType: 'number',
+});
+const unpackr = new Unpackr({
+    useRecords: false,
+    int64AsType: 'number',
+});
+export const pack = (message) => {
+    return packr.pack(message);
+};
+export const unpack = (message) => {
+    return unpackr.unpack(message);
+};
+//# sourceMappingURL=index.js.map

package/dist/packer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/packer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAE1C,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC;IACtB,UAAU,EAAE,KAAK;IACjB,oBAAoB,EAAE,IAAI;IAC1B,WAAW,EAAE,QAAQ;CACtB,CAAC,CAAC;AAEH,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC;IAC1B,UAAU,EAAE,KAAK;IACjB,WAAW,EAAE,QAAQ;CACtB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,OAAY,EAAU,EAAE;IAC3C,OAAO,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC7B,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,MAAM,GAAG,CAAU,OAA4B,EAAK,EAAE;IACjE,OAAO,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AACjC,CAAC,CAAC"}

package/dist/python/index.d.ts

@@ -0,0 +1,48 @@
+import { PortablePython } from '@bjia56/portable-python';
+import { Logger } from '../logger/index.js';
+import type { LoggerOptions } from '../logger/index.js';
+export declare const DEFAULT_PY_VERSION = "3.11";
+export declare class PythonInstaller {
+    static readonly versions: string[];
+    logger: Logger;
+    readonly python: PortablePython;
+    readonly venvPath?: string;
+    readonly installPath: string;
+    private identifier;
+    private needsUpdate;
+    get isInstalled(): boolean;
+    get pluginPythonPath(): string;
+    get serverPythonPath(): string;
+    get pluginPackagesPath(): string;
+    get serverPackagesPath(): string;
+    get version(): string;
+    private get logPrefix();
+    constructor(homePath: string, identifier: string, venvDir?: string, version?: string, loggerOptions?: LoggerOptions);
+    install(type: 'plugin' | 'server', requirementsPath?: string): Promise<void>;
+    installPluginPython(): Promise<void>;
+    uninstall(): Promise<void>;
+    updatePluginDependencies(requirementsPath: string): Promise<void>;
+    updateServerDependencies(requirementsPath: string): Promise<void>;
+    installPluginPackages(pkgs: string[]): Promise<string>;
+    installServerPackages(pkgs: string[]): Promise<string>;
+    reinstallPluginPackes(pkgs: string[]): Promise<string>;
+    reinstallServerPackages(pkgs: string[]): Promise<string>;
+    uninstallPluginPackages(pkgs: string[]): Promise<string>;
+    uninstallServerPackages(pkgs: string[]): Promise<string>;
+    private installPluginRequirements;
+    private installServerRequirements;
+    private updateRequirements;
+    private analyzeDependencies;
+    private updateDependencies;
+    private installRequirements;
+    private installPackages;
+    private uninstallPackages;
+    private reinstallPackages;
+    private ensureVenv;
+    private createVenv;
+    private removeVenv;
+    private removeOldVersions;
+    private getMajorMinorVersion;
+    private cleanPackageName;
+    private difference;
+}

package/dist/python/index.js

@@ -0,0 +1,478 @@
+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 { Logger } from '../logger/index.js';
+import { IS_ELECTRON } from '../utils/env.js';
+export const DEFAULT_PY_VERSION = '3.11';
+export class PythonInstaller {
+    static versions = ['3.12', '3.11', '3.10', '3.9'];
+    logger;
+    python;
+    venvPath;
+    installPath;
+    identifier;
+    needsUpdate = false;
+    get isInstalled() {
+        return this.python.isInstalled();
+    }
+    get pluginPythonPath() {
+        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() {
+        return this.python.executablePath;
+    }
+    get pluginPackagesPath() {
+        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() {
+        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() {
+        return this.python.version;
+    }
+    get logPrefix() {
+        return `${this.identifier}:`;
+    }
+    constructor(homePath, identifier, venvDir, version = DEFAULT_PY_VERSION, loggerOptions = {}) {
+        this.logger = new Logger({ ...loggerOptions, prefix: 'camera.ui', suffix: 'Python Installer' });
+        this.identifier = identifier;
+        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)}`);
+        }
+    }
+    async install(type, requirementsPath) {
+        if (!this.isInstalled) {
+            this.logger.trace(this.logPrefix, `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);
+                }
+            }
+        }
+    }
+    async installPluginPython() {
+        await this.install('plugin');
+        await this.createVenv();
+    }
+    async uninstall() {
+        if (this.isInstalled) {
+            await this.python.uninstall();
+        }
+        await this.removeVenv();
+    }
+    async updatePluginDependencies(requirementsPath) {
+        try {
+            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);
+            }
+        }
+        catch (error) {
+            this.logger.error(this.logPrefix, `Failed to update plugin dependencies: ${error.message}`);
+        }
+    }
+    async updateServerDependencies(requirementsPath) {
+        try {
+            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);
+            }
+        }
+        catch (error) {
+            this.logger.error(this.logPrefix, `Failed to update server dependencies: ${error.message}`);
+        }
+    }
+    async installPluginPackages(pkgs) {
+        await this.ensureVenv();
+        return this.installPackages(this.pluginPythonPath, pkgs);
+    }
+    async installServerPackages(pkgs) {
+        return this.installPackages(this.serverPythonPath, pkgs);
+    }
+    async reinstallPluginPackes(pkgs) {
+        await this.ensureVenv();
+        return this.reinstallPackages(this.pluginPythonPath, pkgs);
+    }
+    async reinstallServerPackages(pkgs) {
+        return this.reinstallPackages(this.serverPythonPath, pkgs);
+    }
+    async uninstallPluginPackages(pkgs) {
+        await this.ensureVenv();
+        return this.uninstallPackages(this.pluginPythonPath, pkgs);
+    }
+    async uninstallServerPackages(pkgs) {
+        return this.uninstallPackages(this.serverPythonPath, pkgs);
+    }
+    async installPluginRequirements(requirementsPath) {
+        return this.installRequirements(this.pluginPythonPath, requirementsPath);
+    }
+    async installServerRequirements(requirementsPath) {
+        return this.installRequirements(this.serverPythonPath, requirementsPath);
+    }
+    async updateRequirements(requirementsPath, requirementsLockPath) {
+        requirementsLockPath = requirementsLockPath || join(dirname(requirementsPath), 'requirements-lock.txt');
+        const requirementsContent = await readFile(requirementsPath, 'utf8');
+        let lockContent;
+        let updatedLockContent;
+        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 };
+    }
+    async analyzeDependencies(reqContent, reqLockContent, needsUpdate) {
+        const requiredPackages = new Set(reqContent
+            .split('\n')
+            .filter((line) => /^[a-zA-Z]/.test(line))
+            .map((line) => this.cleanPackageName(line))
+            .filter((line) => line !== ''));
+        let oldPackeges = new Set();
+        if (reqLockContent) {
+            oldPackeges = new Set(reqLockContent
+                .split('\n')
+                .filter((line) => /^[a-zA-Z]/.test(line))
+                .map((line) => this.cleanPackageName(line))
+                .filter((line) => line !== ''));
+        }
+        const toReinstall = [];
+        const toUninstall = [...this.difference(oldPackeges, requiredPackages)];
+        if (needsUpdate || this.needsUpdate) {
+            toReinstall.push(...requiredPackages);
+        }
+        else {
+            toReinstall.push(...this.difference(requiredPackages, oldPackeges));
+        }
+        return { reInstall: toReinstall, uninstall: toUninstall };
+    }
+    async updateDependencies(type, requirementsPath, requirementsContent, reInstall = [], uninstall = []) {
+        if (uninstall.length > 0) {
+            this.logger.trace(this.logPrefix, `Uninstalling ${type} packages: ${uninstall.join(', ')}`);
+            if (type === 'plugin') {
+                await this.uninstallPluginPackages(uninstall);
+            }
+            else {
+                await this.uninstallServerPackages(uninstall);
+            }
+        }
+        if (reInstall.length > 0) {
+            this.logger.trace(this.logPrefix, `Installing ${type} requirements...`);
+            if (type === 'plugin') {
+                await this.installPluginRequirements(requirementsPath);
+            }
+            else {
+                await this.installServerRequirements(requirementsPath);
+            }
+        }
+        else {
+            this.logger.trace(this.logPrefix, `Dependencies for ${type} are up to date`);
+        }
+    }
+    async installRequirements(pythonPath, requirementsPath) {
+        const args = [pythonPath, '-m', 'pip', 'install'];
+        args.push('--upgrade pip');
+        args.push('-r', `"${requirementsPath}"`);
+        if ((process.env.SUDO_UID && process.env.SUDO_GID) || process.getuid?.() === 0) {
+            args.unshift('sudo', '-H');
+            args.push('--root-user-action=ignore');
+        }
+        args.push('--use-pep517', '--no-warn-script-location');
+        const child = exec(args.join(' '), { 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) => {
+            this.logger.trace(this.logPrefix, line);
+        });
+        stderrLine.on('line', (line) => {
+            this.logger.error(this.logPrefix, 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}`));
+                }
+            });
+        });
+    }
+    async installPackages(pythonPath, pkgs) {
+        if (pkgs.length === 0)
+            return Promise.resolve('');
+        const args = [pythonPath, '-m', 'pip', 'install'];
+        args.push('--upgrade pip');
+        args.push(...pkgs);
+        if ((process.env.SUDO_UID && process.env.SUDO_GID) || process.getuid?.() === 0) {
+            args.unshift('sudo', '-H');
+            args.push('--root-user-action=ignore');
+        }
+        args.push('--use-pep517', '--no-warn-script-location');
+        this.logger.trace(this.logPrefix, `Installing packages command: ${args.join(' ')}`);
+        const child = exec(args.join(' '), { 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) => {
+            this.logger.trace(this.logPrefix, line);
+        });
+        stderrLine.on('line', (line) => {
+            this.logger.error(this.logPrefix, 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}`));
+                }
+            });
+        });
+    }
+    async uninstallPackages(pythonPath, pkgs) {
+        if (pkgs.length === 0)
+            return Promise.resolve('');
+        const args = [pythonPath, '-m', 'pip', 'uninstall', '-y'];
+        args.push(...pkgs);
+        if ((process.env.SUDO_UID && process.env.SUDO_GID) || process.getuid?.() === 0) {
+            args.unshift('sudo', '-H');
+            args.push('--root-user-action=ignore');
+        }
+        args.push('--no-warn-script-location');
+        this.logger.trace(this.logPrefix, `Uninstalling packages command: ${args.join(' ')}`);
+        const child = exec(args.join(' '), { 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) => {
+            this.logger.trace(this.logPrefix, line);
+        });
+        stderrLine.on('line', (line) => {
+            this.logger.error(this.logPrefix, 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}`));
+                }
+            });
+        });
+    }
+    async reinstallPackages(pythonPath, pkgs) {
+        if (pkgs.length === 0)
+            return Promise.resolve('');
+        const args = [pythonPath, '-m', 'pip', 'install'];
+        args.push('--force-reinstall');
+        args.push(...pkgs);
+        if ((process.env.SUDO_UID && process.env.SUDO_GID) || process.getuid?.() === 0) {
+            args.unshift('sudo', '-H');
+            args.push('--root-user-action=ignore');
+        }
+        args.push('--use-pep517', '--no-warn-script-location');
+        this.logger.trace(this.logPrefix, `Installing packages command: ${args.join(' ')}`);
+        const child = exec(args.join(' '), { 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) => {
+            this.logger.trace(this.logPrefix, line);
+        });
+        stderrLine.on('line', (line) => {
+            this.logger.error(this.logPrefix, 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}`));
+                }
+            });
+        });
+    }
+    async ensureVenv() {
+        if (!this.venvPath) {
+            throw new Error('Venv path is not defined');
+        }
+        if (!existsSync(this.venvPath)) {
+            await this.createVenv();
+        }
+    }
+    async createVenv() {
+        if (!this.venvPath) {
+            throw new Error('Venv path is not defined');
+        }
+        if (existsSync(this.venvPath)) {
+            return;
+        }
+        this.needsUpdate = true;
+        const args = [this.serverPythonPath, '-m', 'virtualenv', this.venvPath];
+        this.logger.trace(this.logPrefix, `Creating venv using virtualenv: ${args.join(' ')}`);
+        const child = exec(args.join(' '), { 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) => {
+            this.logger.trace(this.logPrefix, line);
+        });
+        stderrLine.on('line', (line) => {
+            this.logger.error(this.logPrefix, 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}`));
+                }
+            });
+        });
+    }
+    async removeVenv() {
+        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 });
+        }
+    }
+    async removeOldVersions() {
+        const currentVersion = this.version;
+        const pythonDirs = await readdir(this.installPath);
+        for (const dir of pythonDirs) {
+            const match = dir.match(/^python-(\d+\.\d+(?:\.\d+)?)(.*)$/);
+            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(this.logPrefix, `Removing old Python version: ${version}`);
+                    await remove(fullPath);
+                    await remove(requirementsLockPath);
+                }
+            }
+        }
+    }
+    getMajorMinorVersion(version) {
+        const match = version.match(/^(\d+)(?:\.(\d+))?/);
+        if (match) {
+            const major = match[1];
+            const minor = match[2] || '';
+            return minor ? `${major}.${minor}` : major;
+        }
+        return '';
+    }
+    cleanPackageName(line) {
+        const regex = /^([a-zA-Z0-9_-]+)/;
+        const match = line.match(regex);
+        return match ? match[1] : '';
+    }
+    difference(setA, setB) {
+        return new Set([...setA].filter((x) => !setB.has(x)));
+    }
+}
+//# sourceMappingURL=index.js.map