@genxis/n8nrockstars 1.0.0

package/lib/checker.js

@@ -0,0 +1,90 @@
+/**
+ * Pre-deployment checks
+ * Verifies server meets requirements
+ */
+
+const https = require('https');
+
+async function checkPrerequisites(options) {
+  const checks = [];
+
+  // Check 1: Server connectivity
+  checks.push({
+    name: 'Server connectivity',
+    test: async () => await testConnection(options.server)
+  });
+
+  // Check 2: WHM/cPanel access
+  checks.push({
+    name: 'WHM/cPanel API access',
+    test: async () => await testAPIAccess(options)
+  });
+
+  // Check 3: Disk space
+  checks.push({
+    name: 'Disk space (need 5GB+)',
+    test: async () => true // TODO: Check via API
+  });
+
+  // Check 4: Memory
+  checks.push({
+    name: 'Memory (recommend 2GB+)',
+    test: async () => true // TODO: Check via API
+  });
+
+  // Run all checks
+  for (const check of checks) {
+    try {
+      await check.test();
+    } catch (error) {
+      throw new Error(`${check.name}: ${error.message}`);
+    }
+  }
+
+  return { passed: true };
+}
+
+async function testConnection(server) {
+  return new Promise((resolve, reject) => {
+    const agent = new https.Agent({ rejectUnauthorized: false });
+    
+    https.get(`https://${server}:2087`, { agent, timeout: 5000 }, (res) => {
+      resolve(true);
+    }).on('error', (err) => {
+      reject(new Error(`Cannot reach server: ${err.message}`));
+    });
+  });
+}
+
+async function testAPIAccess(options) {
+  const { server, user, password, whmToken } = options;
+  const agent = new https.Agent({ rejectUnauthorized: false });
+
+  return new Promise((resolve, reject) => {
+    const port = whmToken ? 2087 : 2083;
+    const path = whmToken ? '/json-api/version' : '/execute/Fileman/list_files?dir=/home';
+    const auth = whmToken 
+      ? `whm root:${whmToken}`
+      : `Basic ${Buffer.from(`${user}:${password}`).toString('base64')}`;
+
+    const reqOptions = {
+      hostname: server,
+      port: port,
+      path: path,
+      method: 'GET',
+      headers: { 'Authorization': auth },
+      agent,
+      timeout: 10000
+    };
+
+    https.request(reqOptions, (res) => {
+      if (res.statusCode === 200 || res.statusCode === 403) {
+        resolve(true);
+      } else {
+        reject(new Error(`HTTP ${res.statusCode}`));
+      }
+    }).on('error', reject).end();
+  });
+}
+
+module.exports = { checkPrerequisites };

package/lib/cpanel-subdomain.js

