lantalk 2.0.0__py3-none-any.whl

lantalk/__init__.py

@@ -0,0 +1,2 @@
+"""LanTalk — terminal-based LAN chat."""
+__version__ = "1.1.0"

lantalk/cli.py

@@ -0,0 +1,54 @@
+"""
+lantalk.cli
+-----------
+Entry point for the `lantalk` command.
+"""
+
+import sys
+from lantalk.server import run_server, DEFAULT_PORT as SERVER_PORT
+from lantalk.client import run_client, DEFAULT_PORT as CLIENT_PORT
+
+VERSION = "2.0.0"
+
+BANNER = r"""
+  _                 _____     _ _
+ | |               |_   _|   | | |
+ | |     __ _ _ __  | | __ _| | | __
+ | |    / _` | '_ \ | |/ _` | | |/ /
+ | |___| (_| | | | || | (_| | |   <
+ |______\__,_|_| |_\_/ \__,_|_|_|\_\
+
+  LAN chat — instant, private, no internet needed.
+"""
+
+
+def _color(text: str, code: str) -> str:
+    return f"\033[{code}m{text}\033[0m"
+
+
+def main() -> None:
+    print(_color(BANNER, "1;35"))
+    print(_color(f"  v{VERSION}  •  pure asyncio  •  zero runtime dependencies\n", "35"))
+
+    print("  [1]  Start a Server")
+    print("  [2]  Join as Client")
+    print()
+
+    while True:
+        choice = input("Choose (1 or 2): ").strip()
+        if choice in ("1", "2"):
+            break
+        print(_color("Please enter 1 or 2.", "31"))
+
+    print()
+
+    if choice == "1":
+        port_in = input(f"Port (default {SERVER_PORT}): ").strip()
+        port = int(port_in) if port_in.isdigit() else SERVER_PORT
+        run_server(port=port)
+    else:
+        run_client(default_port=CLIENT_PORT)
+
+
+if __name__ == "__main__":
+    main()

lantalk/client.py

