ChaTerminal 1.0.4__tar.gz → 2.0.0__tar.gz

{chaterminal-1.0.4 → chaterminal-2.0.0}/ChaTerminal/__main__.py

@@ -1,4 +1,4 @@
-from ChaTerminal.cli import main
+from chaterminal.main import main
 
 if __name__ == "__main__":
     main()

chaterminal-2.0.0/ChaTerminal/core/events.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+class EventType(Enum):
+    INCOMING_MESSAGE = "incoming_message"
+    SYSTEM_MESSAGE = "system_message"
+    LOGOUT = "logout"
+    STATE_CHANGE = "state_change"
+    ONLINE_USERS = "online_users"
+    MESSAGE_SENT = "message_sent"
+    MESSAGE_ERROR = "message_error"
+
+def put_event(state, event_type: EventType, **kwargs):
+    kwargs["type"] = event_type
+    state.event_queue.put(kwargs)

chaterminal-2.0.0/ChaTerminal/core/logger.py

@@ -0,0 +1,14 @@
+import logging
+from rich.logging import RichHandler
+from chaterminal.ui.console import console
+
+def setup_logger():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(message)s",
+        datefmt="[%X]",
+        handlers=[RichHandler(console=console, rich_tracebacks=True, show_path=False)]
+    )
+    return logging.getLogger("chaterminal")
+
+logger = setup_logger()

chaterminal-2.0.0/ChaTerminal/core/state.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass, field
+from queue import Queue
+import threading
+
+@dataclass
+class AppState:
+    running: bool = True
+
+    uid: str | None = None
+    token: str | None = None
+    refresh_token: str | None = None
+
+    username: str | None = None
+    device_id: str | None = None
+
+    token_expires_at: int = 0
+
+    event_queue: Queue = field(default_factory=Queue)
+    lock: threading.Lock = field(default_factory=threading.Lock)

chaterminal-2.0.0/ChaTerminal/core/threads.py

@@ -0,0 +1,30 @@
+import threading
+import time
+import logging
+
+logger = logging.getLogger("chaterminal")
+
+class WorkerManager:
+    def __init__(self, state):
+        self.state = state
+        self.threads = {}
+
+    def start(self, name, target, daemon=True):
+        def wrapper():
+            while self.state.running:
+                try:
+                    target()
+                except Exception as e:
+                    logger.error(f"[WORKER CRASH] {name}: {e}")
+                    if not self.state.running:
+                        break
+                    time.sleep(3)
+
+        thread = threading.Thread(
+            target=wrapper,
+            daemon=daemon,
+            name=name
+        )
+
+        self.threads[name] = thread
+        thread.start()

chaterminal-2.0.0/ChaTerminal/main.py

@@ -0,0 +1,79 @@
+import sys
+
+from chaterminal.core.state import AppState
+from chaterminal.core.threads import WorkerManager
+from chaterminal.core.logger import logger
+from chaterminal.storage.database import Database
+from chaterminal.storage.session_store import get_or_create_device_id
+from chaterminal.services.firebase_service import FirebaseClient
+from chaterminal.services.auth_service import AuthService
+from chaterminal.services.websocket_service import WebsocketService
+from chaterminal.services.presence_service import PresenceService
+from chaterminal.services.message_service import MessageService
+from chaterminal.ui.terminal_ui import TerminalUI
+from chaterminal.crypto.encryption import get_public_key_pem
+from chaterminal.ui.splash import splash
+from chaterminal.ui.console import console
+
+
+def main():
+    splash()
+    logger.info("[*] Initializing ChaTerminal v2...")
+
+    # 1. State
+    state = AppState()
+    state.device_id = get_or_create_device_id()
+
+    # 2. Storage
+    db = Database()
+
+    # 3. Services
+    firebase = FirebaseClient(state)
+    ws_service = WebsocketService(state)
+    presence = PresenceService(state, firebase, ws_service)
+    message_service = MessageService(state, firebase, ws_service, db)
+
+    # 4. Auth - show Live activation panel while waiting
+    live_login = None
+
+    def ui_activation_callback(code, remaining):
+        nonlocal live_login
+        from chaterminal.ui.panels import activation_panel
+        from rich.live import Live
+        if live_login is None:
+            live_login = Live(refresh_per_second=4, console=console)
+            live_login.start()
+        live_login.update(activation_panel(code, remaining))
+
+    auth = AuthService(state, firebase, ui_activation_callback)
+    success = auth.login_flow()
+
+    if live_login:
+        live_login.stop()
+
+    if not success:
+        logger.error("[!] Authentication failed. Exiting.")
+        sys.exit(1)
+
+    logger.info(f"[+] Logged in as @{state.username}")
+
+    # 5. Register session & E2EE key
+    pub_key = get_public_key_pem()
+    presence.register_session(pub_key)
+
+    # 6. Start background workers
+    worker_manager = WorkerManager(state)
+    worker_manager.start("WebsocketClient", ws_service.run)
+    worker_manager.start("Heartbeat", presence.heartbeat_loop)
+    worker_manager.start("MessageSender", message_service.sender_worker)
+
+    # 7. Run UI - single-threaded, blocks until /exit or Ctrl+C
+    ui = TerminalUI(state, message_service, presence)
+    ui.run()
+
+    state.running = False
+    console.print("\n[cyan][*] Goodbye![/cyan]")
+
+
+if __name__ == "__main__":
+    main()

