webfast 0.1.32 → 0.1.37

package/app/content/js/webfast.js

@@ -1,4 +1,174 @@
 console.log(`WebFast!`);
-window.WebFast = {
-    ts : Date.now()
-}
+let web= {};
+web.fast = {
+    ts : Date.now(),
+    action : function(data,ell) {
+        console.log(`Action Function`,data,ell);
+    },
+    functions : {
+        form : function(data,ell) {
+            console.log(`Handle Form Function`);
+        }
+    },
+    que : {
+        list : [],
+        state : false,
+        run : function(count){
+            // Grab first before sending
+            item = web.fast.que.list[0];
+            if (item != undefined) {
+                delete web.fast.que.list[0];
+                web.fast.que.list.slice(1);
+                console.log(`Sending Item`,item);
+                
+                web.fast.socket.send(JSON.stringify(item)); // Send data to the server
+            }
+        }
+    },
+    tmp : {
+        int : {}
+    },
+    socket : undefined
+}
+// Connect to the Socket.IO server
+const telegram = window.Telegram.WebApp;
+// Step 1: Parse the query string
+if (webfastSocket == undefined) {
+    webfastSocket = window.location.host;
+}
+
+let setData;
+if (telegram.initData == ``) {
+    setData = `hybrid.institute.anonymous`
+} else {
+    setData = telegram.initData;
+}
+
+const socketURL = `wss://${webfastSocket.replace(`https://`,``)}socket.io/?qbt=${setData}`;
+
+// Assuming you have a variable `socketURL` containing your WebSocket URL
+web.fast.connectWebSocket = function(socketURL,maxRetries = 40, retries = 0) {
+    web.fast.createWebSocket = function(socketURL, maxRetries, retries) {
+        const ws = new WebSocket(socketURL);
+        web.fast.socket = ws;
+        ws.onopen = () => {
+            console.log('WebSocket connected');
+            // Start other things (e.g., send initial data)
+            web.fast.que.state = true;
+        };
+
+        ws.onmessage = (event) => {
+            console.log('Received:', event.data);
+            // Handle received data
+            web.fast.que.state = Date.now();
+            web.fast.receive(`socket`,event.data); // Placeholder for processing response
+        };
+
+        ws.onclose = (event) => {
+            web.fast.que.state = false;
+            if (retries < maxRetries) {
+                retries++;
+                console.log(`WebSocket closed. Retrying in 10 seconds...`);
+                setTimeout(web.fast.createWebSocket(socketURL,maxRetries,retries), 10000); // Retry after 10 seconds
+            } else {
+                console.log(`WebSocket connection failed after ${maxRetries} attempts.`);
+                // Handle failure (e.g., show an error message)
+            }
+        };
+
+        ws.onerror = (error) => {
+            console.error('WebSocket error:', error);
+            // Handle error (e.g., show an error message)
+            web.fast.que.state = false;
+        };
+
+        // Send message to path for example api.example.event
+        web.fast.sendMessage = function(path,message) {
+            // Add to que
+            web.fast.que.list.push({
+                path : path,
+                message : message});
+        }
+    };
+
+    web.fast.createWebSocket(socketURL, maxRetries, retries); // Initial connection
+}
+
+// Call the function to start the WebSocket connection
+web.fast.connectWebSocket(socketURL);
+web.fast.receive = function(data) {
+    // Placeholder for processing the received data
+    // Implement your logic here (e.g., update UI, handle specific messages)
+    console.log('Processing received data:', data);
+}
+
+// On Ready desable all forms with jquery
+jQuery(document).ready(function() {
+
+    // Make function
+    web.fast.tmp.int.que = setInterval(function(){
+        // This is the function
+        if (web.fast.que.state != false && web.fast.que.list.length > 0) {
+            // State check
+            web.fast.que.run();
+        }
+    },10);
+
+    // Scan for all webfast ellements
+    jQuery(`[webfast]`).each(function() {
+        let elementType = jQuery(this).prop('nodeName');
+        console.log('Element type:', elementType);
+
+        // Get now the data 
+        let webAction = jQuery(this).attr(`webfast`);
+        let action = jQuery(this).attr(`webfast-${webAction}`);
+        console.log(`Data Actions webAction, action`,webAction,action);
+
+        // Create action runner
+        // Check if id
+        if (jQuery(this).attr(`id`) == undefined) {
+            const array = new Uint32Array(1);
+            window.crypto.getRandomValues(array);
+            const randomValue = array[0];
+
+            console.log(`Set UUID: ${randomValue}`);
+            jQuery(this).attr(`id`,randomValue);
+        }
+        
+        switch (elementType) {
+            case "FORM":
+                jQuery(this).submit(function(e) {
+                    e.preventDefault(); // Prevent the default form submission
+                    
+                    // Check what to do like socketpath
+                    web.fast.action(action,this,e);
+                    return false;
+                });
+            break;
+            case "DIV":
+                // We will do the div element part
+                // check whyt type etc
+                // Make request to server with websocket thingy
+                // Set in QUE
+                let other;
+                if (action == `list`) {
+                    other = {
+                        type : action,
+                        html : jQuery(this).html()
+                    }
+                }
+                web.fast.sendMessage(`socket.api.${webAction}`,{
+                    ts : Date.now(),
+                    ell : jQuery(this).attr(`id`),
+                    other : other
+                })
+            break;
+            case "BUTTON":
+                // Check button interaction
+                console.error(`SETUP BUTTON INTERACTION`);
+            break;
+            default:
+                console.error(`No Action for : ${elementType}`);
+        }
+    });
+});