@@ -0,0 +1,269 @@
+"""
+lantalk.client
+--------------
+Async LAN chat client. Features:
+  - UDP auto-discovery (lists servers on LAN)
+  - JSON protocol with validation
+  - Password support
+  - /pm, /users, /quit commands
+  - Polished prompt: [username | lantalk] >
+  - Connection + read timeouts
+"""
+
+import asyncio
+import json
+import socket
+import sys
+from datetime import datetime
+from typing import Optional
+
+DEFAULT_PORT = 5050
+DISCOVERY_PORT = 5051
+ENCODING = "utf-8"
+DISCOVERY_TIMEOUT = 3.0
+CONNECT_TIMEOUT   = 5.0
+AUTH_TIMEOUT      = 10.0
+VERSION = "2.0.0"
+
+
+# ── Helpers ────────────────────────────────────────────────────────────────── #
+
+def _ts() -> str:
+    return datetime.now().strftime("%H:%M")
+
+
+def _color(text: str, code: str) -> str:
+    return f"\033[{code}m{text}\033[0m"
+
+
+def _make_msg(**kwargs) -> str:
+    return json.dumps(kwargs) + "\n"
+
+
+# ── UDP Discovery ──────────────────────────────────────────────────────────── #
+
+def discover_servers(timeout: float = DISCOVERY_TIMEOUT) -> list[tuple[str, int]]:
+    """Listen for UDP beacons and return list of (ip, port) tuples."""
+    found: dict[str, int] = {}
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.settimeout(timeout)
+        try:
+            sock.bind(("", DISCOVERY_PORT))
+        except OSError:
+            return []
+
+        import time
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            try:
+                data, _ = sock.recvfrom(256)
+                text = data.decode()
+                if text.startswith("LANTALK_SERVER:"):
+                    _, ip, port = text.split(":", 2)
+                    found[ip] = int(port)
+            except socket.timeout:
+                break
+            except (ValueError, UnicodeDecodeError):
+                continue
+
+    return list(found.items())
+
+
+# ── Client ─────────────────────────────────────────────────────────────────── #
+
+class LanTalkClient:
+    def __init__(self, host: str, port: int = DEFAULT_PORT,
+                 username: str = "User", password: str = ""):
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self._reader: Optional[asyncio.StreamReader] = None
+        self._writer: Optional[asyncio.StreamWriter] = None
+        self._running = False
+
+    def _prompt(self) -> str:
+        return _color(f"[{self.username} | lantalk] > ", "1;36")
+
+    async def _send(self, **kwargs):
+        if self._writer:
+            self._writer.write(_make_msg(**kwargs).encode(ENCODING))
+            await self._writer.drain()
+
+    # ── Receive loop ─────────────────────────────────────────────────────── #
+
+    async def _receive_loop(self):
+        while self._running:
+            try:
+                line = await self._reader.readline()
+            except (asyncio.IncompleteReadError, OSError, ConnectionResetError):
+                break
+            if not line:
+                break
+
+            try:
+                msg = json.loads(line.decode(ENCODING).strip())
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                continue
+
+            self._render(msg)
+
+        if self._running:
+            sys.stdout.write(
+                "\n" + _color("[Disconnected from server]\n", "31")
+            )
+            sys.stdout.flush()
+            self._running = False
+
+    def _render(self, msg: dict):
+        type_ = msg.get("type")
+        ts    = msg.get("ts", _ts())
+
+        sys.stdout.write("\r\033[K")  # clear prompt line
+
+        if type_ == "message":
+            user = msg.get("user", "?")
+            text = msg.get("text", "")
+            line = f"[{ts}] {_color(user, '36')}: {text}"
+        elif type_ == "pm":
+            from_user = msg.get("from_user", "?")
+            text = msg.get("text", "")
+            line = _color(f"[{ts}] 🔒 PM from {from_user}: {text}", "33")
+        elif type_ == "system":
+            line = _color(f"[{ts}] *** {msg.get('text', '')} ***", "32")
+        elif type_ in ("auth_ok", "auth_fail"):
+            line = _color(f"[{ts}] {msg.get('reason') or msg.get('text', '')}", "33")
+        else:
+            line = str(msg)
+
+        sys.stdout.write(line + "\n")
+        sys.stdout.write(self._prompt())
+        sys.stdout.flush()
+
+    # ── Send loop ─────────────────────────────────────────────────────────── #
+
+    async def _send_loop(self):
+        loop = asyncio.get_event_loop()
+        while self._running:
+            try:
+                text = await loop.run_in_executor(None, self._blocking_input)
+            except (EOFError, KeyboardInterrupt):
+                break
+
+            if not self._running:
+                break
+            text = text.strip()
+            if not text:
+                sys.stdout.write(self._prompt())
+                sys.stdout.flush()
+                continue
+
+            if text.lower() in ("/quit", "/exit", "/q"):
+                break
+
+            await self._send(type="message", text=text)
+
+        self._running = False
+
+    def _blocking_input(self) -> str:
+        sys.stdout.write(self._prompt())
+        sys.stdout.flush()
+        return sys.stdin.readline()
+
+    # ── Connect & handshake ───────────────────────────────────────────────── #
+
+    async def _connect(self):
+        try:
+            self._reader, self._writer = await asyncio.wait_for(
+                asyncio.open_connection(self.host, self.port),
+                timeout=CONNECT_TIMEOUT,
+            )
+        except (ConnectionRefusedError, OSError):
+            print(_color(f"[Error] Cannot connect to {self.host}:{self.port}", "31"))
+            sys.exit(1)
+        except asyncio.TimeoutError:
+            print(_color("[Error] Connection timed out.", "31"))
+            sys.exit(1)
+
+        # Auth handshake
+        line = await asyncio.wait_for(self._reader.readline(), timeout=AUTH_TIMEOUT)
+        req  = json.loads(line.decode().strip())
+        if req.get("type") != "auth_request":
+            print(_color("[Error] Unexpected handshake.", "31"))
+            sys.exit(1)
+
+        self._writer.write(
+            _make_msg(username=self.username, password=self.password).encode(ENCODING)
+        )
+        await self._writer.drain()
+
+        line   = await asyncio.wait_for(self._reader.readline(), timeout=AUTH_TIMEOUT)
+        result = json.loads(line.decode().strip())
+        if result.get("type") == "auth_fail":
+            print(_color(f"[Auth failed] {result.get('reason', '')}", "31"))
+            sys.exit(1)
+
+        self._running = True
+
+        print(_color("=" * 54, "36"))
+        print(_color(f"  LanTalk Client v{VERSION}  —  {self.username}", "1;36"))
+        print(_color(f"  Connected to {self.host}:{self.port}", "36"))
+        print(_color("  Commands: /users  /pm <user> <msg>  /quit", "36"))
+        print(_color("=" * 54, "36"))
+        sys.stdout.write(self._prompt())
+        sys.stdout.flush()
+
+        await asyncio.gather(
+            self._receive_loop(),
+            self._send_loop(),
+        )
+
+        try:
+            self._writer.close()
+            await self._writer.wait_closed()
+        except OSError:
+            pass
+        print(_color("Disconnected.", "31"))
+
+    def connect(self):
+        try:
+            asyncio.run(self._connect())
+        except KeyboardInterrupt:
+            print(_color("\nDisconnected.", "31"))
+
+
+# ── CLI entry ──────────────────────────────────────────────────────────────── #
+
+def run_client(default_port: int = DEFAULT_PORT) -> None:
+    print(_color("Scanning for LanTalk servers…", "33"))
+    servers = discover_servers()
+
+    if servers:
+        print(_color(f"Found {len(servers)} server(s):\n", "32"))
+        for i, (ip, port) in enumerate(servers, 1):
+            print(f"  [{i}] {ip}:{port}")
+        print("  [m] Enter manually\n")
+        choice = input("Choose server: ").strip()
+        if choice.isdigit() and 1 <= int(choice) <= len(servers):
+            host, port = servers[int(choice) - 1]
+        else:
+            host     = input("Server IP: ").strip()
+            port_in  = input(f"Port (default {default_port}): ").strip()
+            port     = int(port_in) if port_in.isdigit() else default_port
+    else:
+        print(_color("No servers found via auto-discovery.\n", "33"))
+        host    = input("Server IP: ").strip()
+        port_in = input(f"Port (default {default_port}): ").strip()
+        port    = int(port_in) if port_in.isdigit() else default_port
+
+    if not host:
+        print("IP address is required.")
+        sys.exit(1)
+
+    username = input("Display name: ").strip() or "User"
+    password = input("Password (leave blank if none): ").strip()
+
+    LanTalkClient(
+        host=host, port=port, username=username, password=password
+    ).connect()

