topnic-https 1.2.1 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "topnic-https",
-  "version": "1.2.1",
+  "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,68 +1,59 @@
-const TunnelServer = require('./tunnelServer');
-const { nanoid } = require('nanoid/non-secure');
+const DirectServer = require('./directServer');
 
 class ShareManager {
   constructor() {
     this.activeShares = new Map();
-    this.tunnelServer = TunnelServer;
+    this.server = DirectServer;
   }
 
   async init() {
-    await this.tunnelServer.start();
+    await this.server.start();
   }
 
-  async createShare(port, duration) {
+  async createShare(port) {
     try {
-      const tunnelId = await this.tunnelServer.createTunnel(port);
-      const publicIp = this.tunnelServer.publicIp;
-      const shareUrl = `http://${publicIp}:8000`;
+      const shareId = this.server.createConnection(port);
+      const shareUrl = `http://${this.server.publicIp}:3500/${shareId}`;
       
       const share = {
-        id: tunnelId,
+        id: shareId,
         url: shareUrl,
-        startTime: Date.now(),
-        duration: duration * 60 * 1000
+        port: port,
+        startTime: Date.now()
       };
 
-      this.activeShares.set(tunnelId, share);
-
-      setTimeout(() => {
-        this.closeShare(tunnelId);
-      }, share.duration);
+      this.activeShares.set(shareId, share);
 
       return {
-        id: tunnelId,
+        id: shareId,
         url: shareUrl,
-        localUrl: `http://localhost:8000`
+        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('لم يتم العثور على المشاركة');
     }
 
-    this.tunnelServer.closeTunnel(shareId);
+    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) // بالدقائق
+    };
   }
 }