Update Dockerfile

Dockerfile

@@ -1,20 +1,1101 @@
+FROM n8n/n8n:latest
+USER root
+
 FROM n8nio/n8n:latest
 
-USER root
+# 1. 覆盖 license-state.js
+RUN cat > /usr/local/lib/node_modules/n8n/node_modules/@n8n/backend-common/dist/license-state.js <<'EOF'
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicenseState = void 0;
+const constants_1 = require("@n8n/constants");
+const di_1 = require("@n8n/di");
+const n8n_workflow_1 = require("n8n-workflow");
+class ProviderNotSetError extends n8n_workflow_1.UnexpectedError {
+    constructor() {
+        super('Cannot query license state because license provider has not been set');
+    }
+}
+let LicenseState = class LicenseState {
+    constructor() {
+        this.licenseProvider = null;
+    }
+    setLicenseProvider(provider) {
+        this.licenseProvider = provider;
+    }
+    assertProvider() {
+        if (!this.licenseProvider)
+            throw new ProviderNotSetError();
+    }
+    isLicensed(feature) {
+        return true;
+    }
+    getValue(feature) {
+        this.assertProvider();
+        return this.licenseProvider.getValue(feature);
+    }
+    isCustomRolesLicensed() { return true; }
+    isDynamicCredentialsLicensed() { return true; }
+    isPersonalSpacePolicyLicensed() { return true; }
+    isSharingLicensed() { return true; }
+    isLogStreamingLicensed() { return true; }
+    isLdapLicensed() { return true; }
+    isSamlLicensed() { return true; }
+    isOidcLicensed() { return true; }
+    isMFAEnforcementLicensed() { return true; }
+    isApiKeyScopesLicensed() { return true; }
+    isAiAssistantLicensed() { return true; }
+    isAskAiLicensed() { return true; }
+    isAiCreditsLicensed() { return true; }
+    isAiGatewayLicensed() { return true; }
+    isAdvancedExecutionFiltersLicensed() { return true; }
+    isAdvancedPermissionsLicensed() { return true; }
+    isDebugInEditorLicensed() { return true; }
+    isBinaryDataS3Licensed() { return true; }
+    isMultiMainLicensed() { return true; }
+    isVariablesLicensed() { return true; }
+    isSourceControlLicensed() { return true; }
+    isExternalSecretsLicensed() { return true; }
+    isAPIDisabled() { return false; }
+    isWorkerViewLicensed() { return true; }
+    isProjectRoleAdminLicensed() { return true; }
+    isProjectRoleEditorLicensed() { return true; }
+    isProjectRoleViewerLicensed() { return true; }
+    isCustomNpmRegistryLicensed() { return true; }
+    isFoldersLicensed() { return true; }
+    isInsightsSummaryLicensed() { return true; }
+    isInsightsDashboardLicensed() { return true; }
+    isInsightsHourlyDataLicensed() { return true; }
+    isWorkflowDiffsLicensed() { return true; }
+    isDataRedactionLicensed() { return true; }
+    isProvisioningLicensed() { return true; }
+    getMaxUsers() {
+        return constants_1.UNLIMITED_LICENSE_QUOTA;
+    }
+    getMaxActiveWorkflows() {
+        return constants_1.UNLIMITED_LICENSE_QUOTA;
+    }
+    getMaxVariables() {
+        return constants_1.UNLIMITED_LICENSE_QUOTA;
+    }
+    getMaxAiCredits() {
+        return 99999999;
+    }
+    getWorkflowHistoryPruneQuota() {
+        return constants_1.UNLIMITED_LICENSE_QUOTA;
+    }
+    getInsightsMaxHistory() {
+        return 3650;
+    }
+    getInsightsRetentionMaxAge() {
+        return 3650;
+    }
+    getInsightsRetentionPruneInterval() {
+        return 24;
+    }
+    getMaxTeamProjects() {
+        return -1;
+    }
+    getMaxWorkflowsWithEvaluations() {
+        return -1;
+    }
+};
+exports.LicenseState = LicenseState;
+exports.LicenseState = LicenseState = __decorate([
+    (0, di_1.Service)()
+], LicenseState);
+//# sourceMappingURL=license-state.js.map
+EOF
+
+# 2. 覆盖 license.js
+RUN cat > /usr/local/lib/node_modules/n8n/dist/license.js <<'EOF'
+"use strict";
+var __createBinding = (this && this.__createBinding) || (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+});
+var __setModuleDefault = (this && this.__setModuleDefault) || (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+};
+var __decorate = (this && this.__decorate) || function(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function() {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+});
+var __metadata = (this && this.__metadata) || function(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.License = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const config_1 = require("@n8n/config");
+const constants_1 = require("@n8n/constants");
+const db_1 = require("@n8n/db");
+const decorators_1 = require("@n8n/decorators");
+const di_1 = require("@n8n/di");
+const license_sdk_1 = require("@n8n_io/license-sdk");
+const n8n_core_1 = require("n8n-core");
+const license_metrics_service_1 = require("./metrics/license-metrics.service");
+const constants_2 = require("./constants");
+const LICENSE_RENEWAL_DISABLED_WARNING = 'Automatic license renewal is disabled. The license will not renew automatically, and access to licensed features may be lost!';
+let License = class License {
+    constructor(logger, instanceSettings, settingsRepository, licenseMetricsService, globalConfig) {
+        this.logger = logger;
+        this.instanceSettings = instanceSettings;
+        this.settingsRepository = settingsRepository;
+        this.licenseMetricsService = licenseMetricsService;
+        this.globalConfig = globalConfig;
+        this.isShuttingDown = false;
+        this.refreshCallbacks = [];
+        this.logger = this.logger.scoped('license');
+    }
+    async init({ forceRecreate = false, isCli = false, } = {}) {
+        if (this.manager && !forceRecreate) {
+            this.logger.warn('License manager already initialized or shutting down');
+            return;
+        }
+        if (this.isShuttingDown) {
+            this.logger.warn('License manager already shutting down');
+            return;
+        }
+        const { instanceType } = this.instanceSettings;
+        const isMainInstance = instanceType === 'main';
+        const server = this.globalConfig.license.serverUrl;
+        const offlineMode = !isMainInstance;
+        const autoRenewOffset = 72 * constants_1.Time.hours.toSeconds;
+        const saveCertStr = isMainInstance
+            ? async (value) => await this.saveCertStr(value)
+            : async () => { };
+        const onFeatureChange = isMainInstance
+            ? async () => await this.onFeatureChange()
+            : async () => { };
+        const onLicenseRenewed = isMainInstance
+            ? async () => await this.onLicenseRenewed()
+            : async () => { };
+        const collectUsageMetrics = isMainInstance
+            ? async () => await this.licenseMetricsService.collectUsageMetrics()
+            : async () => [];
+        const collectPassthroughData = isMainInstance
+            ? async () => await this.licenseMetricsService.collectPassthroughData()
+            : async () => ({});
+        const onExpirySoon = !this.instanceSettings.isLeader ? () => this.onExpirySoon() : undefined;
+        const expirySoonOffsetMins = !this.instanceSettings.isLeader ? 120 : undefined;
+        const { isLeader } = this.instanceSettings;
+        const { autoRenewalEnabled } = this.globalConfig.license;
+        const eligibleToRenew = isCli || isLeader;
+        const shouldRenew = eligibleToRenew && autoRenewalEnabled;
+        if (eligibleToRenew && !autoRenewalEnabled) {
+            this.logger.warn(LICENSE_RENEWAL_DISABLED_WARNING);
+        }
+        try {
+            this.manager = new license_sdk_1.LicenseManager({
+                server,
+                tenantId: this.globalConfig.license.tenantId,
+                productIdentifier: `n8n-${constants_2.N8N_VERSION}`,
+                autoRenewEnabled: shouldRenew,
+                renewOnInit: shouldRenew,
+                autoRenewOffset,
+                detachFloatingOnShutdown: this.globalConfig.license.detachFloatingOnShutdown,
+                offlineMode,
+                logger: this.logger,
+                loadCertStr: async () => await this.loadCertStr(),
+                saveCertStr,
+                deviceFingerprint: () => this.instanceSettings.instanceId,
+                collectUsageMetrics,
+                collectPassthroughData,
+                onFeatureChange,
+                onLicenseRenewed,
+                onExpirySoon,
+                expirySoonOffsetMins,
+            });
+            await this.manager.initialize();
+            this.logger.debug('License initialized');
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.logger.error('Could not initialize license manager sdk', { error });
+            }
+        }
+    }
+    async loadCertStr() {
+        const ephemeralLicense = this.globalConfig.license.cert;
+        if (ephemeralLicense) {
+            return ephemeralLicense;
+        }
+        const databaseSettings = await this.settingsRepository.findOne({
+            where: {
+                key: constants_2.SETTINGS_LICENSE_CERT_KEY,
+            },
+        });
+        return databaseSettings?.value ?? '';
+    }
+    async onFeatureChange() {
+        void this.broadcastReloadLicenseCommand();
+        await this.notifyRefreshCallbacks();
+    }
+    async onLicenseRenewed() {
+        void this.broadcastReloadLicenseCommand();
+        await this.notifyRefreshCallbacks();
+    }
+    async broadcastReloadLicenseCommand() {
+        if (this.globalConfig.executions.mode === 'queue' && this.instanceSettings.isLeader) {
+            const { Publisher } = await Promise.resolve().then(() => __importStar(require('./scaling/pubsub/publisher.service')));
+            await di_1.Container.get(Publisher).publishCommand({ command: 'reload-license' });
+        }
+    }
+    async saveCertStr(value) {
+        if (this.globalConfig.license.cert)
+            return;
+        await this.settingsRepository.upsert({
+            key: constants_2.SETTINGS_LICENSE_CERT_KEY,
+            value,
+            loadOnStartup: false,
+        }, ['key']);
+    }
+    onCertRefresh(refreshCallback) {
+        this.refreshCallbacks.push(refreshCallback);
+        return () => {
+            const index = this.refreshCallbacks.indexOf(refreshCallback);
+            if (index > -1) {
+                this.refreshCallbacks.splice(index, 1);
+            }
+        };
+    }
+    async notifyRefreshCallbacks() {
+        const cert = await this.loadCertStr();
+        for (const refreshCallback of this.refreshCallbacks) {
+            try {
+                refreshCallback(cert);
+            }
+            catch (error) {
+                this.logger.error('Error in license refresh callback', { error });
+            }
+        }
+    }
+    async activate(activationKey, eulaUri, userEmail) {
+        if (!this.manager) {
+            return;
+        }
+        await this.manager.activate(activationKey, { eulaUri, email: userEmail });
+        this.logger.debug('License activated');
+    }
+    async reload() {
+        if (!this.manager) {
+            return;
+        }
+        await this.manager.reload();
+        await this.notifyRefreshCallbacks();
+        this.logger.debug('License reloaded');
+    }
+    async renew() {
+        if (!this.manager) {
+            return;
+        }
+        await this.manager.renew();
+        this.logger.debug('License renewed');
+    }
+    async clear() {
+        if (!this.manager) {
+            return;
+        }
+        await this.manager.clear();
+        this.logger.info('License cleared');
+    }
+    async shutdown() {
+        this.isShuttingDown = true;
+        if (!this.manager) {
+            return;
+        }
+        await this.manager.shutdown();
+        this.logger.debug('License shut down');
+    }
+    isLicensed(feature) {
+        return true;
+    }
+    isDynamicCredentialsEnabled() {
+        return true;
+    }
+    isSharingEnabled() {
+        return true;
+    }
+    isLogStreamingEnabled() {
+        return true;
+    }
+    isLdapEnabled() {
+        return true;
+    }
+    isSamlEnabled() {
+        return true;
+    }
+    isAiAssistantEnabled() {
+        return true;
+    }
+    isAskAiEnabled() {
+        return true;
+    }
+    isAiCreditsEnabled() {
+        return true;
+    }
+    isAdvancedExecutionFiltersEnabled() {
+        return true;
+    }
+    isAdvancedPermissionsLicensed() {
+        return true;
+    }
+    isDebugInEditorLicensed() {
+        return true;
+    }
+    isBinaryDataS3Licensed() {
+        return true;
+    }
+    isMultiMainLicensed() {
+        return true;
+    }
+    isVariablesEnabled() {
+        return true;
+    }
+    isSourceControlLicensed() {
+        return true;
+    }
+    isExternalSecretsEnabled() {
+        return true;
+    }
+    isAPIDisabled() {
+        return false;
+    }
+    isWorkerViewLicensed() {
+        return true;
+    }
+    isProjectRoleAdminLicensed() {
+        return true;
+    }
+    isProjectRoleEditorLicensed() {
+        return true;
+    }
+    isProjectRoleViewerLicensed() {
+        return true;
+    }
+    isCustomNpmRegistryEnabled() {
+        return true;
+    }
+    isFoldersEnabled() {
+        return true;
+    }
+    getCurrentEntitlements() {
+        return [];
+    }
+    getValue(feature) {
+        if (feature === 'planName') return 'Enterprise';
+        return constants_1.UNLIMITED_LICENSE_QUOTA;
+    }
+    getManagementJwt() {
+        return '';
+    }
+    getMainPlan() {
+        return undefined;
+    }
+    getConsumerId() {
+        return 'Enterprise';
+    }
+    getUsersLimit() {
+        return constants_1.UNLIMITED_LICENSE_QUOTA;
+    }
+    getTriggerLimit() {
+        return constants_1.UNLIMITED_LICENSE_QUOTA;
+    }
+    getVariablesLimit() {
+        return constants_1.UNLIMITED_LICENSE_QUOTA;
+    }
+    getAiCredits() {
+        return constants_1.UNLIMITED_LICENSE_QUOTA;
+    }
+    getWorkflowHistoryPruneLimit() {
+        return constants_1.DEFAULT_WORKFLOW_HISTORY_PRUNE_LIMIT;
+    }
+    getTeamProjectLimit() {
+        return constants_1.UNLIMITED_LICENSE_QUOTA;
+    }
+    getPlanName() {
+        return 'Enterprise';
+    }
+    getExpiryDate() {
+        return new Date('9999-12-31');
+    }
+    getTerminationDate() {
+        return new Date('9999-12-31');
+    }
+    getExpiringInDays() {
+        return 36500;
+    }
+    getTerminatingInDays() {
+        return 36500;
+    }
+    getInfo() {
+        return 'Enterprise License (Unlimited) - Cracked by: keflag.';
+    }
+    isWithinUsersLimit() {
+        return true;
+    }
+    enableAutoRenewals() {
+    }
+    disableAutoRenewals() {
+    }
+    onExpirySoon() {
+    }
+};
+exports.License = License;
+__decorate([
+    (0, decorators_1.OnPubSubEvent)('reload-license'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], License.prototype, "reload", null);
+__decorate([
+    (0, decorators_1.OnShutdown)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], License.prototype, "shutdown", null);
+__decorate([
+    (0, decorators_1.OnLeaderTakeover)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], License.prototype, "enableAutoRenewals", null);
+__decorate([
+    (0, decorators_1.OnLeaderStepdown)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], License.prototype, "disableAutoRenewals", null);
+exports.License = License = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [backend_common_1.Logger,
+        n8n_core_1.InstanceSettings,
+        db_1.SettingsRepository,
+        license_metrics_service_1.LicenseMetricsService,
+        config_1.GlobalConfig])
+], License);
+//# sourceMappingURL=license.js.map
+EOF
 
