Upload index.js

.streamlit/index.js

@@ -0,0 +1,643 @@
+// server/index.js (نسخه بهینه شده: انتخاب تصادفی کلیدها + پایداری بالا)
+const express = require('express');
+const path = require('node:path');
+const fs = require('node:fs');
+const { WebSocketServer, WebSocket } = require('ws');
+const http = require('node:http');
+require('dotenv').config();
+
+const app = express();
+app.set('trust proxy', true);
+
+// ==================== مدیریت محدودیت زمانی رایگان روزانه (سه لایه) ====================
+// شناسایی هر کاربر با ترکیب سه لایه انجام می‌شود:
+//   لایه ۱: آی‌پی کاربر
+//   لایه ۲: اثر انگشت مرورگر/دستگاه (fingerprint) - از src/lib/fingerprint.ts
+//   لایه ۳: یک شناسه ذخیره‌شده در حافظه مرورگر کاربر (localStorage)
+// اگر فقط یکی از این سه مورد با یکی از کاربران قبلی یکی باشد، همان پروفایل
+// (و همان اعتبار باقیمانده) به کاربر نسبت داده می‌شود. یعنی:
+//  - پاک کردن حافظه مرورگر (لایه ۳) کمکی نمی‌کند، چون IP و fingerprint هنوز شناخته می‌شوند.
+//  - باز کردن در تب ناشناس/مرورگر دیگر روی همان دستگاه و همان اینترنت هم چون IP یکی
+//    می‌ماند و در بسیاری موارد fingerprint هم شبیه است، همان اعتبار قبلی نشان داده می‌شود.
+// همه چیز روی سرور محاسبه و ذخیره می‌شود، مرورگر کاربر هیچ نقشی در تعیین اعتبار واقعی ندارد.
+
+const DAILY_LIMIT_SECONDS = 300; // ۵ دقیقه
+
+// مسیر ذخیره‌سازی دائمی (باکت/دیسک پایدار هاگینگ‌فیس معمولاً روی /data مونت می‌شود)
+const PRIMARY_DATA_DIR = process.env.PERSIST_DATA_DIR || '/data';
+const FALLBACK_DATA_DIR = __dirname;
+const DB_FILE_NAME = 'sotifree.db';
+
+function resolveWritableDataDir() {
+  try {
+    fs.mkdirSync(PRIMARY_DATA_DIR, { recursive: true });
+    const testFile = path.join(PRIMARY_DATA_DIR, '.write-test');
+    fs.writeFileSync(testFile, 'ok');
+    fs.unlinkSync(testFile);
+    console.log(`✅ مسیر ذخیره‌سازی دائمی فعال است: ${PRIMARY_DATA_DIR}`);
+    return PRIMARY_DATA_DIR;
+  } catch (e) {
+    console.warn(`⚠️ مسیر ${PRIMARY_DATA_DIR} در دسترس/قابل نوشتن نیست (${e.message})، استفاده از مسیر جایگزین: ${FALLBACK_DATA_DIR}`);
+    return FALLBACK_DATA_DIR;
+  }
+}
+
+const DATA_DIR = resolveWritableDataDir();
+const USAGE_FILE = path.join(DATA_DIR, DB_FILE_NAME);
+
+// ساختار داده در حافظه:
+// profiles: { [profileId]: { date: 'YYYY-MM-DD', usedSeconds: number } }
+// ipIndex / fpIndex / sidIndex: { [value]: profileId }
+let db = {
+  profiles: {},
+  ipIndex: {},
+  fpIndex: {},
+  sidIndex: {},
+};
+
+function loadDb() {
+  try {
+    if (fs.existsSync(USAGE_FILE)) {
+      const raw = fs.readFileSync(USAGE_FILE, 'utf8');
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === 'object') {
+        db = {
+          profiles: parsed.profiles || {},
+          ipIndex: parsed.ipIndex || {},
+          fpIndex: parsed.fpIndex || {},
+          sidIndex: parsed.sidIndex || {},
+        };
+      }
+      console.log(`✅ فایل اعتبار کاربران بارگذاری شد (${USAGE_FILE})`);
+    } else {
+      console.log(`ℹ️ فایل اعتبار کاربران وجود نداشت، یک فایل جدید ساخته می‌شود (${USAGE_FILE})`);
+    }
+  } catch (e) {
+    console.error('⚠️ خطا در بارگذاری فایل اعتبار کاربران، شروع از صفر:', e.message);
+    db = { profiles: {}, ipIndex: {}, fpIndex: {}, sidIndex: {} };
+  }
+}
+
+let dirty = false;
+function markDirty() {
+  dirty = true;
+}
+
+function flushDbToDisk() {
+  if (!dirty) return;
+  try {
+    fs.writeFileSync(USAGE_FILE, JSON.stringify(db));
+    dirty = false;
+  } catch (e) {
+    console.error('⚠️ خطا در ذخیره فایل اعتبار کاربران:', e.message);
+  }
+}
+
+// طبق درخواست: چون هر بار فقط چند ثانیه از اعتبار کم می‌شود، نیازی نیست هر
+// ثانیه روی دیسک نوشته شود. هر ۳۰ ثانیه یک‌بار روی دیسک ذخیره می‌شود.
+const PERSIST_INTERVAL_MS = 30000;
+setInterval(flushDbToDisk, PERSIST_INTERVAL_MS);
+
+// ذخیره نهایی در زمان خاموش شدن سرور (تا حد امکان)
+process.on('SIGTERM', () => { flushDbToDisk(); process.exit(0); });
+process.on('SIGINT', () => { flushDbToDisk(); process.exit(0); });
+
+loadDb();
+
+function getTodayString() {
+  // تاریخ روز جاری بر مبنای UTC، تا در ری‌استارت سرور دچار اختلاف منطقه زمانی نشویم
+  return new Date().toISOString().slice(0, 10);
+}
+
+function getClientIp(req) {
+  const forwarded = req.headers['x-forwarded-for'];
+  if (forwarded) {
+    return String(forwarded).split(',')[0].trim();
+  }
+  return (req.socket && req.socket.remoteAddress) || 'unknown-ip';
+}
+
+function normalizeKeyPart(value, maxLen) {
+  if (value && typeof value === 'string' && value.length > 0 && value.length <= maxLen) {
+    return value;
+  }
+  return null;
+}
+
+function createNewProfileId() {
+  return 'p_' + Date.now().toString(36) + '_' + Math.random().toString(36).slice(2, 10);
+}
+
+function getUsedSecondsToday(profileId) {
+  const profile = db.profiles[profileId];
+  if (!profile) return 0;
+  const today = getTodayString();
+  if (profile.date !== today) return 0;
+  return profile.usedSeconds || 0;
+}
+
+// پیدا کردن یا ساختن پروفایل کاربر بر اساس سه لایه (IP، fingerprint، شناسه حافظه مرورگر)
+// اگر هرکدام از این سه به یک پروفایل قبلی اشاره کنند، همان پروفایل (پروفایلی که
+// بیشترین اعتبار مصرف‌شده امروز را دارد، برای جلوگیری از دور زدن محدودیت) انتخاب می‌شود
+// و هر سه ایندکس به آن پروفایل واحد متصل می‌شوند.
+function resolveProfileId(ip, fp, sid) {
+  const safeIp = normalizeKeyPart(ip, 100) || 'unknown-ip';
+  const safeFp = normalizeKeyPart(fp, 200);
+  const safeSid = normalizeKeyPart(sid, 200);
+
+  const candidateIds = new Set();
+  if (db.ipIndex[safeIp]) candidateIds.add(db.ipIndex[safeIp]);
+  if (safeFp && db.fpIndex[safeFp]) candidateIds.add(db.fpIndex[safeFp]);
+  if (safeSid && db.sidIndex[safeSid]) candidateIds.add(db.sidIndex[safeSid]);
+
+  let profileId;
+  if (candidateIds.size === 0) {
+    profileId = createNewProfileId();
+    db.profiles[profileId] = { date: getTodayString(), usedSeconds: 0, lastSeen: Date.now() };
+  } else {
+    // از بین همه پروفایل‌های مرتبط، پروفایلی که بیشترین مصرف امروز را دارد به عنوان
+    // مرجع انتخاب می‌شود (رویکرد محافظه‌کارانه برای جلوگیری از دور زدن محدودیت)
+    let maxUsed = -1;
+    for (const id of candidateIds) {
+      const used = getUsedSecondsToday(id);
+      if (used > maxUsed) {
+        maxUsed = used;
+        profileId = id;
+      }
+    }
+    if (!db.profiles[profileId] || db.profiles[profileId].date !== getTodayString()) {
+      db.profiles[profileId] = { date: getTodayString(), usedSeconds: maxUsed > 0 ? maxUsed : 0, lastSeen: Date.now() };
+    } else {
+      db.profiles[profileId].lastSeen = Date.now();
+    }
+  }
+
+  // اتصال هر سه لایه به همین پروفایل واحد
+  if (db.ipIndex[safeIp] !== profileId) { db.ipIndex[safeIp] = profileId; markDirty(); }
+  if (safeFp && db.fpIndex[safeFp] !== profileId) { db.fpIndex[safeFp] = profileId; markDirty(); }
+  if (safeSid && db.sidIndex[safeSid] !== profileId) { db.sidIndex[safeSid] = profileId; markDirty(); }
+
+  return profileId;
+}
+
+function getRemainingSeconds(ip, fp, sid) {
+  const profileId = resolveProfileId(ip, fp, sid);
+  const used = getUsedSecondsToday(profileId);
+  return Math.max(0, DAILY_LIMIT_SECONDS - used);
+}
+
+function addUsageSeconds(ip, fp, sid, seconds) {
+  const profileId = resolveProfileId(ip, fp, sid);
+  const today = getTodayString();
+  if (!db.profiles[profileId] || db.profiles[profileId].date !== today) {
+    db.profiles[profileId] = { date: today, usedSeconds: 0, lastSeen: Date.now() };
+  }
+  db.profiles[profileId].usedSeconds += seconds;
+  db.profiles[profileId].lastSeen = Date.now();
+  markDirty();
+  return Math.max(0, DAILY_LIMIT_SECONDS - db.profiles[profileId].usedSeconds);
+}
+
+// ---------- پاکسازی خودکار رکوردهای قدیمی‌تر از ۲۴ ساعت ----------
+// چون محدودیت، «روزانه» است، هیچ نیازی نیست اطلاعات کاربری که بیش از ۲۴
+// ساعت است سراغش نیامده در فایل sotifree.db نگه داشته شود. این تابع به‌طور
+// دوره‌ای هر پروفایلی که در ۲۴ ساعت اخیر هیچ فعالیتی نداشته را، به همراه
+// تمام ایندکس‌های (IP/fingerprint/sid) متصل به آن، کامل از فایل حذف می‌کند.
+const TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1000;
+
+function cleanupOldData() {
+  const cutoff = Date.now() - TWENTY_FOUR_HOURS_MS;
+  const staleProfileIds = new Set();
+
+  for (const profileId of Object.keys(db.profiles)) {
+    const profile = db.profiles[profileId];
+    const lastSeen = typeof profile.lastSeen === 'number' ? profile.lastSeen : 0;
+    if (lastSeen < cutoff) {
+      staleProfileIds.add(profileId);
+    }
+  }
+
+  if (staleProfileIds.size === 0) return;
+
+  for (const profileId of staleProfileIds) {
+    delete db.profiles[profileId];
+  }
+  for (const key of Object.keys(db.ipIndex)) {
+    if (staleProfileIds.has(db.ipIndex[key])) delete db.ipIndex[key];
+  }
+  for (const key of Object.keys(db.fpIndex)) {
+    if (staleProfileIds.has(db.fpIndex[key])) delete db.fpIndex[key];
+  }
+  for (const key of Object.keys(db.sidIndex)) {
+    if (staleProfileIds.has(db.sidIndex[key])) delete db.sidIndex[key];
+  }
+
+  markDirty();
+  flushDbToDisk();
+  console.log(`🧹 پاکسازی خودکار: ${staleProfileIds.size} رکورد کاربر که بیش از ۲۴ ساعت بی‌استفاده بودند، از فایل ${USAGE_FILE} حذف شدند.`);
+}
+
+// یک‌بار در لحظه بالا آمدن سرور، و از آن به بعد هر یک ساعت یک‌بار اجرا می‌شود
+cleanupOldData();
+const CLEANUP_INTERVAL_MS = 60 * 60 * 1000; // هر ۱ ساعت
+setInterval(cleanupOldData, CLEANUP_INTERVAL_MS);
+// ================================================================================
+
+// افزایش محدودیت‌ها برای جلوگیری از خطای هدر در درخواست‌های سنگین
+const server = http.createServer({
+    maxHeaderSize: 16384 // 16KB
+}, app);
+
+const wss = new WebSocketServer({ 
+    server,
+    clientTracking: true, // برای مدیریت هارت‌بیت و بستن اتصالات مرده
+    perMessageDeflate: false // غیرفعال کردن فشرده‌سازی برای کاهش بار CPU و حافظه
+});
+
+// --- بخش مدیریت تنظیمات شخصیت‌ها ---
+const instructionSecretNames = {
+  default: 'PERSONALITY_DEFAULT',
+  teacher: 'PERSONALITY_TEACHER',
+  poetic: 'PERSONALITY_POETIC',
+  funny: 'PERSONALITY_FUNNY',
+};
+
+const personalityInstructions = {};
+console.log('🔄 در حال خواندن دستورالعمل‌های شخصیت از Secrets...');
+Object.keys(instructionSecretNames).forEach(key => {
+  const secretName = instructionSecretNames[key];
+  const instruction = process.env[secretName];
+  if (instruction) {
+    personalityInstructions[key] = instruction;
+  } else {
+    personalityInstructions[key] = `دستورالعمل '${key}' یافت نشد.`;
+  }
+});
+
+// --- بخش مدیریت کلیدهای API (Random Selection) ---
+const apiKeysEnv = process.env.ALL_GEMINI_API_KEYS;
+// تبدیل رشته کلیدها به آرایه و حذف فاصله‌های اضافی
+const apiKeys = apiKeysEnv ? apiKeysEnv.split(',').map(key => key.trim()).filter(key => key) : [];
+
+if (apiKeys.length === 0) {
+  console.error('🔴 خطای حیاتی: هیچ کلید API یافت نشد! لطفا متغیر ALL_GEMINI_API_KEYS را تنظیم کنید.');
+  process.exit(1);
+}
+console.log(`🚀 سرور با ${apiKeys.length} کلید API آماده‌سازی شد. (حالت انتخاب تصادفی)`);
+
+// --- مکانیزم Heartbeat برای جلوگیری از قطعی و هنگ کردن سرور ---
+// این تابع هر ۳۰ ثانیه اتصالات مرده را پاک می‌کند تا حافظه آزاد شود
+function heartbeat() {
+  this.isAlive = true;
+}
+
+const interval = setInterval(function ping() {
+  wss.clients.forEach(function each(ws) {
+    if (ws.isAlive === false) {
+        // اگر کلاینت پاسخ نداد، اتصال را قطع کن تا حافظه آزاد شود
+        return ws.terminate();
+    }
+    
+    ws.isAlive = false;
+    ws.ping();
+  });
+}, 30000);
+
+wss.on('close', function close() {
+  clearInterval(interval);
+});
+
+// --- توابع اتصال به گوگل ---
+
+/**
+ * اتصال سوکت کلاینت و سوکت جمینای را به هم متصل می‌کند
+ */
+function attachGeminiEventHandlers(clientWs, geminiWs, apiKeyUsed) {
+  // انتقال پیام از گوگل به کلاینت
+  geminiWs.on('message', (data) => {
+    if (clientWs.readyState === WebSocket.OPEN) {
+        clientWs.send(data, { binary: true });
+    }
+  });
+
+  geminiWs.on('error', (error) => {
+    console.error(`🔴 خطای جمینای (کلید ...${apiKeyUsed.slice(-4)}):`, error.message);
+    // در صورت خطا، سوکت کلاینت را نمی‌بندیم تا شاید بتواند دوباره تلاش کند، 
+    // اما معمولا کلاینت خودش قطع می‌شود.
+    if (clientWs.readyState === WebSocket.OPEN) clientWs.close();
+  });
+
+  geminiWs.on('close', (code) => {
+    if (clientWs.readyState === WebSocket.OPEN) clientWs.close();
+  });
+  
+  geminiWs.on('ping', () => {
+      try { geminiWs.pong(); } catch (e) {}
+  });
+}
+
+/**
+ * تلاش برای اتصال به جمینای با انتخاب تصادفی و امتحان مجدد
+ * @param {WebSocket} clientWs سوکت کاربر
+ * @param {Object} setupData داده‌های اولیه (کانفیگ)
+ * @param {Number} startIndex ایندکس شروع (که به صورت تصادفی انتخاب شده)
+ * @param {Number} attemptCount شمارنده تلاش‌ها
+ */
+async function tryConnectToGemini(clientWs, setupData, startIndex, attemptCount = 0) {
+  // اگر کلاینت در حین تلاش قطع شد، ادامه نده (جلوگیری از لیک حافظه)
+  if (clientWs.readyState !== WebSocket.OPEN) return null;
+
+  // اگر تمام کلیدها تست شدند و هیچکدام کار نکرد
+  if (attemptCount >= apiKeys.length) {
+    console.error(`⛔ تمام ${apiKeys.length} کلید API با شکست مواجه شدند.`);
+    if (clientWs.readyState === WebSocket.OPEN) {
+        clientWs.send(JSON.stringify({ error: "سرویس موقتاً در دسترس نیست (ظرفیت تکمیل)." }));
+        clientWs.close();
+    }
+    return null;
+  }
+
+  // منطق انتخاب کلید:
+  // بار اول: ایندکس کاملا تصادفی (startIndex)
+  // دفعات بعد (در صورت خطا): کلید بعدی در لیست به صورت چرخشی
+  const keyIndexToTry = (startIndex + attemptCount) % apiKeys.length;
+  const apiKey = apiKeys[keyIndexToTry];
+  
+  const url = `wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1alpha.GenerativeService.BidiGenerateContent?key=${apiKey}`;
+
+  return new Promise((resolve) => {
+    const geminiWs = new WebSocket(url);
+    
+    // تایم‌اوت سخت: اگر گوگل تا ۸ ثانیه هیچ پاسخی نداد (هنگ کرد)، برو کلید بعدی
+    const timeout = setTimeout(() => {
+      console.warn(`⏳ تایم‌اوت اتصال (کلید ...${apiKey.slice(-4)}). رفتن به کلید بعدی...`);
+      geminiWs.terminate(); 
+      resolve(tryConnectToGemini(clientWs, setupData, startIndex, attemptCount + 1));
+    }, 8000);
+
+    geminiWs.on('open', () => {
+      clearTimeout(timeout);
+      
+      if (clientWs.readyState !== WebSocket.OPEN) {
+          geminiWs.close();
+          return resolve(null);
+      }
+      
+      console.log(`🔗 اتصال موفق با کلید شماره ${keyIndexToTry} (تلاش ${attemptCount + 1})`);
+      
+      try {
+        geminiWs.send(JSON.stringify(setupData));
+        attachGeminiEventHandlers(clientWs, geminiWs, apiKey);
+        resolve(geminiWs);
+      } catch (e) {
+        console.error("خطا در ارسال تنظیمات اولیه:", e);
+        geminiWs.close();
+        resolve(tryConnectToGemini(clientWs, setupData, startIndex, attemptCount + 1));
+      }
+    });
+
+    geminiWs.on('error', (err) => {
+      clearTimeout(timeout);
+      console.warn(`⚠️ خطای اتصال (کلید ...${apiKey.slice(-4)}): ${err.message || 'Unknown'}. تلاش با کلید بعدی...`);
+      // فراخوانی بازگشتی برای تست کلید بعدی
+      resolve(tryConnectToGemini(clientWs, setupData, startIndex, attemptCount + 1));
+    });
+  });
+}
+
+// --- سرو کردن فایل‌های استاتیک ---
+app.use(express.static(path.join(__dirname, '../build')));
+
+// API Endpoint دستورالعمل‌ها
+app.get('/api/instructions', (req, res) => {
+    res.setHeader('Cache-Control', 'no-store'); 
+    res.json(personalityInstructions);
+});
+
+// API Endpoint استعلام زمان باقیمانده رایگان روزانه (سه لایه: IP + fingerprint + شناسه حافظه مرورگر)
+app.get('/api/usage', (req, res) => {
+    res.setHeader('Cache-Control', 'no-store');
+    const ip = getClientIp(req);
+    const fp = req.query.fp;
+    const sid = req.query.sid;
+    const remainingSeconds = getRemainingSeconds(ip, fp, sid);
+    res.json({ remainingSeconds, limitSeconds: DAILY_LIMIT_SECONDS });
+});
+
+// --- مدیریت WebSocket کلاینت ---
+wss.on('connection', (ws, req) => {
+  ws.isAlive = true;
+  ws.on('pong', heartbeat);
+
+  // --- شناسایی کاربر بر اساس سه لایه: IP + اثر انگشت مرورگر + شناسه حافظه مرورگر ---
+  const ip = getClientIp(req);
+  let fp = null;
+  let sid = null;
+  try {
+    const parsedUrl = new URL(req.url, 'http://localhost');
+    fp = parsedUrl.searchParams.get('fp');
+    sid = parsedUrl.searchParams.get('sid');
+  } catch (e) {
+    fp = null;
+    sid = null;
+  }
+
+  // اگر همین الان هم زمان کاربر برای امروز تمام شده، اصلا اجازه اتصال نده
+  if (getRemainingSeconds(ip, fp, sid) <= 0) {
+    try {
+      ws.send(JSON.stringify({ type: 'limitreached' }));
+    } catch (e) {}
+    ws.close(4001, 'DAILY_LIMIT_REACHED');
+    return;
+  }
+
+  // *تغییر اصلی:* انتخاب یک نقطه شروع کاملاً تصادفی برای هر کاربر
+  // این کار باعث می‌شود بار روی سرور پخش شود و نیاز به حافظه برای نگهداری نوبت نباشد.
+  const randomStartIndex = Math.floor(Math.random() * apiKeys.length);
+  
+  let geminiWs = null;
+  let isConnecting = false;
+  let usageIntervalRef = null;
+  let micActive = false; // آخرین وضعیتی که کلاینت اعلام کرده (مکالمه فعال است یا نه)
+  let lastActiveHeartbeatAt = 0; // زمان آخرین باری که کلاینت واقعا (با اجرای جاوااسکریپت) اعلام «هنوز فعالم» کرد
+  let lastRealtimeDataAt = 0; // زمان آخرین باری که داده صوتی/تصویری واقعی از کلاینت دریافت شد
+  let heartbeatWatchdogRef = null;
+
+  // حداکثر فاصله مجاز بین دو هارتبیت متوالی کلاینت. کلاینت هر ۵ ثانیه یک بار
+  // این سیگنال را می‌فرستد؛ اگر تا ۱۵ ثانیه (سه برابر فاصله عادی، برای
+  // اطمینان از نوسانات طبیعی شبکه) هیچ هارتبیت جدیدی نرسد، یعنی به احتمال
+  // زیاد صفحه/برنامه به پس‌زمینه رفته و جاوااسکریپتش متوقف شده. در این حالت
+  // شمارش زمان به‌طور خودکار متوقف می‌شود تا اعتبار کاربر در پس‌زمینه هدر نرود.
+  const HEARTBEAT_TIMEOUT_MS = 15000;
+
+  function stopUsageTracking() {
+    if (usageIntervalRef) {
+      clearInterval(usageIntervalRef);
+      usageIntervalRef = null;
+    }
+  }
+
+  function forceCloseForLimit() {
+    stopUsageTracking();
+    try {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'limitreached' }));
+        ws.close(4001, 'DAILY_LIMIT_REACHED');
+      }
+    } catch (e) {}
+    if (geminiWs) {
+      try { geminiWs.terminate(); } catch (e) {}
+      geminiWs = null;
+    }
+  }
+
+  // این شمارنده هر ثانیه یک ثانیه از سهمیه واقعی کاربر روی سرور (در حافظه) کم می‌کند
+  // و مقدار باقیمانده را برای همگام‌سازی نمایش تایمر به کلاینت ارسال می‌کند.
+  // ذخیره‌سازی روی دیسک/باکت هر ۳۰ ثانیه یک‌بار انجام می‌شود (نه هر ثانیه)، اما شمارش
+  // و اعمال محدودیت همیشه لحظه‌به‌لحظه و سمت سرور است، پس قابل دور زدن نیست.
+  //
+  // *مهم - تضمین اتمی*: این شمارنده فقط زمانی واقعا اعتبار کم می‌کند که در
+  // ۱۰ ثانیه اخیر داده صوتی/تصویری واقعی از کلاینت دریافت شده باشد (یا در
+  // ۱۰ ثانیه اول بعد از شروع، به‌عنوان فرصت راه‌اندازی). این یعنی شمارش به
+  // «وجود واقعی و قابل‌اثبات جریان مکالمه» گره خورده، نه صرفا یک پرچم که
+  // ممکن است به هر دلیلی (باگ، پیام گم‌شده، تاخیر شبکه) اشتباه بماند. اگر
+  // داده صوتی واقعی قطع شود، شمارش خودش و بدون نیاز به هیچ پیام دیگری متوقف می‌شود.
+  const REALTIME_DATA_TIMEOUT_MS = 10000;
+
+  function startUsageTracking() {
+    if (usageIntervalRef) return;
+    const trackingStartedAt = Date.now();
+    usageIntervalRef = setInterval(() => {
+      const hasRecentRealtimeData = lastRealtimeDataAt > 0 && (Date.now() - lastRealtimeDataAt) < REALTIME_DATA_TIMEOUT_MS;
+      const withinStartupGrace = (Date.now() - trackingStartedAt) < REALTIME_DATA_TIMEOUT_MS;
+      if (!hasRecentRealtimeData && !withinStartupGrace) {
+        // مدتی است هیچ داده صوتی/تصویری واقعی‌ای دریافت نشده؛ یعنی عملا
+        // مکالمه‌ای در جریان نیست، پس شمارش را قطعا متوقف کن
+        micActive = false;
+        stopUsageTracking();
+        return;
+      }
+      const remaining = addUsageSeconds(ip, fp, sid, 1);
+      if (ws.readyState === WebSocket.OPEN) {
+        try {
+          ws.send(JSON.stringify({ type: 'usage', remainingSeconds: remaining, limitSeconds: DAILY_LIMIT_SECONDS }));
+        } catch (e) {}
+      }
+      if (remaining <= 0) {
+        forceCloseForLimit();
+      }
+    }, 1000);
+  }
+
+  // این تابع وضعیت واقعی شمارش زمان را با «آخرین سیگنالی که کلاینت فرستاده» و
+  // «وضعیت فعلی اتصال به Gemini» هماهنگ می‌کند. چون اتصال به Gemini کمی طول
+  // می‌کشد، ممکن است سیگنال «مکالمه فعال است» کمی زودتر از برقرار شدن اتصال
+  // برسد؛ این تابع تضمین می‌کند در آن حالت هم به‌محض آماده شدن اتصال، شمارش
+  // به‌درستی شروع شود.
+  function syncUsageTracking() {
+    if (micActive && geminiWs && getRemainingSeconds(ip, fp, sid) > 0) {
+      startUsageTracking();
+    } else {
+      stopUsageTracking();
+    }
+  }
+
+  // *نگهبان هارتبیت*: صرفِ باز بودن اتصال WebSocket (که با پینگ/پونگ خودکار
+  // مرورگر حتی در پس‌زمینه هم زنده نشان داده می‌شود) دلیل کافی برای «در حال
+  // مکالمه بودن» ن��ست. این نگهبان هر ۵ ثانیه بررسی می‌کند که آیا هارتبیت
+  // واقعی و تازه‌ای (که فقط با اجرای جاوااسکریپت صفحه ارسال می‌شود) از کلاینت
+  // رسیده یا نه؛ اگر نرسیده باشد، شمارش را متوقف می‌کند.
+  heartbeatWatchdogRef = setInterval(() => {
+    if (micActive && lastActiveHeartbeatAt > 0 && (Date.now() - lastActiveHeartbeatAt) > HEARTBEAT_TIMEOUT_MS) {
+      micActive = false;
+      stopUsageTracking();
+    }
+  }, 5000);
+
+  ws.on('message', async (message) => {
+    try {
+      // بررسی مجدد قبل از پردازش هر پیام، برای جلوگیری از سوءاستفاده در لحظه آخر
+      if (getRemainingSeconds(ip, fp, sid) <= 0) {
+        forceCloseForLimit();
+        return;
+      }
+
+      if (!Buffer.isBuffer(message) || message[0] === 123) { 
+        const msgStr = message.toString();
+        if (msgStr.startsWith('{')) {
+            const data = JSON.parse(msgStr);
+            if (data.setup) {
+                if (isConnecting || geminiWs) return; 
+                isConnecting = true;
+                // ارسال ایندکس تصادفی به تابع اتصال
+                geminiWs = await tryConnectToGemini(ws, data, randomStartIndex);
+                isConnecting = false;
+                if (geminiWs) {
+                    // اگر کلاینت از قبل (حتی چند لحظه زودتر) اعلام کرده بود که
+                    // مکالمه فعال است، همین الان که اتصال واقعا برقرار شد شمارش شروع می‌شود.
+                    syncUsageTracking();
+                    if (ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({ type: 'usage', remainingSeconds: getRemainingSeconds(ip, fp, sid), limitSeconds: DAILY_LIMIT_SECONDS }));
+                    }
+                }
+                return;
+            }
+
+            if (data.type === 'usage_control') {
+                // کلاینت دقیقا اعلام می‌کند که مکالمه الان فعال است یا نه.
+                // شمارش زمان فقط و فقط بر اساس همین سیگنال شروع یا متوقف می‌شود،
+                // نه صرفا باز بودن اتصال. به همین دلیل با قطع مکالمه (حتی اگر
+                // اتصال WebSocket برای اتصال سریع‌تر دفعه بعد باز بماند)، دیگر
+                // چیزی از اعتبار کاربر کم نمی‌شود.
+                micActive = data.active === true;
+                if (micActive) {
+                    lastActiveHeartbeatAt = Date.now();
+                }
+                syncUsageTracking();
+                if (micActive && ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({ type: 'usage', remainingSeconds: getRemainingSeconds(ip, fp, sid), limitSeconds: DAILY_LIMIT_SECONDS }));
+                }
+                return;
+            }
+        }
+      }
+      
+      if (geminiWs && geminiWs.readyState === WebSocket.OPEN) {
+        // این دقیقا لحظه‌ای است که داده صوتی/تصویری واقعی از کلاینت به سمت
+        // Gemini فوروارد می‌شود؛ یعنی مکالمه واقعا در جریان است.
+        lastRealtimeDataAt = Date.now();
+        geminiWs.send(message);
+      }
+    } catch (e) {
+      console.error("خطا در پردازش پیام کلاینت:", e.message);
+    }
+  });
+
+  ws.on('close', () => {
+    stopUsageTracking();
+    if (heartbeatWatchdogRef) { clearInterval(heartbeatWatchdogRef); heartbeatWatchdogRef = null; }
+    flushDbToDisk(); // ذخیره فوری روی دیسک/باکت در پایان هر تماس، برای اطمینان بیشتر
+    if (geminiWs) {
+        // بستن اجباری اتصال گوگل برای آزادسازی منابع
+        try {
+            geminiWs.terminate(); 
+        } catch(e) {}
+        geminiWs = null;
+    }
+  });
+
+  ws.on('error', (error) => {
+    stopUsageTracking();
+    if (heartbeatWatchdogRef) { clearInterval(heartbeatWatchdogRef); heartbeatWatchdogRef = null; }
+    if (geminiWs) {
+        try { geminiWs.terminate(); } catch(e) {}
+        geminiWs = null;
+    }
+  });
+});
+
+// ارسال تمام درخواست‌های دیگر به React
+app.get('*', (req, res) => res.sendFile(path.join(__dirname, '../build', 'index.html')));
+
+const PORT = process.env.PORT || 3001;
+server.listen(PORT, () => console.log(`🚀 سرور (حالت تصادفی) روی پورت ${PORT} اجرا شد.`));