tlsd 2.12.2 → 2.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tlsd",
-  "version": "2.12.2",
+  "version": "2.15.0",
   "description": "A server for web app prototyping with HTTPS and Websockets",
   "main": "tlsd.js",
   "bin": {

package/rpc_static/rpc/rpc.js

@@ -48,11 +48,9 @@
 				delete wraps[id]
 				num -= 1
 				if(num == 0) {
-					//DBG( "clearInterval", timer );
 					clearInterval(timer)
 					timer = null
 				}
-				//DBG("forgetting", id, p );
 			}
 			return p
 		}
@@ -61,7 +59,6 @@
 		// Put a msg into the list
 		// ttl is in secs and should not be less than 10 (default is 60 if not provided)
 		const ins = self.ins = function(p, id, ttl) {
-			//DBG( "remembering", id, p );
 			const w = {
 				expire: time() + (ttl || 60),
 				payload: p,
@@ -78,7 +75,6 @@
 						}
 					}
 				}, 10 * 1000);
-				//DBG( "setInterval", timer );
 			}
 		}
 
@@ -177,7 +173,7 @@
 				var m = x.msg
 				var fail = x.fail;
 				if( fail ) {
-					fail(msg_in.error);
+					fail( msg_in.error );
 				}
 
                 return
@@ -201,7 +197,7 @@
 
 				return
 			}
-			
+
 			cb_ctrl( "error", "invalid message", msg_in );
 		}
 

package/tlsd.js

@@ -1,6 +1,6 @@
 
-//Copyright 2024 Sleepless Software Inc.
-//All Rights Reserved
+// Copyright 2025 Sleepless Software Inc.
+// All Rights Reserved
 
 const { path, http, https, fs, crypto, tls, } = require( "allcore" );
 
@@ -13,8 +13,7 @@ const compression = require( "compression" )();
 const cors = require( "cors" )();
 const queryString = require( "querystring" );
 
-require( "sleepless" ).globalize();
-
+const { log5, o2j, j2o, toInt, is_dir } = require( "sleepless" );
 const L = log5.mkLog( "TLSD: " );
 const { D, V, I, W, E } = L;
 
@@ -35,6 +34,7 @@ function usage() {
 	process.exit( 1 );
 }
 
