veilchat 0.2.0__tar.gz

veilchat-0.2.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: veilchat
+Version: 0.2.0
+Summary: Privacy-first terminal social network and chat
+Author: Razie1
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: bcrypt>=4.0.0
+Provides-Extra: tor
+Requires-Dist: PySocks>=1.7.0; extra == "tor"

veilchat-0.2.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "veilchat"
+version = "0.2.0"
+description = "Privacy-first terminal social network and chat"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Razie1" }]
+dependencies = [
+    "click>=8.0.0",
+    "requests>=2.31.0",
+    "bcrypt>=4.0.0",
+]
+
+[project.optional-dependencies]
+tor = ["PySocks>=1.7.0"]
+
+[project.scripts]
+vt = "vt_cli:vt"
+vc = "vc_cli:vc"
+veiltalk = "vt_cli:vt"
+veilchat = "vc_cli:vc"
+
+[tool.setuptools]
+packages = ["veilchat", "veilchat.core", "veilchat.utils"]
+py-modules = ["vt_cli", "vc_cli"]

veilchat-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

veilchat-0.2.0/vc_cli.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+Veilchat chat CLI (vc).
+"""
+import getpass
+import re
+import sys
+
+import click
+
+from veilchat.config import DEFAULT_REGISTRY
+
+
+@click.group()
+@click.version_option(version="0.2.0")
+def vc():
+    """🕶️  Veilchat — terminal chat rooms."""
+    pass
+
+
+@vc.command()
+@click.option("--name", "-n", required=True)
+@click.option("--port", "-p", default=5555, type=int)
+@click.option("--password", "--pass", default=None)
+@click.option("--master-key", default=None,
+              help="Shared secret for --adminkey bypass")
+@click.option("--registry", default=DEFAULT_REGISTRY)
+def open(name, port, password, master_key, registry):
+    """Open a new chat room."""
+    from veilchat.core.server import start_server
+
+    if not re.match(r"^[a-zA-Z0-9_\- ]{1,32}$", name):
+        click.echo("\033[91m✗ Room name must be 1-32 chars\033[0m"); sys.exit(1)
+
+    click.echo(f"\n\033[95m🕶️  Opening '{name}' on port {port}\033[0m")
+    if password: click.echo("\033[93m🔒 Password protected\033[0m")
+    if master_key: click.echo("\033[93m🔑 Master key bypass enabled\033[0m")
+    click.echo(f"\033[90m📡 Registry: {registry}\033[0m\n")
+
+    try:
+        start_server(port=port, server_name=name,
+                     registry_url=registry, password=password,
+                     master_key=master_key)
+    except KeyboardInterrupt:
+        click.echo("\n\033[91m[Room closed]\033[0m")
+        sys.exit(0)
+
+
+@vc.command()
+@click.argument("name", required=False)
+@click.option("--registry", default=DEFAULT_REGISTRY)
+def search(name, registry):
+    """Search for chat rooms. Leave blank to list all."""
+    from veilchat.utils.registry import RegistryClient
+
+    c = RegistryClient(registry)
+    if not c.check_connection():
+        click.echo("\033[91m❌ Registry unreachable\033[0m"); sys.exit(1)
+
+    servers = c.list_servers()
+    if name:
+        servers = [s for s in servers if name.lower() in s.get("name", "").lower()]
+
+    click.echo(f"\n\033[95m🕶️  {'All Rooms' if not name else f'Search: {name}'}\033[0m")
+    click.echo(f"\033[90m{'━' * 50}\033[0m\n")
+
+    if not servers:
+        click.echo("\033[93m📭 No rooms\033[0m"); return
+
+    for s in servers:
+        uc = s.get("user_count", 0)
+        color = "\033[92m" if uc >= 10 else "\033[93m" if uc >= 5 else "\033[95m"
+        click.echo(f"{color}{s.get('name','?')}\033[0m")
+        if s.get("description"):
+            click.echo(f"   \033[90m{s['description']}\033[0m")
+        click.echo(f"   👥 \033[93m{uc}\033[0m  \033[90mvc enter {s.get('name','')}\033[0m\n")
+
+
+@vc.command()
+@click.argument("name")
+@click.option("--registry", default=DEFAULT_REGISTRY)
+@click.option("--direct", is_flag=True)
+@click.option("--adminkey", is_flag=True)
+@click.option("--tor", is_flag=True, help="Route through local Tor SOCKS5 (127.0.0.1:9050)")
+def enter(name, registry, direct, adminkey, tor):
+    """Enter a chat room."""
+    from veilchat.core.client import start_client
+    from veilchat.utils.registry import resolve_server
+    from veilchat.utils.session import (
+        master_key_exists, get_master_key, get_session,
+    )
+    from veilchat.core.social import WhisprSocial
+
+    click.echo(f"\n\033[95m🕶️  Entering '{name}'\033[0m\n")
+
+    raw_key = None
+    if adminkey:
+        u = get_session()
+        if not u:
+            click.echo("\033[91m✗ Login required for --adminkey\033[0m"); sys.exit(1)
+        s = WhisprSocial()
+        if not s.is_staff(u):
+            click.echo("\033[91m✗ Staff only\033[0m"); sys.exit(1)
+        if not master_key_exists():
+            click.echo("\033[91m✗ No master key set\033[0m"); sys.exit(1)
+
+        # Load from local store — user proved identity when they set it.
+        # If they want re-auth, delete ~/.veilchat/masterkey and re-set.
+        raw_key = get_master_key()
+        click.echo("\033[92m✓ Master key loaded (server will verify via HMAC)\033[0m\n")
+
+    if direct:
+        host, port = (name.split(":") + ["5555"])[:2]
+        try:
+            port = int(port)
+        except ValueError:
+            click.echo("\033[91m✗ Invalid port\033[0m"); sys.exit(1)
+    else:
+        host, port = resolve_server(name, registry)
+        if not host:
+            click.echo(f"\033[91m❌ Room '{name}' not found\033[0m"); sys.exit(1)
+
+    try:
+        start_client(host, port, admin_key=raw_key, use_tor=tor)
+    except KeyboardInterrupt:
+        click.echo("\n\033[91m[Left room]\033[0m")
+        sys.exit(0)
+
+
+veilchat = vc
+
+if __name__ == "__main__":
+    vc()

veilchat-0.2.0/veilchat/_init_.py

@@ -0,0 +1,7 @@
+"""
+Veilchat - Chat beyond the surface.
+Privacy-first terminal social network and chat.
+"""
+
+__version__ = "0.2.0"
+__author__  = "Razie1"

veilchat-0.2.0/veilchat/config.py

@@ -0,0 +1,11 @@
+"""
+Central config. Everything reads from here so we have one source of truth.
+"""
+import os
+
+DEFAULT_REGISTRY = os.environ.get(
+    "VEILCHAT_REGISTRY",
+    "https://veil.pythonanywhere.com",
+).rstrip("/")
+
+VEILCHAT_DIR = os.path.expanduser("~/.veilchat")

veilchat-0.2.0/veilchat/core/_init_.py

@@ -0,0 +1,3 @@
+from .server import ChatServer, start_server
+from .client import ChatClient, start_client
+from .social import WhisprSocial

veilchat-0.2.0/veilchat/core/client.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""
+Veilchat chat client.
+Tor is opt-in via the `use_tor` argument or VEILCHAT_TOR=1 env var.
+"""
+import getpass
+import os
+import socket
+import sys
+import threading
+import time
+
+from ..utils.session import compute_master_hmac, get_master_key
+
+
+class ChatClient:
+    def __init__(self, host, port, admin_key=None, use_tor=False):
+        self.host = host
+        self.port = port
+        self.admin_key = admin_key
+        self.nickname = ""
+        self.connected = True
+
+        if use_tor or os.environ.get("VEILCHAT_TOR") == "1":
+            try:
+                import socks
+                socks.set_default_proxy(socks.SOCKS5, "127.0.0.1", 9050)
+                socket.socket = socks.socksocket
+            except ImportError:
+                print("\033[91m[PySocks not installed — cannot use Tor]\033[0m")
+                sys.exit(1)
+
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+    # ─────────────────────────────────────────
+    # HANDSHAKE — synchronous, before we spawn threads
+    # ─────────────────────────────────────────
+
+    def _send_line(self, s: str) -> None:
+        self.sock.sendall(s.encode("utf-8") + b"\n")
+
+    def _recv_line(self) -> str:
+        buf = b""
+        while not buf.endswith(b"\n"):
+            chunk = self.sock.recv(1)
+            if not chunk:
+                raise ConnectionError("disconnected")
+            buf += chunk
+        return buf.decode("utf-8", errors="replace").strip()
+
+    def _handshake(self) -> bool:
+        """Handle room password + master key + auth. Returns True if logged in."""
+        while True:
+            try:
+                msg = self._recv_line()
+            except ConnectionError:
+                print("\033[91m[Connection closed during handshake]\033[0m")
+                return False
+
+            if msg == "ROOM_PASS":
+                if self.admin_key:
+                    self._send_line("MASTER_REQ")
+                    nonce_hex = self._recv_line()
+                    if not nonce_hex.startswith("MASTER_NONCE:"):
+                        print("\033[91m[Unexpected server response]\033[0m")
+                        return False
+                    nonce = bytes.fromhex(nonce_hex.split(":", 1)[1])
+                    resp = compute_master_hmac(self.admin_key, nonce)
+                    self._send_line(f"MASTER_RESP:{resp}")
+                else:
+                    pw = getpass.getpass("\033[95m🔒 Room password: \033[0m")
+                    self._send_line(f"PASS:{pw}")
+
+            elif msg == "PASS_OK":
+                print("\033[92m[Room password accepted]\033[0m")
+
+            elif msg == "WRONG_PASS":
+                print("\033[91m[Wrong password — access denied]\033[0m")
+                return False
+
+            elif msg == "BANNED":
+                print("\033[91m[You are banned from this server]\033[0m")
+                return False
+
+            elif msg == "AUTH_TYPE":
+                print("\n\033[96m1. Login\033[0m")
+                print("\033[96m2. Register\033[0m")
+                choice = input("\nChoice (1/2): ").strip()
+                if choice == "1":
+                    self._send_line("LOGIN")
+                elif choice == "2":
+                    self._send_line("REGISTER")
+                else:
+                    print("\033[91m[Invalid choice]\033[0m")
+                    return False
+
+            elif msg == "REG_USER":
+                self.nickname = input("\n\033[96mChoose a username: \033[0m").strip()
+                self._send_line(self.nickname)
+
+            elif msg == "REG_PASS":
+                pw = getpass.getpass("\033[96mChoose a password: \033[0m")
+                confirm = getpass.getpass("\033[96mConfirm: \033[0m")
+                if pw != confirm:
+                    print("\033[91m[Passwords don't match]\033[0m")
+                    return False
+                self._send_line(pw)
+
+            elif msg == "REG_OK":
+                print("\033[92m[Account created!]\033[0m")
+
+            elif msg == "REG_FAIL":
+                print("\033[91m[Registration failed]\033[0m")
+                return False
+
+            elif msg == "USER_EXISTS":
+                print("\033[91m[Username already taken]\033[0m")
+                return False
+
+            elif msg == "LOGIN_USER":
+                self.nickname = input("\n\033[96mUsername: \033[0m").strip()
+                self._send_line(self.nickname)
+
+            elif msg == "LOGIN_PASS":
+                pw = getpass.getpass("\033[96mPassword: \033[0m")
+                self._send_line(pw)
+
+            elif msg == "LOGIN_OK":
+                print("\033[92m[Login successful!]\033[0m")
+
+            elif msg == "LOGIN_FAIL":
+                print("\033[91m[Login failed — wrong password]\033[0m")
+                return False
+
+            elif msg == "NO_ACCOUNT":
+                print("\033[91m[Account doesn't exist — register first]\033[0m")
+                return False
+
+            elif msg == "ALREADY_ONLINE":
+                print("\033[91m[Account already logged in]\033[0m")
+                return False
+
+            elif msg == "CONNECTED":
+                return True
+
+            else:
+                # Non-protocol line — likely a chat message arriving early. Print it.
+                print(msg)
+
+    # ─────────────────────────────────────────
+    # RUNTIME
+    # ─────────────────────────────────────────
+
+    def _recv_loop(self):
+        buf = ""
+        while self.connected:
+            try:
+                chunk = self.sock.recv(2048).decode("utf-8", errors="replace")
+            except OSError:
+                break
+            if not chunk:
+                break
+            buf += chunk
+            while "\n" in buf:
+                line, buf = buf.split("\n", 1)
+                print(f"\r{line}")
+                print(f"\033[96m{self.nickname}\033[0m > ", end="", flush=True)
+        if self.connected:
+            print("\n\033[91m[Connection lost]\033[0m")
+        self.connected = False
+
+    def _send_loop(self):
+        while self.connected:
+            try:
+                line = input(f"\033[96m{self.nickname}\033[0m > ")
+            except (EOFError, KeyboardInterrupt):
+                break
+            if line.strip().lower() == "/quit":
+                break
+            if line.strip():
+                try:
+                    self.sock.sendall(line.encode("utf-8") + b"\n")
+                except OSError:
+                    break
+        self.connected = False
+        try:
+            self.sock.close()
+        except OSError:
+            pass
+
+    def start(self):
+        print(f"\033[93m[Connecting to {self.host}:{self.port}...]\033[0m")
+        try:
+            self.sock.connect((self.host, self.port))
+        except OSError as e:
+            print(f"\033[91m[Could not connect: {e}]\033[0m")
+            sys.exit(1)
+
+        if not self._handshake():
+            self.sock.close()
+            sys.exit(1)
+
+        # Server sends a welcome banner after CONNECTED — drain it briefly
+        time.sleep(0.2)
+
+        threading.Thread(target=self._recv_loop, daemon=True).start()
+        self._send_loop()
+
+
+def start_client(host, port, admin_key=None, use_tor=False):
+    c = ChatClient(host, port, admin_key=admin_key, use_tor=use_tor)
+    try:
+        c.start()
+    except KeyboardInterrupt:
+        print("\n\033[91m[Disconnected]\033[0m")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    import argparse
+    p = argparse.ArgumentParser(description="Veilchat chat client")
+    p.add_argument("host")
+    p.add_argument("port", nargs="?", type=int, default=5555)
+    p.add_argument("--tor", action="store_true")
+    args = p.parse_args()
+    start_client(args.host, args.port, use_tor=args.tor)