802 lines
28 KiB
JavaScript
802 lines
28 KiB
JavaScript
#!/usr/bin/env node
|
||
/**
|
||
* Emulated N8N License Patcher
|
||
* Replaces minified LicenseManager with clean implementation
|
||
*/
|
||
|
||
const fs = require('fs');
|
||
const { execSync } = require('child_process');
|
||
|
||
class EmulatedLicensePatcher {
|
||
constructor() {
|
||
this.installations = [];
|
||
}
|
||
|
||
findN8NInstallations() {
|
||
console.log('🔍 Finding n8n installations...');
|
||
|
||
const searchPaths = [
|
||
// Current directory and parent (for local installs)
|
||
'./node_modules/@n8n_io/license-sdk/dist/LicenseManager.js',
|
||
'../node_modules/@n8n_io/license-sdk/dist/LicenseManager.js',
|
||
'../../node_modules/@n8n_io/license-sdk/dist/LicenseManager.js',
|
||
];
|
||
|
||
// Try to find pnpm installations
|
||
try {
|
||
const pnpmPaths = execSync('find . -path "*/node_modules/.pnpm/@n8n_io+license-sdk*/node_modules/@n8n_io/license-sdk/dist/LicenseManager.js" 2>/dev/null || true', { encoding: 'utf8' }).trim();
|
||
if (pnpmPaths) {
|
||
pnpmPaths.split('\n').forEach(path => path.trim() && searchPaths.push(path));
|
||
}
|
||
} catch (e) {}
|
||
|
||
// Try to find npm global installation
|
||
try {
|
||
const globalPath = execSync('npm root -g', { encoding: 'utf8' }).trim();
|
||
searchPaths.push(`${globalPath}/n8n/node_modules/@n8n_io/license-sdk/dist/LicenseManager.js`);
|
||
} catch (e) {}
|
||
|
||
// Try to find where n8n is installed globally
|
||
try {
|
||
const n8nPath = execSync('which n8n', { encoding: 'utf8' }).trim();
|
||
if (n8nPath) {
|
||
const realPath = fs.realpathSync(n8nPath);
|
||
const licenseSDKPath = realPath.replace(/bin\/n8n$/, 'node_modules/@n8n_io/license-sdk/dist/LicenseManager.js');
|
||
searchPaths.push(licenseSDKPath);
|
||
}
|
||
} catch (e) {}
|
||
|
||
// Try to find via yarn global
|
||
try {
|
||
const yarnGlobalDir = execSync('yarn global dir', { encoding: 'utf8' }).trim();
|
||
searchPaths.push(`${yarnGlobalDir}/node_modules/n8n/node_modules/@n8n_io/license-sdk/dist/LicenseManager.js`);
|
||
} catch (e) {}
|
||
|
||
// Try common nvm paths (cross-platform)
|
||
const os = require('os');
|
||
const homeDir = os.homedir();
|
||
|
||
try {
|
||
// Find nvm node versions
|
||
const nvmDir = process.env.NVM_DIR || `${homeDir}/.nvm`;
|
||
if (fs.existsSync(nvmDir)) {
|
||
const versionsDir = `${nvmDir}/versions/node`;
|
||
if (fs.existsSync(versionsDir)) {
|
||
const versions = fs.readdirSync(versionsDir);
|
||
versions.forEach(version => {
|
||
searchPaths.push(`${versionsDir}/${version}/lib/node_modules/n8n/node_modules/@n8n_io/license-sdk/dist/LicenseManager.js`);
|
||
});
|
||
}
|
||
}
|
||
} catch (e) {}
|
||
|
||
// Try Windows AppData paths
|
||
if (process.platform === 'win32') {
|
||
const appData = process.env.APPDATA || `${homeDir}/AppData/Roaming`;
|
||
searchPaths.push(`${appData}/npm/node_modules/n8n/node_modules/@n8n_io/license-sdk/dist/LicenseManager.js`);
|
||
}
|
||
|
||
// Try macOS/Linux common paths
|
||
if (process.platform !== 'win32') {
|
||
searchPaths.push('/usr/local/lib/node_modules/n8n/node_modules/@n8n_io/license-sdk/dist/LicenseManager.js');
|
||
searchPaths.push('/usr/lib/node_modules/n8n/node_modules/@n8n_io/license-sdk/dist/LicenseManager.js');
|
||
}
|
||
|
||
// Try Docker container paths (when running inside containers)
|
||
searchPaths.push('/usr/local/lib/node_modules/n8n/node_modules/@n8n_io/license-sdk/dist/LicenseManager.js');
|
||
searchPaths.push('/usr/local/bin/node_modules/n8n/node_modules/@n8n_io/license-sdk/dist/LicenseManager.js');
|
||
|
||
// Remove duplicates and filter existing paths
|
||
const uniquePaths = [...new Set(searchPaths)];
|
||
|
||
for (const path of uniquePaths) {
|
||
if (fs.existsSync(path)) {
|
||
this.installations.push({
|
||
path: path,
|
||
backupPath: path + '.original'
|
||
});
|
||
}
|
||
}
|
||
|
||
console.log(`Found ${this.installations.length} installation(s):`);
|
||
this.installations.forEach((inst, i) => {
|
||
const status = fs.existsSync(inst.backupPath) ? '(has backup)' : '(no backup)';
|
||
console.log(` ${i + 1}. ${inst.path} ${status}`);
|
||
});
|
||
|
||
return this.installations;
|
||
}
|
||
|
||
generateCleanLicenseManager() {
|
||
return `"use strict";
|
||
|
||
// Emulated LicenseManager that bypasses all validation
|
||
const AUTORENEWAL_INTERVAL = 15 * 60 * 1000;
|
||
|
||
class LicenseManager {
|
||
constructor(config) {
|
||
this.config = config;
|
||
this.expirySoonCallbackFired = false;
|
||
this.isShuttingDown = false;
|
||
this.initializationPromise = null;
|
||
this.deviceFingerprint = null;
|
||
this.currentFeatures = {};
|
||
|
||
// Mock license certificate
|
||
this.licenseCert = {
|
||
consumerId: "emulated-consumer",
|
||
version: 1,
|
||
tenantId: config.tenantId || 1,
|
||
renewalToken: "emulated-token",
|
||
deviceLock: false,
|
||
deviceFingerprint: "",
|
||
createdAt: new Date("2025-01-01"),
|
||
issuedAt: new Date("2025-01-01"),
|
||
expiresAt: new Date("2030-01-01"),
|
||
terminatesAt: new Date("2030-01-01"),
|
||
planName: "Enterprise",
|
||
entitlements: [{
|
||
id: "emulated-entitlement",
|
||
productId: "emulated-product",
|
||
productMetadata: { terms: { isMainPlan: true }, planName: "Enterprise" },
|
||
features: {
|
||
"feat:sharing": true,
|
||
"feat:ldap": true,
|
||
"feat:saml": true,
|
||
"feat:variables": true,
|
||
"feat:external-secrets": true,
|
||
"feat:workflow-history": true,
|
||
"feat:binary-data-s3": true,
|
||
"feat:multiple-main-instances": true,
|
||
"feat:source-control": true,
|
||
"feat:advanced-permissions": true,
|
||
"feat:debug-in-editor": true,
|
||
"feat:showNonProdBanner": false,
|
||
"quota:users": -1,
|
||
"quota:activeWorkflowTriggers": -1,
|
||
"quota:variables": -1
|
||
},
|
||
featureOverrides: {},
|
||
validFrom: new Date("2025-01-01"),
|
||
validTo: new Date("2030-01-01"),
|
||
isFloatable: false
|
||
}],
|
||
detachedEntitlementsCount: 0,
|
||
managementJwt: "",
|
||
isEphemeral: true
|
||
};
|
||
|
||
this.updateCurrentFeatures();
|
||
|
||
// Setup logger
|
||
if (config.logger) {
|
||
this.logger = config.logger;
|
||
} else {
|
||
this.logger = {
|
||
error: () => console.log("ERROR:", ...arguments),
|
||
warn: () => console.log("WARN:", ...arguments),
|
||
info: () => console.log("INFO:", ...arguments),
|
||
debug: () => console.log("DEBUG:", ...arguments)
|
||
};
|
||
}
|
||
}
|
||
|
||
get isInitialized() {
|
||
return !!this.initializationPromise;
|
||
}
|
||
|
||
log(message, level) {
|
||
this.logger[level](\`[license SDK] \${message}\`);
|
||
}
|
||
|
||
async initialize() {
|
||
if (this.initializationPromise) {
|
||
return this.initializationPromise;
|
||
}
|
||
|
||
this.initializationPromise = this._doInitialization();
|
||
return await this.initializationPromise;
|
||
}
|
||
|
||
async _doInitialization() {
|
||
this.deviceFingerprint = await this.computeDeviceFingerprint();
|
||
this.log(\`initializing for deviceFingerprint \${this.deviceFingerprint}\`, "debug");
|
||
this.log("Emulated license manager initialized with Enterprise features", "info");
|
||
}
|
||
|
||
async computeDeviceFingerprint() {
|
||
if (this.config.deviceFingerprint && typeof this.config.deviceFingerprint === "function") {
|
||
return await this.config.deviceFingerprint();
|
||
}
|
||
return "emulated-device-fingerprint";
|
||
}
|
||
|
||
// All validation methods return true
|
||
isValid(logErrors = true) {
|
||
return true;
|
||
}
|
||
|
||
hasFeatureEnabled(feature, validateLicense = true) {
|
||
// Special case: this feature should be FALSE for licensed instances
|
||
if (feature === 'feat:showNonProdBanner') {
|
||
return false;
|
||
}
|
||
// All other enterprise features should be true
|
||
return true;
|
||
}
|
||
|
||
hasFeatureDefined(feature, validateLicense = true) {
|
||
return true;
|
||
}
|
||
|
||
hasQuotaLeft(feature, used) {
|
||
return true;
|
||
}
|
||
|
||
getFeatureValue(feature, validateLicense = true) {
|
||
// Special case: this feature should be FALSE for licensed instances
|
||
if (feature === 'feat:showNonProdBanner') {
|
||
return false;
|
||
}
|
||
// Return unlimited quota for quota features
|
||
if (feature.startsWith("quota:")) {
|
||
return -1;
|
||
}
|
||
// Return true for boolean features
|
||
return true;
|
||
}
|
||
|
||
hasCert() {
|
||
return true;
|
||
}
|
||
|
||
isTerminated() {
|
||
return false;
|
||
}
|
||
|
||
getExpiryDate() {
|
||
return this.licenseCert.expiresAt;
|
||
}
|
||
|
||
getTerminationDate() {
|
||
return this.licenseCert.terminatesAt;
|
||
}
|
||
|
||
getFeatures() {
|
||
return this.currentFeatures;
|
||
}
|
||
|
||
updateCurrentFeatures() {
|
||
this.currentFeatures = {
|
||
"feat:sharing": true,
|
||
"feat:ldap": true,
|
||
"feat:saml": true,
|
||
"feat:variables": true,
|
||
"feat:external-secrets": true,
|
||
"feat:workflow-history": true,
|
||
"feat:binary-data-s3": true,
|
||
"feat:multiple-main-instances": true,
|
||
"feat:source-control": true,
|
||
"feat:advanced-permissions": true,
|
||
"feat:debug-in-editor": true,
|
||
"feat:showNonProdBanner": false,
|
||
"quota:users": -1,
|
||
"quota:activeWorkflowTriggers": -1,
|
||
"quota:variables": -1
|
||
};
|
||
}
|
||
|
||
getCurrentEntitlements() {
|
||
return this.licenseCert.entitlements;
|
||
}
|
||
|
||
getManagementJwt() {
|
||
return this.licenseCert.managementJwt;
|
||
}
|
||
|
||
async getCertStr() {
|
||
return "emulated-cert-string";
|
||
}
|
||
|
||
getConsumerId() {
|
||
return this.licenseCert.consumerId;
|
||
}
|
||
|
||
isRenewalDue() {
|
||
return false;
|
||
}
|
||
|
||
// License management methods (no-ops)
|
||
async activate(activationKey) {
|
||
this.log("license activation bypassed (emulated)", "info");
|
||
return Promise.resolve();
|
||
}
|
||
|
||
async renew() {
|
||
this.log("license renewal bypassed (emulated)", "info");
|
||
return Promise.resolve();
|
||
}
|
||
|
||
async clear() {
|
||
this.log("license clear bypassed (emulated)", "info");
|
||
return Promise.resolve();
|
||
}
|
||
|
||
async shutdown() {
|
||
this.isShuttingDown = true;
|
||
this.log("license manager shutdown (emulated)", "info");
|
||
return Promise.resolve();
|
||
}
|
||
|
||
// Timer management (no-ops)
|
||
setupSingleTimer(callback, delay) {
|
||
return setTimeout(callback, delay);
|
||
}
|
||
|
||
clearSingleTimer(timer) {
|
||
if (timer) clearTimeout(timer);
|
||
}
|
||
|
||
setupRepeatingTimer(callback, interval) {
|
||
return setInterval(callback, interval);
|
||
}
|
||
|
||
clearRepeatingTimer(timer) {
|
||
if (timer) clearInterval(timer);
|
||
}
|
||
|
||
// Utility methods
|
||
formatDuration(seconds) {
|
||
const hours = Math.floor(seconds / 3600);
|
||
const minutes = Math.floor((seconds % 3600) / 60);
|
||
const secs = seconds % 60;
|
||
return \`\${hours}h \${minutes}m \${secs}s\`;
|
||
}
|
||
|
||
toString() {
|
||
return \`## EMULATED LICENSE MANAGER ##
|
||
License: Enterprise (Emulated)
|
||
Valid: true
|
||
Features: All Enterprise features enabled
|
||
Expiry: \${this.licenseCert.expiresAt}
|
||
Status: Active (Bypassed)\`;
|
||
}
|
||
|
||
// Additional methods that might be called
|
||
async reload() {
|
||
await this.initialize();
|
||
}
|
||
|
||
async reset() {
|
||
// No-op for emulated manager
|
||
}
|
||
|
||
triggerOnFeatureChangeCallback() {
|
||
if (this.config.onFeatureChange) {
|
||
this.config.onFeatureChange(this.currentFeatures);
|
||
}
|
||
}
|
||
|
||
enableAutoRenewals() {
|
||
this.log("Auto-renewals enabled (emulated)", "info");
|
||
}
|
||
|
||
disableAutoRenewals() {
|
||
this.log("Auto-renewals disabled (emulated)", "info");
|
||
}
|
||
}
|
||
|
||
// Export in the expected format
|
||
module.exports = {
|
||
AUTORENEWAL_INTERVAL,
|
||
LicenseManager
|
||
};
|
||
`;
|
||
}
|
||
|
||
debugFilePermissions(filePath) {
|
||
try {
|
||
const stats = fs.statSync(filePath);
|
||
const perms = (stats.mode & parseInt('777', 8)).toString(8);
|
||
console.log(`📋 File: ${filePath}`);
|
||
console.log(` Permissions: ${perms}`);
|
||
console.log(` Owner: ${stats.uid}:${stats.gid}`);
|
||
console.log(` Size: ${stats.size} bytes`);
|
||
|
||
// Check current user
|
||
try {
|
||
const whoami = execSync('whoami', { encoding: 'utf8' }).trim();
|
||
const id = execSync('id', { encoding: 'utf8' }).trim();
|
||
console.log(` Current user: ${whoami}`);
|
||
console.log(` User info: ${id}`);
|
||
} catch (e) {}
|
||
|
||
// Check if directory is writable
|
||
const dirPath = require('path').dirname(filePath);
|
||
try {
|
||
fs.accessSync(dirPath, fs.constants.W_OK);
|
||
console.log(` Directory writable: ✅`);
|
||
} catch (e) {
|
||
console.log(` Directory writable: ❌ ${e.message}`);
|
||
}
|
||
|
||
} catch (e) {
|
||
console.log(`❌ Could not debug file: ${e.message}`);
|
||
}
|
||
}
|
||
|
||
patchInstallation(installation) {
|
||
console.log(`\n🔧 Patching: ${installation.path}`);
|
||
|
||
// Debug file permissions
|
||
this.debugFilePermissions(installation.path);
|
||
|
||
try {
|
||
// Create backup first if possible
|
||
if (!fs.existsSync(installation.backupPath)) {
|
||
try {
|
||
fs.copyFileSync(installation.path, installation.backupPath);
|
||
console.log('✅ Created backup');
|
||
} catch (backupError) {
|
||
console.log('⚠️ Could not create backup, proceeding anyway...');
|
||
}
|
||
}
|
||
|
||
// Try direct write first
|
||
const cleanImplementation = this.generateCleanLicenseManager();
|
||
fs.writeFileSync(installation.path, cleanImplementation);
|
||
|
||
console.log('✅ Replaced with clean emulated license manager');
|
||
return true;
|
||
|
||
} catch (error) {
|
||
console.error(`❌ Direct patching failed: ${error.message}`);
|
||
|
||
// Try alternative approaches for Docker/readonly filesystems
|
||
const alternatives = [
|
||
() => {
|
||
console.log('🔧 Trying to change file permissions...');
|
||
execSync(`chmod 666 "${installation.path}"`);
|
||
fs.writeFileSync(installation.path, this.generateCleanLicenseManager());
|
||
},
|
||
() => {
|
||
console.log('🔧 Trying to remove and recreate file...');
|
||
execSync(`rm -f "${installation.path}"`);
|
||
fs.writeFileSync(installation.path, this.generateCleanLicenseManager());
|
||
},
|
||
() => {
|
||
console.log('🔧 Trying with sudo-like approach...');
|
||
const tempFile = '/tmp/LicenseManager.js.patched';
|
||
fs.writeFileSync(tempFile, this.generateCleanLicenseManager());
|
||
execSync(`cat "${tempFile}" > "${installation.path}"`);
|
||
},
|
||
() => {
|
||
console.log('🔧 Trying to mount tmpfs overlay...');
|
||
const tempFile = '/tmp/LicenseManager.js.patched';
|
||
fs.writeFileSync(tempFile, this.generateCleanLicenseManager());
|
||
execSync(`mount --bind "${tempFile}" "${installation.path}"`);
|
||
}
|
||
];
|
||
|
||
for (let i = 0; i < alternatives.length; i++) {
|
||
try {
|
||
alternatives[i]();
|
||
console.log(`✅ Alternative method ${i + 1} succeeded`);
|
||
return true;
|
||
} catch (altError) {
|
||
console.log(`❌ Alternative method ${i + 1} failed: ${altError.message}`);
|
||
}
|
||
}
|
||
|
||
console.log('💡 All patching methods failed. This might be a read-only container.');
|
||
console.log(' Consider running the container with --privileged or mounting the file as writable.');
|
||
return false;
|
||
}
|
||
}
|
||
|
||
restoreInstallation(installation) {
|
||
console.log(`\n🔄 Restoring: ${installation.path}`);
|
||
|
||
if (!fs.existsSync(installation.backupPath)) {
|
||
console.log('❌ No backup found');
|
||
return false;
|
||
}
|
||
|
||
try {
|
||
fs.copyFileSync(installation.backupPath, installation.path);
|
||
console.log('✅ Restored successfully');
|
||
return true;
|
||
} catch (error) {
|
||
console.error(`❌ Error restoring: ${error.message}`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
patchAll() {
|
||
const installations = this.findN8NInstallations();
|
||
|
||
if (installations.length === 0) {
|
||
console.log('\n❌ No n8n installations found!');
|
||
console.log('Make sure n8n is installed or check the search paths.');
|
||
return;
|
||
}
|
||
|
||
console.log('\n🚀 Applying patches...');
|
||
|
||
let successCount = 0;
|
||
for (const installation of installations) {
|
||
if (this.patchInstallation(installation)) {
|
||
successCount++;
|
||
}
|
||
}
|
||
|
||
console.log(`\n✅ Successfully patched ${successCount}/${installations.length} installations!`);
|
||
|
||
if (successCount > 0) {
|
||
console.log('\n🎉 N8N License Manager Replaced with Emulated Version!');
|
||
console.log('\nWhat this does:');
|
||
console.log(' • Replaces minified code with clean implementation');
|
||
console.log(' • All license validation methods return true');
|
||
console.log(' • All Enterprise features are enabled');
|
||
console.log(' • No certificate or signature validation');
|
||
console.log(' • Clean, readable code that\'s easy to maintain');
|
||
console.log('\nTry running n8n now:');
|
||
console.log(' n8n --help');
|
||
console.log(' n8n start');
|
||
}
|
||
}
|
||
|
||
restoreAll() {
|
||
const installations = this.findN8NInstallations();
|
||
|
||
console.log('\n🔄 Restoring all installations...');
|
||
|
||
let successCount = 0;
|
||
for (const installation of installations) {
|
||
if (this.restoreInstallation(installation)) {
|
||
successCount++;
|
||
}
|
||
}
|
||
|
||
console.log(`\n✅ Successfully restored ${successCount} installations!`);
|
||
}
|
||
|
||
patchDockerCompose(filePath) {
|
||
console.log(`\n🐳 Patching Docker Compose file: ${filePath}`);
|
||
|
||
if (!fs.existsSync(filePath)) {
|
||
console.log('❌ Docker Compose file not found');
|
||
return false;
|
||
}
|
||
|
||
try {
|
||
const content = fs.readFileSync(filePath, 'utf8');
|
||
const backupPath = filePath + '.backup';
|
||
|
||
// Create backup if it doesn't exist
|
||
if (!fs.existsSync(backupPath)) {
|
||
fs.writeFileSync(backupPath, content);
|
||
console.log('✅ Created backup');
|
||
}
|
||
|
||
// Check if already patched
|
||
if (content.includes('./emulated-license-patcher.js:/tmp/patcher.js:ro')) {
|
||
console.log('⚠️ File appears to already be patched');
|
||
return true;
|
||
}
|
||
|
||
// Find n8n service
|
||
const lines = content.split('\n');
|
||
let n8nServiceIndex = -1;
|
||
let volumesIndex = -1;
|
||
let inN8nService = false;
|
||
let serviceIndent = '';
|
||
|
||
for (let i = 0; i < lines.length; i++) {
|
||
const line = lines[i];
|
||
|
||
// Look for n8n service
|
||
if (line.match(/^\s+n8n:\s*$/) || line.match(/^\s+n8n:\s+#/)) {
|
||
n8nServiceIndex = i;
|
||
inN8nService = true;
|
||
serviceIndent = line.match(/^(\s+)/)?.[1] || ' ';
|
||
continue;
|
||
}
|
||
|
||
// If we're in n8n service, look for volumes
|
||
if (inN8nService && line.match(/^\s+volumes:\s*$/)) {
|
||
volumesIndex = i;
|
||
continue;
|
||
}
|
||
|
||
// Stop when we hit another service or end of current service
|
||
if (inN8nService && line.match(/^\s+\w+:\s*$/) && !line.match(/^\s+(volumes|environment|ports|links|depends_on|entrypoint|command):/)) {
|
||
inN8nService = false;
|
||
}
|
||
}
|
||
|
||
if (n8nServiceIndex === -1) {
|
||
console.log('❌ Could not find n8n service in docker-compose file');
|
||
return false;
|
||
}
|
||
|
||
console.log(`✅ Found n8n service at line ${n8nServiceIndex + 1}`);
|
||
|
||
// Insert patcher volume mount and entrypoint override
|
||
let insertionPoint = -1;
|
||
let hasEntrypoint = false;
|
||
|
||
// Find where to insert the volume mount
|
||
if (volumesIndex !== -1) {
|
||
// Add to existing volumes section
|
||
let lastVolumeIndex = volumesIndex;
|
||
for (let i = volumesIndex + 1; i < lines.length; i++) {
|
||
if (lines[i].match(/^\s+- /)) {
|
||
lastVolumeIndex = i;
|
||
} else if (lines[i].match(/^\s+\w+:/)) {
|
||
break;
|
||
}
|
||
}
|
||
insertionPoint = lastVolumeIndex + 1;
|
||
} else {
|
||
// Create volumes section
|
||
let servicesEndIndex = n8nServiceIndex + 1;
|
||
for (let i = n8nServiceIndex + 1; i < lines.length; i++) {
|
||
if (lines[i].match(/^\s+\w+:\s*$/) && !lines[i].match(/^\s+(image|restart|environment|ports|links|depends_on|entrypoint|command):/)) {
|
||
break;
|
||
}
|
||
if (lines[i].match(/^\s+(ports|links|depends_on):/)) {
|
||
servicesEndIndex = i;
|
||
}
|
||
}
|
||
|
||
// Insert volumes section
|
||
lines.splice(servicesEndIndex + 1, 0, `${serviceIndent} volumes:`);
|
||
insertionPoint = servicesEndIndex + 2;
|
||
volumesIndex = servicesEndIndex + 1;
|
||
}
|
||
|
||
// Add patcher volume mount
|
||
lines.splice(insertionPoint, 0, `${serviceIndent} - ./emulated-license-patcher.js:/tmp/patcher.js:ro`);
|
||
|
||
// Find or add entrypoint
|
||
for (let i = n8nServiceIndex; i < lines.length; i++) {
|
||
if (lines[i].match(/^\s+entrypoint:/)) {
|
||
hasEntrypoint = true;
|
||
break;
|
||
}
|
||
if (lines[i].match(/^\s+\w+:\s*$/) && !lines[i].match(/^\s+(image|restart|environment|ports|links|depends_on|volumes|entrypoint|command):/)) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (hasEntrypoint) {
|
||
console.log('⚠️ Found existing entrypoint - you may need to manually merge the patching logic');
|
||
} else {
|
||
// Add entrypoint after volumes section
|
||
const entrypointLines = [
|
||
`${serviceIndent} # Override entrypoint to patch before starting`,
|
||
`${serviceIndent} entrypoint: >`,
|
||
`${serviceIndent} sh -c "`,
|
||
`${serviceIndent} echo '🔑 Applying license patch...';`,
|
||
`${serviceIndent} node /tmp/patcher.js patch;`,
|
||
`${serviceIndent} echo '✅ Patch applied, starting n8n...';`,
|
||
`${serviceIndent} exec tini -- n8n start;`,
|
||
`${serviceIndent} "`
|
||
];
|
||
|
||
// Find where to insert entrypoint (after volumes)
|
||
let entrypointInsertIndex = insertionPoint + 1;
|
||
for (let i = insertionPoint + 1; i < lines.length; i++) {
|
||
if (lines[i].match(/^\s+\w+:/)) {
|
||
entrypointInsertIndex = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
lines.splice(entrypointInsertIndex, 0, ...entrypointLines);
|
||
}
|
||
|
||
// Write patched file
|
||
fs.writeFileSync(filePath, lines.join('\n'));
|
||
console.log('✅ Docker Compose file patched successfully');
|
||
|
||
console.log('\n📋 What was added:');
|
||
console.log(' • Volume mount: ./emulated-license-patcher.js:/tmp/patcher.js:ro');
|
||
if (!hasEntrypoint) {
|
||
console.log(' • Entrypoint override to run patcher before n8n starts');
|
||
}
|
||
console.log('\n⚠️ Make sure emulated-license-patcher.js is in the same directory as your docker-compose.yml');
|
||
|
||
return true;
|
||
|
||
} catch (error) {
|
||
console.error(`❌ Error patching Docker Compose: ${error.message}`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
unpatchDockerCompose(filePath) {
|
||
console.log(`\n🔄 Unpatching Docker Compose file: ${filePath}`);
|
||
|
||
const backupPath = filePath + '.backup';
|
||
|
||
if (!fs.existsSync(backupPath)) {
|
||
console.log('❌ No backup found');
|
||
return false;
|
||
}
|
||
|
||
try {
|
||
const backupContent = fs.readFileSync(backupPath, 'utf8');
|
||
fs.writeFileSync(filePath, backupContent);
|
||
console.log('✅ Docker Compose file restored from backup');
|
||
return true;
|
||
} catch (error) {
|
||
console.error(`❌ Error restoring Docker Compose: ${error.message}`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
showUsage() {
|
||
console.log('🔑 Emulated N8N License Patcher');
|
||
console.log('===============================');
|
||
console.log('');
|
||
console.log('Replaces minified LicenseManager with clean emulated implementation.');
|
||
console.log('');
|
||
console.log('Usage:');
|
||
console.log(' node emulated-license-patcher.js patch # Apply patches');
|
||
console.log(' node emulated-license-patcher.js restore # Restore original files');
|
||
console.log(' node emulated-license-patcher.js find # Just find installations');
|
||
console.log(' node emulated-license-patcher.js docker-patch <file> # Patch docker-compose.yml');
|
||
console.log(' node emulated-license-patcher.js docker-unpatch <file> # Unpatch docker-compose.yml');
|
||
console.log(' node emulated-license-patcher.js help # Show this help');
|
||
console.log('');
|
||
console.log('Docker Examples:');
|
||
console.log(' node emulated-license-patcher.js docker-patch docker-compose.yml');
|
||
console.log(' node emulated-license-patcher.js docker-unpatch docker-compose.yml');
|
||
console.log('');
|
||
console.log('⚠️ For development/testing purposes only!');
|
||
}
|
||
}
|
||
|
||
// Main execution
|
||
const patcher = new EmulatedLicensePatcher();
|
||
const command = process.argv[2];
|
||
const filePath = process.argv[3];
|
||
|
||
switch (command) {
|
||
case 'patch':
|
||
patcher.patchAll();
|
||
break;
|
||
case 'restore':
|
||
patcher.restoreAll();
|
||
break;
|
||
case 'find':
|
||
patcher.findN8NInstallations();
|
||
break;
|
||
case 'docker-patch':
|
||
if (!filePath) {
|
||
console.log('❌ Please specify docker-compose file path');
|
||
console.log('Usage: node emulated-license-patcher.js docker-patch <file>');
|
||
process.exit(1);
|
||
}
|
||
patcher.patchDockerCompose(filePath);
|
||
break;
|
||
case 'docker-unpatch':
|
||
if (!filePath) {
|
||
console.log('❌ Please specify docker-compose file path');
|
||
console.log('Usage: node emulated-license-patcher.js docker-unpatch <file>');
|
||
process.exit(1);
|
||
}
|
||
patcher.unpatchDockerCompose(filePath);
|
||
break;
|
||
case 'help':
|
||
case '--help':
|
||
case '-h':
|
||
case undefined:
|
||
patcher.showUsage();
|
||
break;
|
||
default:
|
||
console.log('❌ Invalid command. Use "help" for usage information.');
|
||
process.exit(1);
|
||
} |