mango-cms 0.2.48 → 0.2.50

package/cli.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 
 const { Command } = require('commander');
-const { execSync } = require('child_process');
+const { execSync, spawn } = require('child_process');
 const path = require('path');
 const inquirer = require('inquirer');
 const fs = require('fs-extra');
 const axios = require('axios');
 const AdmZip = require('adm-zip');
+const { addHosts, removeHosts } = require('./lib/hosts-manager');
 
 const program = new Command();
 
@@ -783,4 +784,130 @@ program
         }
     });
 
+// --- Dev Proxy Commands ---
+const proxyCmd = program
+    .command('proxy <action>')
+    .description('Manage local dev proxy domains (start, stop, status)')
+    .action(async (action) => {
+        const allowed = ['start', 'stop', 'status'];
+        if (!allowed.includes(action)) {
+            console.error(`Unknown proxy action: ${action}. Use: ${allowed.join(', ')}`);
+            process.exit(1);
+        }
+
+        const pidPath = path.join(process.cwd(), '.mango-proxy.pid');
+        const settingsPath = path.join(process.cwd(), 'mango/config/settings.json');
+
+        if (action === 'start') {
+            if (!fs.existsSync(settingsPath)) {
+                console.error('Error: mango/config/settings.json not found. Run this from your project root.');
+                process.exit(1);
+            }
+
+            const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+            const { siteName } = settings;
+
+            if (!siteName) {
+                console.error('Error: siteName must be set in settings.json');
+                process.exit(1);
+            }
+
+            // Derive dev proxy domains from siteName
+            const slug = siteName.toLowerCase().replace(/[^a-z0-9]/g, '');
+            const frontDomain = `${slug}.mango`;
+            const apiDomain = `api.${slug}.mango`;
+
+            // Kill existing proxy if running
+            if (fs.existsSync(pidPath)) {
+                try {
+                    const oldPid = fs.readFileSync(pidPath, 'utf8').trim();
+                    execSync(`sudo kill ${oldPid} 2>/dev/null || true`);
+                } catch (e) { /* ignore */ }
+                fs.unlinkSync(pidPath);
+            }
+
+            // Add /etc/hosts entries
+            addHosts([frontDomain, apiDomain]);
+
+            const frontendPort = settings.frontPort || 5173;
+            const backendPort = settings.port || 3002;
+
+            // Start the proxy server as a detached background process
+            const proxyScript = path.join(__dirname, 'lib/dev-proxy.js');
+            const logPath = path.join(process.cwd(), '.mango-proxy.log');
+
+            // Use shell to redirect output to a log file and background the process
+            // This keeps sudo in the current TTY so the password prompt works
+            execSync(
+                `sudo node "${proxyScript}" ${frontDomain} ${apiDomain} ${frontendPort} ${backendPort} "${pidPath}" > "${logPath}" 2>&1 &`,
+                { stdio: 'inherit', shell: true }
+            );
+
+            // Wait briefly for the proxy to start and write its PID
+            let started = false;
+            for (let i = 0; i < 10; i++) {
+                await new Promise(r => setTimeout(r, 300));
+                if (fs.existsSync(pidPath)) {
+                    const pid = fs.readFileSync(pidPath, 'utf8').trim();
+                    try {
+                        execSync(`kill -0 ${pid} 2>/dev/null`);
+                        started = true;
+                        break;
+                    } catch (e) { /* not running yet */ }
+                }
+            }
+
+            if (!started) {
+                console.error('\nFailed to start proxy server.');
+                if (fs.existsSync(logPath)) {
+                    console.error('Log output:\n' + fs.readFileSync(logPath, 'utf8'));
+                }
+                process.exit(1);
+            }
+
+            console.log(`
+Mango Dev Proxy started.
+
+  http://${frontDomain}   -> localhost:${frontendPort} (frontend)
+  http://${apiDomain}  -> localhost:${backendPort} (backend)
+
+Start your dev servers with proxy support:
+  mango start                                          (backend on port ${backendPort})
+  VITE_DEV_PROXY=${apiDomain} mango ui dev   (frontend on port ${frontendPort})
+
+Proxy log: ${logPath}
+To stop: mango proxy stop
+`);
+        } else if (action === 'stop') {
+            if (fs.existsSync(pidPath)) {
+                try {
+                    const pid = fs.readFileSync(pidPath, 'utf8').trim();
+                    execSync(`sudo kill ${pid}`);
+                    console.log('Proxy server stopped.');
+                } catch (e) {
+                    console.log('Proxy process not found (may have already exited).');
+                }
+                fs.unlinkSync(pidPath);
+            } else {
+                console.log('No proxy PID file found. Proxy may not be running.');
+            }
+
+            removeHosts();
+            console.log('Dev proxy cleaned up.');
+
+        } else if (action === 'status') {
+            if (fs.existsSync(pidPath)) {
+                const pid = fs.readFileSync(pidPath, 'utf8').trim();
+                try {
+                    execSync(`kill -0 ${pid} 2>/dev/null`);
+                    console.log(`Proxy is running (PID: ${pid}).`);
+                } catch (e) {
+                    console.log('Proxy PID file exists but process is not running.');
+                }
+            } else {
+                console.log('Proxy is not running.');
+            }
+        }
+    });
+
 program.parse(process.argv);

