Upload 3 files

app.py

@@ -71,15 +71,57 @@ HEAD = """
     clearTimeout(window.__cvToast);window.__cvToast=setTimeout(()=>node.classList.remove('show'),2100);
   }
 
+  function syncTranslateLanguages(){
+    const nativeSelect=document.querySelector('#google_translate_element select.goog-te-combo');
+    const customSelect=document.getElementById('cv-language-select');
+    if(!nativeSelect || !customSelect) return false;
+    if(customSelect.options.length<=1){
+      [...nativeSelect.options].forEach((option,index)=>{
+        if(index===0 || !option.value) return;
+        const clone=document.createElement('option');
+        clone.value=option.value;
+        clone.textContent=option.textContent;
+        customSelect.appendChild(clone);
+      });
+    }
+    return customSelect.options.length>1;
+  }
+
+  window.cloudVaultGoogleTranslateInit=function(){
+    new google.translate.TranslateElement({
+      pageLanguage:'en',
+      autoDisplay:false,
+      includedLanguages:''
+    },'google_translate_element');
+    let attempts=0;
+    const timer=setInterval(()=>{
+      attempts++;
+      if(syncTranslateLanguages() || attempts>40) clearInterval(timer);
+    },250);
+  };
+
+  document.addEventListener('change',(event)=>{
+    const customSelect=event.target.closest('#cv-language-select');
+    if(!customSelect || !customSelect.value) return;
+    const nativeSelect=document.querySelector('#google_translate_element select.goog-te-combo');
+    if(nativeSelect){
+      nativeSelect.value=customSelect.value;
+      nativeSelect.dispatchEvent(new Event('change',{bubbles:true}));
+      document.getElementById('cv-translate-panel')?.classList.remove('open');
+    }
+  });
+
   document.addEventListener('click', async (event)=>{
     const translate=event.target.closest('[data-cloudvault-translate]');
     if(translate){
       event.preventDefault();
-      const current=window.location.href;
-      const target='https://translate.google.com/translate?sl=auto&tl=en&u='+encodeURIComponent(current);
-      window.open(target,'_blank','noopener,noreferrer');
+      syncTranslateLanguages();
+      document.getElementById('cv-translate-panel')?.classList.toggle('open');
       return;
     }
+    if(!event.target.closest('.cloudvault-translate-wrap')){
+      document.getElementById('cv-translate-panel')?.classList.remove('open');
+    }
     const copy=event.target.closest('[data-copy-token]');
     if(copy){
       const link=location.origin+DOWNLOAD_BASE+encodeURIComponent(copy.dataset.copyToken);
@@ -105,6 +147,47 @@ memory_lock = threading.RLock()
 memory_auto_paused = False
 last_memory_gb = 0.0
 
+active_users_lock = threading.RLock()
+active_users_seen: dict[str, float] = {}
+
+
+def active_users_heartbeat(user_id: str | None):
+    """Refresh the live-user count every 3 seconds.
+
+    A user is treated as active while their browser keeps sending heartbeats.
+    Entries older than 7 seconds are removed to tolerate normal timer jitter.
+    """
+    now = time.monotonic()
+    with active_users_lock:
+        if user_id and STORE.get_user(user_id):
+            active_users_seen[user_id] = now
+        stale = [uid for uid, seen_at in active_users_seen.items() if now - seen_at > 7.0]
+        for uid in stale:
+            active_users_seen.pop(uid, None)
+        count = len(active_users_seen)
+
+    is_admin = bool(user_id and STORE.is_admin(user_id))
+    if not is_admin:
+        return gr.update(value="", visible=False)
+
+    return gr.update(
+        value=(
+            '<section class="live-users-card cv-card">'
+            '<div class="live-users-pulse"><i></i><span>LIVE USERS</span></div>'
+            f'<strong>{count}</strong>'
+            f'<p>{count} active user{"s" if count != 1 else ""} · refreshed every 3 seconds</p>'
+            '</section>'
+        ),
+        visible=True,
+    )
+
+
+def remove_active_user(user_id: str | None):
+    with active_users_lock:
+        if user_id:
+            active_users_seen.pop(user_id, None)
+
+
 
 def _memory_used_gb() -> float:
     candidates = [
@@ -341,25 +424,13 @@ def chat_room_controls(user_id: str | None):
     user = STORE.get_user(user_id)
     if not user or not PLANS[user.get("plan", "free")].chat_access:
         return gr.update(choices=[], value=None, visible=False, interactive=False), ""
-    state = STORE.chat_room_state(user["id"])
-    rooms = state.get("rooms", [])
-    room_map = {room["id"]: room for room in rooms}
-    current = state.get("current")
-    current_room = room_map.get(current, {})
-    multi_visible = state.get("mode") == "multi" and len(rooms) > 1
-    choices = [
-        (f"{'⏸️' if room.get('paused') else '🌐'} {room.get('name')} · {room.get('members', 0)}/{state.get('capacity', 0)} users", room["id"])
-        for room in rooms
-    ]
-    can_choose = bool(state.get("can_choose"))
-    assignment_text = (
-        "You can choose any available room." if can_choose
-        else "Plus accounts are assigned automatically to an available room."
+    info = (
+        '<div class="room-status cv-card single-room">'
+        '<div><span>🌐 GLOBAL CHAT</span><h3>One shared room</h3>'
+        '<p>All Plus, Pro and developer accounts chat together in the same room.</p></div>'
+        '<div class="room-counter"><b>1</b><small>room</small></div></div>'
     )
-    if state.get("mode") == "single":
-        assignment_text = "Single-room mode is active. Everyone speaks in Global 1."
-    info = f'''<div class="room-status cv-card"><div><span>🌐 CURRENT CHAT ROOM</span><h3>{html.escape(str(current_room.get('name', 'Global 1')))}</h3><p>{html.escape(assignment_text)}</p></div><div class="room-counter"><b>{int(current_room.get('messages', 0))}/200</b><small>messages kept</small></div></div>'''
-    return gr.update(choices=choices, value=current, visible=multi_visible, interactive=can_choose), info
+    return gr.update(choices=[("Global Chat", "global-1")], value="global-1", visible=False, interactive=False), info
 
 
 def chat_html(user_id: str | None, room_id: str | None = None) -> tuple[str, str]:
@@ -379,10 +450,10 @@ def chat_html(user_id: str | None, room_id: str | None = None) -> tuple[str, str
         return '<div class="chat-paused cv-card"><span>⏸️</span><h3>Global Chat is paused for Plus accounts</h3></div>', "Plus Chat paused"
     if user.get("role") != "admin" and user.get("plan") == "pro" and not cfg.get("pro_chat_enabled", True):
         return '<div class="chat-paused cv-card"><span>⏸️</span><h3>Global Chat is paused for Pro accounts</h3></div>', "Pro Chat paused"
+    selected = "global-1"
     state = STORE.chat_room_state(user["id"])
     valid_rooms = {room["id"]: room for room in state.get("rooms", [])}
-    selected = room_id if room_id in valid_rooms and state.get("can_choose") else state.get("current")
-    room = valid_rooms.get(selected, {"name": "Global 1", "paused": False})
+    room = valid_rooms.get("global-1", {"name": "Global Chat", "paused": False})
     if room.get("paused") and user.get("role") != "admin":
         return f'<div class="chat-paused cv-card"><span>⏸️</span><h3>{html.escape(str(room.get("name", "Room")))} is paused</h3><p>The developer paused writing in this room.</p></div>', "Room paused by developer."
     messages = STORE.chat_messages(user["id"], selected)
@@ -399,8 +470,8 @@ def chat_html(user_id: str | None, room_id: str | None = None) -> tuple[str, str
             clock = created.astimezone(timezone.utc).strftime("%H:%M") if created else ""
             blocks.append(f'<div class="chat-line {"mine" if mine else "theirs"}"><div class="chat-bubble {tier}"><div class="chat-name">{sender}<span>{clock}</span></div><p>{text}</p></div></div>')
         body = "".join(blocks)
-    room_name = html.escape(str(room.get("name", "Global 1")))
-    status = f"{room_name} · {len(messages)}/200 messages · {memory_gb:.2f} GB memory"
+    room_name = "Global Chat"
+    status = f"{room_name} · {len(messages)} visible messages"
     return f'<div class="chat-shell"><div class="chat-top"><div><span class="online-dot"></span><b>{room_name}</b><small>{"Up to 400 messages are visible for Pro" if plan.key in {"pro", "admin"} else "Up to 200 messages are visible for Plus"}</small></div><em>3s cooldown · 1000 characters</em></div><div class="chat-stream">{body}</div></div>', status
 
 
@@ -415,7 +486,7 @@ def send_chat_message(text: str, user_id: str | None, room_id: str | None):
         messages, status = chat_html(user_id, room_id)
         return "❌ Global Chat is currently paused.", text, messages, status, room_update, room_info
     try:
-        STORE.send_chat(user_id, text, room_id)
+        STORE.send_chat(user_id, text, "global-1")
         room_update, room_info = chat_room_controls(user_id)
         messages, status = chat_html(user_id, room_id)
         return "✅ Message accepted. It will appear in 2 seconds.", "", messages, status, room_update, room_info
@@ -442,26 +513,34 @@ def change_chat_room_ui(room_id: str | None, user_id: str | None):
 
 def developer_room_data(admin_id: str | None):
     if not admin_id or not STORE.is_admin(admin_id):
-        return gr.update(value="single"), gr.update(value=200), gr.update(choices=[], value=None), ""
+        return gr.update(value="single"), gr.update(value=0), gr.update(choices=[], value=None), ""
     state = STORE.chat_room_state(admin_id)
-    choices = []
-    cards = []
-    for room in state.get("rooms", []):
-        label = f"{room.get('name')} · {room.get('members', 0)}/{state.get('capacity', 0)} users · {room.get('messages', 0)}/200 messages"
-        choices.append((label, room["id"]))
-        cards.append(f'''<article class="room-admin-card {'paused' if room.get('paused') else ''}"><span>{'⏸️' if room.get('paused') else '🌐'}</span><div><h4>{html.escape(str(room.get('name')))}</h4><p>{int(room.get('members',0))}/{int(state.get('capacity',0))} assigned users · {int(room.get('messages',0))}/200 messages</p></div><b>{'PAUSED' if room.get('paused') else 'LIVE'}</b></article>''')
-    overview = '<div class="room-admin-grid">'+''.join(cards)+'</div>' if cards else '<div class="empty-state cv-card"><h3>No chat rooms</h3></div>'
-    values = [value for _, value in choices]
-    selected = state.get("current") if state.get("current") in values else (values[0] if values else None)
-    return gr.update(value=state.get("mode", "single")), gr.update(value=state.get("capacity", 200)), gr.update(choices=choices, value=selected), overview
+    room = next(iter(state.get("rooms", [])), {"id": "global-1", "messages": 0, "paused": False})
+    overview = (
+        '<div class="room-admin-grid"><article class="room-admin-card '
+        + ('paused' if room.get("paused") else '')
+        + '"><span>'
+        + ('⏸️' if room.get("paused") else '🌐')
+        + '</span><div><h4>Global Chat</h4><p>One shared room · '
+        + str(int(room.get("messages", 0)))
+        + ' stored messages</p></div><b>'
+        + ('PAUSED' if room.get("paused") else 'LIVE')
+        + '</b></article></div>'
+    )
+    return (
+        gr.update(value="single"),
+        gr.update(value=0),
+        gr.update(choices=[("Global Chat", "global-1")], value="global-1"),
+        overview,
+    )
 
 
 def apply_chat_room_configuration(mode: str, capacity: float, admin_id: str | None):
     try:
         if not admin_id:
             raise PermissionError("Developer access required.")
-        STORE.set_chat_configuration(admin_id, mode, int(capacity))
-        status = "✅ Global Chat room configuration updated."
+        STORE.set_chat_configuration(admin_id, "single", 0)
+        status = "✅ Global Chat uses one shared room."
     except Exception as exc:
         status = f"❌ {exc}"
     return status, *developer_room_data(admin_id), *chat_room_controls(admin_id)
@@ -681,7 +760,19 @@ with gr.Blocks(title="CloudVault", fill_width=True) as demo:
     with gr.Row(elem_classes="navbar"):
         gr.HTML('<div class="brand"><span>☁️</span><div><b>CloudVault</b><small>Secure file command center</small></div><em>LIVE</em></div>')
         gr.HTML('<div class="nav-space"></div>')
-        gr.HTML('<a class="cloudvault-translate-btn" href="https://translate.google.com/" target="_blank" rel="noopener noreferrer" data-cloudvault-translate title="Open this page in Google Translate and choose any supported language"><span>🌐</span><b>Translate</b><small>All Google languages</small></a>')
+        gr.HTML('''<div class="cloudvault-translate-wrap">
+          <button type="button" class="cloudvault-translate-btn" data-cloudvault-translate aria-expanded="false">
+            <span>🌐</span><b>Translate</b><small>Choose language</small>
+          </button>
+          <div id="cv-translate-panel" class="cv-translate-panel">
+            <div class="cv-translate-title"><span>🌍</span><div><b>Select language</b><small>Google Translate supported languages</small></div></div>
+            <select id="cv-language-select" aria-label="Choose translation language">
+              <option value="">Choose a language…</option>
+            </select>
+            <div id="google_translate_element" class="cv-native-translate"></div>
+          </div>
+        </div>
+        <script src="https://translate.google.com/translate_a/element.js?cb=cloudVaultGoogleTranslateInit"></script>''')
         home_btn = gr.Button("🏠 Home", variant="primary", elem_classes="nav-btn")
         dashboard_top_btn = gr.Button("⚡ Dashboard", elem_classes="nav-btn")
         login_top_btn = gr.Button("🔐 Login", elem_classes="nav-btn")
@@ -744,9 +835,9 @@ with gr.Blocks(title="CloudVault", fill_width=True) as demo:
             with gr.Column(scale=2, min_width=245, elem_classes="sidebar"):
                 sidebar_profile = gr.HTML()
                 storage_nav = gr.Button("☁️  Storage\nFiles and uploads", variant="primary", elem_classes="side-btn")
-                analytics_nav = gr.Button("📊  Analytics\nCountries and devices", elem_classes="side-btn")
-                settings_nav = gr.Button("⚙️  Settings\nPackage and account", elem_classes="side-btn")
-                chat_nav = gr.Button("💬  Global Chat\nPlus and Pro only", visible=False, elem_classes="side-btn")
+                analytics_nav = gr.Button("📊  Analytics", elem_classes="side-btn")
+                settings_nav = gr.Button("⚙️  Settings", elem_classes="side-btn")
+                chat_nav = gr.Button("💬  Global Chat", visible=False, elem_classes="side-btn")
                 developer_nav = gr.Button("👑  Developer Analytics\nAdmin controls", visible=False, elem_classes="side-btn developer")
                 change_plan_btn = gr.Button("💳 Change Package", elem_classes="side-btn")
                 logout_btn = gr.Button("🚪 Log Out", elem_classes="side-btn danger")
@@ -800,6 +891,7 @@ with gr.Blocks(title="CloudVault", fill_width=True) as demo:
                 developer_panel = gr.Column(visible=False)
                 with developer_panel:
                     developer_header = gr.HTML()
+                    active_users_html = gr.HTML(visible=False)
                     developer_system_status = gr.HTML()
                     with gr.Column(elem_classes="admin-card cv-card"):
                         gr.HTML('<div class="panel-heading"><div><span>👥 ACCOUNT CONTROL</span><h3>Ban, unban or delete an account</h3><p>Usernames and package details are visible. Passwords are never shown.</p></div></div>')
@@ -823,17 +915,16 @@ with gr.Blocks(title="CloudVault", fill_width=True) as demo:
                             clear_chat_btn = gr.Button("🧹 Clear Chat")
                             cancel_shutdown_btn = gr.Button("♻️ Cancel Shutdown")
                     with gr.Column(elem_classes="admin-card room-control-card cv-card"):
-                        gr.HTML('<div class="panel-heading"><div><span>🌐 GLOBAL CHAT ROOMS</span><h3>Single room or automatic multi-room system</h3><p>Each room stores up to 400 messages. Plus sees the latest 200; Pro sees the latest 400 and can choose rooms.</p></div></div>')
-                        with gr.Row():
-                            admin_chat_mode = gr.Radio(label="Chat mode", choices=[("Single room", "single"), ("Multiple rooms", "multi")], value="single")
-                            admin_room_capacity = gr.Number(label="Maximum users per room", value=200, minimum=1, maximum=100000, precision=0)
-                        admin_apply_chat_rooms = gr.Button("💾 Apply Room Configuration", variant="primary")
-                        admin_room_select = gr.Dropdown(label="Select a room", choices=[])
-                        with gr.Row():
-                            admin_toggle_room_btn = gr.Button("⏯️ Start / Pause Selected Room")
-                            admin_clear_room_btn = gr.Button("🧹 Clear Selected Room", variant="stop")
+                        gr.HTML('<div class="panel-heading"><div><span>🌐 GLOBAL CHAT</span><h3>One shared room</h3><p>All eligible users use the same Global Chat room. There is no room capacity limit.</p></div></div>')
                         admin_rooms_html = gr.HTML()
+                        with gr.Row():
+                            admin_toggle_room_btn = gr.Button("⏯️ Start / Pause Global Chat Room")
+                            admin_clear_room_btn = gr.Button("🧹 Clear Global Chat Messages", variant="stop")
                         admin_room_action_status = gr.Markdown()
+                        admin_chat_mode = gr.Radio(choices=[("Single room", "single")], value="single", visible=False)
+                        admin_room_capacity = gr.Number(value=0, visible=False)
+                        admin_apply_chat_rooms = gr.Button("Apply", visible=False)
+                        admin_room_select = gr.Dropdown(choices=[("Global Chat", "global-1")], value="global-1", visible=False)
                     with gr.Column(elem_classes="admin-card destructive cv-card"):
                         gr.HTML('<div class="panel-heading"><div><span>🧨 DESTRUCTIVE ACTIONS</span><h3>Mass account and shutdown controls</h3><p>Use the exact confirmation phrase before pressing a button.</p></div></div>')
                         mass_confirm = gr.Textbox(label="Confirmation", placeholder="DELETE FREE, DELETE ALL or SHUTDOWN")
@@ -918,7 +1009,11 @@ with gr.Blocks(title="CloudVault", fill_width=True) as demo:
     chat_timer = gr.Timer(2.0, active=True)
     chat_timer.tick(chat_html, inputs=[session_user, chat_room_select], outputs=[chat_messages_html, chat_status_html], queue=False)
 
-    logout_btn.click(logout_user, outputs=[session_user, login_status, *navigation_outputs], queue=False)
+    active_users_timer = gr.Timer(3.0, active=True)
+    active_users_timer.tick(active_users_heartbeat, inputs=session_user, outputs=active_users_html, queue=False)
+
+    logout_click = logout_btn.click(remove_active_user, inputs=session_user, outputs=None, queue=False)
+    logout_click.then(logout_user, outputs=[session_user, login_status, *navigation_outputs], queue=False)
     delete_account_btn.click(delete_account, inputs=[delete_confirm, session_user], outputs=[session_user, account_status_md, *navigation_outputs], queue=False)
 
     def refresh_developer(admin_id):

core.py

@@ -317,7 +317,7 @@ class StateStore:
             "delete_paid_on_expiry": False,
             "shutdown_mode": False,
             "chat_mode": "single",
-            "chat_room_capacity": 200,
+            "chat_room_capacity": 0,
         }
         if not isinstance(self.state.get("users"), dict):
             self.state["users"] = {}; changed = True
@@ -334,22 +334,25 @@ class StateStore:
         for key, value in defaults.items():
             if key not in self.state["config"]:
                 self.state["config"][key] = value; changed = True
-        if self.state["config"].get("chat_mode") not in {"single", "multi"}:
+        # CloudVault uses exactly one unlimited Global Chat room.
+        if self.state["config"].get("chat_mode") != "single":
             self.state["config"]["chat_mode"] = "single"; changed = True
-        try:
-            capacity = int(self.state["config"].get("chat_room_capacity", 200))
-        except (TypeError, ValueError):
-            capacity = 200
-        capacity = max(1, min(capacity, 100000))
-        if self.state["config"].get("chat_room_capacity") != capacity:
-            self.state["config"]["chat_room_capacity"] = capacity; changed = True
+        if self.state["config"].get("chat_room_capacity") != 0:
+            self.state["config"]["chat_room_capacity"] = 0; changed = True
         if "global-1" not in self.state["chat_rooms"]:
             self.state["chat_rooms"]["global-1"] = {
                 "id": "global-1", "name": "Global 1", "paused": False, "created_at": iso()
             }
             changed = True
+        if set(self.state["chat_rooms"]) != {"global-1"}:
+            room1 = self.state["chat_rooms"].get("global-1", {
+                "id": "global-1", "name": "Global Chat", "paused": False, "created_at": iso()
+            })
+            room1["name"] = "Global Chat"
+            self.state["chat_rooms"] = {"global-1": room1}
+            changed = True
         for message in self.state["chat"]:
-            if not message.get("room_id"):
+            if message.get("room_id") != "global-1":
                 message["room_id"] = "global-1"; changed = True
         for user in self.state["users"].values():
             if "role" not in user:
@@ -360,22 +363,15 @@ class StateStore:
                 user["ban_until"] = None; changed = True
             if "delete_on_expiry" not in user:
                 user["delete_on_expiry"] = False; changed = True
-            if "chat_room_id" not in user:
+            if user.get("chat_room_id") != "global-1":
                 user["chat_room_id"] = "global-1"; changed = True
-        # Keep only the newest 400 messages per room.
-        kept: list[dict[str, Any]] = []
-        for room_id in list(self.state["chat_rooms"]):
-            room_messages = [m for m in self.state["chat"] if m.get("room_id", "global-1") == room_id]
-            kept.extend(room_messages[-200:])
-        orphaned = [m for m in self.state["chat"] if m.get("room_id", "global-1") not in self.state["chat_rooms"]]
-        if orphaned:
-            for message in orphaned:
-                message["room_id"] = "global-1"
-            kept.extend(orphaned[-200:])
-            changed = True
-        if len(kept) != len(self.state["chat"]):
+        # Keep only the newest 400 messages in the single Global Chat room.
+        normalized_chat = sorted(self.state["chat"], key=lambda m: m.get("created_at", ""))[-400:]
+        for message in normalized_chat:
+            message["room_id"] = "global-1"
+        if len(normalized_chat) != len(self.state["chat"]):
             changed = True
-        self.state["chat"] = sorted(kept, key=lambda m: m.get("created_at", ""))
+        self.state["chat"] = normalized_chat
         self.state["version"] = 4
         return changed
 
@@ -990,27 +986,24 @@ class StateStore:
             user = self.state["users"].get(user_id)
             if not self._chat_eligible_unlocked(user):
                 return {"mode": "single", "capacity": 0, "current": None, "can_choose": False, "rooms": []}
-            current_before = user.get("chat_room_id")
-            current = self._assign_room_unlocked(user_id)
-            if current_before != current:
-                self._save_unlocked("Assign CloudVault chat room")
-            rooms = []
-            for room_id, room in sorted(self.state["chat_rooms"].items(), key=lambda pair: self._room_sort_key_unlocked(pair[0])):
-                rooms.append({
-                    "id": room_id,
-                    "name": room.get("name", room_id),
-                    "paused": bool(room.get("paused", False)),
-                    "members": self._room_member_count_unlocked(room_id),
-                    "messages": sum(1 for m in self.state["chat"] if m.get("room_id", "global-1") == room_id),
-                })
-            mode = self.state["config"].get("chat_mode", "single")
-            can_choose = bool(mode == "multi" and len(rooms) > 1 and (user.get("role") == "admin" or user.get("plan") == "pro"))
+            user["chat_room_id"] = "global-1"
+            room = self.state["chat_rooms"].setdefault(
+                "global-1",
+                {"id": "global-1", "name": "Global Chat", "paused": False, "created_at": iso()},
+            )
+            room["name"] = "Global Chat"
             return {
-                "mode": mode,
-                "capacity": int(self.state["config"].get("chat_room_capacity", 200)),
-                "current": current,
-                "can_choose": can_choose,
-                "rooms": rooms,
+                "mode": "single",
+                "capacity": 0,
+                "current": "global-1",
+                "can_choose": False,
+                "rooms": [{
+                    "id": "global-1",
+                    "name": "Global Chat",
+                    "paused": bool(room.get("paused", False)),
+                    "members": self._room_member_count_unlocked("global-1"),
+                    "messages": len(self.state["chat"]),
+                }],
             }
 
     def change_chat_room(self, user_id: str, room_id: str) -> str:
@@ -1037,44 +1030,23 @@ class StateStore:
             return room_id
 
     def set_chat_configuration(self, admin_id: str, mode: str, capacity: int) -> dict[str, Any]:
-        mode = (mode or "single").strip().lower()
-        if mode not in {"single", "multi"}:
-            raise ValueError("Chat mode must be single or multi.")
-        try:
-            capacity = int(capacity)
-        except (TypeError, ValueError):
-            raise ValueError("Room capacity must be a whole number.")
-        capacity = max(1, min(capacity, 100000))
         with self.lock:
             self._assert_admin_unlocked(admin_id)
-            self.state["config"]["chat_mode"] = mode
-            self.state["config"]["chat_room_capacity"] = capacity
-            if "global-1" not in self.state["chat_rooms"]:
-                self._ensure_room_unlocked("global-1")
-            eligible = [uid for uid, user in self.state["users"].items() if self._chat_eligible_unlocked(user)]
-            if mode == "single":
-                for uid in eligible:
-                    self.state["users"][uid]["chat_room_id"] = "global-1"
-                all_messages = sorted(self.state["chat"], key=lambda m: m.get("created_at", ""))[-400:]
-                for message in all_messages:
-                    message["room_id"] = "global-1"
-                self.state["chat"] = all_messages
-                room1 = self.state["chat_rooms"]["global-1"]
-                room1["paused"] = False
-                self.state["chat_rooms"] = {"global-1": room1}
-            else:
-                required = max(1, (len(eligible) + capacity - 1) // capacity)
-                while len(self.state["chat_rooms"]) < required:
-                    self._new_room_unlocked()
-                active_rooms = [rid for rid, room in sorted(self.state["chat_rooms"].items(), key=lambda pair: self._room_sort_key_unlocked(pair[0])) if not room.get("paused")]
-                if not active_rooms:
-                    self.state["chat_rooms"]["global-1"]["paused"] = False
-                    active_rooms = ["global-1"]
-                secrets.SystemRandom().shuffle(eligible)
-                for index, uid in enumerate(eligible):
-                    room_index = min(index // capacity, len(active_rooms) - 1)
-                    self.state["users"][uid]["chat_room_id"] = active_rooms[room_index]
-            self._save_unlocked("Update CloudVault chat room configuration")
+            self.state["config"]["chat_mode"] = "single"
+            self.state["config"]["chat_room_capacity"] = 0
+            room = self.state["chat_rooms"].setdefault(
+                "global-1",
+                {"id": "global-1", "name": "Global Chat", "paused": False, "created_at": iso()},
+            )
+            room["name"] = "Global Chat"
+            self.state["chat_rooms"] = {"global-1": room}
+            for user in self.state["users"].values():
+                if self._chat_eligible_unlocked(user):
+                    user["chat_room_id"] = "global-1"
+            for message in self.state["chat"]:
+                message["room_id"] = "global-1"
+            self.state["chat"] = sorted(self.state["chat"], key=lambda m: m.get("created_at", ""))[-400:]
+            self._save_unlocked("Use one unlimited Global Chat room")
             return dict(self.state["config"])
 
     def toggle_chat_room(self, admin_id: str, room_id: str) -> bool:
@@ -1122,18 +1094,8 @@ class StateStore:
                 raise PermissionError("Global Chat is paused for Plus accounts.")
             if user.get("role") != "admin" and user.get("plan") == "pro" and not cfg.get("pro_chat_enabled", True):
                 raise PermissionError("Global Chat is paused for Pro accounts.")
-            if room_id and (user.get("role") == "admin" or user.get("plan") == "pro"):
-                # Inline room change to avoid a second state write.
-                selected = self.state["chat_rooms"].get(room_id)
-                if not selected:
-                    raise ValueError("The selected chat room does not exist.")
-                if selected.get("paused") and user.get("role") != "admin":
-                    raise ValueError("The selected chat room is paused.")
-                capacity = int(cfg.get("chat_room_capacity", 200))
-                if user.get("chat_room_id") != room_id and user.get("role") != "admin" and self._room_member_count_unlocked(room_id) >= capacity:
-                    raise ValueError("The selected chat room is full.")
-                user["chat_room_id"] = room_id
-            assigned_room = self._assign_room_unlocked(user_id)
+            user["chat_room_id"] = "global-1"
+            assigned_room = "global-1"
             room = self.state["chat_rooms"].get(assigned_room)
             if room and room.get("paused") and user.get("role") != "admin":
                 raise PermissionError("This chat room is paused by the developer.")
@@ -1154,10 +1116,7 @@ class StateStore:
             }
             user["last_chat_at"] = iso(now)
             self.state["chat"].append(record)
-            room_messages = [m for m in self.state["chat"] if m.get("room_id", "global-1") == assigned_room]
-            if len(room_messages) > 400:
-                remove_ids = {m.get("id") for m in room_messages[:-400]}
-                self.state["chat"] = [m for m in self.state["chat"] if m.get("id") not in remove_ids]
+            self.state["chat"] = sorted(self.state["chat"], key=lambda m: m.get("created_at", ""))[-400:]
             self._save_unlocked("Send CloudVault Global Chat message")
             return dict(record)
 
@@ -1167,8 +1126,6 @@ class StateStore:
             if not self._chat_eligible_unlocked(user):
                 return []
             assigned = self._assign_room_unlocked(user_id)
-            if room_id and (user.get("role") == "admin" or user.get("plan") == "pro") and room_id in self.state["chat_rooms"]:
-                assigned = room_id
             now = utcnow()
             limit = 400 if user.get("role") == "admin" or user.get("plan") == "pro" else 200
             return [

style.css

@@ -148,3 +148,99 @@ body:after{content:"";position:fixed;inset:-30%;pointer-events:none;opacity:.12;
 .cloudvault-translate-btn>small{align-self:start;color:#8fc8db;font-size:8px;line-height:1.1;white-space:nowrap}
 .goog-te-banner-frame,.skiptranslate iframe{display:none!important}body{top:0!important}
 @media(max-width:900px){.cloudvault-translate-btn{min-width:54px;width:54px;padding:8px;grid-template-columns:1fr}.cloudvault-translate-btn>span{grid-row:auto}.cloudvault-translate-btn>b,.cloudvault-translate-btn>small{display:none}}
+
+/* V15 — inline Google Translate language menu */
+.cloudvault-translate-wrap{position:relative;min-width:0;z-index:80}
+.cloudvault-translate-btn{width:166px;min-width:166px;max-width:166px;border:0;cursor:pointer;text-align:left}
+.cv-translate-panel{position:absolute;top:calc(100% + 10px);left:0;width:320px;max-width:min(88vw,320px);padding:15px;border:1px solid rgba(96,165,250,.34);border-radius:18px;background:linear-gradient(145deg,#101a2e,#070b14);box-shadow:0 26px 80px rgba(0,0,0,.65);opacity:0;visibility:hidden;transform:translateY(-8px) scale(.98);transform-origin:top left;transition:.2s ease;z-index:9999}
+.cv-translate-panel.open{opacity:1;visibility:visible;transform:translateY(0) scale(1)}
+.cv-translate-title{display:flex;align-items:center;gap:11px;margin-bottom:12px;padding-bottom:11px;border-bottom:1px solid rgba(148,163,184,.14)}
+.cv-translate-title>span{width:38px;height:38px;display:grid;place-items:center;border-radius:12px;background:linear-gradient(135deg,#0e7490,#3730a3);font-size:19px}
+.cv-translate-title b,.cv-translate-title small{display:block}.cv-translate-title b{font-size:13px}.cv-translate-title small{margin-top:3px;color:#7f91aa;font-size:9px}
+#cv-language-select{width:100%!important;max-height:380px!important;min-height:46px!important;padding:0 13px!important;border:1px solid #30415f!important;border-radius:13px!important;background:#08101e!important;color:#f7fbff!important;font-size:12px!important;font-weight:750!important;cursor:pointer}
+#cv-language-select option{background:#08101e;color:#eef4ff;padding:8px}
+.cv-native-translate{position:absolute!important;width:1px!important;height:1px!important;overflow:hidden!important;opacity:0!important;pointer-events:none!important}
+.goog-te-banner-frame,.skiptranslate iframe{display:none!important}body{top:0!important}
+@media(max-width:1100px){.cloudvault-translate-btn{width:54px;min-width:54px;max-width:54px;padding:8px;grid-template-columns:1fr}.cloudvault-translate-btn>b,.cloudvault-translate-btn>small{display:none}.cv-translate-panel{left:0}}
+@media(max-width:700px){.cv-translate-panel{position:fixed;top:86px;left:50%;transform:translate(-50%,-8px) scale(.98);transform-origin:top center}.cv-translate-panel.open{transform:translate(-50%,0) scale(1)}}
+
+
+/* V15: compact sidebar labels and live active-user card */
+.side-btn button,
+.side-btn {
+  white-space: nowrap !important;
+  line-height: 1.1 !important;
+}
+
+.live-users-card {
+  display: grid;
+  grid-template-columns: auto 1fr;
+  align-items: center;
+  gap: 14px 22px;
+  padding: 22px 24px;
+  margin-bottom: 16px;
+  overflow: hidden;
+  position: relative;
+}
+
+.live-users-card::after {
+  content: "";
+  position: absolute;
+  inset: -80% auto auto 45%;
+  width: 260px;
+  height: 260px;
+  border-radius: 50%;
+  background: radial-gradient(circle, rgba(38, 224, 154, .22), transparent 68%);
+  animation: cvLiveGlow 3s ease-in-out infinite;
+  pointer-events: none;
+}
+
+.live-users-card strong {
+  grid-row: 1 / span 2;
+  font-size: clamp(2.2rem, 5vw, 4.6rem);
+  color: #72f2bd;
+  letter-spacing: -0.06em;
+  text-shadow: 0 0 28px rgba(64, 240, 170, .25);
+  z-index: 1;
+}
+
+.live-users-card p {
+  margin: 0;
+  color: var(--cv-muted);
+  z-index: 1;
+}
+
+.live-users-pulse {
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  color: #d9fff0;
+  font-size: .76rem;
+  letter-spacing: .16em;
+  font-weight: 800;
+  z-index: 1;
+}
+
+.live-users-pulse i {
+  width: 10px;
+  height: 10px;
+  border-radius: 999px;
+  background: #43eca7;
+  box-shadow: 0 0 0 0 rgba(67, 236, 167, .55);
+  animation: cvLivePulse 1.5s infinite;
+}
+
+.room-status.single-room {
+  grid-template-columns: 1fr auto;
+}
+
+@keyframes cvLivePulse {
+  0% { box-shadow: 0 0 0 0 rgba(67, 236, 167, .55); }
+  70% { box-shadow: 0 0 0 12px rgba(67, 236, 167, 0); }
+  100% { box-shadow: 0 0 0 0 rgba(67, 236, 167, 0); }
+}
+
+@keyframes cvLiveGlow {
+  0%,100% { transform: scale(.9); opacity: .5; }
+  50% { transform: scale(1.12); opacity: 1; }
+}