lantalk/protocol.py

@@ -0,0 +1,72 @@
+"""
+lantalk.protocol
+----------------
+Shared message construction, parsing, and validation utilities.
+"""
+
+import json
+from datetime import datetime
+
+ENCODING = "utf-8"
+
+# Message type constants
+AUTH_REQUEST = "auth_request"
+AUTH_OK      = "auth_ok"
+AUTH_FAIL    = "auth_fail"
+MESSAGE      = "message"
+PM           = "pm"
+SYSTEM       = "system"
+
+VALID_TYPES = frozenset({
+    AUTH_REQUEST, AUTH_OK, AUTH_FAIL, MESSAGE, PM, SYSTEM
+})
+
+# Per-field constraints
+MAX_TEXT_LEN     = 2000
+MAX_USERNAME_LEN = 24
+
+
+def ts() -> str:
+    return datetime.now().strftime("%H:%M")
+
+
+def make(type_: str, **kwargs) -> str:
+    """Return a JSON-encoded protocol message terminated with newline."""
+    return json.dumps({"type": type_, "ts": ts(), **kwargs}) + "\n"
+
+
+def parse(line: str | bytes) -> dict:
+    """Parse a protocol line. Returns {} on error."""
+    if isinstance(line, bytes):
+        line = line.decode(ENCODING, errors="replace")
+    try:
+        return json.loads(line.strip())
+    except json.JSONDecodeError:
+        return {}
+
+
+def validate(msg: dict) -> tuple[bool, str]:
+    """
+    Validate a parsed message dict.
+    Returns (True, "") on success, (False, reason) on failure.
+    """
+    if not isinstance(msg, dict):
+        return False, "not a dict"
+    msg_type = msg.get("type")
+    if not isinstance(msg_type, str) or not msg_type:
+        return False, "missing type"
+    # Text field
+    text = msg.get("text")
+    if text is not None:
+        if not isinstance(text, str):
+            return False, "text must be a string"
+        if len(text) > MAX_TEXT_LEN:
+            return False, f"text too long (max {MAX_TEXT_LEN})"
+    # Username field
+    username = msg.get("username")
+    if username is not None:
+        if not isinstance(username, str):
+            return False, "username must be a string"
+        if len(username) > MAX_USERNAME_LEN:
+            return False, f"username too long (max {MAX_USERNAME_LEN})"
+    return True, ""

lantalk/server.py

