n8n 2.36.7 → 2.37.1

package/dist/modules/community-packages/community-packages.service.js

@@ -8,6 +8,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommunityPackagesService = void 0;
 exports.isValidVersionSpecifier = isValidVersionSpecifier;
@@ -23,6 +26,7 @@ const node_child_process_1 = require("node:child_process");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
+const p_limit_1 = __importDefault(require("p-limit"));
 const semver_1 = require("semver");
 const constants_2 = require("../../constants");
 const feature_not_licensed_error_1 = require("../../errors/feature-not-licensed.error");
@@ -52,9 +56,9 @@ let CommunityPackagesService = class CommunityPackagesService {
         this.publisher = publisher;
         this.license = license;
         this.config = config;
-        this.missingPackages = [];
         this.downloadFolder = this.instanceSettings.nodesDownloadDir;
         this.packageJsonPath = (0, node_path_1.join)(this.downloadFolder, 'package.json');
+        this.packageMutex = (0, p_limit_1.default)(1);
         this.http = outboundHttp.requests({
             ssrf: 'disabled',
             timeout: REQUEST_TIMEOUT_MS,
@@ -64,18 +68,12 @@ let CommunityPackagesService = class CommunityPackagesService {
         await this.ensurePackageJson();
         await this.checkForMissingPackages();
     }
-    get hasMissingPackages() {
-        return this.missingPackages.length > 0;
-    }
     async findInstalledPackage(packageName) {
         return await this.installedPackageRepository.findOne({
             where: { packageName },
             relations: ['installedNodes'],
         });
     }
-    async isPackageInstalled(packageName) {
-        return await this.installedPackageRepository.exist({ where: { packageName } });
-    }
     async getAllInstalledPackages() {
         return await this.installedPackageRepository.find({ relations: ['installedNodes'] });
     }
@@ -140,27 +138,15 @@ let CommunityPackagesService = class CommunityPackagesService {
             return acc;
         }, []);
     }
-    matchMissingPackages(installedPackages) {
-        const missingPackagesList = this.missingPackages
-            .map((name) => {
-            try {
-                const parsedPackageData = this.parseNpmPackageName(name);
-                return parsedPackageData.packageName;
-            }
-            catch {
-                return;
-            }
-        })
-            .filter((i) => i !== undefined);
-        const packages = [];
-        for (const installedPackage of installedPackages) {
-            const pkg = { ...installedPackage };
-            if (missingPackagesList.includes(pkg.packageName)) {
-                pkg.failedLoading = true;
-            }
-            packages.push(pkg);
-        }
-        return packages;
+    areNodesLoaded(installedNodes) {
+        return (installedNodes.length === 0 ||
+            installedNodes.some((node) => this.loadNodesAndCredentials.isKnownNode(node.type)));
+    }
+    withLoadStatus(installedPackages) {
+        return installedPackages.map((installedPackage) => ({
+            ...installedPackage,
+            failedLoading: !this.areNodesLoaded(installedPackage.installedNodes),
+        }));
     }
     async checkNpmPackageStatus(packageName) {
         const N8N_BACKEND_SERVICE_URL = 'https://api.n8n.io/api/package';
@@ -178,48 +164,55 @@ let CommunityPackagesService = class CommunityPackagesService {
         }
         return { status: constants_2.NPM_PACKAGE_STATUS_GOOD };
     }
-    hasPackageLoaded(packageName) {
-        if (!this.missingPackages.length)
-            return true;
-        return !this.missingPackages.some((packageNameAndVersion) => packageNameAndVersion.startsWith(packageName) &&
-            packageNameAndVersion.replace(packageName, '').startsWith('@'));
-    }
-    removePackageFromMissingList(packageName) {
-        try {
-            this.missingPackages = this.missingPackages.filter((packageNameAndVersion) => !packageNameAndVersion.startsWith(packageName) ||
-                !packageNameAndVersion.replace(packageName, '').startsWith('@'));
-        }
-        catch {
-        }
+    isPackageLoaded(installedPackage) {
+        return this.areNodesLoaded(installedPackage.installedNodes);
+    }
+    async readPackageJson() {
+        const content = await (0, promises_1.readFile)(this.packageJsonPath, 'utf-8').catch(() => null);
+        if (content === null)
+            return null;
+        const packageJson = (0, n8n_workflow_1.jsonParse)(content, { fallbackValue: null });
+        if (packageJson?.dependencies)
+            return packageJson;
+        this.logger.warn('Community package ledger is unusable, rebuilding it');
+        return null;
+    }
+    async readInstalledPackageVersion(packageName) {
+        const packageJsonPath = `${this.resolvePackageDirectory(packageName)}/package.json`;
+        const content = await (0, promises_1.readFile)(packageJsonPath, 'utf-8').catch(() => null);
+        if (content === null)
+            return null;
+        return (0, n8n_workflow_1.jsonParse)(content, { fallbackValue: null })?.version ?? null;
+    }
+    async buildPackageJsonFromDatabase() {
+        const installedPackages = await this.getAllInstalledPackages();
+        return {
+            name: 'installed-nodes',
+            private: true,
+            dependencies: Object.fromEntries(installedPackages.map(({ packageName, installedVersion }) => [
+                packageName,
+                installedVersion,
+            ])),
+        };
     }
     async ensurePackageJson() {
-        try {
-            await (0, promises_1.access)(this.packageJsonPath, promises_1.constants.F_OK);
-        }
-        catch {
-            await (0, promises_1.mkdir)(this.downloadFolder, { recursive: true });
-            const packageJson = {
-                name: 'installed-nodes',
-                private: true,
-                dependencies: {},
-            };
-            await (0, promises_1.writeFile)(this.packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8');
-        }
+        if (await this.readPackageJson())
+            return;
+        const packageJson = await this.buildPackageJsonFromDatabase();
+        await (0, promises_1.mkdir)(this.downloadFolder, { recursive: true });
+        await (0, promises_1.writeFile)(this.packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8');
     }
     async checkForMissingPackages() {
         const installedPackages = await this.getAllInstalledPackages();
         const missingPackages = new Set();
         installedPackages.forEach((installedPackage) => {
-            installedPackage.installedNodes.forEach((installedNode) => {
-                if (!this.loadNodesAndCredentials.isKnownNode(installedNode.type)) {
-                    missingPackages.add({
-                        packageName: installedPackage.packageName,
-                        version: installedPackage.installedVersion,
-                    });
-                }
+            if (this.areNodesLoaded(installedPackage.installedNodes))
+                return;
+            missingPackages.add({
+                packageName: installedPackage.packageName,
+                version: installedPackage.installedVersion,
             });
         });
-        this.missingPackages = [];
         if (missingPackages.size === 0)
             return;
         const { reinstallMissing } = this.config;
@@ -271,7 +264,6 @@ let CommunityPackagesService = class CommunityPackagesService {
         else {
             this.logger.warn('n8n detected that some packages are missing. For more information, visit https://docs.n8n.io/integrations/community-nodes/troubleshooting/');
         }
-        this.missingPackages = [...missingPackages].map((missingPackage) => `${missingPackage.packageName}@${missingPackage.version}`);
     }
     async installPackage(packageName, version, checksum) {
         return await this.installOrUpdatePackage(packageName, { version, checksum });
@@ -282,9 +274,16 @@ let CommunityPackagesService = class CommunityPackagesService {
     async removePackage(packageName, installedPackage) {
         await this.removeNpmPackage(packageName);
         await this.removePackageFromDatabase(installedPackage);
-        void this.publisher.publishCommand({
+        void this.publisher
+            .publishCommand({
             command: 'community-package-uninstall',
             payload: { packageName },
+        })
+            .catch((error) => {
+            this.logger.warn('Failed to publish community package uninstall event', {
+                error: (0, ensure_error_1.ensureError)(error),
+                packageName,
+            });
         });
     }
     getNpmRegistry() {
@@ -303,51 +302,37 @@ let CommunityPackagesService = class CommunityPackagesService {
         }
     }
     async installOrUpdatePackage(packageName, options = {}) {
-        const isUpdate = 'installedPackage' in options;
-        const packageVersion = !options.version ? 'latest' : options.version;
-        const shouldValidateChecksum = 'checksum' in options && Boolean(options.checksum);
-        this.checkInstallPermissions(shouldValidateChecksum);
-        const authToken = this.getNpmAuthToken();
-        if (options.checksum) {
-            await (0, npm_utils_1.verifyIntegrity)(packageName, packageVersion, this.getNpmRegistry(), options.checksum, authToken);
-        }
-        await (0, npm_utils_1.checkIfVersionExistsOrThrow)(packageName, packageVersion, this.getNpmRegistry(), authToken);
-        const previousVersion = isUpdate ? options.installedPackage.installedVersion : undefined;
-        const backupDirectory = isUpdate && (await this.packageDirectoryExists(packageName))
-            ? await this.backupPackageDirectory(packageName)
-            : undefined;
-        try {
-            await this.downloadPackage(packageName, packageVersion, authToken);
-        }
-        catch (error) {
-            await this.restoreFailedPackageInstallation(packageName, {
-                backupDirectory,
-                previousVersion,
-            });
-            if (error instanceof Error && error.message === constants_2.RESPONSE_ERROR_MESSAGES.PACKAGE_NOT_FOUND) {
-                throw new n8n_workflow_1.UserError('npm package not found', { extra: { packageName } });
+        return await this.packageMutex(async () => {
+            const isUpdate = 'installedPackage' in options;
+            const packageVersion = !options.version ? 'latest' : options.version;
+            const shouldValidateChecksum = 'checksum' in options && Boolean(options.checksum);
+            this.checkInstallPermissions(shouldValidateChecksum);
+            const authToken = this.getNpmAuthToken();
+            if (options.checksum) {
+                await (0, npm_utils_1.verifyIntegrity)(packageName, packageVersion, this.getNpmRegistry(), options.checksum, authToken);
             }
-            throw error;
-        }
-        let loader;
-        try {
-            await this.loadNodesAndCredentials.unloadPackage(packageName);
-            loader = await this.loadNodesAndCredentials.loadPackage(packageName);
-        }
-        catch (error) {
-            await this.restoreFailedPackageInstallation(packageName, {
-                backupDirectory,
-                previousVersion,
-                reloadPackage: isUpdate,
-            });
-            throw new n8n_workflow_1.UnexpectedError(constants_2.RESPONSE_ERROR_MESSAGES.PACKAGE_LOADING_FAILED, { cause: error });
-        }
-        if (loader.loadedNodes.length > 0) {
-            let installedPackage;
+            await (0, npm_utils_1.checkIfVersionExistsOrThrow)(packageName, packageVersion, this.getNpmRegistry(), authToken);
+            const previousVersion = isUpdate ? options.installedPackage.installedVersion : undefined;
+            const backupDirectory = isUpdate && (await this.packageDirectoryExists(packageName))
+                ? await this.backupPackageDirectory(packageName)
+                : undefined;
             try {
-                installedPackage = isUpdate
-                    ? await this.replaceInstalledPackage(options.installedPackage, loader)
-                    : await this.persistInstalledPackage(loader);
+                await this.downloadPackage(packageName, packageVersion, authToken);
+            }
+            catch (error) {
+                await this.restoreFailedPackageInstallation(packageName, {
+                    backupDirectory,
+                    previousVersion,
+                });
+                if (error instanceof Error && error.message === constants_2.RESPONSE_ERROR_MESSAGES.PACKAGE_NOT_FOUND) {
+                    throw new n8n_workflow_1.UserError('npm package not found', { extra: { packageName } });
+                }
+                throw error;
+            }
+            let loader;
+            try {
+                await this.loadNodesAndCredentials.unloadPackage(packageName);
+                loader = await this.loadNodesAndCredentials.loadPackage(packageName);
             }
             catch (error) {
                 await this.restoreFailedPackageInstallation(packageName, {
@@ -355,62 +340,115 @@ let CommunityPackagesService = class CommunityPackagesService {
                     previousVersion,
                     reloadPackage: isUpdate,
                 });
-                throw new n8n_workflow_1.UnexpectedError('Failed to save installed package', {
-                    extra: { packageName },
+                throw new n8n_workflow_1.UnexpectedError(constants_2.RESPONSE_ERROR_MESSAGES.PACKAGE_LOADING_FAILED, {
                     cause: error,
                 });
             }
-            if (backupDirectory) {
+            if (loader.loadedNodes.length > 0) {
+                let installedPackage;
                 try {
-                    await (0, promises_1.rm)(backupDirectory, { recursive: true, force: true });
+                    installedPackage = isUpdate
+                        ? await this.replaceInstalledPackage(options.installedPackage, loader)
+                        : await this.persistInstalledPackage(loader);
                 }
                 catch (error) {
-                    this.logger.warn('Failed to remove community package backup directory', {
-                        error: (0, ensure_error_1.ensureError)(error),
-                        packageName,
+                    await this.restoreFailedPackageInstallation(packageName, {
                         backupDirectory,
+                        previousVersion,
+                        reloadPackage: isUpdate,
+                    });
+                    throw new n8n_workflow_1.UnexpectedError('Failed to save installed package', {
+                        extra: { packageName },
+                        cause: error,
                     });
                 }
+                if (backupDirectory) {
+                    try {
+                        await (0, promises_1.rm)(backupDirectory, { recursive: true, force: true, maxRetries: 3 });
+                    }
+                    catch (error) {
+                        this.logger.warn('Failed to remove community package backup directory', {
+                            error: (0, ensure_error_1.ensureError)(error),
+                            packageName,
+                            backupDirectory,
+                        });
+                    }
+                }
+                const { installedVersion } = installedPackage;
+                void this.publisher
+                    .publishCommand({
+                    command: isUpdate ? 'community-package-update' : 'community-package-install',
+                    payload: { packageName, packageVersion: installedVersion },
+                })
+                    .catch((error) => {
+                    this.logger.warn('Failed to publish community package install/update event', {
+                        error: (0, ensure_error_1.ensureError)(error),
+                        packageName,
+                        packageVersion: installedVersion,
+                    });
+                });
+                await this.loadNodesAndCredentials.postProcessLoaders();
+                this.loadNodesAndCredentials.releaseTypes();
+                this.logger.info(`Community package installed: ${packageName}`);
+                return installedPackage;
             }
-            void this.publisher.publishCommand({
-                command: isUpdate ? 'community-package-update' : 'community-package-install',
-                payload: { packageName, packageVersion },
-            });
-            await this.loadNodesAndCredentials.postProcessLoaders();
-            this.loadNodesAndCredentials.releaseTypes();
-            this.logger.info(`Community package installed: ${packageName}`);
-            return installedPackage;
+            else {
+                await this.restoreFailedPackageInstallation(packageName, {
+                    backupDirectory,
+                    previousVersion,
+                    reloadPackage: isUpdate,
+                });
+                throw new n8n_workflow_1.UnexpectedError(constants_2.RESPONSE_ERROR_MESSAGES.PACKAGE_DOES_NOT_CONTAIN_NODES);
+            }
+        });
+    }
+    async handleInstallEvent({ packageName, packageVersion, }) {
+        try {
+            await this.installOrUpdateNpmPackage(packageName, packageVersion);
         }
-        else {
-            await this.restoreFailedPackageInstallation(packageName, {
-                backupDirectory,
-                previousVersion,
-                reloadPackage: isUpdate,
+        catch (error) {
+            this.logger.error(`Failed to install community package ${packageName} from pubsub event`, {
+                error: (0, ensure_error_1.ensureError)(error),
+                packageName,
+                packageVersion,
             });
-            throw new n8n_workflow_1.UnexpectedError(constants_2.RESPONSE_ERROR_MESSAGES.PACKAGE_DOES_NOT_CONTAIN_NODES);
         }
     }
-    async handleInstallEvent({ packageName, packageVersion, }) {
-        await this.installOrUpdateNpmPackage(packageName, packageVersion);
-    }
     async handleUninstallEvent({ packageName }) {
-        await this.removeNpmPackage(packageName);
+        try {
+            await this.removeNpmPackage(packageName);
+        }
+        catch (error) {
+            this.logger.error(`Failed to uninstall community package ${packageName} from pubsub event`, {
+                error: (0, ensure_error_1.ensureError)(error),
+                packageName,
+            });
+        }
     }
     async installOrUpdateNpmPackage(packageName, packageVersion) {
-        const authToken = this.getNpmAuthToken();
-        await this.downloadPackage(packageName, packageVersion, authToken);
-        await this.loadNodesAndCredentials.unloadPackage(packageName);
-        await this.loadNodesAndCredentials.loadPackage(packageName);
-        await this.loadNodesAndCredentials.postProcessLoaders();
-        this.loadNodesAndCredentials.releaseTypes();
-        this.logger.info(`Community package installed: ${packageName}`);
+        return await this.packageMutex(async () => {
+            const onDiskVersion = await this.readInstalledPackageVersion(packageName);
+            if (onDiskVersion === packageVersion && this.loadNodesAndCredentials.loaders[packageName]) {
+                this.logger.debug(`Community package ${packageName} already at ${packageVersion}, skipping`);
+                return;
+            }
+            const authToken = this.getNpmAuthToken();
+            await this.downloadPackage(packageName, packageVersion, authToken);
+            await this.loadNodesAndCredentials.unloadPackage(packageName);
+            await this.loadNodesAndCredentials.loadPackage(packageName);
+            await this.loadNodesAndCredentials.postProcessLoaders();
+            this.loadNodesAndCredentials.releaseTypes();
+            this.logger.info(`Community package installed: ${packageName}`);
+        });
     }
     async removeNpmPackage(packageName) {
-        await this.deletePackageDirectory(packageName);
-        await this.loadNodesAndCredentials.unloadPackage(packageName);
-        await this.loadNodesAndCredentials.postProcessLoaders();
-        this.loadNodesAndCredentials.releaseTypes();
-        this.logger.info(`Community package uninstalled: ${packageName}`);
+        return await this.packageMutex(async () => {
+            await this.deletePackageDirectory(packageName);
+            await this.loadNodesAndCredentials.unloadPackage(packageName);
+            await this.loadNodesAndCredentials.postProcessLoaders();
+            this.loadNodesAndCredentials.releaseTypes();
+            this.logger.info(`Community package uninstalled: ${packageName}`);
+        });
     }
     resolvePackageDirectory(packageName) {
         return `${this.downloadFolder}/node_modules/${packageName}`;
@@ -430,25 +468,44 @@ let CommunityPackagesService = class CommunityPackagesService {
         await (0, promises_1.rename)(packageDirectory, backupDirectory);
         return backupDirectory;
     }
+    async restorePackageDirectoryFromBackup(packageName, backupDirectory) {
+        await this.deletePackageDirectory(packageName);
+        if (!backupDirectory)
+            return;
+        await (0, promises_1.rename)(backupDirectory, this.resolvePackageDirectory(packageName));
+    }
     async restoreFailedPackageInstallation(packageName, options) {
         const { backupDirectory, previousVersion, reloadPackage = false } = options;
         try {
-            await this.deletePackageDirectory(packageName);
+            await this.restorePackageDirectoryFromBackup(packageName, backupDirectory);
+            if (backupDirectory && reloadPackage) {
+                try {
+                    await this.loadNodesAndCredentials.unloadPackage(packageName);
+                    await this.loadNodesAndCredentials.loadPackage(packageName);
+                    await this.loadNodesAndCredentials.postProcessLoaders();
+                    this.loadNodesAndCredentials.releaseTypes();
+                }
+                catch (cleanupError) {
+                    this.logger.warn('Failed to reload community package after failed installation', {
+                        error: (0, ensure_error_1.ensureError)(cleanupError),
+                        packageName,
+                    });
+                }
+            }
+        }
+        catch (cleanupError) {
+            this.logger.warn('Failed to restore community package directory after failed installation', {
+                error: (0, ensure_error_1.ensureError)(cleanupError),
+                packageName,
+            });
+        }
+        try {
             if (previousVersion) {
                 await this.updatePackageJsonDependency(packageName, previousVersion);
             }
             else {
                 await this.removePackageJsonDependency(packageName);
             }
-            if (!backupDirectory)
-                return;
-            await (0, promises_1.rename)(backupDirectory, this.resolvePackageDirectory(packageName));
-            if (!reloadPackage)
-                return;
-            await this.loadNodesAndCredentials.unloadPackage(packageName);
-            await this.loadNodesAndCredentials.loadPackage(packageName);
-            await this.loadNodesAndCredentials.postProcessLoaders();
-            this.loadNodesAndCredentials.releaseTypes();
         }
         catch (cleanupError) {
             this.logger.warn('Failed to restore community package after failed installation', {
@@ -460,35 +517,65 @@ let CommunityPackagesService = class CommunityPackagesService {
     async downloadPackage(packageName, packageVersion, authToken) {
         const registry = this.getNpmRegistry();
         const packageDirectory = this.resolvePackageDirectory(packageName);
-        await this.deletePackageDirectory(packageName);
-        await (0, promises_1.mkdir)(packageDirectory, { recursive: true });
-        const tarOutput = await (0, npm_utils_1.executeNpmCommand)(['pack', `${packageName}@${packageVersion}`, '--quiet'], { cwd: this.downloadFolder, registry, authToken });
-        const tarballName = tarOutput?.trim();
+        const backupDirectory = (await this.packageDirectoryExists(packageName))
+            ? await this.backupPackageDirectory(packageName)
+            : undefined;
         try {
-            await asyncExecFile('tar', ['-xzf', tarballName, '-C', packageDirectory, '--strip-components=1'], { cwd: this.downloadFolder });
-            const packageJsonPath = `${packageDirectory}/package.json`;
-            const packageJsonContent = await (0, promises_1.readFile)(packageJsonPath, 'utf-8');
-            const { devDependencies, peerDependencies, optionalDependencies, ...packageJson } = JSON.parse(packageJsonContent);
-            await (0, promises_1.writeFile)(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8');
-            await (0, npm_utils_1.executeNpmCommand)([
-                'install',
-                '--audit=false',
-                '--fund=false',
-                '--bin-links=false',
-                '--install-strategy=shallow',
-                '--ignore-scripts=true',
-                '--package-lock=false',
-            ], { cwd: packageDirectory, registry, authToken });
-            await this.updatePackageJsonDependency(packageName, packageJson.version);
+            await (0, promises_1.mkdir)(packageDirectory, { recursive: true });
+            const tarOutput = await (0, npm_utils_1.executeNpmCommand)(['pack', `${packageName}@${packageVersion}`, '--quiet'], { cwd: this.downloadFolder, registry, authToken });
+            const tarballName = tarOutput?.trim();
+            try {
+                await asyncExecFile('tar', ['-xzf', tarballName, '-C', packageDirectory, '--strip-components=1'], { cwd: this.downloadFolder });
+                const packageJsonPath = `${packageDirectory}/package.json`;
+                const packageJsonContent = await (0, promises_1.readFile)(packageJsonPath, 'utf-8');
+                const { devDependencies, peerDependencies, optionalDependencies, ...packageJson } = JSON.parse(packageJsonContent);
+                await (0, promises_1.writeFile)(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8');
+                await (0, npm_utils_1.executeNpmCommand)([
+                    'install',
+                    '--audit=false',
+                    '--fund=false',
+                    '--bin-links=false',
+                    '--install-strategy=shallow',
+                    '--ignore-scripts=true',
+                    '--package-lock=false',
+                ], { cwd: packageDirectory, registry, authToken });
+                await this.updatePackageJsonDependency(packageName, packageJson.version);
+            }
+            finally {
+                if (tarballName) {
+                    await (0, promises_1.rm)((0, node_path_1.join)(this.downloadFolder, tarballName));
+                }
+            }
+        }
+        catch (error) {
+            try {
+                await this.restorePackageDirectoryFromBackup(packageName, backupDirectory);
+            }
+            catch (restoreError) {
+                this.logger.warn('Failed to restore community package directory after failed download', {
+                    error: (0, ensure_error_1.ensureError)(restoreError),
+                    packageName,
+                });
+            }
+            throw error;
         }
-        finally {
-            await (0, promises_1.rm)((0, node_path_1.join)(this.downloadFolder, tarballName));
+        if (backupDirectory) {
+            try {
+                await (0, promises_1.rm)(backupDirectory, { recursive: true, force: true, maxRetries: 3 });
+            }
+            catch (error) {
+                this.logger.warn('Failed to remove community package backup directory', {
+                    error: (0, ensure_error_1.ensureError)(error),
+                    packageName,
+                    backupDirectory,
+                });
+            }
         }
         return packageDirectory;
     }
     async deletePackageDirectory(packageName) {
         const packageDirectory = this.resolvePackageDirectory(packageName);
-        await (0, promises_1.rm)(packageDirectory, { recursive: true, force: true });
+        await (0, promises_1.rm)(packageDirectory, { recursive: true, force: true, maxRetries: 3 });
     }
     async updatePackageJsonDependency(packageName, version) {
         await this.mutatePackageJsonDependencies((dependencies) => {
@@ -501,8 +588,7 @@ let CommunityPackagesService = class CommunityPackagesService {
         });
     }
     async mutatePackageJsonDependencies(mutate) {
-        const existingContent = await (0, promises_1.readFile)(this.packageJsonPath, 'utf-8');
-        const packageJson = (0, n8n_workflow_1.jsonParse)(existingContent);
+        const packageJson = (await this.readPackageJson()) ?? (await this.buildPackageJsonFromDatabase());
         mutate(packageJson.dependencies);
         await (0, promises_1.writeFile)(this.packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8');
     }