chaterminal-2.0.0/ChaTerminal/services/auth_service.py

@@ -0,0 +1,119 @@
+import time
+import secrets
+from chaterminal.core.logger import logger
+from chaterminal.core.events import EventType, put_event
+from chaterminal.storage.session_store import save_session, load_session, delete_session
+
+class AuthService:
+    def __init__(self, state, firebase_client, ui_callback=None):
+        self.state = state
+        self.firebase = firebase_client
+        self.ui_callback = ui_callback
+
+    def login_flow(self):
+        session = load_session()
+
+        if session:
+            self.state.token = session.get("idToken")
+            self.state.refresh_token = session.get("refreshToken")
+            self.state.uid = session.get("localId")
+            self.state.token_expires_at = session.get("expiresAt", 0)
+
+            if self.state.token_expires_at <= int(time.time()):
+                logger.info("[*] Refreshing session...")
+                if not self.firebase.refresh_token():
+                    delete_session()
+                    session = None
+
+        if not session:
+            code = self._generate_activation_code()
+            if not code:
+                logger.error("[!] Failed to generate activation code.")
+                return False
+
+            res = self.firebase.put_public(
+                f"chaterminal/loginCodes/{code}",
+                {
+                    "pending": True,
+                    "createdAt": int(time.time() * 1000)
+                }
+            )
+            if res.status_code != 200:
+                logger.error(f"[!] Failed to write activation code: {res.text}")
+                return False
+
+            data = self._poll_activation_code(code)
+
+            if not data:
+                logger.error("[!] Activation timed out.")
+                return False
+
+            self.state.token = data["idToken"]
+            self.state.refresh_token = data["refreshToken"]
+            self.state.uid = data["localId"]
+            self.state.token_expires_at = int(time.time()) + int(data.get("expiresIn", 3600))
+
+            save_session({
+                "idToken": self.state.token,
+                "refreshToken": self.state.refresh_token,
+                "localId": self.state.uid,
+                "expiresAt": self.state.token_expires_at
+            })
+
+        # Fetch username
+        try:
+            res = self.firebase.get(f"users/{self.state.uid}/username")
+            if res.status_code == 200 and res.text.strip() != "null":
+                self.state.username = res.json()
+            else:
+                self.state.username = f"user_{self.state.uid[:6]}"
+        except Exception:
+            self.state.username = f"user_{self.state.uid[:6]}"
+            
+        return True
+
+    def _generate_activation_code(self):
+        alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+        attempts = 0
+        while attempts < 10:
+            code = ''.join(secrets.choice(alphabet) for _ in range(8))
+            try:
+                res = self.firebase.get_public(f"chaterminal/loginCodes/{code}")
+                if res.status_code == 200 and res.text.strip() == "null":
+                    return code
+                elif res.status_code != 200:
+                    logger.error(f"Error checking code: {res.status_code} {res.text}")
+            except Exception as e:
+                logger.error(f"Exception checking code: {e}")
+            attempts += 1
+            time.sleep(1)
+        return None
+
+    def _poll_activation_code(self, code, timeout=300):
+        path = f"chaterminal/loginCodes/{code}"
+        deadline = time.time() + timeout
+
+        while time.time() < deadline:
+            remaining = int(deadline - time.time())
+            
+            if self.ui_callback:
+                self.ui_callback(code, remaining)
+            
+            try:
+                res = self.firebase.get_public(path)
+                if res.status_code == 200 and res.text.strip() != "null":
+                    data = res.json()
+                    if isinstance(data, dict) and data.get("idToken"):
+                        delete_res = self.firebase.delete_public(
+                            path,
+                            params={"auth": data["idToken"]}
+                        )
+                        if delete_res.status_code != 200:
+                            logger.error(f"[!] Failed to delete activation code: {delete_res.status_code} {delete_res.text}")
+                        return data
+            except Exception:
+                pass
+
+            time.sleep(1)
+
+        return None