@@ -0,0 +1,522 @@
+"""
+lantalk.server
+--------------
+Async LAN chat server (pure asyncio). Features:
+  - UDP broadcast for auto-discovery (pure asyncio, no threads)
+  - Optional password authentication (SHA-256)
+  - Duplicate username rejection
+  - JSON message protocol with full validation
+  - Rate limiting (kicks spammers)
+  - Connection timeouts via asyncio.wait_for
+  - /kick, /ban, /stats server commands
+  - Private messages (/pm)
+  - /users command
+  - Structured logging
+  - Persistent bans (bans.json)
+"""
+
+import asyncio
+import hashlib
+import json
+import logging
+import os
+import socket
+import sys
+from collections import deque
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+HOST = "0.0.0.0"
+DEFAULT_PORT = 5050
+DISCOVERY_PORT = 5051
+BUFFER = 8192
+ENCODING = "utf-8"
+VERSION = "2.0.0"
+
+BANS_FILE = Path("bans.json")
+RATE_LIMIT = 10        # max messages per window
+RATE_WINDOW = 5.0      # seconds
+READ_TIMEOUT = 300.0   # idle disconnect (5 min)
+AUTH_TIMEOUT = 15.0    # handshake timeout
+
+
+# ── Logging ────────────────────────────────────────────────────────────────── #
+
+def _setup_logging() -> logging.Logger:
+    logger = logging.getLogger("lantalk")
+    if not logger.handlers:
+        logger.setLevel(logging.DEBUG)
+        fmt = logging.Formatter("[%(asctime)s] %(levelname)s  %(message)s",
+                                datefmt="%H:%M:%S")
+        ch = logging.StreamHandler(sys.stdout)
+        ch.setFormatter(fmt)
+        ch.setLevel(logging.INFO)
+        fh = logging.FileHandler("lantalk.log", encoding="utf-8")
+        fh.setFormatter(fmt)
+        fh.setLevel(logging.DEBUG)
+        logger.addHandler(ch)
+        logger.addHandler(fh)
+    return logger
+
+log = _setup_logging()
+
+
+# ── Helpers ────────────────────────────────────────────────────────────────── #
+
+def _ts() -> str:
+    return datetime.now().strftime("%H:%M")
+
+
+def _color(text: str, code: str) -> str:
+    return f"\033[{code}m{text}\033[0m"
+
+
+def _hash(password: str) -> str:
+    return hashlib.sha256(password.encode()).hexdigest()
+
+
+def _make_msg(type_: str, **kwargs) -> str:
+    return json.dumps({"type": type_, "ts": _ts(), **kwargs}) + "\n"
+
+
+def _get_lan_ip() -> str:
+    try:
+        probe = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        probe.connect(("8.8.8.8", 80))
+        ip = probe.getsockname()[0]
+        probe.close()
+        return ip
+    except OSError:
+        return "127.0.0.1"
+
+
+# ── Message validation ─────────────────────────────────────────────────────── #
+
+VALID_TYPES = {"message", "pm", "system", "auth_request", "auth_ok", "auth_fail"}
+
+def _validate(msg: dict) -> bool:
+    """Return True if msg has the minimum required fields and sensible values."""
+    if not isinstance(msg, dict):
+        return False
+    if "type" not in msg:
+        return False
+    if not isinstance(msg.get("type"), str):
+        return False
+    # Text field sanity
+    text = msg.get("text")
+    if text is not None and not isinstance(text, str):
+        return False
+    if isinstance(text, str) and len(text) > 2000:
+        return False
+    return True
+
+
+# ── Persistent bans ────────────────────────────────────────────────────────── #
+
+def _load_bans() -> set:
+    if BANS_FILE.exists():
+        try:
+            return set(json.loads(BANS_FILE.read_text(encoding="utf-8")))
+        except Exception:
+            pass
+    return set()
+
+
+def _save_bans(banned: set) -> None:
+    try:
+        BANS_FILE.write_text(json.dumps(sorted(banned), indent=2), encoding="utf-8")
+    except Exception as e:
+        log.warning("Could not save bans.json: %s", e)
+
+
+# ── Pure-asyncio UDP discovery beacon ─────────────────────────────────────── #
+
+class _DiscoveryProtocol(asyncio.DatagramProtocol):
+    """Minimal UDP sink — we send, we don't receive."""
+    def error_received(self, exc):
+        log.debug("Discovery UDP error: %s", exc)
+    def connection_lost(self, exc):
+        pass
+
+
+async def _discovery_beacon(lan_ip: str, port: int, stop_event: asyncio.Event):
+    """Broadcast LANTALK_SERVER beacon every 2 s without spawning a thread."""
+    message = f"LANTALK_SERVER:{lan_ip}:{port}".encode()
+    loop = asyncio.get_running_loop()
+    transport = None
+    try:
+        transport, _ = await loop.create_datagram_endpoint(
+            _DiscoveryProtocol,
+            local_addr=("0.0.0.0", 0),
+            family=socket.AF_INET,
+            allow_broadcast=True,
+        )
+        while not stop_event.is_set():
+            try:
+                transport.sendto(message, ("<broadcast>", DISCOVERY_PORT))
+            except Exception as e:
+                log.debug("Beacon send error: %s", e)
+            try:
+                await asyncio.wait_for(stop_event.wait(), timeout=2)
+            except asyncio.TimeoutError:
+                pass
+    finally:
+        if transport:
+            transport.close()
+
+
+# ── Client state ───────────────────────────────────────────────────────────── #
+
+class _RateLimiter:
+    """Sliding-window rate limiter."""
+    def __init__(self, limit: int, window: float):
+        self._limit = limit
+        self._window = window
+        self._timestamps: deque = deque()
+
+    def is_allowed(self) -> bool:
+        import time as _time
+        now = _time.monotonic()
+        while self._timestamps and now - self._timestamps[0] > self._window:
+            self._timestamps.popleft()
+        if len(self._timestamps) >= self._limit:
+            return False
+        self._timestamps.append(_time.monotonic())
+        return True
+
+
+class Client:
+    def __init__(self, username: str, reader: asyncio.StreamReader,
+                 writer: asyncio.StreamWriter):
+        self.username = username
+        self.reader = reader
+        self.writer = writer
+        self.addr = writer.get_extra_info("peername", ("?", 0))
+        self.joined_at = datetime.now()
+        self.rate = _RateLimiter(RATE_LIMIT, RATE_WINDOW)
+
+    async def send(self, payload: str):
+        try:
+            self.writer.write(payload.encode(ENCODING))
+            await self.writer.drain()
+        except (OSError, ConnectionResetError):
+            pass
+
+
+# ── Server ─────────────────────────────────────────────────────────────────── #
+
+class LanTalkServer:
+    def __init__(self, port: int = DEFAULT_PORT, username: str = "Server",
+                 password: Optional[str] = None):
+        self.port = port
+        self.username = username
+        self.password_hash: Optional[str] = _hash(password) if password else None
+        self.lan_ip = _get_lan_ip()
+
+        self._clients: dict[str, Client] = {}
+        self._banned: set[str] = _load_bans()
+        self._lock = asyncio.Lock()
+        self._server: Optional[asyncio.AbstractServer] = None
+        self._stop_beacon = asyncio.Event()
+
+    # ── Broadcast / send helpers ──────────────────────────────────────────── #
+
+    async def _broadcast(self, payload: str, exclude: Optional[str] = None):
+        async with self._lock:
+            targets = list(self._clients.values())
+        for c in targets:
+            if c.username != exclude:
+                await c.send(payload)
+
+    async def _send_to(self, username: str, payload: str) -> bool:
+        async with self._lock:
+            c = self._clients.get(username)
+        if c:
+            await c.send(payload)
+            return True
+        return False
+
+    async def _remove(self, username: str, announce: bool = True):
+        async with self._lock:
+            c = self._clients.pop(username, None)
+        if c:
+            try:
+                c.writer.close()
+                await c.writer.wait_closed()
+            except OSError:
+                pass
+            if announce:
+                msg = _make_msg("system", text=f"{username} left the chat.")
+                log.info("%s left.", username)
+                await self._broadcast(msg)
+
+    # ── Client handler ────────────────────────────────────────────────────── #
+
+    async def _handle(self, reader: asyncio.StreamReader,
+                      writer: asyncio.StreamWriter):
+        addr = writer.get_extra_info("peername", ("?", 0))
+        ip = addr[0]
+
+        if ip in self._banned:
+            writer.close()
+            log.info("Rejected banned IP %s", ip)
+            return
+
+        async def send_raw(payload: str):
+            writer.write(payload.encode(ENCODING))
+            await writer.drain()
+
+        # ① Auth handshake
+        await send_raw(_make_msg("auth_request",
+                                 needs_password=self.password_hash is not None))
+        try:
+            line = await asyncio.wait_for(reader.readline(), timeout=AUTH_TIMEOUT)
+        except asyncio.TimeoutError:
+            writer.close()
+            log.debug("Auth timeout from %s", ip)
+            return
+
+        try:
+            auth = json.loads(line.decode(ENCODING).strip())
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            writer.close()
+            return
+
+        username = (auth.get("username") or "").strip()[:24]
+        given_pw = auth.get("password") or ""
+
+        # Username validation
+        if not username or not username.replace("_", "").replace("-", "").isalnum():
+            await send_raw(_make_msg("auth_fail", reason="Invalid username."))
+            writer.close()
+            return
+
+        async with self._lock:
+            taken = username in self._clients
+        if taken:
+            await send_raw(_make_msg("auth_fail", reason="Username already taken."))
+            writer.close()
+            return
+
+        if self.password_hash and _hash(given_pw) != self.password_hash:
+            await send_raw(_make_msg("auth_fail", reason="Wrong password."))
+            log.warning("Wrong password attempt for '%s' from %s", username, ip)
+            writer.close()
+            return
+
+        # ② Register client
+        client = Client(username, reader, writer)
+        async with self._lock:
+            self._clients[username] = client
+
+        await send_raw(_make_msg("auth_ok", username=username,
+                                 server_name=self.username))
+        log.info("%s joined from %s", username, ip)
+        await self._broadcast(
+            _make_msg("system", text=f"{username} joined from {ip}."),
+            exclude=username,
+        )
+
+        # ③ Message loop
+        try:
+            while True:
+                try:
+                    line = await asyncio.wait_for(
+                        reader.readline(), timeout=READ_TIMEOUT
+                    )
+                except asyncio.TimeoutError:
+                    await client.send(
+                        _make_msg("system", text="Idle timeout — disconnecting.")
+                    )
+                    break
+
+                if not line:
+                    break
+
+                try:
+                    msg = json.loads(line.decode(ENCODING).strip())
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    log.debug("Malformed message from %s — ignored", username)
+                    continue
+
+                if not _validate(msg):
+                    log.debug("Invalid message structure from %s — ignored", username)
+                    continue
+
+                if msg.get("type") == "message":
+                    text = str(msg.get("text", "")).strip()
+                    if not text:
+                        continue
+
+                    # Rate limiting
+                    if not client.rate.is_allowed():
+                        await client.send(
+                            _make_msg("system",
+                                      text="⚠ Slow down — you're sending too fast.")
+                        )
+                        log.warning("%s hit rate limit", username)
+                        continue
+
+                    if text.startswith("/"):
+                        await self._handle_client_command(client, text)
+                    else:
+                        log.debug("<%s> %s", username, text)
+                        await self._broadcast(
+                            _make_msg("message", user=username, text=text),
+                            exclude=username,
+                        )
+        finally:
+            await self._remove(username)
+
+    async def _handle_client_command(self, client: Client, text: str):
+        parts = text.split(maxsplit=2)
+        cmd = parts[0].lower()
+
+        if cmd == "/users":
+            async with self._lock:
+                names = list(self._clients.keys())
+            await client.send(
+                _make_msg("system", text="Online: " + ", ".join(names))
+            )
+        elif cmd == "/pm" and len(parts) >= 3:
+            target, pm_text = parts[1], parts[2]
+            payload = _make_msg("pm", from_user=client.username, text=pm_text)
+            if not await self._send_to(target, payload):
+                await client.send(
+                    _make_msg("system", text=f"User '{target}' not found.")
+                )
+        elif cmd in ("/quit", "/exit", "/q"):
+            await client.send(_make_msg("system", text="Goodbye!"))
+        else:
+            await client.send(
+                _make_msg("system", text=f"Unknown command: {cmd}")
+            )
+
+    # ── Server console commands ───────────────────────────────────────────── #
+
+    async def _server_console(self):
+        loop = asyncio.get_event_loop()
+        while True:
+            try:
+                text = await loop.run_in_executor(None, input, "")
+            except (EOFError, KeyboardInterrupt):
+                break
+            text = text.strip()
+            if not text:
+                continue
+
+            parts = text.split(maxsplit=1)
+            cmd = parts[0].lower()
+
+            if cmd in ("/quit", "/exit", "/q"):
+                log.info("Server shutting down.")
+                self._stop_beacon.set()
+                if self._server:
+                    self._server.close()
+                break
+
+            elif cmd == "/users":
+                async with self._lock:
+                    names = list(self._clients.keys())
+                print(_color("Online: " + (", ".join(names) or "(none)"), "36"))
+
+            elif cmd == "/stats":
+                async with self._lock:
+                    count = len(self._clients)
+                print(_color(
+                    f"Connected: {count}  |  Banned IPs: {len(self._banned)}", "36"
+                ))
+
+            elif cmd == "/kick" and len(parts) == 2:
+                target = parts[1].strip()
+                if target in self._clients:
+                    await self._send_to(
+                        target, _make_msg("system", text="You have been kicked.")
+                    )
+                    await self._remove(target)
+                    log.info("Kicked %s", target)
+                else:
+                    print(_color(f"User '{target}' not found.", "31"))
+
+            elif cmd == "/ban" and len(parts) == 2:
+                target = parts[1].strip()
+                async with self._lock:
+                    c = self._clients.get(target)
+                if c:
+                    self._banned.add(c.addr[0])
+                    _save_bans(self._banned)
+                    await self._send_to(
+                        target, _make_msg("system", text="You have been banned.")
+                    )
+                    await self._remove(target)
+                    log.info("Banned %s (%s)", target, c.addr[0])
+                else:
+                    print(_color(f"User '{target}' not found.", "31"))
+
+            elif cmd == "/unban" and len(parts) == 2:
+                ip = parts[1].strip()
+                if ip in self._banned:
+                    self._banned.discard(ip)
+                    _save_bans(self._banned)
+                    log.info("Unbanned %s", ip)
+                    print(_color(f"Unbanned {ip}", "32"))
+                else:
+                    print(_color(f"IP {ip} not in ban list.", "31"))
+
+            elif cmd == "/bans":
+                if self._banned:
+                    print(_color("Banned IPs: " + ", ".join(sorted(self._banned)), "36"))
+                else:
+                    print(_color("No banned IPs.", "36"))
+
+            elif cmd == "/help":
+                print(_color(
+                    "/users  /stats  /kick <user>  /ban <user>  "
+                    "/bans  /unban <ip>  /quit",
+                    "36"
+                ))
+
+            else:
+                # Server chat
+                msg = _make_msg("message", user=self.username + " (server)", text=text)
+                log.debug("[server] %s", text)
+                await self._broadcast(msg)
+
+    # ── Start ─────────────────────────────────────────────────────────────── #
+
+    async def _run(self):
+        self._server = await asyncio.start_server(
+            self._handle, HOST, self.port
+        )
+
+        print(_color("=" * 54, "35"))
+        print(_color(f"  LanTalk Server v{VERSION}  —  {self.username}", "1;35"))
+        print(_color(f"  Listening on  {self.lan_ip}:{self.port}", "35"))
+        print(_color(f"  Discovery beacon active (UDP {DISCOVERY_PORT})", "35"))
+        if self.password_hash:
+            print(_color("  Password protection: ON", "35"))
+        if self._banned:
+            print(_color(f"  Loaded {len(self._banned)} persistent ban(s)", "35"))
+        print(_color("  /help for server commands", "35"))
+        print(_color("=" * 54, "35"))
+        log.info("Server started on %s:%s", self.lan_ip, self.port)
+
+        async with self._server:
+            await asyncio.gather(
+                self._server.serve_forever(),
+                self._server_console(),
+                _discovery_beacon(self.lan_ip, self.port, self._stop_beacon),
+            )
+
+    def start(self):
+        try:
+            asyncio.run(self._run())
+        except KeyboardInterrupt:
+            pass
+
+
+def run_server(port: int = DEFAULT_PORT) -> None:
+    username = input("Server display name: ").strip() or "Server"
+    pw = input("Set password (leave blank for none): ").strip() or None
+    LanTalkServer(port=port, username=username, password=pw).start()

