topnic-https 0.2.13 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "topnic-https",
-  "version": "0.2.13",
+  "version": "1.2.1",
   "main": "./src/main/index.js",
   "type": "commonjs",
   "scripts": {

package/src/sharing/shareManager.js

@@ -1,55 +1,39 @@
-const ngrok = require('ngrok');
+const TunnelServer = require('./tunnelServer');
 const { nanoid } = require('nanoid/non-secure');
 
 class ShareManager {
   constructor() {
     this.activeShares = new Map();
+    this.tunnelServer = TunnelServer;
   }
 
-  async createTunnel(port) {
-    try {
-      const url = await ngrok.connect({
-        addr: port,
-        onStatusChange: status => {
-          if (status === 'closed') {
-            console.log('🔄 تم إغلاق النفق');
-          }
-        },
-        onLogEvent: data => {
-          if (data.err) {
-            console.error('❌ خطأ في النفق:', data.err);
-          }
-        }
-      });
-
-      return { url, disconnect: ngrok.disconnect };
-    } catch (error) {
-      throw new Error(`فشل إنشاء النفق: ${error.message}`);
-    }
+  async init() {
+    await this.tunnelServer.start();
   }
 
   async createShare(port, duration) {
     try {
-      const tunnel = await this.createTunnel(port);
-      const shareId = nanoid(6);
+      const tunnelId = await this.tunnelServer.createTunnel(port);
+      const publicIp = this.tunnelServer.publicIp;
+      const shareUrl = `http://${publicIp}:8000`;
       
       const share = {
-        id: shareId,
-        url: tunnel.url,
-        tunnel,
+        id: tunnelId,
+        url: shareUrl,
         startTime: Date.now(),
         duration: duration * 60 * 1000
       };
 
-      this.activeShares.set(shareId, share);
+      this.activeShares.set(tunnelId, share);
 
       setTimeout(() => {
-        this.closeShare(shareId);
+        this.closeShare(tunnelId);
       }, share.duration);
 
       return {
-        id: shareId,
-        url: tunnel.url
+        id: tunnelId,
+        url: shareUrl,
+        localUrl: `http://localhost:8000`
       };
     } catch (error) {
       throw new Error(`فشل إنشاء المشاركة: ${error.message}`);
@@ -62,7 +46,7 @@ class ShareManager {
       throw new Error('لم يتم العثور على المشاركة');
     }
 
-    await share.tunnel.disconnect();
+    this.tunnelServer.closeTunnel(shareId);
     this.activeShares.delete(shareId);
   }
 

package/src/sharing/tunnelServer.js

@@ -0,0 +1,110 @@
+const http = require('http');
+const https = require('https');
+const WebSocket = require('ws');
+const { nanoid } = require('nanoid/non-secure');
+const os = require('os');
+
+class TunnelServer {
+  constructor() {
+    this.tunnels = new Map();
+    this.server = http.createServer(this.handleRequest.bind(this));
+    this.wss = new WebSocket.Server({ server: this.server });
+    this.publicIp = this.getPublicIp();
+  }
+
+  getPublicIp() {
+    const interfaces = os.networkInterfaces();
+    let address;
+    
+    for (const iface of Object.values(interfaces)) {
+      for (const alias of iface) {
+        if (alias.family === 'IPv4' && !alias.internal) {
+          address = alias.address;
+          break;
+        }
+      }
+      if (address) break;
+    }
+    
+    return address;
+  }
+
+  async start(port = 8000) {
+    return new Promise((resolve) => {
+      this.server.listen(port, '0.0.0.0', () => {
+        console.log(`🚀 خادم النفق يعمل على المنفذ ${port}`);
+        console.log(`📡 عنوان IP العام: ${this.publicIp}`);
+        resolve();
+      });
+    });
+  }
+
+  async createTunnel(targetPort) {
+    const tunnelId = nanoid(6);
+    const tunnel = {
+      id: tunnelId,
+      targetPort,
+      clients: new Set(),
+      createdAt: Date.now()
+    };
+
+    this.tunnels.set(tunnelId, tunnel);
+    return tunnelId;
+  }
+
+  async handleRequest(req, res) {
+    const tunnelId = req.headers.host.split('.')[0];
+    const tunnel = this.tunnels.get(tunnelId);
+
+    if (!tunnel) {
+      res.writeHead(404);
+      res.end('النفق غير موجود');
+      return;
+    }
+
+    // إعادة توجيه الطلب إلى الخادم المحلي
+    const options = {
+      hostname: 'localhost',
+      port: tunnel.targetPort,
+      path: req.url,
+      method: req.method,
+      headers: req.headers
+    };
+
+    const proxyReq = http.request(options, (proxyRes) => {
+      res.writeHead(proxyRes.statusCode, proxyRes.headers);
+      proxyRes.pipe(res);
+    });
+
+    req.pipe(proxyReq);
+
+    proxyReq.on('error', (error) => {
+      console.error('خطأ في النفق:', error);
+      res.writeHead(502);
+      res.end('خطأ في الاتصال بالخادم المحلي');
+    });
+  }
+
+  handleConnection(ws, req) {
+    const tunnelId = req.headers.host.split('.')[0];
+    const tunnel = this.tunnels.get(tunnelId);
+
+    if (tunnel) {
+      tunnel.clients.add(ws);
+      
+      ws.on('close', () => {
+        tunnel.clients.delete(ws);
+      });
+    }
+  }
+
+  closeTunnel(tunnelId) {
+    const tunnel = this.tunnels.get(tunnelId);
+    if (tunnel) {
+      tunnel.clients.forEach(client => client.close());
+      this.tunnels.delete(tunnelId);
+    }
+  }
+}
+
+module.exports = new TunnelServer();