@@ -0,0 +1,94 @@
+/**
+ * cPanel subdomain creation via UAPI
+ * Handles DNS record creation
+ */
+
+const https = require('https');
+
+async function createSubdomain(options) {
+  const { server, user, whmToken, subdomain, domain, docRoot } = options;
+
+  // Create subdomain via UAPI
+  const result = await callUAPI({
+    server,
+    user,
+    whmToken,
+    module: 'SubDomain',
+    func: 'addsubdomain',
+    params: {
+      domain: subdomain,
+      rootdomain: domain,
+      dir: docRoot
+    }
+  });
+
+  // Add DNS A record (manual since ZoneEdit module broken)
+  await addDNSRecord({
+    server,
+    user,
+    whmToken,
+    subdomain: `${subdomain}.${domain}`,
+    ip: server
+  });
+
+  return result;
+}
+
+async function callUAPI(options) {
+  const { server, user, whmToken, module, func, params } = options;
+
+  const agent = new https.Agent({ rejectUnauthorized: false });
+  
+  const queryString = Object.entries(params)
+    .map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
+    .join('&');
+
+  const apiUrl = whmToken
+    ? `/json-api/cpanel?cpanel_jsonapi_user=${user}&cpanel_jsonapi_module=${module}&cpanel_jsonapi_func=${func}&${queryString}`
+    : `/execute/${module}/${func}?${queryString}`;
+
+  const port = whmToken ? 2087 : 2083;
+
+  return new Promise((resolve, reject) => {
+    const reqOptions = {
+      hostname: server,
+      port: port,
+      path: apiUrl,
+      method: 'GET',
+      headers: whmToken 
+        ? { 'Authorization': `whm root:${whmToken}` }
+        : { 'Authorization': `Basic ${Buffer.from(`${user}:${options.password}`).toString('base64')}` },
+      agent,
+      timeout: 30000
+    };
+
+    https.request(reqOptions, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch {
+          resolve({ raw: data });
+        }
+      });
+    }).on('error', reject).end();
+  });
+}
+
+async function addDNSRecord(options) {
+  const { server, user, whmToken, subdomain, ip } = options;
+  const { executeSSH } = require('./ssh-executor');
+
+  // Add DNS via zone file edit (ZoneEdit module broken)
+  const domain = subdomain.split('.').slice(1).join('.');
+  const command = `echo "${subdomain}. 14400 IN A ${ip}" >> /var/named/${domain}.db && /scripts/rebuilddnsconfig`;
+
+  try {
+    await executeSSH({ server, user, whmToken, command });
+  } catch (e) {
+    // May fail if already exists
+  }
+}
+
+module.exports = { createSubdomain };

package/lib/deployer.js