chaterminal-2.0.0/ChaTerminal/services/firebase_service.py

@@ -0,0 +1,124 @@
+import requests
+import time
+from chaterminal.core.logger import logger
+from chaterminal.core.events import EventType, put_event
+
+BASE_URL = "https://memerdevs-default-rtdb.firebaseio.com"
+API_KEY = "AIzaSyChVoNLaFnfZScOmOvzf25xTPnvuKOA9a0"
+SESSION_TIMEOUT = (10, 30)
+
+class FirebaseClient:
+    def __init__(self, state):
+        self.state = state
+        self.http = requests.Session()
+        self.http.headers.update({
+            "User-Agent": "ChaTerminal/2.0"
+        })
+
+    def get_public(self, path, **kwargs):
+        return self.http.get(
+            f"{BASE_URL}/{path}.json",
+            timeout=SESSION_TIMEOUT,
+            **kwargs
+        )
+
+    def put_public(self, path, data, **kwargs):
+        return self.http.put(
+            f"{BASE_URL}/{path}.json",
+            json=data,
+            timeout=SESSION_TIMEOUT,
+            **kwargs
+        )
+
+    def delete_public(self, path, **kwargs):
+        return self.http.delete(
+            f"{BASE_URL}/{path}.json",
+            timeout=SESSION_TIMEOUT,
+            **kwargs
+        )
+
+    def get(self, path, **kwargs):
+        return self.request("GET", path, **kwargs)
+
+    def post(self, path, data, **kwargs):
+        return self.request("POST", path, json=data, **kwargs)
+
+    def put(self, path, data, **kwargs):
+        return self.request("PUT", path, json=data, **kwargs)
+
+    def patch(self, path, data, **kwargs):
+        return self.request("PATCH", path, json=data, **kwargs)
+
+    def delete(self, path, **kwargs):
+        return self.request("DELETE", path, **kwargs)
+
+    def request(self, method, path, **kwargs):
+        self.ensure_token()
+
+        headers = kwargs.pop("headers", {})
+        params = kwargs.pop("params", {})
+        if not self.state.token:
+            logger.error("Authenticated request attempted without token")
+            raise RuntimeError("Missing token")
+
+        headers["Authorization"] = f"Bearer {self.state.token}"
+        params["auth"] = self.state.token
+        url = f"{BASE_URL}/{path}.json"
+
+        return self.http.request(
+            method,
+            url,
+            headers=headers,
+            params=params,
+            timeout=SESSION_TIMEOUT,
+            **kwargs
+        )
+
+    def ensure_token(self):
+        if not self.state.refresh_token:
+            return
+
+        remaining = self.state.token_expires_at - int(time.time())
+        if remaining > 300:
+            return
+
+        self.refresh_token()
+
+    def refresh_token(self):
+        url = f"https://securetoken.googleapis.com/v1/token?key={API_KEY}"
+        try:
+            res = self.http.post(
+                url,
+                data={
+                    "grant_type": "refresh_token",
+                    "refresh_token": self.state.refresh_token
+                },
+                timeout=SESSION_TIMEOUT
+            )
+            
+            data = res.json() if res.status_code == 200 else None
+
+            if not data:
+                return False
+
+            self.state.token = data["access_token"]
+            self.state.refresh_token = data["refresh_token"]
+            self.state.uid = data["user_id"]
+            self.state.token_expires_at = int(time.time()) + int(data["expires_in"])
+
+            put_event(self.state, EventType.STATE_CHANGE, field="token")
+
+            # Update session store
+            from chaterminal.storage.session_store import save_session
+            save_session({
+                "idToken": self.state.token,
+                "refreshToken": self.state.refresh_token,
+                "localId": self.state.uid,
+                "expiresAt": self.state.token_expires_at
+            })
+
+            return True
+
+        except Exception as e:
+            logger.error(f"[!] Token refresh failed: {e}")
+            return False

