@metric-im/administrate 1.0.0 → 1.0.2

package/README.md

@@ -1,2 +1,28 @@
 # administrate
 Tools for site administration
+
+## Certify
+Certify will detect the hostname of incoming ssl requests and present the certs. If the domain name does not have a valid cert it requests one from letsencrypt and saves the keys to $HOME/.metric-im/
+
+```javascript
+import https from "https";
+import { Certify } from '@metric-im/administrate';
+const app = express();
+const certify = await Certify.attach(app,{contactEmail:'me@there.com'});
+// certify.SNI return {key: xxx, cert: ...} for the current domain and/or triggers a request for a cert
+const https_server = https.createServer({...certify.SNI},app);
+```
+>NOTE: Set the environment variable PROFILE=DEV to instruct acme to fetch test circuits. Use this when testing or you will be throttled.
+
+## Multisite
+Multisite acts as a proxy service. It listens on port 80 (4080), 443 (4443) for all web traffic and routes to the designated service. A service is identified by domain name. multisite will look for a service matching the incoming domain name in the *sites* folder. It spawns the app found with npm start and assigns it an http port. All subsquent traffic for that domain are routed to this process.
+
+Multisite can also launch a new instance of the current app with the sanitized domain name as the first argument. In this way the same code can run multiple named apps in separate silos.
+
+```javascript
+const multiSite = MultiSite.attach(app);
+```
+See the Roots project [Harness](https;//github.com/rootz-global/harness). This is a simple host for multisite. It expects symlinks to all the apps the server responds to by domain name.
+
+## Syncrhonize
+Provides a web hook to github for manaing synchronization with a code branch.

package/config.mjs

@@ -56,7 +56,7 @@ export class DomainConfig extends Config {
     this.domainConfigFile = join(this.domainConfigDir, 'config.ini');
     if (!fs.existsSync(this.domainConfigDir)) {
       fs.mkdirSync(this.domainConfigDir);
-      fs.writeFileSync(this.domainConfigFile,JSON.stringify([]));
+      fs.writeFileSync(this.domainConfigFile,`name=${domain}`);
     }
     this.load();
   }

package/multisite.mjs

@@ -18,6 +18,8 @@ export class MultiSite {
         this._spawnPort = (parseInt(this.options.spawnPort||0) || 53874);
         this.usedPorts = new Set();
         this.healthCheckIntervals = new Map();
+        this.isShuttingDown = false;
+        this.errorLogTracker = new Map(); // Track error frequency for rate limiting
         this.setupCleanup();
     }
     get spawnPort() {
@@ -27,13 +29,58 @@ export class MultiSite {
     }
 
     setupCleanup() {
-        process.on('SIGTERM', () => this.cleanup());
-        process.on('SIGINT', () => this.cleanup());
-        process.on('exit', () => this.cleanup());
+        // Set up centralized signal handlers that host applications can use
+        this.gracefulShutdown = this.gracefulShutdown.bind(this);
+
+        // Only handle the 'exit' event for emergency cleanup
+        process.on('exit', () => {
+            // Synchronous cleanup only - no async operations allowed in 'exit'
+            console.log('Emergency cleanup on exit...');
+            Object.values(this.sites).forEach((site) => {
+                if (site.proc && !site.proc.killed) {
+                    site.proc.kill('SIGKILL');
+                }
+            });
+        });
+    }
+
+    async gracefulShutdown(signal) {
+        if (this.isShuttingDown) {
+            console.log(`Received ${signal} again, forcing exit...`);
+            process.exit(1);
+        }
+
+        this.isShuttingDown = true;
+        console.log(`Received ${signal}, shutting down gracefully...`);
+
+        try {
+            console.log("Cleaning up child processes...");
+            await this.cleanup();
+
+            console.log("Graceful shutdown complete");
+            process.exit(0);
+        } catch (error) {
+            console.error("Error during shutdown:", error);
+            process.exit(1);
+        }
+    }
+
+    setupSignalHandlers() {
+        // Method host applications can call to set up proper signal handling
+        process.on('SIGINT', () => this.gracefulShutdown('SIGINT'));
+        process.on('SIGTERM', () => this.gracefulShutdown('SIGTERM'));
+        console.log('MultiSite signal handlers installed');
     }
 
     async cleanup() {
         console.log('Cleaning up spawned processes...');
+
+        // Set a global timeout for the entire cleanup process
+        const cleanupTimeout = setTimeout(() => {
+            console.log('Cleanup taking too long, forcing exit...');
+            process.exit(1);
+        }, 15000); // 15 second total timeout
+
         const promises = Object.values(this.sites).map(async (site) => {
             if (site.proc && !site.proc.killed) {
                 return new Promise((resolve) => {
@@ -43,7 +90,7 @@ export class MultiSite {
                             site.proc.kill('SIGKILL');
                         }
                         resolve();
-                    }, 10000); // 10 second timeout for graceful shutdown
+                    }, 5000); // Reduced to 5 second timeout per process
 
                     site.proc.kill('SIGTERM');
 
@@ -62,6 +109,7 @@ export class MultiSite {
         this.healthCheckIntervals.forEach(interval => clearInterval(interval));
         this.healthCheckIntervals.clear();
 
+        clearTimeout(cleanupTimeout);
         console.log('All spawned processes cleaned up');
     }
 
@@ -129,13 +177,44 @@ export class MultiSite {
             }
         });
     }
+
+    // Rate limit error logging to prevent spam
+    shouldLogError(target, clientIP) {
+        const key = `${clientIP}:${target}`;
+        const now = Date.now();
+        const logEntry = this.errorLogTracker.get(key);
+        
+        if (!logEntry) {
+            this.errorLogTracker.set(key, { count: 1, firstSeen: now, lastLogged: now });
+            return true;
+        }
+        
+        logEntry.count++;
+        
+        // Reset counter if it's been more than 5 minutes since first error
+        if (now - logEntry.firstSeen > 300000) {
+            logEntry.count = 1;
+            logEntry.firstSeen = now;
+            logEntry.lastLogged = now;
+            return true;
+        }
+        
+        // Log first error, then every 10th error, but not more than once per minute
+        if (logEntry.count === 1 || 
+            (logEntry.count % 10 === 0 && now - logEntry.lastLogged > 60000)) {
+            logEntry.lastLogged = now;
+            return true;
+        }
+        
+        return false;
+    }
     static async attach(app,options) {
         const instance = new MultiSite(app,options);
         instance.config = new Config();
         // spawn declared sites
         if (fs.existsSync(resolve('./sites'))) {
             instance.sites = (fs.readdirSync(resolve('./sites'))).reduce((result,hostName)=>{
-                const domainName = Site.GetId(hostName);
+                const domainName = Site.WashName(hostName);
                 const options = {
                     cwd: resolve(`./sites/${hostName}`),
                     env: {PORT:instance.spawnPort,meta:instance.options}
@@ -151,13 +230,14 @@ export class MultiSite {
         const router = express.Router();
 
         router.all(/.*/, async (req, res) => {
-            const domain = Site.GetId(req.hostname);
+            const domain = Site.WashName(req.hostname);
             const site = this.sites[domain];
             if (site) {
                 let target = `http://127.0.0.1:${site.options.env.PORT}${req.url}`;
                 const method = req.method;
                 const isBodyMethod = ['POST', 'PUT', 'PATCH'].includes(method);
                 const payload = isBodyMethod ? req.body : null;
+                const clientIP = req.ip || req.connection.remoteAddress || req.headers['x-forwarded-for'];
 
                 // Debug logging for POST requests
                 if (method === 'POST') {
@@ -188,14 +268,14 @@ export class MultiSite {
                             timeout: 30000,
                             responseType: 'stream'
                         });
-                        
+
                         console.log(`${response.status} ${target} (binary stream)`);
-                        
+
                         // Set headers without the problematic ones
                         const cleanHeaders = {...response.headers};
                         delete cleanHeaders['transfer-encoding'];
                         delete cleanHeaders['content-encoding'];
-                        
+
                         res.status(response.status).set(cleanHeaders);
                         response.data.pipe(res);
                     } else {
@@ -210,17 +290,25 @@ export class MultiSite {
                             timeout: 30000,
                             responseType: 'text'
                         });
-                        
+
                         console.log(`${response.status} ${target}`);
-                        
+
                         const cleanHeaders = {...response.headers};
                         delete cleanHeaders['transfer-encoding'];
                         delete cleanHeaders['content-encoding'];
-                        
+
                         res.status(response.status).set(cleanHeaders).send(response.data);
                     }
                 } catch (error) {
-                    console.error(`[Proxy] Error connecting to ${target}:`, error.message);
+                    // Rate limit error logging to prevent spam
+                    if (this.shouldLogError(target, clientIP)) {
+                        const logEntry = this.errorLogTracker.get(`${clientIP}:${target}`);
+                        if (logEntry && logEntry.count > 1) {
+                            console.error(`${clientIP}:E: [Proxy] Error connecting to ${target}: ${error.message} (${logEntry.count} times)`);
+                        } else {
+                            console.error(`${clientIP}:E: [Proxy] Error connecting to ${target}: ${error.message}`);
+                        }
+                    }
 
                     // // Clean up dead processes
                     // this.removeDeadSites();
@@ -319,9 +407,12 @@ export class Site {
             console.error(`${this.name}: Exception while spawning:`, err);
             this.proc = null;
         }
-   }
-    static GetId(hostName="") {
-        if (hostName.match(/^[\d]{1,3}\.[\d]{1,3}\.[\d]{1,3}\.[\d]{1,3}$/)) return null
-        return hostName.toLowerCase().replace(/[^a-z0-9-]+/g,'_');
+    }
+    static WashName(hostName="") {
+      if (!hostName || hostName.match(/^[\d]{1,3}\.[\d]{1,3}\.[\d]{1,3}\.[\d]{1,3}$/)) return "";
+      else return hostName.toLowerCase();
+    }
+    static SafeName(hostName) {
+      return Site.WashName(hostName).replace(/[^a-z0-9-]+/g,'_');
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metric-im/administrate",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Tools for site administration",
   "homepage": "https://github.com/metric-im/administrate#readme",
   "bugs": {

package/.claude/settings.local.json

@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Read(//home/msprague/workspace/sitewell/**)",
-      "Read(//home/msprague/workspace/rootz/data-wallet-demos/**)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}