@@ -0,0 +1,209 @@
+/**
+ * Main deployment orchestrator
+ * Coordinates all the nightmare steps
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+const { installPostgreSQL } = require('./postgres-installer');
+const { createSubdomain } = require('./cpanel-subdomain');
+const { uploadFiles } = require('./ftp-uploader');
+const { configureApache } = require('./apache-proxy');
+const { startN8n } = require('./n8n-starter');
+const fs = require('fs');
+
+async function deployN8n(options) {
+  const {
+    server,
+    user,
+    password,
+    whmToken,
+    subdomain = 'n8n',
+    domain,
+    skipPostgres = false,
+    skipSsl = false
+  } = options;
+
+  const fullDomain = `${subdomain}.${domain}`;
+  const results = {
+    url: `https://${fullDomain}`,
+    username: 'admin',
+    password: generatePassword(16),
+    dbPassword: generatePassword(20)
+  };
+
+  let spinner;
+
+  try {
+    // Step 1: Install PostgreSQL
+    if (!skipPostgres) {
+      spinner = ora('Installing PostgreSQL 15...').start();
+      await installPostgreSQL({ server, user, password, whmToken });
+      spinner.succeed('PostgreSQL 15 installed');
+    }
+
+    // Step 2: Create PostgreSQL database
+    spinner = ora('Creating PostgreSQL database...').start();
+    await createPostgresDB({
+      server,
+      user,
+      password,
+      dbName: `${user}_n8n`,
+      dbUser: `${user}_n8n`,
+      dbPassword: results.dbPassword
+    });
+    spinner.succeed('Database created');
+
+    // Step 3: Create subdomain
+    spinner = ora(`Creating subdomain ${fullDomain}...`).start();
+    await createSubdomain({
+      server,
+      user,
+      password,
+      whmToken,
+      subdomain,
+      domain,
+      docRoot: `/home/${user}/n8n`
+    });
+    spinner.succeed('Subdomain created');
+
+    // Step 4: Generate server.js
+    spinner = ora('Generating n8n startup script...').start();
+    const serverJs = generateServerJs({
+      domain: fullDomain,
+      dbName: `${user}_n8n`,
+      dbUser: `${user}_n8n`,
+      dbPassword: results.dbPassword,
+      adminPassword: results.password
+    });
+    fs.writeFileSync('server.js', serverJs);
+    spinner.succeed('Startup script generated');
+
+    // Step 5: Upload files via FTP
+    spinner = ora('Uploading files to server...').start();
+    await uploadFiles({
+      server,
+      user,
+      password,
+      localPath: 'server.js',
+      remotePath: `/n8n/server.js`
+    });
+    spinner.succeed('Files uploaded');
+
+    // Step 6: Install n8n via SSH commands
+    spinner = ora('Installing n8n (this takes 1-2 minutes)...').start();
+    await installN8nPackage({ server, user, password, whmToken });
+    spinner.succeed('n8n installed');
+
+    // Step 7: Configure Apache proxy
+    spinner = ora('Configuring Apache reverse proxy...').start();
+    await configureApache({
+      server,
+      user,
+      password,
+      whmToken,
+      subdomain: fullDomain
+    });
+    spinner.succeed('Apache proxy configured');
+
+    // Step 8: Start n8n
+    spinner = ora('Starting n8n...').start();
+    await startN8n({
+      server,
+      user,
+      password,
+      whmToken,
+      path: `/home/${user}/n8n`
+    });
+    spinner.succeed('n8n started');
+
+    // Step 9: Verify it's running
+    spinner = ora('Verifying deployment...').start();
+    await verifyDeployment({ server, url: results.url });
+    spinner.succeed('Deployment verified');
+
+    // Save credentials
+    const credsFile = `n8n-credentials.txt`;
+    const creds = `n8n Deployment Credentials
+=============================
+
+URL: ${results.url}
+Username: ${results.username}
+Password: ${results.password}
+
+Database: ${user}_n8n
+DB User: ${user}_n8n
+DB Password: ${results.dbPassword}
+
+Server: ${server}
+cPanel User: ${user}
+
+Deployed: ${new Date().toISOString()}
+`;
+    fs.writeFileSync(credsFile, creds);
+
+    return results;
+
+  } catch (error) {
+    if (spinner) spinner.fail('Deployment failed');
+    throw error;
+  }
+}
+
+function generatePassword(length) {
+  const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+  return Array(length).fill(0)
+    .map(() => chars[Math.floor(Math.random() * chars.length)])
+    .join('');
+}
+
+function generateServerJs(config) {
+  const template = fs.readFileSync(__dirname + '/../templates/server.js.template', 'utf8');
+  return template
+    .replace(/{{DOMAIN}}/g, config.domain)
+    .replace(/{{DB_NAME}}/g, config.dbName)
+    .replace(/{{DB_USER}}/g, config.dbUser)
+    .replace(/{{DB_PASSWORD}}/g, config.dbPassword)
+    .replace(/{{ADMIN_PASSWORD}}/g, config.adminPassword);
+}
+
+async function createPostgresDB(options) {
+  const { executeSSH } = require('./ssh-executor');
+  
+  const commands = [
+    `su - postgres -c "psql -c \\"CREATE DATABASE ${options.dbName};\\"" 2>/dev/null || true`,
+    `su - postgres -c "psql -c \\"CREATE USER ${options.dbUser} WITH PASSWORD '${options.dbPassword}';\\"" 2>/dev/null || true`,
+    `su - postgres -c "psql -c \\"ALTER DATABASE ${options.dbName} OWNER TO ${options.dbUser};\\""`  ,
+    `su - postgres -c "psql -d ${options.dbName} -c \\"GRANT ALL ON SCHEMA public TO ${options.dbUser};\\""`
+  ];
+
+  for (const cmd of commands) {
+    await executeSSH({ ...options, command: cmd });
+  }
+}
+
+async function installN8nPackage(options) {
+  const { executeSSH } = require('./ssh-executor');
+  
+  await executeSSH({
+    ...options,
+    command: `cd /home/${options.user}/n8n && npm install n8n`
+  });
+}
+
+async function verifyDeployment(options) {
+  const https = require('https');
+  const agent = new https.Agent({ rejectUnauthorized: false });
+
+  return new Promise((resolve, reject) => {
+    https.get(options.url, { agent, timeout: 10000 }, (res) => {
+      if (res.statusCode === 200) {
+        resolve(true);
+      } else {
+        reject(new Error(`HTTP ${res.statusCode}`));
+      }
+    }).on('error', reject);
+  });
+}
+
+module.exports = { deployN8n };

package/lib/ftp-uploader.js

@@ -0,0 +1,54 @@
+/**
+ * FTP file uploader
+ * Bypasses the UAPI file upload complexity
+ */
+
+const ftp = require('basic-ftp');
+
+async function uploadFiles(options) {
+  const { server, user, password, localPath, remotePath } = options;
+
+  const client = new ftp.Client();
+  client.ftp.verbose = false;
+
+  try {
+    // Connect to FTP
+    await client.access({
+      host: server,
+      user: user,
+      password: password,
+      secure: false
+    });
+
+    // Ensure remote directory exists
+    const remoteDir = remotePath.substring(0, remotePath.lastIndexOf('/'));
+    try {
+      await client.ensureDir(remoteDir);
+    } catch (e) {
+      // Directory might exist
+    }
+
+    // Upload file
+    await client.uploadFrom(localPath, remotePath);
+
+    // Verify upload
+    const list = await client.list(remoteDir);
+    const fileName = remotePath.split('/').pop();
+    const uploaded = list.find(f => f.name === fileName);
+
+    if (!uploaded) {
+      throw new Error('File verification failed');
+    }
+
+    return {
+      uploaded: true,
+      size: uploaded.size,
+      path: remotePath
+    };
+
+  } finally {
+    client.close();
+  }
+}
+
+module.exports = { uploadFiles };