chaterminal-2.0.0/ChaTerminal/services/message_service.py

@@ -0,0 +1,144 @@
+import time
+from queue import Queue, Empty
+from chaterminal.core.logger import logger
+from chaterminal.core.events import EventType, put_event
+from chaterminal.crypto.encryption import encrypt_msg, decrypt_msg
+from chaterminal.storage.database import Database
+
+class MessageService:
+    def __init__(self, state, firebase_client, ws_service, db):
+        self.state = state
+        self.firebase = firebase_client
+        self.ws_service = ws_service
+        self.db = db
+        self.outgoing_queue = Queue()
+        self.username_cache = {}
+        self.CACHE_TTL = 300
+
+    def get_username_by_uid(self, uid):
+        now = time.time()
+        cached = self.username_cache.get(uid)
+        
+        if cached:
+            username, ts = cached
+            if now - ts < self.CACHE_TTL:
+                return username
+
+        try:
+            res = self.firebase.get(f"users/{uid}/username")
+            username = res.json() if res.status_code == 200 else None
+            
+            if username and username != "null":
+                self.username_cache[uid] = (username, now)
+                return username
+        except Exception:
+            pass
+
+        return f"user_{uid[:6]}"
+
+    def process_incoming_message(self, msg_id, payload):
+        sender_uid = payload.get("senderUid")
+        encrypted_payload = payload.get("encryptedPayload")
+        timestamp = payload.get("timestamp", int(time.time() * 1000))
+
+        if not sender_uid or not encrypted_payload:
+            return
+
+        try:
+            text = decrypt_msg(encrypted_payload)
+            sender_username = self.get_username_by_uid(sender_uid)
+
+            if sender_uid == self.state.uid:
+                if msg_id != "ws":
+                    self.firebase.delete(f"chaterminal/mailbox/{self.state.uid}/{msg_id}")
+                return None
+
+            # Save to local DB
+            self.db.save_message(
+                sender_uid,
+                sender_username,
+                self.state.uid,
+                text,
+                timestamp
+            )
+
+            # Delete from mailbox if it came from SSE (if using REST fallback)
+            # For WebSockets, the gateway might handle ACKs, but we can do it here too if needed.
+            self.firebase.delete(f"chaterminal/mailbox/{self.state.uid}/{msg_id}")
+
+            return {
+                "sender_username": sender_username,
+                "text": text,
+                "timestamp": timestamp
+            }
+        except Exception as e:
+            logger.error(f"[!] Decryption failed: {e}")
+            self.firebase.delete(f"chaterminal/mailbox/{self.state.uid}/{msg_id}")
+            return None
+
+    def queue_message(self, slug, message):
+        self.outgoing_queue.put({
+            "slug": slug,
+            "message": message
+        })
+
+    def sender_worker(self):
+        while self.state.running:
+            try:
+                task = self.outgoing_queue.get(timeout=1)
+                slug = task["slug"]
+                message = task["message"]
+
+                res = self.firebase.get(f"slugIndex/{slug}")
+                recipient_uid = res.json() if res.status_code == 200 else None
+
+                if not recipient_uid or recipient_uid == "null":
+                    put_event(self.state, EventType.SYSTEM_MESSAGE, text=f"[red][!] User {slug} not found.[/red]")
+                    continue
+
+                res = self.firebase.get(f"users/{recipient_uid}/chaterminal/publicKey")
+                pub_key = res.json() if res.status_code == 200 else None
+
+                if not pub_key or pub_key == "null":
+                    put_event(self.state, EventType.SYSTEM_MESSAGE, text=f"[red][!] User {slug} has no active terminal session.[/red]")
+                    continue
+
+                encrypted_payload = encrypt_msg(message, pub_key)
+
+                payload = {
+                    "senderUid": self.state.uid,
+                    "encryptedPayload": encrypted_payload,
+                    "timestamp": int(time.time() * 1000)
+                }
+
+                # Try sending via WS first, fallback to REST
+                success = False
+                if self.ws_service and self.ws_service.ws and self.ws_service.ws.sock and self.ws_service.ws.sock.connected:
+                    ws_payload = {
+                        "action": "send_message",
+                        "recipientUid": recipient_uid,
+                        "data": payload
+                    }
+                    success = self.ws_service.send(ws_payload)
+
+                if not success:
+                    res = self.firebase.post(f"chaterminal/mailbox/{recipient_uid}", payload)
+                    success = res.status_code == 200
+
+                if success:
+                    # Save to self DB
+                    self.db.save_message(
+                        self.state.uid,
+                        self.state.username,
+                        recipient_uid,
+                        message,
+                        payload["timestamp"]
+                    )
+                    put_event(self.state, EventType.MESSAGE_SENT, slug=slug, message=message, timestamp=payload["timestamp"])
+                else:
+                    put_event(self.state, EventType.SYSTEM_MESSAGE, text=f"[red][!] Failed to send to {slug}.[/red]")
+
+            except Empty:
+                continue
+            except Exception as e:
+                logger.error(f"[!] Send error: {e}")

