aotrautils-srv 0.0.1827 → 0.0.1829

aotrautils-srv/aotrautils-srv.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils COMMONS library associated with aotra version : «1_29072022-2359 (17/03/2026-14:39:15)»*/
+/*utils COMMONS library associated with aotra version : «1_29072022-2359 (17/03/2026-16:49:52)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -5076,7 +5076,7 @@ AOTRAUTILS_LIB_IS_LOADED=true;
 
 	
 
-/*utils AI library associated with aotra version : «1_29072022-2359 (17/03/2026-14:39:15)»*/
+/*utils AI library associated with aotra version : «1_29072022-2359 (17/03/2026-16:49:52)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -5222,7 +5222,7 @@ getOpenAIAPIClient=(modelName, apiURL, agentRole, defaultPrompt)=>{
 
 
 
-/*utils CONSOLE library associated with aotra version : «1_29072022-2359 (17/03/2026-14:39:15)»*/
+/*utils CONSOLE library associated with aotra version : «1_29072022-2359 (17/03/2026-16:49:52)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -6228,6 +6228,1352 @@ function capitalize(str){
 }
 
 
+/* ## Utility global methods in a javascript, console (nodejs) or vanilla javascript with no browser environment.
+ *
+ * This set of methods gathers utility generic-purpose methods usable in any JS project.
+ * Several authors of snippets published freely on the Internet contributed to this library.
+ * Feel free to use/modify-enhance/publish them under the terms of its license.
+ * 
+ * # Library name : «aotrautils» 
+ * # Library license : HGPL(Help Burma) (see aotra README information for details : https://alqemia.com/aotra.js )
+ * # Author name : Jérémie Ratomposon (massively helped by his native country free education system)
+ * # Author email : info@alqemia.com
+ * # Organization name : Alqemia
+ * # Organization email : admin@alqemia.com
+ * # Organization website :  https://alqemia.com
+ * 
+ *  
+ */
+
+
+// COMPATIBILITY browser javascript / nodejs environment :
+if(typeof(window)==="undefined")	window=global;	
+
+
+
+// OLD : socket.io :
+// https://stackoverflow.com/questions/31156884/how-to-use-https-on-node-js-using-express-socket-io
+// https://stackoverflow.com/questions/6599470/node-js-socket-io-with-ssl
+// https://nodejs.org/api/https.html#https_https_createserver_options_requestlistener
+// https://socket.io/docs/v4/client-socket-instance/
+
+// NEW : ws :
+// https://github.com/websockets/ws#installing
+// https://github.com/websockets/ws/blob/master/doc/ws.md#event-message
+// ON BROWSER SIDE : Native Websockets :
+// https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+// https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_client_applications
+
+
+
+// =================================================================================
+// NODEJS UTILS
+
+const FILE_ENCODING="utf8";
+
+const ADD_CORS_HEADER=true;
+
+
+// DEBUG
+console.log("DEBUG : Importing «fs» dependency.");
+
+
+if(typeof(require)!=="undefined" && typeof(fs)==="undefined" ){
+	window.fs=require("fs");
+}
+
+// For debug (WORKAROUND):
+fs=window.fs;
+
+
+// Nodejs filesystem utils :
+if(typeof(fs)==="undefined"){
+	// TRACE
+	console.log("WARN : Could not find the nodejs dependency «fs», aborting persister setup.");
+	window.getPersister=()=>{	return null;	};
+	
+}else{
+	
+	
+	window.getPersister=function(dataDirPath,prefix=""){
+		
+		let self={
+		
+			dataDirPath:dataDirPath,
+			prefix:prefix,
+			
+			//FILE_NAME_PATTERN:"data.clientId.repositoryName.json",
+			/*private*/getPath:function(clientId="noclient", repositoryName="norepository"){
+		//	let path=self.FILE_NAME_PATTERN.replace(new RegExp("@clientId@","g"),clientId);
+				let path=`${self.dataDirPath}`
+								+ (blank(self.prefix)?"":(self.prefix+"."))
+								+`${clientId}.${repositoryName}.json`;
+				return path;
+			},
+			
+			readTreeObjectFromFile:function(clientId="noclient", repositoryName="norepository", keepClassName=false){
+				
+				let path=self.getPath(clientId,repositoryName);
+				let resultFlat=null;
+		
+				try{
+
+					resultFlat=fs.readFileSync(path, FILE_ENCODING);
+					
+				}catch(error){
+					// TRACE
+					console.log("ERROR : Could not read file «"+path+"».");
+		
+					return null;
+				}
+				
+				
+				let resultData={};
+				
+				// 1)
+				if(!empty(resultFlat))	resultData=parseJSON(resultFlat);
+				
+				// 2)
+				if(!empty(resultData) && isFlatMap(resultData)){
+					// CAUTION : We have to keep the type information, here too ! (in the sub-objects)				
+					resultData=getAsTreeStructure(resultData, keepClassName);
+				}
+				
+				return resultData;
+			},
+
+			
+			saveDataToFileForClient:function(clientId,repositoryName,dataFlatForClient,forceKeepUnflatten=false,doOnSuccess=null){
+				
+				if(!empty(dataFlatForClient) && !isFlatMap(dataFlatForClient) && !forceKeepUnflatten){
+					dataFlatForClient=getAsFlatStructure(dataFlatForClient);
+				}
+				
+				// reserved characters : -/\^$*+?.()|[]{}
+				// CANNOT USE stringifyObject(...) function because we are in a common, lower-level library !
+				let dataFlatStr=stringifyObject(dataFlatForClient)
+					// We «aerate» the produced JSON :
+					.replace(/":[\w]*\{/gim,"\":{\n").replace(/,"/gim,",\n\"")
+					// ...except for inline, escaped JSON string representations :
+					.replace(/\\\":[\w]*\{\n/gim,"\\\":{");
+					// NO : .replace(/}/gim,"}\n");
+				
+				
+				let path=self.getPath(clientId,repositoryName);
+				fs.writeFile(path, dataFlatStr, FILE_ENCODING, (error) => {
+			    if(error){
+			    	// TRACE
+						console.log("ERROR : Could not write file «"+path+"»:",error);
+			    	throw error;
+			    }
+			    if(doOnSuccess)	doOnSuccess(dataFlatForClient);
+				});
+			}
+			
+		};
+		
+		
+		return self;
+	};
+	
+}
+
+
+window.fileExists=(filePath)=>{
+	if(typeof(fs)=="undefined"){
+		// TRACE
+		lognow("ERROR : «fs» node dependency is not available ! Cannot test if file exists.");
+		return null;
+	}
+	return fs.existsSync(filePath);
+};
+
+
+
+// Nodejs server launching helper functions :
+//Networking management :
+//- WEBSOCKETS AND NODEJS :
+
+function isConnected(clientSocket){
+	if(!WebsocketImplementation.useSocketIOImplementation)
+		return (clientSocket.readyState===WebSocket.OPEN)
+	return (clientSocket.connected);
+}
+
+// Client-side or Server-side :
+window.getURLOrConsoleParameter=(parameterName)=>{
+	if(typeof(getURLParameter)!="undefined")	return getURLParameter(parameterName);	
+	return getConsoleParam(parameterName);
+}
+
+
+// Server-side :
+
+getConsoleServerParams=function(portParam=null, certPathParam=null, keyPathParam=null, ignoreConsoleArgs=false, argsOffset=0){
+	
+	// Node dependencies :
+	// https=require("https");
+	// fs=require("fs");
+	
+	if(typeof(https)==="undefined"){
+		// TRACE
+		console.log("WARN : Could not find the nodejs dependency «https», aborting SSL setup.");
+		return null;
+	}
+	if(typeof(fs)==="undefined"){
+		// TRACE
+		console.log("WARN : Could not find the nodejs dependency «fs», aborting SSL setup.");
+		return null;
+	}
+
+	const result={};
+	
+	// We read the command-line arguments if needed :
+	const argCLPort=getConsoleParam(0, argsOffset);
+	const argCLCertPath=getConsoleParam(1, argsOffset);
+	const argCLKeyPath=getConsoleParam(2, argsOffset);
+	
+	// Console, command-line arguments OVERRIDE parameters values :
+	
+	result.port=(ignoreConsoleArgs?portParam:nonull(argCLPort,portParam));
+	result.certPath=null;
+	result.keyPath=null;
+	result.isSecure=!!(certPathParam || keyPathParam);
+	
+	if(result.isSecure){
+		result.certPath=(ignoreConsoleArgs?certPathParam:nonull(argCLCertPath,certPathParam));
+		result.keyPath=(ignoreConsoleArgs?keyPathParam:nonull(argCLKeyPath,keyPathParam));
+	}
+	
+	// Eventual encryption options :
+	result.sslOptions=null;
+	if(result.isSecure){
+		result.sslOptions={
+			cert: fs.readFileSync(result.certPath),
+			key: fs.readFileSync(result.keyPath),
+		};
+	}
+	
+	return result;
+}
+
+getConsoleParam=function(indexOrName=0, argsOffset=2/*arg 0 is «node» and arg 1 is the js file*/){
+	if(!process){
+		throw new Error("ERROR : Cannot extract console parameter in this context !");
+	}
+	
+	const allArgs=process.argv;
+	if(empty(allArgs))	return null;
+
+	// Case indexOrName is a number for the parameter index :
+	if(!isString(indexOrName) && isNumber(indexOrName)){
+		return allArgs[indexOrName+argsOffset];
+	}
+
+	// Case indexOrName is a string for the parameter name :
+	for(let i=argsOffset;i<allArgs.length;i++){
+		const val=allArgs[i];
+		if(!contains(val,"="))
+			continue;
+		const splits=val.split("=");
+		if(splits.length<2)
+			continue;
+		const name=splits[0].trim();
+		const value=splits[1].trim();
+		if(name==indexOrName)
+			return value;
+	}
+	return null;
+}
+
+
+
+window.getConsoleCLI=(doOnCommands={"makeSandiwch":()=>{}}, promptText="Enter command> ")=>{
+
+	const readline = require("node:readline");
+
+	const cliInterface = readline.createInterface({
+	  input: process.stdin,
+	  output: process.stdout,
+	  prompt: nonoull(promptText,"Enter command> ")
+	});
+
+	cliInterface.prompt();
+
+	cliInterface.on("line", (line) => {
+	  const input = line.trim();
+	  switch (input) {
+	    case "quit":
+	      console.log("Bye!");
+	      cliInterface.close();
+	      break;
+	    case "help":
+	      console.log("Available commands: quit, help and :", Object.keys(doOnCommands));
+	      break;
+	    default:
+				if(doOnCommands)	doOnCommands[input]();
+	      break;
+	  }
+		
+		// Show the prompt again :
+	  cliInterface.prompt();
+		
+	}).on("close", () => {
+	  process.exit(0);
+	});
+	
+	return cliInterface
+};
+
+
+
+
+
+// NODE ONLY SERVER / CLIENTS : 
+WebsocketImplementation={
+
+
+		isNodeContext:true,
+		useSocketIOImplementation:false,
+		useFlatStrings:false,
+		
+		// COMMON METHODS
+		/*private static*/isInRoom(clientSocket, clientsRoomsTag){
+			return (!clientsRoomsTag || empty(clientsRoomsTag) || contains(clientsRoomsTag, clientSocket.clientRoomTag));
+		},
+		
+		
+		//
+		// CONSOLE NODE SERVER/CLIENT
+		//
+		getStatic:(isNodeContext=true, useSocketIOImplementation=/*DEBUG*/false)=>{
+			
+			WebsocketImplementation.isNodeContext=isNodeContext;
+			WebsocketImplementation.useSocketIOImplementation=useSocketIOImplementation;
+
+			if(!WebsocketImplementation.useSocketIOImplementation){
+				// TRACE
+				lognow("INFO : (SERVER/CLIENT) Using native WebSocket implementation.");	
+				
+				// https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_client_applications
+				if(isNodeContext){
+					if(typeof(WebSocket)==="undefined"){
+						// TRACE
+						console.log("«ws» SERVER library not called yet, calling it now.");
+						
+						window.WebSocket=require("ws");
+						
+						if(typeof(WebSocket)==="undefined"){
+							// TRACE
+							console.log("ERROR : «ws» CONSOLE/BROWSER CLIENT/SERVER library not found. Cannot launch nodejs server. Aborting.");
+						}
+					}
+				}
+				
+			}else{
+				// TRACE
+				lognow("INFO : (SERVER/CLIENT) Using socket.io websocket implementation.");	
+				
+				if(isNodeContext){
+					
+					// NODE SERVER :
+					// DBG
+					lognow("INFO : Loading NODE SERVER socket.io libraries.")
+					if(typeof(Socket)==="undefined"){
+						// TRACE
+						console.log("«socket.io» NODE SERVER library not called yet, calling it now.");
+						Socket=require("socket.io");
+					}
+					if(typeof(Socket)==="undefined"){
+						// TRACE
+						console.log("ERROR : «socket.io» NODE CLIENT/SERVER library not found. Cannot launch nodejs server. Aborting.");
+					}
+					
+					// NODE CLIENT :
+					// DBG
+					lognow("INFO : Loading NODE CLIENT socket.io libraries.")
+					if(typeof(io)==="undefined"){
+						// TRACE
+						console.log("«socket.io-client» NODE CLIENT library not called yet, calling it now.");
+						io=require("socket.io-client");
+					}
+					if(typeof(io)==="undefined"){
+						// TRACE
+						console.log("ERROR : «socket-client.io» NODE CLIENT library not found. Cannot launch nodejs server. Aborting.");
+					}
+				}
+
+				
+			}
+
+			// *********************************************************************************
+			
+			return WebsocketImplementation;
+		},
+		
+		
+		/*private*/getMessageDataBothImplementations:(eventOrMessageParam)=>{
+			
+				const eventOrMessage=(!WebsocketImplementation.useSocketIOImplementation?eventOrMessageParam.data:eventOrMessageParam);
+			
+				let dataResult=eventOrMessage;
+				
+				try{
+					dataResult=(WebsocketImplementation.useFlatStrings || isString(eventOrMessage)?parseJSON(eventOrMessage):eventOrMessage);
+				}catch(error1){
+					// TRACE
+					lognow(`ERROR : Failed to parse JSON for string «${dataResult}»`,error1);
+					dataResult=(isString(eventOrMessage)?eventOrMessage:stringifyObject(eventOrMessage));
+				}
+				
+				return dataResult;
+		},
+		
+		
+		getServer:(listenableServer)=>{
+			
+			if(!WebsocketImplementation.isNodeContext){
+				// TRACE
+				throw new Error("ERROR : SERVER : Server launch is not supported in a non-nodejs context for any implementation.");
+			}
+			
+			
+			// TODO : FIXME : Use one single interface !
+			// NODE SERVER MODE ONLY :
+			let serverSocket;
+			if(!WebsocketImplementation.useSocketIOImplementation){
+				serverSocket=new WebSocket.Server({ "server":listenableServer });
+			}else{
+				
+				// NOW : socket.io :
+				// Loading socket.io
+//			OLD SYNTAX : serverSocket=Socket.listen(listenableServer);
+				serverSocket=new Socket.Server(listenableServer);
+				
+				if(listenableServer.cert || listenableServer.key){
+					// TRACE :
+					lognow("WARN : CAUTION ! ON TODAY (01/08/2022) socket.io SERVER LIBRARY IS BOGUS AND WON'T WORK (node clients can't connect !!) IF listenableServer IS A https SERVER !!!");
+				}
+				
+				// Setting up the disconnect event for a client :
+				serverSocket.on("endConnection",()=>{
+					serverSocket.disconnect();
+				});
+			}
+			
+			serverSocket.on("error",(error)=>{
+				// TRACE
+				lognow("ERROR : An error occurred when trying to start the server : ",error);
+				
+			});
+
+			// NODE SERVER INSTANCE :
+			const nodeServerInstance=new NodeServerInstance(serverSocket, listenableServer);
+			
+			// Join room server part protocol :
+			nodeServerInstance.receive("protocol",(message, clientSocket)=>{
+				nodeServerInstance.addToRoom(clientSocket, message.clientRoomTag);
+			},{listenerMessageType:"joinRoom"});
+			
+			// To make the server aware of the clients connections states :
+			nodeServerInstance.serverSocket.on("close", function close() {
+				
+				// TODO : FIXME : Use one single interface !
+				if(!WebsocketImplementation.useSocketIOImplementation)	serverClients=nodeServerInstance.serverSocket.clients;
+				// OLD : else																						serverClients=nodeServerInstance.serverSocket.sockets.clients();
+				else																										serverClients=nodeServerInstance.serverSocket.sockets.sockets;
+				
+				serverClients.forEach((clientSocket)=>{
+				 	clearInterval(clientSocket.stateCheckInterval);
+				});
+			});
+
+			return nodeServerInstance;
+		},
+		
+		// DO NOT USE DIRECTLY, USE INSTEAD initClient(...) (this function uses connectToServer(...)) !
+		// NODE / BROWSER CLIENT CONNECTS TO SERVER MAIN ENTRYPOINT:
+		connectToServer:(serverURL, port, isSecure=false, timeout)=>{
+
+			// TRACE
+			lognow("INFO : Using socket library flavor : "+(WebsocketImplementation.isNodeContext?"node (client/server-side)":"browser (client-side only)"));
+
+			if(WebsocketImplementation.isNodeContext)
+				return WebsocketImplementation.connectToServerFromNode(serverURL, port, isSecure, timeout);
+			else
+				return WebsocketImplementation.connectToServerFromBrowser(serverURL, port, isSecure, timeout);
+		},
+		
+	
+		//
+		// NODE CLIENT
+		//
+		/*private*/connectToServerFromNode:(serverURL, port, isSecure, timeout)=>{
+			
+			// NODE CLIENT MODE ONLY :
+			let clientSocket;
+			if(!WebsocketImplementation.useSocketIOImplementation){
+			
+				// NEW : ws :
+				if(typeof(WebSocket)==="undefined"){
+					// TRACE
+					lognow("ERROR : CLIENT : Could not find websocket client lib, aborting client connection.");
+					return null;
+				}
+
+				clientSocket=new WebSocket(serverURL+":"+port,/*WORKAROUND:*/{ 
+					// CAUTION : SECURITY BREACH :
+					// BUT ALSO NECESSARY TO ALLOW SELF-SIGNED CERTIFICATES USAGE WITH THE YESBOT SYSTEM !
+					rejectUnauthorized:false, // (THIS IS A KNOWN SECURITY BREACH)
+					secure: isSecure
+				});
+				
+				clientSocket.addEventListener("error", error=>{
+					// TRACE
+				  lognow("ERROR : (NODEJS) A WebSocket client error occurred while trying to connect to server:", error.message);
+				});
+				
+			}else{
+				// NOW : socket.io :
+				//client on server-side:
+				
+				if(WebsocketImplementation.isNodeContext && typeof(io)!=="undefined"){
+					
+//				OLD SYNTAX:	clientSocket=Socket.connect(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+//				NO :	clientSocket=new Socket.Client(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+					clientSocket=io(serverURL + ":" + port,{timeout: timeout, secure: isSecure, autoConnect:true});
+					// UNUSEFUL (since we have the autoconnect:true option) : clientSocket.connect();
+					
+					clientSocket.on("connect_error", error=>{
+						// TRACE
+					  lognow("ERROR : (NODEJS) A SocketIO client error occurred while trying to connect to server:", error.message);
+					});
+
+				}
+			}
+			
+			// DBG
+			lognow("DEBUG : CLIENT : clientSocket created:");
+
+			const nodeClientInstance=new ClientInstance(clientSocket);
+			return nodeClientInstance;
+		},
+		
+		//
+		// BROWSER CLIENT
+		//
+		
+		/*private*/connectToServerFromBrowser:(serverURL, port, isSecure, timeout)=>{
+			
+			// NEW : ws :
+			if(typeof(WebSocket)==="undefined"){
+				// TRACE
+				lognow("ERROR : CLIENT : Could not find websocket client lib, aborting client connection.");
+				return null;
+			}
+			
+			// TODO : FIXME : Use one single interface !
+			// BROWSER CLIENT MODE ONLY :
+			let clientSocket;
+			if(!WebsocketImplementation.useSocketIOImplementation){
+				// CAUTION : PARAMETER rejectUnauthorized:false WILL DO NOTHING,
+				// BECAUSE THIS IS COMPLETLY HANDLED BY THE BROWSER SECURITY POLICY !
+				// SO TO CLEAR THE SSL ERROR :
+				// - FIRST GO TO THE HTTPS:// SERVER ADDRESS WITH BROWSER
+				// - THEN ADD THE SECURITY EXCEPTION IN THE BROWSER !
+				clientSocket=new WebSocket(serverURL+":"+port,["ws","wss"]);
+				
+				clientSocket.addEventListener("error", error=>{
+					// TRACE
+				  lognow("ERROR : (BROWSER) A WebSocket client error occurred while trying to connect to server:", error.message);
+				});
+				
+			}else if(typeof(io)!=="undefined"){
+				// OLD SYNTAX :clientSocket=io.connect(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+				// ALTERNATIVE :
+				clientSocket=io(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+				
+				clientSocket.on("connect_error", error=>{
+					// TRACE
+				  lognow("ERROR : (BROWSER) A SocketIO client error occurred while trying to connect to server:", error.message);
+				});
+					
+			}
+			
+			// BROWSER CLIENT INSTANCE :
+			const browserClientInstance=new ClientInstance(clientSocket);
+			return browserClientInstance;
+		},
+
+};
+
+
+
+launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /*OPTIONAL*/sslOptions=null, httpHandlerParam=null, addCORSHeader=ADD_CORS_HEADER){
+	
+	const EXCLUDED_FILENAMES_PARTS=[".keyHash.",".pem"];
+	
+	
+	
+	if(typeof(https)==="undefined"){
+		// TRACE
+		console.log("«https» SERVER library not called yet, calling it now.");
+		https=require("https");
+	}
+	if(typeof(http)==="undefined"){
+		// TRACE
+		console.log("«http» SERVER library not called yet, calling it now.");
+		http=require("http");
+	}
+	
+	
+	const DEFAULT_HANDLER=function(request, response){
+		
+		const url=request.url;
+
+		let isURLInExclusionZone=!!foreach(EXCLUDED_FILENAMES_PARTS,(excludedStr)=>{
+			if(contains(url,excludedStr)){
+				return true;
+			}
+		});
+		
+		if(isURLInExclusionZone){
+      	// TRACE
+      	console.log("ERROR 403 forbidden access error :");
+      	console.log(error);
+      	
+      	response.writeHead(403);
+        response.end("Sorry, cannot access resource : error: "+error.code+" ..\n");
+        response.end();
+        return;
+		}
+		
+		
+
+		const urlFile="." + url;
+		
+		let filePath=urlFile.indexOf("?")!==-1?urlFile.split("?")[0]:urlFile;
+  	if(filePath=="./") filePath="./index.html";
+
+  	let contentType="text/html";
+    
+		const headers={ "Content-Type": contentType };
+
+		// To remove the CORS error message (cf. https://medium.com/@dtkatz/3-ways-to-fix-the-cors-error-and-how-access-control-allow-origin-works-d97d55946d9)
+		if(addCORSHeader)		headers["Access-Control-Allow-Origin"]="*";
+		
+    
+    fs.readFile(filePath, function(error, fileContent){
+      if(error){
+          if(error.code=="ENOENT"){
+          	// TRACE
+          	console.log("ERROR 404 file not found :"+filePath);
+          	
+            fs.readFile("./404.html", function(error, fileContent){
+            	response.writeHead(200, headers);
+              response.end(fileContent, "utf-8");
+            });
+              
+          }else {
+
+        	// TRACE
+          	console.log("ERROR 500 server error :");
+          	console.log(error);
+          	
+          	response.writeHead(500);
+            response.end("Sorry, check with the site admin for error: "+error.code+" ..\n");
+            response.end(); 
+            
+          }
+      }else {
+    	
+    	// TRACE
+      	console.log("INFO 200 OK :"+filePath);
+
+
+      	response.writeHead(200, headers);
+        response.end(fileContent, "utf-8");
+        
+  		// res.writeHead(200);
+  		// res.end("hello world\n");
+  		// res.sendFile(__dirname + "/public/index.html");
+    		
+      }
+    });
+      
+	};
+	
+	
+	const handler=nonull(httpHandlerParam, DEFAULT_HANDLER);
+	
+	
+	
+	let listenableServer;
+	if(sslOptions){
+		let httpsServer=https.createServer(sslOptions, handler).listen(port);
+		// TRACE
+		console.log("INFO : SERVER : HTTPS Server launched and listening on port " + port + "!");
+		listenableServer=httpsServer;
+	}else{
+		let httpServer=http.createServer(handler).listen(port);
+		// TRACE
+		console.log("INFO : SERVER : HTTP Server launched and listening on port " + port + "!");
+		listenableServer=httpServer;
+	}
+	
+	
+	const server=WebsocketImplementation.getStatic(true).getServer(listenableServer);
+	
+	// When a client connects, we execute the callback :
+	// CAUTION : MUST BE CALLED ONLY ONCE !
+	server.onConnectionToClient((serverParam, clientSocketParam)=>{
+		if(doOnConnect) doOnConnect(serverParam, clientSocketParam);
+	});
+
+
+	server.onFinalize((serverParam)=>{
+		
+		// DBG
+		lognow("onFinalize() server");
+		
+		if(doOnFinalizeServer)	doOnFinalizeServer(serverParam);
+	});
+	
+
+	// TRACE
+	console.log("INFO : SERVER : Generic Nodejs server launched and listening on port:" + port + "!");
+	
+	
+	
+
+
+	return server;
+}
+
+
+initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFinalizeServer=null,
+			 /*OPTIONAL*/portParam,
+			 /*OPTIONAL*/certPathParam,
+			 /*OPTIONAL*/keyPathParam){
+
+	// TRACE
+	console.log("Server launched.");
+	console.log("Usage :													node <server.js> conf {port:[port], sslCertPath:[ssl certificate path | unsecure ], sslKeyPath:[ssl key path], serverConfig:[JSON server configuration]}");
+	console.log("Or (to generate password hash) :	node <server.js> hash <clientId@repositoryName> <clearTextSecretString>");
+	// 			EXAMPLE : 							node orita-srv.js hash orita.global@keyHash 1234567890
+	console.log("Server launched.");
+	
+	
+	// We read the command-line arguments if needed :
+
+	let argCLPort;
+	let argCLCertPath;
+	let argCLKeyPath;
+	
+	let serverConfig={};
+	let isForceUnsecure;
+
+	let isHashAsked=false;
+	let clearTextParam=null;
+	let persisterId=null;
+	
+	
+	process.argv.forEach(function (val, i){
+		if(!val)	return;
+		// 0 corresponds to «node / nodejs»
+		if(i<=1)	return; // 1 corresponds to « <server.js> »
+		else if(i==2){
+			if(val==="hash")		isHashAsked=true;
+		}else if(i==3){
+			if(!isHashAsked){
+				try{
+					const jsonConf=parseJSON(val);	
+					argCLPort=jsonConf.port;
+					argCLCertPath=jsonConf.sslCertPath;
+					argCLKeyPath=jsonConf.sslKeyPath;
+					serverConfig=nonull(jsonConf.serverConfig,{});
+				}catch(err1){
+					lognow("WARN : Cannot parse argument JSON string «"+val+"».");
+				}
+			}	else						persisterId=val;
+		}else if(i==4){
+			if(isHashAsked)		clearTextParam=val;
+		}
+	});
+	isForceUnsecure=(argCLCertPath==="unsecure");
+
+
+
+
+
+	const aotraNodeServer={config:serverConfig};
+	aotraNodeServer.serverManager={ start:()=>{/*DEFAULT START FUNCTION, WILL BE OVERRIDEN LATER*/}};
+
+	if(isHashAsked){
+		// We instanciate a temporary persister just to read the key hash file:
+		const persister=getPersister("./");
+		let persisterIdSplits=persisterId.split("@");
+		if(empty(persisterIdSplits) || persisterIdSplits.length!=2){
+			// TRACE
+			console.log("ERROR : No persister repository IDs provided correctly. Cannot read key hash. Aborting hash generation.");
+			return aotraNodeServer;
+		}
+		const persisterClientId=persisterIdSplits[0];
+		const persisterRepositoryName=persisterIdSplits[1];
+		let globalKeyHashObject=persister.readTreeObjectFromFile(persisterClientId, persisterRepositoryName);
+		if(!globalKeyHashObject || !globalKeyHashObject.keyHash){
+			// TRACE
+			console.log("WARN : No key hash found. Generating one now.");
+			globalKeyHashObject={keyHash:getUUID(), hashes:[]};
+			persister.saveDataToFileForClient(persisterClientId,persisterRepositoryName,globalKeyHashObject,false,()=>{
+				// TRACE
+				console.log("INFO : Key hash generated and saved successfully.");
+			});
+		}
+		const globalKeyHash=globalKeyHashObject.keyHash;
+		
+		let firstHash=getHashedString(clearTextParam);
+		
+		let generatedHash=getHashedString( firstHash + globalKeyHash, "SHA-256", true);// (we use the heavy treatment thing.)
+		globalKeyHashObject.hashes.push(generatedHash);
+
+		// We update the repository :
+		persister.saveDataToFileForClient(persisterClientId,persisterRepositoryName,globalKeyHashObject,false,()=>{
+			// TRACE
+			console.log("INFO : Hash added to repository and saved successfully.");
+		});
+		
+		// OUTPUT
+		console.log("Here is your key : share it with your main clients but DO NOT LEAK IT !\n********************\n"+clearTextParam+"\n********************\n");
+		
+		return aotraNodeServer;
+	}
+
+	
+	const DEFAULT_PORT=nonull(argCLPort,25000);
+	const DEFAULT_CERT_PATH=nonull(argCLCertPath,"cert.pem");
+	const DEFAULT_KEY_PATH=nonull(argCLKeyPath,"key.key");
+
+	
+	let port=portParam ? portParam : DEFAULT_PORT;
+	let certPath=null;
+	let keyPath=null;
+
+	if(!isForceUnsecure){
+		certPath=certPathParam?certPathParam:DEFAULT_CERT_PATH;
+		keyPath=keyPathParam?keyPathParam:DEFAULT_KEY_PATH;
+	}
+	
+	
+
+	
+	// UNUSEFUL :
+//aotraNodeServer.serverManager.microClientsSockets=[];
+	// UNUSEFUL :
+//aotraNodeServer.serverManager.mainClientsSockets=[];
+
+	aotraNodeServer.serverManager.start=function(){
+
+		// Eventual encryption options : 
+		let sslOptions=null; 
+		if(!isForceUnsecure){
+			if(typeof(fs)==="undefined"){
+				// TRACE
+				lognow("ERROR : «fs» node subsystem not present, cannot access files. Aborting SSL configuration of server.");
+			}else{
+				try{
+		  		sslOptions={
+		  			cert: fs.readFileSync(certPath, {encoding: "utf8"}),
+		  			key: fs.readFileSync(keyPath, {encoding: "utf8"}),
+		  		};
+				}catch(exception){
+					// TRACE
+					lognow("ERROR : Could not open SSL files certPath:«"+certPath+"» or keyPath:«"+keyPath+"». Aborting SSL configuration of server.");
+				}
+			}
+		}
+		
+		aotraNodeServer.server=launchNodeHTTPServer(port, doOnClientConnection, doOnFinalizeServer, sslOptions);
+		
+
+		return aotraNodeServer;
+	};
+
+	return aotraNodeServer;
+}
+
+// ========================= FUSRODA SERVER : =========================
+
+//
+// DOES NOT WORK : USE Java FusrodaServer instead :
+//
+///*FUSRODA server stands from FSRD SERVER, for Fucking Simple Remote Desktop SERVER*/
+//createFusrodaServer=function(certPathParam=null,keyPathParam=null,portParam=4000){
+//	
+//	// https://www.npmjs.com/package/screenshot-desktop
+//	// https://github.com/octalmage/robotjs
+//	// npm install --save screenshot-desktop
+//	//
+//	// sudo apt-get install libxtst-dev libx11-dev
+//	// npm install --save robotjs
+//	
+//	// http://getrobot.net/docs/usage.html
+//	// 
+//	// apt-get install build-essential python libxt-dev libxtst-dev libxinerama-dev -y 
+//	
+//	const screenshot=require("screenshot-desktop");
+//
+//	const REFRESH_SCREENSHOTS_MILLIS=500;
+//
+//	
+//	const server=initNodeServerInfrastructureWrapper(
+//		// On each client connection :
+// //	(serverParam, clientSocketParam)=>{},
+//		null,
+//		// On server finalization :
+//		(serverParam)=>{
+//
+//			serverParam.receive("protocol_fusroda", (message, clientSocket)=> {
+//				serverParam.addToRoom(clientSocket,"clients");
+//			});
+//			
+//			
+//			serverParam.sendScreenshotsRoutine=setInterval(()=>{
+//				if(serverParam.isScreenshotStarted)	return;
+//				
+//				serverParam.isScreenshotStarted=true;		
+//			
+//				screenshot().then((img) => {
+//	
+//					const data={image:img,listenerMessageType:"imageData"};
+//					serverParam.send("message", data, "clients");
+//					
+//					serverParam.isScreenshotStarted=false;		
+//
+//				}).catch((error) => {
+//				  // TRACE
+//					lognow("ERROR : Error during screenshot :",error);
+//				});
+//				
+//			},REFRESH_SCREENSHOTS_MILLIS);
+//			
+//			
+//		},portParam,certPathParam,keyPathParam);
+//
+//
+// //	const doOnConnect=(serverParam, clientSocketParam)=>{
+// //	};
+// //	const doOnFinalizeServer=(serverParam)=>{
+// //		/*DO NOTHING*/
+// //	};
+// //	const server={};
+// //	server.start=(port=4000)=>{
+// //		server.httpServer=launchNodeHTTPServer(port, doOnConnect, doOnFinalizeServer, sslOptions);
+// //	};
+//
+//	return server;
+//}
+
+
+// ========================= UTILITY SERVERSIDE METHODS : =========================
+
+class ListManager{
+	
+	constructor(config){
+		this.config=config;
+		this.maxItemsNumber=nonull(this.config.max,999);
+		this.simultaneousItemsNumber=nonull(this.config.simultaneous,1);
+		this.sessionDurationSeconds=nonull(this.config.duration,null);
+		this.mode=nonull(this.config.mode,"startAtConnexion");
+		
+		this.itemsInfos={};
+		this.time=null;
+		this.started=false;
+	}
+	
+	addItem(id,item){
+		if(id==null){
+			// TRACE
+			lognow("ERROR : Cannot add item with no id.");
+			return;
+		}
+		if(!item){
+			// TRACE
+			lognow("ERROR : Cannot add null item.");
+			return;
+		}
+		const numberOfItemsCurrently=getArraySize(this.itemsInfos);
+
+		// DBG
+		lognow(">>>>>>>>>numberOfItemsCurrently:",numberOfItemsCurrently);
+		lognow(">>>>>>>>>Object.keys(arrayOfValues):",Object.keys(this.itemsInfos));
+
+		
+		if(this.maxItemsNumber<=numberOfItemsCurrently){
+			// TRACE
+			lognow("ERROR : Cannot add item with id «"+id+"», list already full.");
+			return;
+		}
+		
+		
+		if(numberOfItemsCurrently==0 && this.mode==="startAtConnexion"){
+			
+			// DBG
+			lognow(">>>>>>>>>START SESSION !!!!");
+			
+			this.startSession();
+		}
+		this.itemsInfos[id]={
+			item:item,
+			time:getNow(),
+		};
+	}
+	
+	startSession(){
+		this.time=getNow();
+		this.started=true;
+	}
+	
+	stopSession(){
+		this.started=false;
+	}
+	
+	isSessionActive(){
+				
+		// DBG
+		lognow("				!!! this.sessionDurationSeconds : "+this.sessionDurationSeconds);
+		lognow("				!!! this.started : "+this.started);
+		lognow("				!!! this.time : "+this.time);
+
+		
+		if(!this.sessionDurationSeconds)	return true;
+		if(!this.started)									return false;
+		const result=!hasDelayPassed(this.time, this.sessionDurationSeconds*1000);
+		
+		// DBG
+		lognow("				!!! HAS DELAY PASSED : "+result);
+		
+		return result;
+	}
+	
+	isClientActive(clientId){
+		
+		// DBG
+		lognow("			this.isSessionActive()"+this.isSessionActive());
+		
+		if(!this.isSessionActive())	return false;
+		const clientPosition=this.getItemPosition(clientId);
+		//CAUTION : Client position starts at 1 !
+		const clientIndex=(clientPosition-1);
+		const result=(clientIndex<=this.maxItemsNumber && clientIndex<=this.simultaneousItemsNumber);
+		
+		return result;
+	}
+	
+	removeItemById(id){
+		if(id==null){
+			// TRACE
+			lognow("ERROR : Cannot remove item, no id specified.");
+			return;
+		}
+		if(!this.itemsInfos[id]){
+			// TRACE
+			lognow("ERROR : Cannot remove item, item not found for id «"+id+"».");
+			return;
+		}
+		delete this.itemsInfos[id];
+	}
+	
+	removeItem(item){
+		if(item==null){
+			// TRACE
+			lognow("ERROR : Cannot remove item, none specified.");
+			return;
+		}
+		
+		let id=null;
+		foreach(this.itemsInfos,(itemInfos,key)=>{
+			if(itemInfos.item===item
+					// DEBUG ONLY :
+					|| (itemInfos.item.id && item.id && itemInfos.item.id===item.id)
+			){
+				id=key;
+				return "break";
+			}
+			
+		});
+		
+		if(!id){
+			// TRACE
+			lognow("ERROR : Cannot remove item, item not found for id «"+id+"».");
+			return;
+		}
+		
+		this.removeItemById(id);
+	}
+
+	// Goes from 1 to <length>:
+	getItemPosition(id){
+		if(id==null){
+			// TRACE
+			lognow("ERROR : Cannot calculate item position, no id specified.");
+			return null;
+		}
+		if(!this.itemsInfos[id]){
+			// TRACE
+			lognow("ERROR : Cannot calculate item position, item not found for id «"+id+"».");
+			return null;
+		}
+		let result=0;
+		foreach(this.itemsInfos, (itemInfo, key)=>{
+			result++;
+			if(id===key)	return "break";
+		},null,(item1, item2)=>item1.time<item2.time);
+		return result;
+	}
+
+	getItemsNumber(){
+		return getArraySize(this.itemsInfos);
+	}
+	
+};
+
+getListManager=function(config){
+	return new ListManager(config);
+};
+
+
+// CAUTION ! TODO : FIXME : We replace in response all single quotes with "`" (egrave) in order to avoid errors !
+// NO : IN A NODE CONTEXT WITH require("...") WILL RESULT IN AN UNDEFINED FUNCTION ERROR !!! 
+// function performHTTPRequest(...){...
+// USE THIS INSTEAD :
+performHTTPRequest=function(completeURL, httpMethod="GET", headers={}, requestBodyOrNamedArgs=null, isNodeContext=false, addCORSHeader=ADD_CORS_HEADER){
+
+	// Body
+	let requestBodyOrNamedArgsStr=null;
+	if(requestBodyOrNamedArgs){
+		if(isString(requestBodyOrNamedArgs) && !isObject(requestBodyOrNamedArgs)){
+			// If it's already a string, we assume it's a valid JSOn string already :
+			requestBodyOrNamedArgsStr=requestBodyOrNamedArgs.replace(/[\r\n]+/gim, ""); // We remove all the breaklines
+		}else{
+			try{
+				requestBodyOrNamedArgsStr=stringifyObject(requestBodyOrNamedArgs).replace(/[\r\n]+/gim, ""); // We remove all the breaklines
+			}catch(parseErr){
+				requestBodyOrNamedArgsStr=""+requestBodyOrNamedArgs;
+			}
+		}
+	}
+	
+	let body=null;
+	// Not the same way to send parameters, with POST/PUT http method :
+	if(contains(["POST","PUT"],httpMethod) && requestBodyOrNamedArgs){
+		body=requestBodyOrNamedArgsStr;
+	}
+
+	// Headers	
+	if(contains(["POST","PUT"],httpMethod)){
+		headers["Content-Type"]="application/json";
+		
+		if(requestBodyOrNamedArgsStr && isString(body)){
+			headers["Content-Length"]=Buffer.byteLength(requestBodyOrNamedArgsStr);
+		}
+
+		// To remove the CORS error message (cf. https://medium.com/@dtkatz/3-ways-to-fix-the-cors-error-and-how-access-control-allow-origin-works-d97d55946d9)
+		if(addCORSHeader)		headers["Access-Control-Allow-Origin"]="*";
+		
+	}	else if(httpMethod==="GET" && requestBodyOrNamedArgs){
+		// Not the same way to send parameters in GET http method :
+		// DBG
+		lognow("unformatted API URL : "+completeURL);
+		
+		completeURL=appendGetParameters(completeURL, requestBodyOrNamedArgs);
+		
+		// DBG
+		lognow("formatted API URL : "+completeURL);
+	}
+
+	// CASE BROWSER CONTEXT :
+	if(!isNodeContext || typeof(require)=="undefined"){
+		// TRACE
+		lognow("INFO : We are not running in a browser context (isNodeContext:"+isNodeContext+";typeof(require):"+(typeof(require))+"). Using browser library.");
+		
+		return new Promise((resolve,reject)=>{
+			fetch(completeURL, {
+			   method: httpMethod,
+			   headers: headers,
+			   body: body,
+			  })
+				// STRANGE : DOES NOT WORK !!:
+		    //.then(response => response.json())
+		    // STRANGE : DOES WORK :
+		   .then(response => {
+			
+		  	 	// DBG
+		  	  console.log("~~~~~~~~~~~response :",response);
+		  	  
+					return response.json();
+				}).then(data => {
+			
+					// CAUTION : .request(...) => statusCode, .fetch(...) => status (performHTTPRequest(...) uses fetch(...)) 
+					const status=data.status;
+//					if(status!=200 && data.error){
+//	//					const error=nonull(data.error, data.detail);
+//						const error=data.error;
+//						// TRACE
+//						console.error("Error:", error);
+//						reject({error:""+error, httpStatus:status});
+//						return;
+//					}
+			
+		  	 	// DBG
+		  	  console.log("~~~~~~~~~~~data :",data);
+					
+					data.httpStatus=status;
+					resolve(data);
+		   }).catch(error => {
+					// TRACE
+					console.error("Error:", error);
+					reject({error:`${error}`, httpStatus:null});
+		   });
+		});
+	}// else :
+	
+	// CASE NODEJS CONTEXT :
+	
+	// TRACE
+	lognow("INFO : We are running in a nodejs context (isNodeContext:"+isNodeContext+";typeof(require):"+(typeof(require))+"). Using nodejs library.");
+
+	
+	const isSecure=(!empty(completeURL) && contains(completeURL.toLowerCase(),"https://"));
+	const httpHandler=isSecure?require("https"):require("http");
+	
+	// Options for the HTTP request
+	const options = {
+	  url: completeURL,
+	  method: httpMethod,
+	};
+	
+	if(contains(["POST","PUT"],httpMethod)){
+		options.json=true;
+	}
+	
+  options.headers=headers;
+  
+	return new Promise((resolve,reject)=>{
+		
+		// Create the HTTP request
+		// DOES NOT WORK : const request = httpHandler.request(options, (response) => {
+		// UNLESS YOU SPECIFY in options : hostname, port, path
+		const request = httpHandler.request(completeURL, options, (response) => {
+		
+		  let responseDataStr = "";
+
+		  // A chunk of data has been received.
+		  response.on("data", (chunk) => {
+		    responseDataStr += chunk;
+		    // // DEBUG ONLY
+		    // const str = Buffer.from(chunk).toString("utf8");
+		    // lognow(">>>str:"+str);
+		  });
+		
+		  // The whole response has been received.
+		  response.on("end", () => {
+			
+				try{
+					let responseData;
+					try{
+						responseData=parseJSON(responseDataStr);
+					}catch(parseError1){
+						// CAUTION ! TODO : FIXME : We replace in response all single quotes with "`" (egrave) in order to avoid errors !
+						// DEBUG
+						responseDataStr=responseDataStr.replace(/'/gim,"`");
+						try{
+							responseData=parseJSON(responseDataStr);
+						}catch(parseError2){
+							// DBG
+							lognow("WARN : Could not JSON parse the response data ! Must deal with the raw string:«"+responseDataStr+"»", parseError2);
+							resolve( {response:response, responseDataStr:responseDataStr} );
+							return;
+						}
+					}
+					
+					// CAUTION : .request(...) => statusCode, .fetch(...) => status (performHTTPRequest(...) uses fetch(...)) 
+					const status=response.statusCode;
+//					if(status!=200){
+//						const error=nonull(response.statusMessage, "No error message for error code "+status);
+//						// TRACE
+//						console.error("Error:", error);
+//						reject({error:""+error, httpStatus:status});
+//						return;
+//					}
+
+					resolve( {responseData:responseData, response:response, responseDataStr:responseDataStr, httpStatus: status} );
+				}catch(parseError3){
+					// DBG
+					lognow("WARN : Could not JSON parse the response data ! Must deal with the raw string:«"+responseDataStr+"»", parseError3);
+					resolve( {response:response, responseDataStr:responseDataStr} );
+					return;
+				}
+				
+		  });
+		});
+		
+		// Handle errors
+		request.on("error", (error) => {
+		  reject({error:error, httpStatus:null});
+		});
+		
+		// Not the same way to send parameters, with POST/PUT http method :
+		if(contains(["POST","PUT"],httpMethod) && body){
+			request.write(body);
+		}
+		
+		// End the request
+		request.end();
+
+	});
+	
+};
+
+
+
+
+replacePathVariablesNamesWithValuesIfPossible=function(apiURL, namedArgs){
+	let result=apiURL;
+	foreach(namedArgs,(namedArgValue, namedArgKey)=>{
+		result=result.replace("{"+namedArgKey+"}",namedArgValue);
+	});
+	return result;
+};
+
+appendGetParameters=function(apiURL, namedArgsParam){
+	if(nothing(namedArgsParam))	return "";
+	try{
+		
+		const namedArgs=isString(namedArgsParam)?parseJSON(namedArgsParam):namedArgsParam;
+		
+		let result=apiURL;
+	
+		const paramCouples=[];
+		foreach(namedArgs,(value,key)=>{paramCouples.push(key+"="+value);});
+	
+		if(!empty(paramCouples)) result+=("?"+paramCouples.join("&"));
+	
+		return result;
+	}catch(parseError){
+		// TRACE
+		lognow("ERROR : Could not parse string parameters object «"+namedArgsParam+"», aborting GET parameter request string calculation:", parseError);
+		return "";
+	}
+};
+
+
+
+
+
+
+
+
 /* ## Utility network global methods in a javascript, console (nodejs), or vanilla javascript with no browser environment.
  *
  * This set of methods gathers utility generic-purpose methods usable in any JS project.

aotrautils-srv/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "aotrautils-srv",
-	"version": "0.0.1827",
+	"version": "0.0.1829",
 	"main": "aotrautils-srv.build.js",
 	"description": "A library for vanilla javascript utils (server-side) used in aotra javascript CMS",
 	"author": "Jeremie Ratomposon <info@alqemia.com> (https://alqemia.com)",