package/ejs/collect/event.ejs

@@ -4,10 +4,10 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title><%= title %></title>
-    <script src="<%= url %>/app/content/js/jquery-3.7.1.min.js"></script>
+    <script src="<%= url %>app/content/js/jquery-3.7.1.min.js"></script>
     <script src="https://telegram.org/js/telegram-web-app.js"></script>
     <script src="https://unpkg.com/@tonconnect/ui@latest/dist/tonconnect-ui.min.js"></script>
-    <script src="<%= url %>/app/content/js/webfast.js"></script>
+    <script src="<%= url %>app/content/js/webfast.js"></script>
 </head>
 <body>
 

package/ejs/view/list.ejs

@@ -3,7 +3,12 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title><%= title %></title>
+    <title><%= title %></title><!-- Include Socket.IO from CDN -->
+    <script src="https://cdn.socket.io/4.0.0/socket.io.min.js"></script>
+    <script src="<%= url %>app/content/js/jquery-3.7.1.min.js"></script>
+    <script src="https://telegram.org/js/telegram-web-app.js"></script>
+    <script src="https://unpkg.com/@tonconnect/ui@latest/dist/tonconnect-ui.min.js"></script>
+    <script src="<%= url %>app/content/js/webfast.js"></script>
 </head>
 <body>
 

package/example.js

@@ -1,5 +1,8 @@
 const path = require(`path`);
 let program = require(path.join(__dirname,`index.js`))({
-    wget : '/usr/local/bin/wget'
+    wget : '/usr/local/bin/wget',
+    process : {
+        ts : Date.now()
+    }
 });
 console.log(`Required`);

package/modules/bots/applications/telegram/middleware/message/location.js