package/lib/n8n-starter.js

@@ -0,0 +1,76 @@
+/**
+ * Start n8n as a persistent background service
+ * Survives terminal disconnects
+ */
+
+const { executeSSH } = require('./ssh-executor');
+
+async function startN8n(options) {
+  const { server, user, password, whmToken, path } = options;
+
+  const commands = [
+    // Kill any existing n8n processes
+    `pkill -f "node.*server.js" 2>/dev/null || true`,
+    
+    // Start n8n in background (detached from terminal)
+    `cd ${path} && nohup node server.js > n8n.log 2>&1 </dev/null &`,
+    
+    // Disown to survive terminal close
+    `disown -a 2>/dev/null || true`,
+    
+    // Wait for startup
+    'sleep 10',
+    
+    // Verify it's running
+    `netstat -tulpn | grep 5678 || (echo "n8n failed to start" && exit 1)`
+  ];
+
+  for (const command of commands) {
+    try {
+      await executeSSH({ server, user, password, whmToken, command });
+    } catch (error) {
+      if (error.message.includes('failed to start')) {
+        throw new Error('n8n process failed to start. Check logs at ' + path + '/n8n.log');
+      }
+      // Other errors might be OK (disown not supported, etc)
+    }
+  }
+
+  return { status: 'running', port: 5678 };
+}
+
+async function createSystemdService(options) {
+  const { server, user, path } = options;
+  const { executeSSH } = require('./ssh-executor');
+
+  const serviceContent = `[Unit]
+Description=n8n Workflow Automation
+After=network.target postgresql-15.service
+
+[Service]
+Type=simple
+User=${user}
+WorkingDirectory=${path}
+ExecStart=/usr/bin/node ${path}/server.js
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+`;
+
+  const commands = [
+    `cat > /etc/systemd/system/n8n.service << 'EOF'\n${serviceContent}\nEOF`,
+    'systemctl daemon-reload',
+    'systemctl enable n8n',
+    'systemctl start n8n'
+  ];
+
+  for (const command of commands) {
+    await executeSSH({ ...options, command });
+  }
+
+  return { status: 'service_created' };
+}
+
+module.exports = { startN8n, createSystemdService };

package/lib/postgres-installer.js