package/default/gitignore

@@ -3,3 +3,4 @@ node_modules
 yarn.lock
 build
 dist
+.mango-proxy.pid

package/default/package.json

@@ -25,7 +25,7 @@
         "dayjs": "^1.10.7",
         "express": "^4.18.1",
         "google-maps": "^4.3.3",
-        "mango-cms": "^0.2.48",
+        "mango-cms": "^0.2.50",
         "mapbox-gl": "^2.7.0",
         "sweetalert2": "^11.4.0",
         "vite": "^6.2.2",

package/default/src/helpers/mango.js

@@ -21,8 +21,14 @@ let api = `https://${mangoDomain}`
 let ws = `wss://${mangoDomain}/graphql`
 
 if (process.env.NODE_ENV != 'production' && useDevAPI) {
-	api = `http://localhost:${port}`
-	ws = `ws://localhost:${port}/graphql`
+	if (import.meta.env.VITE_DEV_PROXY) {
+		const proxyApi = import.meta.env.VITE_DEV_PROXY
+		api = `http://${proxyApi}`
+		ws = `ws://${proxyApi}/graphql`
+	} else {
+		api = `http://localhost:${port}`
+		ws = `ws://localhost:${port}/graphql`
+	}
 }
 
 function getQuery(params) {

package/default/src/main.js

@@ -69,6 +69,7 @@ app.provide('darkMode', darkMode().darkMode)
 const user = initUser()
 
 let api = useDevAPI ? `http://localhost:${port}` : `https://${mangoDomain}`
+if (isDev && import.meta.env.VITE_DEV_PROXY) api = `http://${import.meta.env.VITE_DEV_PROXY}`
 if (!isDev) api = `https://${mangoDomain}`
 
 const store = reactive({

package/default/vite.config.js

@@ -57,6 +57,11 @@ export default defineConfig({
 	],
 	server: {
 		host: '0.0.0.0',
+		// When running behind mango proxy, configure HMR to use the proxy domain
+		// VITE_DEV_PROXY is set to api.{slug}.mango; derive frontend domain by stripping "api." prefix
+		...(process.env.VITE_DEV_PROXY?.startsWith('api.') ? {
+			hmr: { host: process.env.VITE_DEV_PROXY.replace(/^api\./, '') }
+		} : {}),
 	},
 	resolve: {
 		alias: {

package/lib/dev-proxy.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+/**
+ * Mango Dev Proxy Server
+ *
+ * Runs on port 80, routes requests by hostname to the correct local dev server.
+ * Supports WebSocket upgrade for Vite HMR and Socket.io.
+ *
+ * Usage: node lib/dev-proxy.js <frontDomain> <apiDomain> <frontPort> <backendPort> [pidPath]
+ */
+
+const http = require('http');
+const httpProxy = require('http-proxy');
+const fs = require('fs');
+
+const frontDomain = process.argv[2];
+const apiDomain = process.argv[3];
+const frontendPort = parseInt(process.argv[4], 10);
+const backendPort = parseInt(process.argv[5], 10);
+const pidPath = process.argv[6];
+
+if (!frontDomain || !apiDomain || !frontendPort || !backendPort) {
+    console.error('Usage: node lib/dev-proxy.js <frontDomain> <apiDomain> <frontPort> <backendPort> [pidPath]');
+    process.exit(1);
+}
+
+const proxy = httpProxy.createProxyServer({
+    ws: true,
+    xfwd: true,
+});
+
+proxy.on('error', (err, req, res) => {
+    console.error(`Proxy error for ${req.headers.host}${req.url}:`, err.message);
+    if (res.writeHead) {
+        res.writeHead(502);
+        res.end('Bad Gateway - is your dev server running?');
+    }
+});
+
+function getTarget(host) {
+    const hostname = host?.split(':')[0];
+    if (hostname === apiDomain) {
+        return `http://127.0.0.1:${backendPort}`;
+    }
+    if (hostname === frontDomain) {
+        return `http://127.0.0.1:${frontendPort}`;
+    }
+    return null;
+}
+
+const server = http.createServer((req, res) => {
+    const target = getTarget(req.headers.host);
+    if (!target) {
+        res.writeHead(404);
+        res.end(`Unknown host: ${req.headers.host}`);
+        return;
+    }
+    proxy.web(req, res, { target });
+});
+
+server.on('upgrade', (req, socket, head) => {
+    const target = getTarget(req.headers.host);
+    if (target) {
+        proxy.ws(req, socket, head, { target });
+    } else {
+        socket.destroy();
+    }
+});
+
+server.listen(80, '0.0.0.0', () => {
+    console.log('Mango Dev Proxy running on port 80');
+    console.log(`  ${frontDomain}  -> http://127.0.0.1:${frontendPort} (frontend)`);
+    console.log(`  ${apiDomain}   -> http://127.0.0.1:${backendPort} (backend)`);
+});
+
+// Write PID for cleanup
+if (pidPath) {
+    fs.writeFileSync(pidPath, String(process.pid));
+}

package/lib/hosts-manager.js

@@ -0,0 +1,53 @@
+/**
+ * Manages /etc/hosts entries for Mango dev proxy domains.
+ * Lines are tagged with "# mango-proxy" for easy cleanup.
+ */
+
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+const HOSTS_FILE = '/etc/hosts';
+const TAG = '# mango-proxy';
+
+function addHosts(domains) {
+    const hostsContent = fs.readFileSync(HOSTS_FILE, 'utf8');
+    const newDomains = domains.filter(d => !hostsContent.includes(d));
+
+    if (newDomains.length === 0) {
+        console.log('Hosts entries already exist, skipping.');
+        return;
+    }
+
+    const entry = `127.0.0.1 ${newDomains.join(' ')} ${TAG}`;
+
+    try {
+        execSync(`echo '${entry}' | sudo tee -a ${HOSTS_FILE} > /dev/null`, { stdio: 'inherit' });
+        console.log(`Added to /etc/hosts: ${newDomains.join(', ')}`);
+    } catch (err) {
+        console.error('Failed to update /etc/hosts. You may need to add this line manually:');
+        console.error(`  ${entry}`);
+    }
+}
+
+function removeHosts() {
+    try {
+        const hostsContent = fs.readFileSync(HOSTS_FILE, 'utf8');
+        const lines = hostsContent.split('\n');
+        const filtered = lines.filter(line => !line.includes(TAG));
+
+        if (lines.length === filtered.length) {
+            console.log('No mango-proxy entries found in /etc/hosts.');
+            return;
+        }
+
+        const tmpFile = '/tmp/mango-hosts-clean';
+        fs.writeFileSync(tmpFile, filtered.join('\n'));
+        execSync(`sudo cp ${tmpFile} ${HOSTS_FILE}`, { stdio: 'inherit' });
+        fs.unlinkSync(tmpFile);
+        console.log('Removed mango-proxy entries from /etc/hosts.');
+    } catch (err) {
+        console.error('Failed to clean /etc/hosts:', err.message);
+    }
+}
+
+module.exports = { addHosts, removeHosts };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mango-cms",
-    "version": "0.2.48",
+    "version": "0.2.50",
     "main": "./index.js",
     "exports": {
         ".": "./index.js",
@@ -10,6 +10,7 @@
         "index.js",
         "cli.js",
         "webpack.config.js",
+        "lib/**/*",
         "default/**/*",
         "!default/node_modules/**"
     ],
@@ -70,6 +71,7 @@
         "graphql-type-datetime": "^0.2.4",
         "graphql-ws": "^5.9.0",
         "html-to-text": "^8.0.0",
+        "http-proxy": "^1.18.1",
         "inquirer": "^8.2.4",
         "json-fn": "^1.1.1",
         "lodash": "^4.17.21",