+# 3. 覆盖 frontend.service.js
+RUN cat > /usr/local/lib/node_modules/n8n/dist/services/frontend.service.js << 'EOF'
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.FrontendService = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const config_1 = require("@n8n/config");
+const constants_1 = require("@n8n/constants");
+const di_1 = require("@n8n/di");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const uniq_1 = __importDefault(require("lodash/uniq"));
+const n8n_core_1 = require("n8n-core");
+const path_1 = __importDefault(require("path"));
+const config_2 = __importDefault(require("../config"));
+const constants_2 = require("../constants");
+const credential_types_1 = require("../credential-types");
+const credentials_overwrites_1 = require("../credentials-overwrites");
+const license_1 = require("../license");
+const load_nodes_and_credentials_1 = require("../load-nodes-and-credentials");
+const mfa_service_1 = require("../mfa/mfa.service");
+const community_packages_config_1 = require("../modules/community-packages/community-packages.config");
+const public_api_1 = require("../public-api");
+const push_config_1 = require("../push/push.config");
+const ownership_service_1 = require("../services/ownership.service");
+const sso_helpers_1 = require("../sso.ee/sso-helpers");
+const email_1 = require("../user-management/email");
+const health_endpoint_util_1 = require("../utils/health-endpoint.util");
+const workflow_history_helper_1 = require("../workflows/workflow-history/workflow-history-helper");
+const ai_usage_service_1 = require("./ai-usage.service");
+const url_service_1 = require("./url.service");
+let FrontendService = class FrontendService {
+    constructor(globalConfig, logger, loadNodesAndCredentials, credentialTypes, credentialsOverwrites, license, mailer, instanceSettings, urlService, securityConfig, pushConfig, binaryDataConfig, licenseState, moduleRegistry, mfaService, ownershipService, aiUsageService) {
+        this.globalConfig = globalConfig;
+        this.logger = logger;
+        this.loadNodesAndCredentials = loadNodesAndCredentials;
+        this.credentialTypes = credentialTypes;
+        this.credentialsOverwrites = credentialsOverwrites;
+        this.license = license;
+        this.mailer = mailer;
+        this.instanceSettings = instanceSettings;
+        this.urlService = urlService;
+        this.securityConfig = securityConfig;
+        this.pushConfig = pushConfig;
+        this.binaryDataConfig = binaryDataConfig;
+        this.licenseState = licenseState;
+        this.moduleRegistry = moduleRegistry;
+        this.mfaService = mfaService;
+        this.ownershipService = ownershipService;
+        this.aiUsageService = aiUsageService;
+        loadNodesAndCredentials.addPostProcessor(async () => await this.generateTypes());
+        void this.generateTypes();
+        if (di_1.Container.get(community_packages_config_1.CommunityPackagesConfig).enabled) {
+            void Promise.resolve().then(() => __importStar(require('../modules/community-packages/community-packages.service'))).then(({ CommunityPackagesService }) => {
+                this.communityPackagesService = di_1.Container.get(CommunityPackagesService);
+            });
+        }
+    }
+    collectEnvFeatureFlags() {
+        const envFeatureFlags = {};
+        for (const [key, value] of Object.entries(process.env)) {
+            if (key.startsWith('N8N_ENV_FEAT_') && value !== undefined) {
+                envFeatureFlags[key] = value;
+            }
+        }
+        return envFeatureFlags;
+    }
+    async getShowSetupOnFirstLoad() {
+        const previewMode = process.env.N8N_PREVIEW_MODE === 'true';
+        const hasInstanceOwner = await this.ownershipService.hasInstanceOwner();
+        return previewMode ? false : !hasInstanceOwner;
+    }
+    async initSettings() {
+        const instanceBaseUrl = this.urlService.getInstanceBaseUrl();
+        const restEndpoint = this.globalConfig.endpoints.rest;
+        const telemetrySettings = {
+            enabled: this.globalConfig.diagnostics.enabled,
+        };
+        if (telemetrySettings.enabled) {
+            const conf = this.globalConfig.diagnostics.frontendConfig;
+            const [key, url] = conf.split(';');
+            const proxy = `${instanceBaseUrl}/${restEndpoint}/telemetry/proxy`;
+            const sourceConfig = `${instanceBaseUrl}/${restEndpoint}/telemetry/rudderstack`;
+            if (!key || !url) {
+                this.logger.warn('Diagnostics frontend config is invalid');
+                telemetrySettings.enabled = false;
+            }
+            telemetrySettings.config = { key, url, proxy, sourceConfig };
+        }
+        const previewMode = process.env.N8N_PREVIEW_MODE === 'true';
+        this.settings = {
+            settingsMode: 'authenticated',
+            inE2ETests: constants_2.inE2ETests,
+            isDocker: this.instanceSettings.isDocker,
+            databaseType: this.globalConfig.database.type,
+            previewMode,
+            endpointForm: this.globalConfig.endpoints.form,
+            endpointFormTest: this.globalConfig.endpoints.formTest,
+            endpointFormWaiting: this.globalConfig.endpoints.formWaiting,
+            endpointMcp: this.globalConfig.endpoints.mcp,
+            endpointMcpTest: this.globalConfig.endpoints.mcpTest,
+            endpointWebhook: this.globalConfig.endpoints.webhook,
+            endpointWebhookTest: this.globalConfig.endpoints.webhookTest,
+            endpointWebhookWaiting: this.globalConfig.endpoints.webhookWaiting,
+            endpointHealth: (0, health_endpoint_util_1.resolveFrontendHealthEndpointPath)(this.globalConfig),
+            saveDataErrorExecution: this.globalConfig.executions.saveDataOnError,
+            saveDataSuccessExecution: this.globalConfig.executions.saveDataOnSuccess,
+            saveManualExecutions: this.globalConfig.executions.saveDataManualExecutions,
+            saveExecutionProgress: this.globalConfig.executions.saveExecutionProgress,
+            executionTimeout: this.globalConfig.executions.timeout,
+            maxExecutionTimeout: this.globalConfig.executions.maxTimeout,
+            workflowCallerPolicyDefaultOption: this.globalConfig.workflows.callerPolicyDefaultOption,
+            timezone: this.globalConfig.generic.timezone,
+            urlBaseWebhook: this.urlService.getWebhookBaseUrl(),
+            urlBaseEditor: instanceBaseUrl,
+            binaryDataMode: this.binaryDataConfig.mode,
+            nodeJsVersion: process.version.replace(/^v/, ''),
+            nodeEnv: process.env.NODE_ENV,
+            versionCli: constants_2.N8N_VERSION,
+            concurrency: this.globalConfig.executions.concurrency.productionLimit,
+            authCookie: {
+                secure: this.globalConfig.auth.cookie.secure,
+            },
+            releaseChannel: this.globalConfig.generic.releaseChannel,
+            oauthCallbackUrls: {
+                oauth1: `${instanceBaseUrl}/${restEndpoint}/oauth1-credential/callback`,
+                oauth2: `${instanceBaseUrl}/${restEndpoint}/oauth2-credential/callback`,
+            },
+            versionNotifications: {
+                enabled: this.globalConfig.versionNotifications.enabled,
+                endpoint: this.globalConfig.versionNotifications.endpoint,
+                whatsNewEnabled: this.globalConfig.versionNotifications.whatsNewEnabled,
+                whatsNewEndpoint: this.globalConfig.versionNotifications.whatsNewEndpoint,
+                infoUrl: this.globalConfig.versionNotifications.infoUrl,
+            },
+            dynamicBanners: {
+                endpoint: this.globalConfig.dynamicBanners.endpoint,
+                enabled: this.globalConfig.dynamicBanners.enabled && this.globalConfig.diagnostics.enabled,
+            },
+            instanceId: this.instanceSettings.instanceId,
+            telemetry: telemetrySettings,
+            posthog: {
+                enabled: this.globalConfig.diagnostics.enabled,
+                apiHost: this.globalConfig.diagnostics.posthogConfig.apiHost,
+                apiKey: this.globalConfig.diagnostics.posthogConfig.apiKey,
+                autocapture: false,
+                disableSessionRecording: this.globalConfig.deployment.type !== 'cloud',
+                proxy: `${instanceBaseUrl}/${restEndpoint}/ph`,
+                debug: this.globalConfig.logging.level === 'debug',
+            },
+            personalizationSurveyEnabled: this.globalConfig.personalization.enabled && this.globalConfig.diagnostics.enabled,
+            defaultLocale: this.globalConfig.defaultLocale,
+            userManagement: {
+                quota: this.license.getUsersLimit(),
+                showSetupOnFirstLoad: await this.getShowSetupOnFirstLoad(),
+                smtpSetup: this.mailer.isEmailSetUp,
+                authenticationMethod: (0, sso_helpers_1.getCurrentAuthenticationMethod)(),
+            },
+            sso: {
+                managedByEnv: this.globalConfig.instanceSettingsLoader.ssoManagedByEnv,
+                saml: {
+                    loginEnabled: false,
+                    loginLabel: '',
+                },
+                ldap: {
+                    loginEnabled: false,
+                    loginLabel: '',
+                },
+                oidc: {
+                    loginEnabled: false,
+                    loginUrl: `${instanceBaseUrl}/${restEndpoint}/sso/oidc/login`,
+                    callbackUrl: `${instanceBaseUrl}/${restEndpoint}/sso/oidc/callback`,
+                },
+            },
+            dataTables: {
+                maxSize: this.globalConfig.dataTable.maxSize,
+            },
+            publicApi: {
+                enabled: (0, public_api_1.isApiEnabled)(),
+                latestVersion: 1,
+                path: this.globalConfig.publicApi.path,
+                swaggerUi: {
+                    enabled: !this.globalConfig.publicApi.swaggerUiDisabled,
+                },
+            },
+            workflowTagsDisabled: this.globalConfig.tags.disabled,
+            logLevel: this.globalConfig.logging.level,
+            hiringBannerEnabled: this.globalConfig.hiringBanner.enabled,
+            aiAssistant: {
+                enabled: false,
+                setup: false,
+            },
+            templates: {
+                enabled: this.globalConfig.templates.enabled,
+                host: this.globalConfig.templates.host,
+            },
+            executionMode: this.globalConfig.executions.mode,
+            isMultiMain: this.instanceSettings.isMultiMain,
+            pushBackend: this.pushConfig.backend,
+            communityNodesEnabled: di_1.Container.get(community_packages_config_1.CommunityPackagesConfig).enabled,
+            unverifiedCommunityNodesEnabled: di_1.Container.get(community_packages_config_1.CommunityPackagesConfig).unverifiedEnabled,
+            deployment: {
+                type: this.globalConfig.deployment.type,
+            },
+            allowedModules: {
+                builtIn: process.env.NODE_FUNCTION_ALLOW_BUILTIN?.split(',') ?? undefined,
+                external: process.env.NODE_FUNCTION_ALLOW_EXTERNAL?.split(',') ?? undefined,
+            },
+            enterprise: {
+                sharing: false,
+                ldap: false,
+                saml: false,
+                oidc: false,
+                mfaEnforcement: false,
+                logStreaming: false,
+                advancedExecutionFilters: false,
+                variables: false,
+                sourceControl: false,
+                auditLogs: false,
+                externalSecrets: false,
+                showNonProdBanner: false,
+                debugInEditor: false,
+                binaryDataS3: false,
+                workerView: false,
+                advancedPermissions: false,
+                workflowDiffs: false,
+                namedVersions: false,
+                provisioning: false,
+                projects: {
+                    team: {
+                        limit: 0,
+                    },
+                },
+                customRoles: false,
+                personalSpacePolicy: false,
+                dataRedaction: false,
+            },
+            mfa: {
+                enabled: false,
+                enforced: false,
+            },
+            hideUsagePage: this.globalConfig.hideUsagePage,
+            license: {
+                consumerId: 'unknown',
+                environment: this.globalConfig.license.tenantId === 1 ? 'production' : 'staging',
+            },
+            variables: {
+                limit: 0,
+            },
+            banners: {
+                dismissed: [],
+            },
+            askAi: {
+                enabled: false,
+            },
+            aiBuilder: {
+                enabled: false,
+                setup: false,
+            },
+            aiCredits: {
+                enabled: false,
+                credits: 0,
+                setup: false,
+            },
+            ai: {
+                allowSendingParameterValues: true,
+            },
+            workflowHistory: {
+                pruneTime: (0, workflow_history_helper_1.getWorkflowHistoryPruneTime)(),
+                licensePruneTime: (0, workflow_history_helper_1.getWorkflowHistoryLicensePruneTime)(),
+            },
+            pruning: {
+                isEnabled: this.globalConfig.executions.pruneData,
+                maxAge: this.globalConfig.executions.pruneDataMaxAge,
+                maxCount: this.globalConfig.executions.pruneDataMaxCount,
+            },
+            security: {
+                blockFileAccessToN8nFiles: this.securityConfig.blockFileAccessToN8nFiles,
+            },
+            easyAIWorkflowOnboarded: false,
+            folders: {
+                enabled: false,
+            },
+            evaluation: {
+                quota: this.licenseState.getMaxWorkflowsWithEvaluations()
+            },
+            activeModules: this.moduleRegistry.getActiveModules(),
+            canvasOnly: this.globalConfig.canvasOnly,
+            envFeatureFlags: this.collectEnvFeatureFlags(),
+        };
+    }
+    async generateTypes() {
+        this.overwriteCredentialsProperties();
+        const { credentials, nodes } = await this.loadNodesAndCredentials.collectTypes();
+        const { staticCacheDir } = this.instanceSettings;
+        await (0, promises_1.mkdir)(path_1.default.join(staticCacheDir, 'types'), { recursive: true });
+        await this.writeStaticJSON('nodes', nodes);
+        const nodeVersionIdentifiers = this.getNodeVersionIdentifiers(nodes);
+        await this.writeStaticJSON('node-versions', nodeVersionIdentifiers);
+        await this.writeStaticJSON('credentials', credentials);
+    }
+    async getSettings() {
+        if (!this.settings) {
+            await this.initSettings();
+        }
+        const restEndpoint = this.globalConfig.endpoints.rest;
+        const instanceBaseUrl = this.urlService.getInstanceBaseUrl();
+        this.settings.urlBaseWebhook = this.urlService.getWebhookBaseUrl();
+        this.settings.urlBaseEditor = instanceBaseUrl;
+        this.settings.oauthCallbackUrls = {
+            oauth1: `${instanceBaseUrl}/${restEndpoint}/oauth1-credential/callback`,
+            oauth2: `${instanceBaseUrl}/${restEndpoint}/oauth2-credential/callback`,
+        };
+        Object.assign(this.settings.userManagement, {
+            quota: this.license.getUsersLimit(),
+            authenticationMethod: (0, sso_helpers_1.getCurrentAuthenticationMethod)(),
+            showSetupOnFirstLoad: await this.getShowSetupOnFirstLoad(),
+        });
+        let dismissedBanners = [];
+        try {
+            dismissedBanners = config_2.default.getEnv('ui.banners.dismissed') ?? [];
+        }
+        catch {
+        }
+        this.settings.banners.dismissed = dismissedBanners;
+        try {
+            this.settings.easyAIWorkflowOnboarded = config_2.default.getEnv('easyAIWorkflowOnboarded') ?? false;
+        }
+        catch {
+            this.settings.easyAIWorkflowOnboarded = false;
+        }
+        try {
+            this.settings.ai.allowSendingParameterValues = await this.aiUsageService.getAiUsageSettings();
+        }
+        catch {
+            this.settings.ai.allowSendingParameterValues = true;
+        }
 
-WORKDIR /
+        const isS3Selected = this.binaryDataConfig.mode === 's3';
+        const isS3Available = this.binaryDataConfig.availableModes.includes('s3');
+        const isS3Licensed = true;
+        const isAiAssistantEnabled = true;
+        const isAskAiEnabled = true;
+        const isAiCreditsEnabled = true;
+        const isAiBuilderEnabled = true;
 
-# 输出 license.js 内容
-RUN echo "====== 1. license.js ======" && cat /usr/local/lib/node_modules/n8n/dist/license.js 2>/dev/null
+        this.settings.license.planName = "Enterprise";
+        this.settings.license.consumerId = "Enterprise";
 
-# 输出 frontend.service.js 内容
-RUN echo -e "\n====== 2. frontend.service.js ======" && cat /usr/local/lib/node_modules/n8n/dist/services/frontend.service.js 2>/dev/null
+        Object.assign(this.settings.enterprise, {
+            sharing: true,
+            logStreaming: true,
+            ldap: true,
+            saml: true,
+            oidc: true,
+            mfaEnforcement: true,
+            provisioning: false,
+            advancedExecutionFilters: true,
+            variables: true,
+            sourceControl: true,
+            externalSecrets: true,
+            showNonProdBanner: false,
+            debugInEditor: true,
+            binaryDataS3: isS3Available && isS3Selected && isS3Licensed,
+            workerView: true,
+            advancedPermissions: true,
+            workflowDiffs: true,
+            namedVersions: true,
+            customRoles: true,
+            personalSpacePolicy: true,
+            dataRedaction: true,
+        });
 
-# 输出 license-state.js 内容
-RUN echo -e "\n====== 3. license-state.js ======" && cat /usr/local/lib/node_modules/n8n/node_modules/.pnpm/@n8n+backend-common@file+packages+@n8n+backend-common/node_modules/@n8n/backend-common/dist/license-state.js 2>/dev/null
+        if (true) {
+            Object.assign(this.settings.sso.ldap, {
+                loginLabel: this.globalConfig.sso.ldap.loginLabel,
+                loginEnabled: this.globalConfig.sso.ldap.loginEnabled,
+            });
+        }
+        if (true) {
+            Object.assign(this.settings.sso.saml, {
+                loginLabel: (0, sso_helpers_1.getSamlLoginLabel)(),
+                loginEnabled: this.globalConfig.sso.saml.loginEnabled,
+            });
+        }
+        if (true) {
+            Object.assign(this.settings.sso.oidc, {
+                loginEnabled: this.globalConfig.sso.oidc.loginEnabled,
+            });
+        }
+        if (true) {
+            this.settings.variables.limit = constants_1.UNLIMITED_LICENSE_QUOTA;
+        }
+        if (this.communityPackagesService) {
+            this.settings.missingPackages = this.communityPackagesService.hasMissingPackages;
+        }
+        if (isAiAssistantEnabled) {
+            this.settings.aiAssistant.enabled = true;
+            this.settings.aiAssistant.setup = true;
+        }
+        if (isAskAiEnabled) {
+            this.settings.askAi.enabled = true;
+        }
+        if (isAiCreditsEnabled) {
+            this.settings.aiCredits.enabled = true;
+            this.settings.aiCredits.credits = constants_1.UNLIMITED_LICENSE_QUOTA;
+            this.settings.aiCredits.setup = true;
+        }
+        if (isAiBuilderEnabled) {
+            this.settings.aiBuilder.enabled = true;
+            this.settings.aiBuilder.setup = true;
+        }
 
-RUN exit
+        this.settings.mfa.enabled = this.globalConfig.mfa.enabled;
+        this.settings.mfa.enforced = true;
+        this.settings.executionMode = this.globalConfig.executions.mode;
+        this.settings.binaryDataMode = this.binaryDataConfig.mode;
+        this.settings.enterprise.projects.team.limit = constants_1.UNLIMITED_LICENSE_QUOTA;
+        this.settings.folders.enabled = true;
+        this.settings.evaluation.quota = 99999;
+        this.settings.envFeatureFlags = this.collectEnvFeatureFlags();
+        return this.settings;
+    }
+    async getPublicSettings(includeMfaSettings) {
+        const { defaultLocale, userManagement: { authenticationMethod, showSetupOnFirstLoad, smtpSetup }, sso: { saml: ssoSaml, ldap: ssoLdap, oidc: ssoOidc }, authCookie, previewMode, enterprise: { saml, ldap, oidc }, mfa, communityNodesEnabled, } = await this.getSettings();
+        const publicSettings = {
+            settingsMode: 'public',
+            defaultLocale,
+            userManagement: {
+                authenticationMethod,
+                showSetupOnFirstLoad,
+                smtpSetup,
+            },
+            sso: {
+                saml: {
+                    loginEnabled: ssoSaml.loginEnabled,
+                },
+                ldap: ssoLdap,
+                oidc: {
+                    loginEnabled: ssoOidc.loginEnabled,
+                    loginUrl: ssoOidc.loginUrl,
+                },
+            },
+            authCookie,
+            previewMode,
+            enterprise: { saml: true, ldap: true, oidc: true },
+            communityNodesEnabled,
+        };
+        if (includeMfaSettings) {
+            publicSettings.mfa = mfa;
+        }
+        return publicSettings;
+    }
+    getModuleSettings() {
+        return Object.fromEntries(this.moduleRegistry.settings);
+    }
+    getNodeVersionIdentifiers(nodes) {
+        const identifiers = new Set();
+        for (const node of nodes) {
+            if (!node?.name || node.version === undefined)
+                continue;
+            const versions = Array.isArray(node.version) ? node.version : [node.version];
+            for (const version of versions) {
+                if (version === undefined)
+                    continue;
+                identifiers.add(`${node.name}@${String(version)}`);
+            }
+        }
+        return Array.from(identifiers);
+    }
+    async writeStaticJSON(name, data) {
+        const { staticCacheDir } = this.instanceSettings;
+        const filePath = path_1.default.join(staticCacheDir, `types/${name}.json`);
+        const stream = (0, fs_1.createWriteStream)(filePath, 'utf-8');
+        return await new Promise((resolve, reject) => {
+            stream.on('error', reject);
+            stream.on('finish', resolve);
+            stream.write('[\n');
+            data.forEach((entry, index) => {
+                stream.write(JSON.stringify(entry));
+                if (index !== data.length - 1)
+                    stream.write(',');
+                stream.write('\n');
+            });
+            stream.write(']\n');
+            stream.end();
+        });
+    }
+    overwriteCredentialsProperties() {
+        const { credentials } = this.loadNodesAndCredentials.types;
+        const credentialsOverwrites = this.credentialsOverwrites.getAll();
+        const { skipTypes } = this.globalConfig.credentials.overwrite;
+        for (const credential of credentials) {
+            delete credential.__overwrittenProperties;
+            delete credential.__skipManagedCreation;
+            const overwrittenProperties = [];
+            this.credentialTypes
+                .getParentTypes(credential.name)
+                .reverse()
+                .map((name) => credentialsOverwrites[name])
+                .forEach((overwrite) => {
+                if (overwrite)
+                    overwrittenProperties.push(...Object.keys(overwrite));
+            });
+            if (credential.name in credentialsOverwrites) {
+                overwrittenProperties.push(...Object.keys(credentialsOverwrites[credential.name]));
+            }
+            if (overwrittenProperties.length) {
+                credential.__overwrittenProperties = (0, uniq_1.default)(overwrittenProperties);
+            }
+            if (skipTypes.includes(credential.name)) {
+                credential.__skipManagedCreation = true;
+            }
+        }
+    }
+};
+exports.FrontendService = FrontendService;
+exports.FrontendService = FrontendService = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [config_1.GlobalConfig,
+        backend_common_1.Logger,
+        load_nodes_and_credentials_1.LoadNodesAndCredentials,
+        credential_types_1.CredentialTypes,
+        credentials_overwrites_1.CredentialsOverwrites,
+        license_1.License,
+        email_1.UserManagementMailer,
+        n8n_core_1.InstanceSettings,
+        url_service_1.UrlService,
+        config_1.SecurityConfig,
+        push_config_1.PushConfig,
+        n8n_core_1.BinaryDataConfig,
+        backend_common_1.LicenseState,
+        backend_common_1.ModuleRegistry,
+        mfa_service_1.MfaService,
+        ownership_service_1.OwnershipService,
+        ai_usage_service_1.AiUsageService])
+], FrontendService);
+//# sourceMappingURL=frontend.service.js.map
+EOF
 
 # ==============================
 # 启动 n8n