@@ -0,0 +1,44 @@
+/**
+ * PostgreSQL installer for CentOS/RHEL cPanel servers
+ * Handles the official repo setup nightmare
+ */
+
+const { executeSSH } = require('./ssh-executor');
+
+async function installPostgreSQL(options) {
+  const commands = [
+    // Install PostgreSQL official repo
+    'dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-8-x86_64/pgdg-redhat-repo-latest.noarch.rpm 2>/dev/null || true',
+    
+    // Disable built-in PostgreSQL module
+    'dnf -qy module disable postgresql',
+    
+    // Install PostgreSQL 15
+    'dnf install -y postgresql15-server postgresql15',
+    
+    // Initialize database
+    'export PGSETUP_INITDB_OPTIONS="--encoding=UTF8" && /usr/pgsql-15/bin/postgresql-15-setup initdb 2>/dev/null || true',
+    
+    // Enable and start service
+    'systemctl enable postgresql-15',
+    'systemctl start postgresql-15',
+    
+    // Wait for startup
+    'sleep 3'
+  ];
+
+  for (const command of commands) {
+    try {
+      await executeSSH({ ...options, command });
+    } catch (error) {
+      // Some commands expected to fail (like if already installed)
+      if (!error.message.includes('already') && !error.message.includes('exists')) {
+        throw error;
+      }
+    }
+  }
+
+  return { status: 'installed' };
+}
+
+module.exports = { installPostgreSQL };

package/lib/ssh-executor.js

@@ -0,0 +1,58 @@
+/**
+ * SSH command executor via WHM API
+ * Uses api.shell when available, falls back to manual instructions
+ */
+
+const https = require('https');
+
+async function executeSSH(options) {
+  const { server, user, password, whmToken, command } = options;
+
+  // Try via WHM API first (if token provided)
+  if (whmToken) {
+    try {
+      return await executeViaWHM({ server, whmToken, command });
+    } catch (error) {
+      // WHM api.shell might be disabled, fall back
+      console.warn('WHM SSH API unavailable, using alternative method');
+    }
+  }
+
+  // Fallback: Return command for manual execution
+  throw new Error(`Please run this command on the server:\n${command}`);
+}
+
+async function executeViaWHM(options) {
+  const { server, whmToken, command } = options;
+  const agent = new https.Agent({ rejectUnauthorized: false });
+
+  return new Promise((resolve, reject) => {
+    const reqOptions = {
+      hostname: server,
+      port: 2087,
+      path: `/json-api/api.shell?cmd=${encodeURIComponent(command)}`,
+      method: 'GET',
+      headers: { 'Authorization': `whm root:${whmToken}` },
+      agent,
+      timeout: 60000 // Some commands take time
+    };
+
+    https.request(reqOptions, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const result = JSON.parse(data);
+          if (result.metadata && result.metadata.result === 0) {
+            reject(new Error(result.metadata.reason || 'Command failed'));
+          }
+          resolve(result);
+        } catch {
+          resolve({ raw: data });
+        }
+      });
+    }).on('error', reject).end();
+  });
+}
+
+module.exports = { executeSSH };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@genxis/n8nrockstars",
+  "version": "1.0.0",
+  "description": "Deploy n8n self-hosted on cPanel/WHM servers - handles all the nightmare edge cases",
+  "main": "index.js",
+  "bin": {
+    "n8nrockstars": "bin/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "n8n",
+    "cpanel",
+    "whm",
+    "automation",
+    "workflow",
+    "deployment",
+    "postgresql",
+    "apache",
+    "proxy",
+    "genxis"
+  ],
+  "author": "GenXis",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "basic-ftp": "^5.0.5",
+    "commander": "^11.1.0",
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "inquirer": "^8.2.6"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/genxis/n8nrockstars.git"
+  },
+  "bugs": {
+    "url": "https://github.com/genxis/n8nrockstars/issues"
+  },
+  "homepage": "https://github.com/genxis/n8nrockstars#readme"
+}