topnic-https 0.2.13 → 1.2.2

package/package.json

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

package/src/sharing/directServer.js

@@ -0,0 +1,96 @@
+const http = require('http');
+const WebSocket = require('ws');
+const { nanoid } = require('nanoid/non-secure');
+const os = require('os');
+
+class DirectServer {
+  constructor() {
+    this.connections = 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();
+    for (const iface of Object.values(interfaces)) {
+      const nonLocalIpv4 = iface.find(addr => addr.family === 'IPv4' && !addr.internal);
+      if (nonLocalIpv4) return nonLocalIpv4.address;
+    }
+    return 'localhost';
+  }
+
+  async start(port = 3500) {
+    return new Promise((resolve) => {
+      this.server.listen(port, '0.0.0.0', () => {
+        console.log(`🚀 خادم المشاركة يعمل على المنفذ ${port}`);
+        console.log(`📡 عنوان IP: ${this.publicIp}:${port}`);
+        resolve();
+      });
+    });
+  }
+
+  createConnection(targetPort) {
+    const id = nanoid(6);
+    this.connections.set(id, {
+      port: targetPort,
+      createdAt: Date.now(),
+      visitors: 0
+    });
+    return id;
+  }
+
+  async handleRequest(req, res) {
+    const connectionId = req.url.split('/')[1];
+    const connection = this.connections.get(connectionId);
+
+    if (!connection) {
+      res.writeHead(404);
+      res.end('رابط المشاركة غير صالح');
+      return;
+    }
+
+    // إعادة توجيه الطلب إلى المنفذ المحلي
+    const options = {
+      hostname: 'localhost',
+      port: connection.port,
+      path: req.url.replace(`/${connectionId}`, '') || '/',
+      method: req.method,
+      headers: {
+        ...req.headers,
+        host: `localhost:${connection.port}`
+      }
+    };
+
+    connection.visitors++;
+
+    const proxyReq = http.request(options, (proxyRes) => {
+      res.writeHead(proxyRes.statusCode, proxyRes.headers);
+      proxyRes.pipe(res);
+    });
+
+    proxyReq.on('error', (error) => {
+      console.error('خطأ في التوجيه:', error);
+      res.writeHead(502);
+      res.end('خطأ في الاتصال بالتطبيق المحلي');
+    });
+
+    req.pipe(proxyReq);
+  }
+
+  removeConnection(id) {
+    return this.connections.delete(id);
+  }
+
+  getConnectionStats(id) {
+    const connection = this.connections.get(id);
+    if (!connection) return null;
+    
+    return {
+      visitors: connection.visitors,
+      uptime: Date.now() - connection.createdAt
+    };
+  }
+}
+
+module.exports = new DirectServer(); 

package/src/sharing/shareManager.js

@@ -1,84 +1,59 @@
-const ngrok = require('ngrok');
-const { nanoid } = require('nanoid/non-secure');
+const DirectServer = require('./directServer');
 
 class ShareManager {
   constructor() {
     this.activeShares = new Map();
+    this.server = DirectServer;
   }
 
-  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.server.start();
   }
 
-  async createShare(port, duration) {
+  async createShare(port) {
     try {
-      const tunnel = await this.createTunnel(port);
-      const shareId = nanoid(6);
+      const shareId = this.server.createConnection(port);
+      const shareUrl = `http://${this.server.publicIp}:3500/${shareId}`;
       
       const share = {
         id: shareId,
-        url: tunnel.url,
-        tunnel,
-        startTime: Date.now(),
-        duration: duration * 60 * 1000
+        url: shareUrl,
+        port: port,
+        startTime: Date.now()
       };
 
       this.activeShares.set(shareId, share);
 
-      setTimeout(() => {
-        this.closeShare(shareId);
-      }, share.duration);
-
       return {
         id: shareId,
-        url: tunnel.url
+        url: shareUrl,
+        localUrl: `http://localhost:${port}`
       };
     } catch (error) {
       throw new Error(`فشل إنشاء المشاركة: ${error.message}`);
     }
   }
 
-  async closeShare(shareId) {
+  closeShare(shareId) {
     const share = this.activeShares.get(shareId);
     if (!share) {
       throw new Error('لم يتم العثور على المشاركة');
     }
 
-    await share.tunnel.disconnect();
+    this.server.removeConnection(shareId);
     this.activeShares.delete(shareId);
   }
 
-  getActiveShares() {
-    const shares = [];
-    for (const [id, share] of this.activeShares) {
-      const remainingTime = share.duration - (Date.now() - share.startTime);
-      const remainingMinutes = Math.max(0, Math.floor(remainingTime / (60 * 1000)));
-      
-      shares.push({
-        id,
-        url: share.url,
-        remainingMinutes
-      });
-    }
-    return shares;
+  getShareStats(shareId) {
+    const share = this.activeShares.get(shareId);
+    if (!share) return null;
+
+    const stats = this.server.getConnectionStats(shareId);
+    return {
+      ...share,
+      ...stats,
+      uptime: Math.floor((Date.now() - share.startTime) / 1000 / 60) // بالدقائق
+    };
   }
 }
 

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();