chaterminal-2.0.0/ChaTerminal/services/presence_service.py

@@ -0,0 +1,82 @@
+import time
+from chaterminal.core.logger import logger
+from chaterminal.core.events import EventType, put_event
+from chaterminal.storage.session_store import get_device_name
+
+class PresenceService:
+    def __init__(self, state, firebase_client, ws_service):
+        self.state = state
+        self.firebase = firebase_client
+        self.ws_service = ws_service
+
+    def register_session(self, pub_key):
+        try:
+            device_name = get_device_name()
+            session_res = self.firebase.put(
+                f"chaterminal/sessions/{self.state.uid}",
+                {
+                    "activeDeviceId": self.state.device_id,
+                    "deviceName": device_name,
+                    "loginTime": int(time.time() * 1000)
+                }
+            )
+            if session_res.status_code != 200:
+                logger.error(f"[!] Failed to write terminal session: {session_res.status_code} {session_res.text}")
+
+            user_res = self.firebase.patch(
+                f"users/{self.state.uid}/chaterminal",
+                {
+                    "publicKey": pub_key,
+                    "deviceId": self.state.device_id,
+                    "deviceName": device_name,
+                    "lastActive": int(time.time() * 1000)
+                }
+            )
+            if user_res.status_code != 200:
+                logger.error(f"[!] Failed to write terminal profile: {user_res.status_code} {user_res.text}")
+        except Exception as e:
+            logger.error(f"[!] Failed to register session: {e}")
+
+    def heartbeat_loop(self):
+        while self.state.running:
+            try:
+                # If we have a connected websocket, we might not need HTTP heartbeat, 
+                # but we'll do both or rely on the backend to update presence via WS.
+                # For now, keep the Firebase patch.
+                self.firebase.patch(
+                    f"users/{self.state.uid}/chaterminal",
+                    {
+                        "lastActive": int(time.time() * 1000)
+                    }
+                )
+            except Exception:
+                pass
+
+            time.sleep(60)
+
+    def fetch_online_users(self):
+        try:
+            res = self.firebase.get("users")
+            users_data = res.json() if res.status_code == 200 else {}
+            
+            if not isinstance(users_data, dict):
+                return []
+
+            now = int(time.time() * 1000)
+            online = []
+
+            for _, user_info in users_data.items():
+                if not isinstance(user_info, dict):
+                    continue
+
+                username = user_info.get("username", "Unknown")
+                ct = user_info.get("chaterminal", {})
+                last_active = ct.get("lastActive", 0)
+
+                if last_active and (now - last_active < 300000):
+                    online.append(username)
+
+            return online
+        except Exception as e:
+            logger.error(f"[!] Failed to fetch online users: {e}")
+            return []