@@ -5,6 +5,10 @@ module.exports = async function(req,res,body,params,command,middleValue) {
     if (middleValue.location != undefined) {
         locSendMessage = `Thank you for sending your location\n ${middleValue.location.longitude}\n${middleValue.location.latitude}`;
     }
+
+    const scripting = await program.modules.telegram.script.function.check(program,command,middleValue.chat.id,middleValue,body);
+    console.log(scripting);
+
     return {
         message : locSendMessage,
         response : {

package/modules/bots/applications/telegram/middleware/message/photo.js

@@ -0,0 +1,63 @@
+module.exports = async function(program,req,res,body,params,command,middleValue) {
+    console.log(`Location Telegram Function`);
+    // We have the start function
+    let locSendMessage = false;
+
+    // Now get the photos and save them in db files
+    // loop through photos
+    const user = middleValue.from.id;
+    const uuid = program.uuid.v4();
+    for (let photoI in middleValue.photo) {
+        let photo = middleValue.photo[photoI];
+        // photo url user
+        const userPhotoURL = await program.modules.telegram.functions.get.file(program,photo.file_id);
+        console.log(userPhotoURL);
+         // create url
+         const photoURL = `https://api.telegram.org/file/bot${process.env.telegram}/${userPhotoURL.result.file_path}`;;
+
+         //res.status(200);
+         // Now do the fetch process thingy
+         await program.modules.telegram.functions.get.downloadAndConvertToBase64(program,photoURL,async function(program,response){
+             console.log(`We have now file data`);
+             // Create id for file that is unique uuid
+             const meta = {
+                 user : response.data.user,
+                 type : response.imageData.type,
+                 size : {
+                     width : response.imageData.width,
+                     height : response.imageData.height
+                 }
+             }
+             await program.modules.data.file.uploadBuffer(program,response.buffer,uuid,meta,async function(progam,upload,meta){
+                 console.log(`Uploaded Buffer`);
+                 // Save to membe
+                 // Now we have received so we can add marker to the receive message
+             });
+             
+         },{
+             user : user,
+             data : middleValue
+         });
+
+    }
+
+    res.status(200);
+    
+    locSendMessage = `Image succesfull received`;
+
+    const scripting = await program.modules.telegram.script.function.check(program,command,middleValue.chat.id,middleValue,body);
+    console.log(scripting);
+    
+    // Send back
+    if (scripting == true) {
+        return true;
+    } else {
+        return {
+            message : locSendMessage,
+            response : {
+                message : locSendMessage,
+                uuid : uuid
+            }
+        }
+    }
+}

package/modules/bots/applications/telegram/que.js

@@ -76,7 +76,27 @@ module.exports = {
                         }
                     }
                 } else {
-                    console.error(`Need to set anwser data`);
+                    // Check if something with type: 
+                    for (let li in question.match.data) {
+                        let matchCheck = question.match.data[li];
+                        if (typeof matchCheck.anwser == `object`) {
+                            // Grab type if it's there
+                            switch (matchCheck.anwser.type) {
+                                case command:
+                                    console.log(`It's the dynamic thing`);
+                                    matched = matchCheck;
+                                    let variable = data.message[command]
+                                    anwserData = {
+                                        type : command,
+                                        data : variable
+                                    };
+                                break;
+                                default:
+                                    console.log(`No matching type found`);
+                            }
+                        }
+                    }
+
                 }
 
                 // End of match process fo matched checking
@@ -132,6 +152,7 @@ module.exports = {
             // Create replacelist
             let replace = {
                 "{{URL}}"   :   process.env.url,
+                "{{WEBURL}}"   :   process.env.webURL,
                 "{{TEST}}"  :   "TEST REPLACED"
             }
 

package/modules/bots/applications/telegram/scripts/function.js

@@ -34,6 +34,7 @@ module.exports = {
         } catch(err) {
             console.error(err);
             console.error(`Error Scripting`);
+            return false;
         }
     },
     response : async function() {

package/modules/bots/applications/telegram/scripts/test/script.json

@@ -15,7 +15,9 @@
                 "function"  :   "program.modules.bots.scripts.function.response",
                 "next"      :   "nextFunc"
             },{
-                "anwser"  :   "hi",
+                "anwser"  :   {
+                    "type" : "photo"
+                },
                 "function"  :   "program.modules.bots.scripts.function.response",
                 "next"      :   "nextFunc"
             }]
@@ -31,7 +33,7 @@
             "text" : "Testing Title : {{START}}",
             "buttons" : [
                 [
-                    { "text": "EventGO!",  "web_app" : { "url" : "{{URL}}events/list"}},
+                    { "text": "EventGO!",  "web_app" : { "url" : "{{WEBURL}}concepts/eventgo/events-list"}},
                     { "text": "Create Event", "callback_data": "create_event" }
                 ]
             ]

package/modules/bots/applications/telegram/set.js

@@ -1,6 +1,6 @@
 const { MongoClient } = require('mongodb');
 const uri = process.env.mongo;