+
 let seq = 0;
 function next_seq() {
 	seq += 1;
@@ -50,47 +50,29 @@ function next_seq() {
 //      { type: "POST", connection: { req, res } }
 function rpc_handler( root, msg, transport, _okay, _fail ) {
 
-	let ll = toInt( msg.log_level );
-    if( ll > 0 ) {
-	    D( "Setting log level to "+ll );
-		log_level = ll;
-		L( log_level );
-        if( ! dev_mode ) {
-            setTimeout( () => { 
-                ll = process.env.VERBOSITY;
-                D( "Reverting log level to "+ll );
-            }, 15 * 1000 );
-        }
-	}
-
 	V( "RPC " + o2j( msg ).abbr( 70 ) );
-	D( "----------->>> "+transport.type+" "+o2j( msg, null, 2 ) );
 
 	const okay = data => {
-		D( "<<<=========== "+transport.type+" OKAY "+o2j( data, null, 2 ) );
 		_okay( data );
 	};
 
-	const fail = error => {
-		D( "<<<*********** "+transport.type+" ERROR "+o2j( error, null, 2 ) );
-		_fail( error );
-	};
-
-	const ouch = audit_error => {
-		E( root + ": " + o2j(audit_error) );
-		fail( "RPC error" );	// this is returned to browser
+	const fail = ( why ) => {
+        if( ! ( why instanceof Error ) ) {
+            why = new Error( why );
+        }
+		E( root + ": " + why.stack );
+		_fail();
 	};
 
 	try {
         // try loading explicit common js module 
 		const path = root + "/rpc/index.cjs";
-		V( "path=" + path );
+		//D( "path=" + path );
 		const mod = require( path );
 		try {
-			mod( msg, okay, ouch, transport );
+			mod( msg, okay, fail, transport );
 		} catch( err ) {
-            E( (err instanceof Error ) ? err.stack : err );
-            ouch( "RPC handler exception" );
+            fail( err ); 
 		}
 
 	} catch( err ) {
@@ -98,18 +80,16 @@ function rpc_handler( root, msg, transport, _okay, _fail ) {
         // try loading it the old way using the dir
         try {
 			const path = root + "/rpc";
-			V( "path=" + path );
+			//D( "path=" + path );
 			const mod = require( path );
 			try {
-				mod( msg, okay, ouch, transport );
+				mod( msg, okay, fail, transport );
 			} catch( err ) {
-				E( (err instanceof Error ) ? err.stack : err );
-				ouch( "RPC handler exception" );
+				fail( err );
 			}
 
         } catch( err ) {
-			E( (err instanceof Error ) ? err.stack : err );
-			ouch( "Error loading RPC handler" );
+            fail( err );
         }
 
 	}
@@ -118,25 +98,22 @@ function rpc_handler( root, msg, transport, _okay, _fail ) {
 
 // Glue function to call rpc handler module and then return response
 // via the websockets msg object
-function ws_msg_handler( root, msg, connection ) {
-	rpc_handler( root, msg.msg, { type: "WS", connection }, data => {
+function ws_msg_handler( root, msg, host, connection ) {
+	rpc_handler( root, msg.msg, { type: "WS", host, connection }, data => {
 		msg.reply( data );
-	}, error => {
-		msg.error( { error } );
-		E( "Should this happen? "+o2j(error,null,2) );
+	}, err => {
+		msg.error( err || "Unspecified Error" );
 	} );
 };
 
 
-// -----------------------
-
-
 // Handler that populates the req.query var with what's in query args
 function populate_query( req, res, next ) {
     req.query = queryString.parse( req._parsedUrl.query );
     next();
 }
 
+
 // Simple logging handler
 function logger( req, res, next ) {
     const host = req.headers[ "host" ];
@@ -146,6 +123,7 @@ function logger( req, res, next ) {
     next();
 }
 
+
 // Creates and returns a handler function that intercepts and services
 // POST requests to "/rpc" endpoint.
 function rpc_post( root ) {
@@ -171,24 +149,28 @@ function rpc_post( root ) {
             input = query;
         }
 
-        // Set up callbacks
-        const done = ( error, data ) => {
+        D( method + " >------> " + o2j( input, null, 2 ) );
+
+        // Summon the rpc handler for the domain root.
+        rpc_handler( root, input, { type: method, connection: { host: req.headers[ "host" ], req, res, } } , output => {
             res.writeHead( 200, {
                 "Content-Type": "application/json",
                 "Cache-Control": "no-store",
             });
-            res.write( o2j( data ) );
+            D( method + " <------< " + o2j( output, null, 2 ) );
+            res.write( o2j( output ) );
             res.end();
-        };
-        const okay = ( data ) => { done( null, data ); };
-        // XXX wrong
-        const fail = ( error, body ) => { done( error, body ); };
-
-        // Summon the rpc handler for the domain root.
-        rpc_handler( root, input, { type: method, connection: { req, res, } } , okay, fail );
+        }, () => {
+            res.writeHead( 500, {
+                "Content-Type": "application/json",
+                "Cache-Control": "no-store",
+            } );
+            res.end();
+        } );
     };
 }
 
+
 // Handler for tlsd's own static files.
 // This is so that "GET /rpc/rpc.js" can return the client-side code for 
 // sending WS RPC messages (similar to how socket.io works).
@@ -214,6 +196,7 @@ function not_found( root ) {
     }
 }
 
+
 // Create and return a connect app/function that implements
 // default (basic) functionality.
 function basic_handler( root ) {
@@ -233,6 +216,7 @@ function basic_handler( root ) {
 
 const cached_basic_handlers = {};
 
+
 // Handle REST calls (as opposed to websocket messages)
 function rest_handler( root, req, rsp ) {
 
@@ -272,33 +256,27 @@ function rest_handler( root, req, rsp ) {
 };
 
 
-// -----------------------
-
-
-// tracked websocket connections
-//const ws_connections = {};
-
-
 // Associate a websocket message handler (msg_handler) to a webserver instance (server)
 function ws_attach( server, msg_handler ) {
 
 	const wsd = new websocket.server( { httpServer: server, autoAcceptConnections: false, } );
 
 	wsd.on( "request", function( wsreq ) {
+
 		V( "WS: connection request from "+wsreq.remoteAddress+" "+wsreq.resource )
 	
-		const domain = wsreq.httpRequest.headers[ "host" ];
+		const host = wsreq.httpRequest.headers[ "host" ];
 
 		const socket = wsreq.accept( null, wsreq.origin );
 
-		const name = "ws-conn-"+next_seq();       // XXX just use the websocket id
+		const name = "ws-conn-" + next_seq();       // XXX just use the websocket id
 
 		// send msg to connected client
 		const send = function( msg, cb ) {
 			if( msg.msg_id === undefined ) {
 				msg.msg_id = "msg-id-" + next_seq();	// every message must have an id
 			}
-			D( name+" <=== WS ===<< "+o2j( msg ) );
+			D( name+"WS <------< "+o2j( msg ) );
 			socket.send( o2j( msg ) ); 
 		};
 
@@ -310,12 +288,11 @@ function ws_attach( server, msg_handler ) {
 
 		socket.on("close", function() {
 			D( "WS: disconnect" );
-            //delete ws_connections[ name ];  // remove from tracked connections
 		});
 
 		// incoming msgs from client come through here
 		socket.on( "message", function( x ) {
-			D( name+" >>--- WS ---> "+x.utf8Data );
+			D( "WS >------> "+x.utf8Data );
 
 			const json = x.utf8Data;			// raw message is a utf8 string
 			const msg_in = j2o( json );
@@ -325,25 +302,23 @@ function ws_attach( server, msg_handler ) {
 			}
 
 			if( msg_in.msg ) {
-				// message initiated by client
+				// this is a message initiated by the client
 				msg_in.reply = function( response ) {
 					send( { msg_id: msg_in.msg_id, response, } );
 				}
 				msg_in.error = function( error ) {
 					send( { msg_id: msg_in.msg_id, error, } );
 				}
-				msg_handler( msg_in, conn, domain );
+				msg_handler( msg_in, conn, host );
 				return;
 			}
 
-			E( "WS: invalid message" );
+			I( "WS: invalid message dropped" );
 
 		} );
 
 		D( "WS: connected: "+name );
 
-        //ws_connections[ name ] = conn;      // add to tracked connections
-
 	} );
 
 	D( "WS: initialized" );
@@ -353,15 +328,16 @@ function ws_attach( server, msg_handler ) {
 };
 
 
-// -----------------------
-
 const argv = process.argv;
 
 if( argv.length == 2 ) {
 
-	const { DOMAINS_ROOT, MAINTAINER_EMAIL, VERBOSITY, } = process.env;
+	let { DOMAINS_ROOT, MAINTAINER_EMAIL, VERBOSITY, } = process.env;
+
+    VERBOSITY = toInt( VERBOSITY );
 
 	if( DOMAINS_ROOT && MAINTAINER_EMAIL && VERBOSITY ) {
+
 		L( toInt( VERBOSITY ) );
 
 		I( "=== TLS MODE ===" );
@@ -378,12 +354,12 @@ if( argv.length == 2 ) {
 
 			var server = glx.httpsServer();
 
-			ws_attach( server, ( msg, connection, domain ) => {
-				const root = path.resolve( DOMAINS_ROOT + "/" + domain );
-				ws_msg_handler( root, msg, connection );
+			ws_attach( server, function( msg, connection, host ) {
+				const root = path.resolve( DOMAINS_ROOT + "/" + host );
+				ws_msg_handler( root, msg, host, connection );
             } );
 
-			glx.serveApp( ( req, res ) => {
+			glx.serveApp( function( req, res ) {
 				const root = path.resolve( DOMAINS_ROOT + "/" + req.headers[ "host" ] );
 				rest_handler( root, req, res );
 			} );
@@ -400,9 +376,13 @@ if( argv.length == 5 ) {
 
 	let [ exe, script, SITE_ROOT, PORT, VERBOSITY, ] = argv;
 
+    VERBOSITY = toInt( VERBOSITY );
+    PORT = toInt( PORT );
+
 	dev_mode = true;
 
 	if( SITE_ROOT && PORT && VERBOSITY ) {
+
 		L( toInt( VERBOSITY ) );
 
 		SITE_ROOT = path.resolve( SITE_ROOT );
@@ -416,8 +396,8 @@ if( argv.length == 5 ) {
 			rest_handler( SITE_ROOT, req, res );
 		} );
 
-        ws_attach( server, ( msg, connection, domain ) => {
-            ws_msg_handler( SITE_ROOT, msg, connection );
+        ws_attach( server, ( msg, connection, host ) => {
+            ws_msg_handler( SITE_ROOT, msg, host, connection );
         } );
 
 		server.listen( toInt( PORT ), () => {
@@ -434,7 +414,6 @@ else
 if( argv.length == 3 && argv[ 2 ] == "-v" ) {
 
 	// pull package version from package.json and print it
-
 	const p = require( __dirname + "/package.json" );
 	log( p.version );