lantalk-2.0.0.dist-info/METADATA

@@ -0,0 +1,300 @@
+Metadata-Version: 2.4
+Name: lantalk
+Version: 2.0.0
+Summary: Terminal-based LAN chat — async, discoverable, secure
+Author-email: Ezra Destaw <ezradestaw@email.com>
+Project-URL: Homepage, https://github.com/Ezradestaw/lantalk
+Project-URL: Repository, https://github.com/Ezradestaw/lantalk
+Project-URL: Issues, https://github.com/Ezradestaw/lantalk/issues
+Keywords: chat,lan,wifi,terminal,networking,broadcast,asyncio
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Internet
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Dynamic: license-file
+
+# LanTalk
+
+> Terminal-based LAN chat — pure asyncio, auto-discoverable, zero runtime dependencies.
+
+```
+  _                 _____     _ _
+ | |               |_   _|   | | |
+ | |     __ _ _ __  | | __ _| | | __
+ | |    / _` | '_ \ | |/ _` | | |/ /
+ | |___| (_| | | | || | (_| | |   <
+ |______\__,_|_| |_\_/ \__,_|_|_|\_\
+```
+
+[![PyPI version](https://img.shields.io/pypi/v/lantalk)](https://pypi.org/project/lantalk/)
+[![Python](https://img.shields.io/pypi/pyversions/lantalk)](https://pypi.org/project/lantalk/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+---
+
+## What is LanTalk?
+
+LanTalk lets people on the **same Wi-Fi or LAN** chat instantly — no accounts, no internet, no servers in the cloud. One person runs `lantalk` and starts a server; everyone else runs `lantalk` and joins. That's it.
+
+- Works on school networks, home networks, offices, hackathons
+- Pure Python stdlib — nothing to `pip install` beyond the package itself
+- Clients auto-discover the server via UDP broadcast (no IP typing required)
+
+---
+
+## Features
+
+| | |
+|---|---|
+| 🔍 **Auto-discovery** | UDP beacon finds servers on your LAN automatically |
+| 🔐 **Password auth** | Optional server password with SHA-256 hashing |
+| 👤 **Username dedup** | Two people can't use the same name simultaneously |
+| 💬 **Private messages** | `/pm <user> <message>` — end-to-end on the wire |
+| 🛡 **Rate limiting** | Spammers get warned then kicked (10 msg / 5 s) |
+| ⏱ **Idle timeouts** | Dead sockets cleaned up after 5 minutes of silence |
+| 🚫 **Persistent bans** | Banned IPs survive server restarts via `bans.json` |
+| 🔇 **Full validation** | Every message checked for type and field constraints |
+| 📝 **Structured logging** | Console + `lantalk.log` file, levels DEBUG/INFO/WARNING |
+| ⚡ **Pure asyncio** | Single event loop — no threads, no race conditions |
+
+---
+
+## Install
+
+```bash
+pip install lantalk
+```
+
+Python 3.10+ required. No third-party dependencies.
+
+### From source
+
+```bash
+git clone https://github.com/yourusername/lantalk
+cd lantalk
+pip install -e ".[dev]"
+```
+
+---
+
+## Quick start
+
+### 1 — Start a server (one person does this)
+
+```
+$ lantalk
+
+  [1]  Start a Server
+  [2]  Join as Client
+
+Choose (1 or 2): 1
+Port (default 5050):
+Server display name: Alice
+Set password (leave blank for none): secret
+
+══════════════════════════════════════════════════════
+  LanTalk Server v2.0.0  —  Alice
+  Listening on  192.168.1.5:5050
+  Discovery beacon active (UDP 5051)
+  Password protection: ON
+══════════════════════════════════════════════════════
+```
+
+### 2 — Join as a client (everyone else)
+
+```
+$ lantalk
+
+  [1]  Start a Server
+  [2]  Join as Client
+
+Choose (1 or 2): 2
+Scanning for LanTalk servers…
+Found 1 server(s):
+
+  [1] 192.168.1.5:5050
+  [m] Enter manually
+
+Choose server: 1
+Display name: Bob
+Password: secret
+
+══════════════════════════════════════════════════════
+  LanTalk Client v2.0.0  —  Bob
+  Connected to 192.168.1.5:5050
+  Commands: /users  /pm <user> <msg>  /quit
+══════════════════════════════════════════════════════
+[Bob | lantalk] > Hey everyone!
+[14:22] Alice: Welcome Bob!
+[Bob | lantalk] > /pm Alice just between us 👋
+[Bob | lantalk] > /users
+[14:23] *** Online: Alice, Bob, Carol ***
+[Bob | lantalk] >
+```
+
+---
+
+## Commands
+
+### Client commands
+
+| Command | Description |
+|---------|-------------|
+| `/users` | List all connected users |
+| `/pm <user> <message>` | Send a private message |
+| `/quit` | Disconnect and exit |
+
+### Server console commands
+
+| Command | Description |
+|---------|-------------|
+| `/users` | List connected users |
+| `/stats` | Show connection count and ban list size |
+| `/kick <user>` | Disconnect a user |
+| `/ban <user>` | Ban a user's IP (persisted to `bans.json`) |
+| `/bans` | Show all banned IPs |
+| `/unban <ip>` | Remove an IP from the ban list |
+| `/help` | Show this list |
+| `/quit` | Shut down the server |
+| *(anything else)* | Broadcast as a server message to all clients |
+
+---
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│  LAN  (e.g. 192.168.1.0/24)                                  │
+│                                                              │
+│  ┌────────────────────────────────────┐                      │
+│  │  LanTalkServer  (pure asyncio)     │                      │
+│  │                                    │◄─── TCP :5050 ───┐   │
+│  │  _discovery_beacon()  ─────────────┼──── UDP bcast    │   │
+│  │  asyncio coroutine, no threads     │     every 2 s    │   │
+│  │                                    │                  │   │
+│  │  per-client _RateLimiter           │                  │   │
+│  │  _validate() on every message      │                  │   │
+│  │  asyncio.wait_for() timeouts       │                  │   │
+│  │  bans.json  (persistent)           │                  │   │
+│  │  lantalk.log  (structured)         │                  │   │
+│  └────────────────────────────────────┘                  │   │
+│                                                          │   │
+│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────┴─┐ │
+│  │ Client A     │  │ Client B     │  │ Client C           │ │
+│  │ UDP discover │  │ UDP discover │  │ manual IP entry    │ │
+│  │ asyncio      │  │ asyncio      │  │ asyncio            │ │
+│  └──────────────┘  └──────────────┘  └────────────────────┘ │
+└──────────────────────────────────────────────────────────────┘
+
+Message flow (post-auth):
+  Client ──JSON──► Server ──broadcast JSON──► all other Clients
+                          └──(PM)──────────► one Client
+```
+
+### Concurrency model
+
+Everything runs in **one asyncio event loop** — no `threading.Thread`, no locks between threads, no shared mutable state across OS threads. The only `asyncio.Lock` is used to guard the `_clients` dict between concurrent coroutines.
+
+### JSON wire protocol
+
+Every message is a single UTF-8 JSON line terminated with `\n`.
+
+```jsonc
+// Server → Client: auth challenge
+{"type": "auth_request", "ts": "14:22", "needs_password": true}
+
+// Client → Server: credentials
+{"username": "Bob", "password": "secret"}
+
+// Server → Client: success / failure
+{"type": "auth_ok",   "ts": "…", "username": "Bob", "server_name": "Alice"}
+{"type": "auth_fail", "ts": "…", "reason": "Username already taken."}
+
+// Client → Server: chat message
+{"type": "message", "text": "Hello!"}
+
+// Server → all clients: broadcast
+{"type": "message", "ts": "14:22", "user": "Bob", "text": "Hello!"}
+
+// Server → one client: private message
+{"type": "pm", "ts": "14:22", "from_user": "Alice", "text": "hey"}
+
+// Server → clients: system event
+{"type": "system", "ts": "14:22", "text": "Bob joined from 192.168.1.10."}
+```
+
+---
+
+## Security notes
+
+- Passwords are **never stored or sent in plaintext**. The server stores a SHA-256 hash; clients send the raw password only during the auth handshake (upgrade to TLS in v3 is planned).
+- Banned IPs are written to `bans.json` in the server's working directory and reloaded on every start.
+- Rate limiting: each client is capped at **10 messages per 5 seconds**. Exceeding this sends a warning; repeat offences kick the user.
+- Usernames are limited to 24 alphanumeric/underscore/hyphen characters.
+- All incoming messages are schema-validated before processing; malformed JSON is silently dropped.
+
+---
+
+## Logging
+
+LanTalk writes structured logs to both the terminal and `lantalk.log`:
+
+```
+[14:22:01] INFO   Server started on 192.168.1.5:5050
+[14:22:15] INFO   Bob joined from 192.168.1.10
+[14:23:44] WARNING  Carol hit rate limit
+[14:25:01] INFO   Kicked Dave
+[14:25:03] INFO   Banned Dave (192.168.1.22)
+```
+
+Set `LANTALK_LOG_LEVEL=DEBUG` to see per-message traces.
+
+---
+
+## Running tests
+
+```bash
+pip install -e ".[dev]"
+pytest -v
+```
+
+---
+
+## Changelog
+
+```
+2.0.0  — pure asyncio (no threads), validation, rate limiting,
+          timeouts, persistent bans, structured logging, v2 prompt
+1.1.0  — asyncio rewrite, UDP discovery, JSON protocol, auth, commands, pytest
+1.0.0  — initial: threading, basic TCP, plain-text protocol
+```
+
+---
+
+## Roadmap
+
+- [ ] TLS encryption (v3)
+- [ ] File transfer (`/send file.pdf`)
+- [ ] Web UI mode (`http://localhost:5050`)
+- [ ] Plugin system (`@lantalk.plugin`)
+
+---
+
+## License
+
+MIT © Ezra

lantalk-2.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+lantalk/__init__.py,sha256=eA0Hf6CMeVoA1eMZAcKSE6Rsv2E6MGzYxZDQyA6Ek4E,65
+lantalk/cli.py,sha256=dsVKrcy_9EkFMNzWVw19Bj4xhVhBSNgtMdK5h2LG6MQ,1307
+lantalk/client.py,sha256=Xx74SBCccoZsw-yFP6GLf5qbQjucnasuYdWc6gK7HTs,9689
+lantalk/protocol.py,sha256=mb_MrfRfSzyXK2AQL8Ugp1FKhk02XnmMudeWPV1oG9s,1961
+lantalk/server.py,sha256=Enrv23LPpjGwXi_QnSBeUTErqBO5r1Gi8Rd810XVcP0,19363
+lantalk-2.0.0.dist-info/licenses/LICENCE,sha256=5LD6OPAP1Fr90OIiWhFsVm1iWY4TR5rICgyNebC5n_k,1087
+lantalk-2.0.0.dist-info/METADATA,sha256=Z3DyPbsheed2RTR8bYNU0yLVsteDyVUo52GcaSlcQ7U,11181
+lantalk-2.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+lantalk-2.0.0.dist-info/entry_points.txt,sha256=D7PNHGH90TMA-5XYPKTt2z1MUv6YcjbuLA-i4_r2Hn8,45
+lantalk-2.0.0.dist-info/top_level.txt,sha256=RvuhHjamhH-V0tKW2wCkJtOxfEL3tnjI0-bp9tYnlXI,8
+lantalk-2.0.0.dist-info/RECORD,,

lantalk-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lantalk-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lantalk = lantalk.cli:main

lantalk-2.0.0.dist-info/licenses/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ezra Destaw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lantalk-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lantalk