-const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
+const client = new MongoClient(uri);
 
 module.exports = {
     profilePhoto : async function(program,content,meta) {

package/modules/bots/applications/telegram.js

@@ -207,7 +207,7 @@ module.exports = async function(program,folder) {
                         } catch (message) {
                             // Process as other
                             console.log(`Process Different`);
-                            let checkArray = [`location`];
+                            let checkArray = [`location`,`photo`];
                             // Loop through checkArray
                             for (let c in checkArray) {
                                 const command = checkArray[c];
@@ -215,7 +215,7 @@ module.exports = async function(program,folder) {
                                 if (indexCheck != -1) {
                                     console.log(`Run this as middleware`);
                                     try {
-                                        const runFunc   =   await program.modules.telegram.middleware[key][command](req,res,body,params,command,middleValue);
+                                        const runFunc   =   await program.modules.telegram.middleware[key][command](program,req,res,body,params,command,middleValue);
                                         const respFunc = runFunc;
                                         // PRocess response for object
                                         if (respFunc == undefined) {

package/modules/data/mongo/file.js

@@ -3,7 +3,7 @@ const fs = require('fs');
 
 // Define the MongoDB URI
 const uri = process.env.mongo;
-const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
+const client = new MongoClient(uri);
 
 module.exports = {
     uploadBuffer: async function (progam,buffer, filename, metadata = {}, callback) {

package/modules/data/mongo/find.js

@@ -18,7 +18,7 @@ module.exports = function(db,collection) {
 
     async function main() {
     // Create a new MongoClient
-    const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
+    const client = new MongoClient(uri);
 
     try {
         // Connect to the MongoDB server

package/modules/express/init.js

@@ -1,178 +1,316 @@
 module.exports = async function (program) {
-    console.log(`Starting UP Express`);
-    program.express = {
+  console.log(`Starting UP Express`);
+  program.express = {
       ts: Date.now(),
-    };
-  
-    const express = require('express');
-    const cors = require('cors');
-    const bodyParser = require('body-parser');
-    const port = 1221;
-    const basePath = `/api`;
-  
-    const app = express();
-  
-    const corsOptions = {
+      process : program.set.process
+  };
+
+  const express = require('express');
+  const cors = require('cors');
+  const bodyParser = require('body-parser');
+  const WebSocket = require('ws');
+  const crypto = require(`crypto`)
+  const port = 1221;
+  const basePath = `/api`;
+
+  const app = express();
+
+  const corsOptions = {
       origin: '*',
       methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
       credentials: true,
       optionsSuccessStatus: 204,
-    };
-  
-    app.use(cors(corsOptions));
-    app.use(bodyParser.json());
-    app.use(bodyParser.urlencoded({ extended: true }));
-    app.set('view engine', 'ejs');
-  
-    let routesPath = program.path.join(__dirname, `routes`);
-    // Check if custom routes path
-    if (program.set.path != undefined) {
-      routesPath = program.path.join(program.set.path,`routes`);
-    }
+  };
 
-    let exprs = {};
-  
-    try {
+  app.use(cors(corsOptions));
+  app.use(bodyParser.json());
+  app.use(bodyParser.urlencoded({ extended: true }));
+  app.set('view engine', 'ejs');
+
+  let routesPath = program.path.join(__dirname, `routes`);
+  // Check if custom routes path
+  if (program.set.path != undefined) {
+      routesPath = program.path.join(program.set.path, `routes`);
+  }
+
+  let exprs = {};
+
+  try {
       let routesData = await program.modules.walkDirectory(routesPath);
-  
+
       for (let routeData of routesData) {
-        let routePath = `${basePath}/${routeData.name}`;
-  
-        const split = routeData.name.split('.');
-        routeData.type = split.length > 1 ? split[split.length - 1] : 'get';
-        routeData.name = split.length > 1 ? split[0] : routeData.name;
-  
-        const routeID = program.uuid.v4();
-        routeData.tempID = routeID;
-  
-        try {
-          const stats = await program.fs.statSync(routeData.path);
-          const isDirectory = stats.isDirectory();
-  
-          if (isDirectory) {
-            for (let subData of routeData.sub) {
-              if (subData !== undefined) {
-                const routeName = subData.name.replace('.get', '').replace('.post', '');
-                const subDataSplit = subData.path.split('.');
-                const type = subDataSplit[subDataSplit.length - 2];
-  
-                subData.name = routeName;
-                delete subData.sub;
-                subData.type = type;
-  
-                subData.func = require(subData.path);
-                exprs[routePath + '/' + routeName] = subData;
+          let routePath = `${basePath}/${routeData.name}`;
+
+          const split = routeData.name.split('.');
+          routeData.type = split.length > 1 ? split[split.length - 1] : 'get';
+          routeData.name = split.length > 1 ? split[0] : routeData.name;
+
+          const routeID = program.uuid.v4();
+          routeData.tempID = routeID;
+
+          try {
+              const stats = await program.fs.statSync(routeData.path);
+              const isDirectory = stats.isDirectory();
+
+              if (isDirectory) {
+                  for (let subData of routeData.sub) {
+                      if (subData !== undefined) {
+                          const routeName = subData.name.replace('.get', '').replace('.post', '');
+                          const subDataSplit = subData.path.split('.');
+                          const type = subDataSplit[subDataSplit.length - 2];
+
+                          subData.name = routeName;
+                          delete subData.sub;
+                          subData.type = type;
+
+                          subData.func = require(subData.path);
+                          exprs[routePath + '/' + routeName] = subData;
+                      }
+                  }
+              } else {
+                  routeData.func = require(routeData.path);
+                  exprs[routePath] = routeData;
               }
-            }
-          } else {
-            routeData.func = require(routeData.path);
-            exprs[routePath] = routeData;
+          } catch (err) {
+              console.error(`Error Route Func`, routePath);
+              console.error(err);
           }
-        } catch (err) {
-          console.error(`Error Route Func`, routePath);
-          console.error(err);
-        }
-  
-        routeData.webwalk = 0;
+
+          routeData.webwalk = 0;
       }
-  
+
       program.express.routes = exprs;
-  
+
       for (let route in exprs) {
-        let routeData = exprs[route];
-        let state = false;
-  
-        try {
-          app[routeData.type](route, async (req, res) => {
-            try {
-              exprs[route].webwalk++;
+          let routeData = exprs[route];
+          let state = false;
+
+          try {
+              app[routeData.type](route, async (req, res) => {
+                  try {
+                      exprs[route].webwalk++;
 
-              // Get body
-              const requestBody = req.body;
-              const reqParams = req.params;
+                      // Get body
+                      const requestBody = req.body;
+                      const reqParams = req.params;
 
-              await routeData.func(program, req, res, route,requestBody,reqParams);
-            } catch (err) {
-              console.error(`Error With Route:`, route);
+                      await routeData.func(program, req, res, route, requestBody, reqParams);
+                  } catch (err) {
+                      console.error(`Error With Route:`, route);
+                      console.error(err);
+                  }
+              });
+              state = true;
+          } catch (err) {
               console.error(err);
-            }
-          });
-          state = true;
-        } catch (err) {
-          console.error(err);
-          console.error(`Error Setting Up Route`);
-        }
-  
-        exprs[route].state = state;
+              console.error(`Error Setting Up Route`);
+          }
+
+          exprs[route].state = state;
       }
-  
+
       console.log(`Routes are set up successfully`);
-    } catch (err) {
+  } catch (err) {
       console.error(err);
       console.error(`Error Setting Up Routes`);
-    }
-  
-    program.express.app = app;
+  }
+
+  program.express.app = app;
 
-    // Let app listen for content
-    app.get(`/app/content/ton/manifest.json`,async (req,res) => {
+  // Let app listen for content
+  app.get(`/app/content/ton/manifest.json`, async (req, res) => {
       // Let's create a json
       const manifest = {
-        url: process.env.url,
-        name: process.env.name,
-        iconUrl: process.env.image
+          url: process.env.url,
+          name: process.env.name,
+          iconUrl: process.env.image
       };
-    
+
       res.setHeader('Content-Type', 'application/json');
       res.json(manifest);
-    });
+  });
 
-    app.get(`/app/content/:type/:file`,async (req,res) => {
-        console.log(`Content Get`);
-        // Try To get file from content folder
-        try {
-            const filePath = program.path.join(__dirname,`..`,`..`,`app`,`content`,req.params.type,req.params.file);
-            let contentFolder = filePath;
-
-            // Check if minify at the end
-            const fileName = req.params.file;
-            const isMinified = /-min\.js$/.test(fileName);
-
-            if (isMinified) {
-                console.log(`${fileName} ends with -min.js`);
-                const toRequestFile = req.params.file.replace(`-min.js`,`.js`);
-                contentFolder = program.path.join(__dirname,`..`,`..`,`app`,`content`,req.params.type,toRequestFile);
-            } else {
-                console.log(`${fileName} does not end with -min.js`);
-            }
+  app.get(`/app/content/:type/:file`, async (req, res) => {
+      console.log(`Content Get`);
+      // Try To get file from content folder
+      try {
+          const filePath = program.path.join(__dirname, `..`, `..`, `app`, `content`, req.params.type, req.params.file);
+          let contentFolder = filePath;
 
-            res.sendFile(contentFolder);
-        } catch (err) {
-            console.error(err);
-            console.error(`Error Getting : ${req.params.type}`,req.params.file);
-        }
-    })
+          // Check if minify at the end
+          const fileName = req.params.file;
+          const isMinified = /-min\.js$/.test(fileName);
+
+          if (isMinified) {
+              console.log(`${fileName} ends with -min.js`);
+              const toRequestFile = req.params.file.replace(`-min.js`, `.js`);
+              contentFolder = program.path.join(__dirname, `..`, `..`, `app`, `content`, req.params.type, toRequestFile);
+          } else {
+              console.log(`${fileName} does not end with -min.js`);
+          }
+
+          res.sendFile(contentFolder);
+      } catch (err) {
+          console.error(err);
+          console.error(`Error Getting : ${req.params.type}`, req.params.file);
+      }
+  })
 
-    app.listen(port, () => {
+  app.listen(port, () => {
       console.log(`Server Listening`, port, basePath);
-    });
-  
-    program.express.url = {
+  });
+
+  program.express.url = {
       adaptive: {
-        get: [],
-        post: [],
+          get: [],
+          post: [],
       },
       set: function (requestPath, actionType, callback) {
-        program.express.url.adaptive[actionType] = app[actionType](requestPath, async (req, res) => {
-          let run = await callback(req, res, req.body, req.params);
-          return run;
-        });
-        return true;
+          program.express.url.adaptive[actionType] = app[actionType](requestPath, async (req, res) => {
+              let run = await callback(req, res, req.body, req.params);
+              return run;
+          });
+          return true;
       },
-    };
-  
-    program.express.setted = true;
-  
-    return program;
   };
-  
+
+  program.express.setted = true;
+
+  let clients = new Map();
+  // Start socket thingy
+  const PORT = process.env.socket || 3000;
+  const wss = new WebSocket.Server({ port: PORT });
+
+ 
+  wss.on('connection', (ws, req) => {
+    console.log(`Socket Connected`);
+
+    // Generate a unique ID for the WebSocket connection
+    const clientId = program.uuid.v4();
+    const reqURL = req.url;
+    console.log(`We have some data`, reqURL);
+    const queryStringWithoutQBT = reqURL.replace('/socket.io/?qbt=', '');
+    const queryParamsArray = queryStringWithoutQBT.split('&');
+
+    const parsedQuery = queryParamsArray.reduce((acc, param) => {
+        const [key, value] = param.split('=');
+        acc[key] = decodeURIComponent(value);
+        return acc;
+    }, {});
+
+    // Extract data from the parsed query
+    const { auth_date, query_id, user, hash } = parsedQuery;
+
+    // Stringify the 'user' field if it contains JSON data
+    if (user != undefined) {
+        try {
+            parsedQuery.user = JSON.stringify(parsedQuery.user);
+        } catch (error) {
+            console.error('Error parsing JSON in user field:', error);
+        }
+    }
+
+    // Construct the data check string
+    const sortedKeys = Object.keys(parsedQuery).sort();
+    const data_check_string = sortedKeys.map(key => `${key}=${String(parsedQuery[key])}`).join('\n');
+
+    function HMAC_SHA256(data, key) {
+        const hmac = crypto.createHmac('sha256', key);
+        hmac.update(data);
+        return hmac.digest('hex');
+    }
+
+    const bot_token = process.env.telegram; // replace with your actual bot token
+    const secret_key = HMAC_SHA256(bot_token, 'WebAppData');
+    const calculated_hash = HMAC_SHA256(data_check_string, secret_key);
+
+    const received_hash = hash; // replace with the actual received hash
+
+    if (calculated_hash === received_hash) {
+        // Data is from Telegram and has not been tampered with
+        // Additional check for auth_date if needed
+        const currentUnixTimestamp = Math.floor(new Date().getTime() / 1000);
+        if (parseInt(auth_date, 10) <= currentUnixTimestamp) {
+            // Data is not outdated
+            // Use the validated data as needed
+            console.log('Data from Telegram is valid');
+        } else {
+            console.error('Received data is outdated');
+        }
+    } else {
+        console.error('Received data has been tampered with');
+    }
+
+    console.log(parsedQuery);
+
+    // Store the WebSocket connection with its ID in the map
+    clients.set(clientId, ws);
+
+    // Send the client ID to the connected client
+    ws.send(JSON.stringify({ type: 'clientId', id: clientId, params: parsedQuery }));
+
+    // Set up a ping interval to keep the connection alive
+    const pingInterval = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.ping();
+        } else {
+            // If the connection is closed, remove it from the map
+            clearInterval(pingInterval);
+            clients.delete(clientId);
+            console.log(`Removed disconnected socket with ID: ${clientId}`);
+        }
+    }, 5000); // Adjust the interval as needed
+
+    ws.on('close', () => {
+        console.log(`Socket Disconnected`);
+        clearInterval(pingInterval);
+        clients.delete(clientId);
+    });
+
+    // WebSocket on message event
+    ws.on('message', async (message) => {
+        console.log(`Received message from ${clientId}: ${message}`);
+
+        try {
+            // Check for function
+            const json = JSON.parse(message.toString(`utf-8`));
+            const data = json.message;
+            const path = json.path;
+            const split = path.split(".")
+            
+            // Check if function is running in program modules that you can add in the init scirpt when using remote
+            if (program.express.process != undefined) {
+                try {
+                    let resp = await program.express.process[split[0]][split[1]][split[2]](program,ws,json,data,path);
+                    if (resp != false) {
+                        ws.send(JSON.stringify(resp));
+                    }
+                } catch (err) {
+                    console.error(`Error Running program.express.process for `,split[0],split[1],split[2]);
+                    ws.send(JSON.stringify({
+                        ts : Date.now(),
+                        error : true,
+                        message : `Error Event Program receive`
+                    }));
+                }
+            }
+
+            // Add your custom on message logic here
+            // For example, you can broadcast the message to all connected clients
+            clients.forEach((client, id) => {
+                if (client.readyState === WebSocket.OPEN && id !== clientId) {
+                    //ws.send(`Broadcast from ${clientId}: ${message}`);
+                }
+            });
+
+            // Check if 
+        } catch(err) {
+            console.error(`Error Something`);
+
+        }
+    });
+});
+
+
+  return program;
+};

package/modules/express/routes/view/list.get.js

@@ -1,12 +1,13 @@
 module.exports = async function(program,req,res,route) {
     console.log(`Create`);
-    const fullPath = program.path.join(__dirname, `..`,`..`,`..`,`..`,`ejs`,`example`,`list.ejs`);
+    const fullPath = program.path.join(__dirname, `..`,`..`,`..`,`..`,`ejs`,`view`,`list.ejs`);
 
     // Render the EJS template
     res.render(fullPath, {
         title: 'EJS Example',
         name: 'John Doe',
         isAdmin: true,
-        fruits: ['Apple', 'Banana', 'Orange']
+        fruits: ['Apple', 'Banana', 'Orange'],
+        url : process.env.url
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webfast",
-  "version": "0.1.32",
+  "version": "0.1.37",
   "description": "WebFast! Bot Application, including TON mini-apps for makign it easy and fast to build ini-apps",
   "main": "index.js",
   "repository": {
@@ -39,6 +39,7 @@
   "dependencies": {
     "body-parser": "^1.20.2",
     "cors": "^2.8.5",
+    "crypto": "^1.0.1",
     "dotenv": "^16.0.3",
     "ejs": "^3.1.9",
     "express": "^4.18.2",
@@ -49,6 +50,7 @@
     "mongodb": "^6.3.0",
     "node-fetch": "^3.3.2",
     "path": "^0.12.7",
-    "uuid": "^9.0.1"
+    "uuid": "^9.0.1",
+    "ws": "^8.16.0"
   }
 }