zapchat 3.0.0__tar.gz

zapchat-3.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Samarth Chugh (Sam3360)
+
+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.

zapchat-3.0.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: zapchat
+Version: 3.0.0
+Summary: Terminal-native LAN chat. No accounts, no cloud, no servers - just your local network.
+Author: Samarth Chugh (Sam3360)
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Sam3360/zapchatnpm
+Project-URL: Repository, https://github.com/Sam3360/zapchatnpm
+Project-URL: Issues, https://github.com/Sam3360/zapchatnpm/issues
+Keywords: lan,chat,cli,terminal,p2p,udp,discovery,local-network
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Communications :: Chat
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Dynamic: license-file
+
+# zapchat (Python)
+
+**Terminal-native LAN chat. No accounts, no cloud, no servers — just your
+local network.**
+
+This is the Python distribution of [zapchat](https://github.com/Sam3360/zapchatnpm).
+It speaks the same discovery protocol as the Node.js version, so a Python user
+and an npm user on the same Wi-Fi can chat with each other.
+
+> The Python client runs the proven protocol v1 wire format (JSON envelopes
+> over TCP, signed discovery beacons). The Node.js client's protocol v2 adds
+> TLS-style encryption on top of the same envelope shapes — the Python client
+> interoperates with npm peers via the shared discovery and messaging format.
+
+## Install
+
+```bash
+pip install zapchat
+```
+
+## Run
+
+```bash
+zapchat
+```
+
+That is it. Everyone on the same network who runs `zapchat` shows up
+automatically, and you can start chatting.
+
+```
+zapchat 3.0.0 — LAN chat, no accounts, no server
+  you are sam on #general (tcp:45913)
+  waiting for people on this network... (ctrl+c to quit, /help)
+* alex connected
+10:24 alex: morning all
+10:25 sam: morning! which room are we using today?
+```
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `/help` | Show the command list |
+| `/rooms` | Rooms discovered on the LAN |
+| `/users` `/who` | Who is on the LAN and connected |
+| `/join <room>` | Join a room (created if nobody is in it) |
+| `/name <username>` | Change your display name |
+| `/connect <ip[:port]>` | Connect straight to a peer when discovery is blocked |
+| `/status` | Discovery state, ports, peers |
+| `/quit` | Exit |
+
+## How it works
+
+- Every instance sends a small UDP beacon (multicast + subnet broadcast)
+  announcing its username, room and TCP port.
+- Beacons are how instances find each other; then they open direct TCP
+  connections and exchange newline-delimited JSON messages.
+- Rooms are derived, not stored: a room exists while somebody is in it.
+- There is no server of any kind. If the LAN works, zapchat works.
+
+Works with the npm version of zapchat on the same network (same beacons, same
+message protocol).
+
+## Privacy
+
+- No accounts, no telemetry, no cloud: the only network traffic is UDP
+  beacons and TCP messages on your local network.
+- Config is one small JSON file (your username, a random client id, the last
+  room). Chat history stays in memory.
+- Messages are plain text on your LAN — anyone who can capture that traffic
+  can read it. For sensitive conversations use an encrypted messenger.
+
+## Requirements
+
+- Python 3.9+ (standard library only — zero dependencies)
+- Python 3.9+ on any OS: Windows, macOS, Linux
+
+## License
+
+MIT © Samarth Chugh (Sam3360)

zapchat-3.0.0/README.md

@@ -0,0 +1,80 @@
+# zapchat (Python)
+
+**Terminal-native LAN chat. No accounts, no cloud, no servers — just your
+local network.**
+
+This is the Python distribution of [zapchat](https://github.com/Sam3360/zapchatnpm).
+It speaks the same discovery protocol as the Node.js version, so a Python user
+and an npm user on the same Wi-Fi can chat with each other.
+
+> The Python client runs the proven protocol v1 wire format (JSON envelopes
+> over TCP, signed discovery beacons). The Node.js client's protocol v2 adds
+> TLS-style encryption on top of the same envelope shapes — the Python client
+> interoperates with npm peers via the shared discovery and messaging format.
+
+## Install
+
+```bash
+pip install zapchat
+```
+
+## Run
+
+```bash
+zapchat
+```
+
+That is it. Everyone on the same network who runs `zapchat` shows up
+automatically, and you can start chatting.
+
+```
+zapchat 3.0.0 — LAN chat, no accounts, no server
+  you are sam on #general (tcp:45913)
+  waiting for people on this network... (ctrl+c to quit, /help)
+* alex connected
+10:24 alex: morning all
+10:25 sam: morning! which room are we using today?
+```
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `/help` | Show the command list |
+| `/rooms` | Rooms discovered on the LAN |
+| `/users` `/who` | Who is on the LAN and connected |
+| `/join <room>` | Join a room (created if nobody is in it) |
+| `/name <username>` | Change your display name |
+| `/connect <ip[:port]>` | Connect straight to a peer when discovery is blocked |
+| `/status` | Discovery state, ports, peers |
+| `/quit` | Exit |
+
+## How it works
+
+- Every instance sends a small UDP beacon (multicast + subnet broadcast)
+  announcing its username, room and TCP port.
+- Beacons are how instances find each other; then they open direct TCP
+  connections and exchange newline-delimited JSON messages.
+- Rooms are derived, not stored: a room exists while somebody is in it.
+- There is no server of any kind. If the LAN works, zapchat works.
+
+Works with the npm version of zapchat on the same network (same beacons, same
+message protocol).
+
+## Privacy
+
+- No accounts, no telemetry, no cloud: the only network traffic is UDP
+  beacons and TCP messages on your local network.
+- Config is one small JSON file (your username, a random client id, the last
+  room). Chat history stays in memory.
+- Messages are plain text on your LAN — anyone who can capture that traffic
+  can read it. For sensitive conversations use an encrypted messenger.
+
+## Requirements
+
+- Python 3.9+ (standard library only — zero dependencies)
+- Python 3.9+ on any OS: Windows, macOS, Linux
+
+## License
+
+MIT © Samarth Chugh (Sam3360)

zapchat-3.0.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zapchat"
+version = "3.0.0"
+description = "Terminal-native LAN chat. No accounts, no cloud, no servers - just your local network."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Samarth Chugh (Sam3360)" }]
+keywords = ["lan", "chat", "cli", "terminal", "p2p", "udp", "discovery", "local-network"]
+classifiers = [
+    "Environment :: Console",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Communications :: Chat",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["build>=1.2"]
+
+[project.scripts]
+zapchat = "zapchat.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/Sam3360/zapchatnpm"
+Repository = "https://github.com/Sam3360/zapchatnpm"
+Issues = "https://github.com/Sam3360/zapchatnpm/issues"
+
+[tool.setuptools]
+packages = ["zapchat"]

zapchat-3.0.0/setup.cfg

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

zapchat-3.0.0/tests/test_protocol.py

@@ -0,0 +1,81 @@
+"""Tests for the wire protocol helpers."""
+
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from zapchat.protocol import (
+    create_envelope,
+    decode_frames,
+    encode_envelope,
+    parse_announce_data,
+    parse_envelope,
+    parse_message_data,
+    sanitize_room_name,
+    sanitize_username,
+)
+
+
+def test_roundtrip_envelope():
+    sender = {"clientId": "zc-test-1234", "username": "sam"}
+    envelope = create_envelope("MESSAGE", sender["clientId"], sender["username"], room="general", data={"text": "hi"})
+    wire = encode_envelope(envelope)
+    parsed, leftover = decode_frames(wire)
+    assert leftover == ""
+    assert len(parsed) == 1
+    assert parsed[0]["type"] == "MESSAGE"
+    assert parsed[0]["data"]["text"] == "hi"
+
+
+def test_rejects_garbage():
+    for bad in ["hello", None, [], 42]:
+        assert parse_envelope(bad) is None
+
+
+def test_rejects_wrong_version_and_types():
+    envelope = create_envelope("PING", "zc-test-1234", "sam")
+    assert parse_envelope({**envelope, "v": 99}) is None
+    assert parse_envelope({**envelope, "type": "DROP TABLE"}) is None
+    assert parse_envelope({**envelope, "from": "x"}) is None
+
+
+def test_strips_control_characters():
+    # ANSI styling is stripped and the remaining name is clean text —
+    # matching the npm client's repair-don't-reject behaviour.
+    assert sanitize_username("\x1b[31mhacker\x1b[0m\x07") == "hacker"
+    text = parse_message_data({"text": "hi\x1b[31mthere"})
+    assert text == "hithere"
+    # Pure control garbage with no usable name is rejected.
+    assert sanitize_username("\x07\x1b") is None
+
+
+def test_room_names_are_normalised():
+    assert sanitize_room_name("General") == "general"
+    assert sanitize_room_name("bad/room") is None
+    assert sanitize_room_name("") is None
+
+
+def test_announce_parsing():
+    data = parse_announce_data({"port": 45913, "addresses": ["192.168.1.5", "nope"], "rooms": ["general", "BAD/", 42]})
+    assert data["port"] == 45913
+    assert data["addresses"] == ["192.168.1.5"]
+    assert data["rooms"] == ["general"]
+
+
+def test_frames_split_across_chunks():
+    first = encode_envelope(create_envelope("PING", "zc-test-1234", "sam"))
+    second = encode_envelope(create_envelope("PONG", "zc-test-1234", "sam"))
+    stream = first + second[:5]
+    parsed, buffer = decode_frames(stream)
+    assert len(parsed) == 1
+    parsed2, buffer2 = decode_frames(second[5:].encode() if isinstance(second[5:], str) else second[5:], buffer)
+    assert len(parsed2) == 1
+
+
+def test_max_message_length():
+    long_text = "x" * 1500
+    result = parse_message_data({"text": long_text})
+    assert result is not None
+    assert len(result) <= 1000
+    assert parse_message_data({"text": "x" * 5000}) is None

zapchat-3.0.0/tests/test_two_instances.py

@@ -0,0 +1,120 @@
+"""Live integration test: two real zapchat processes chat over the LAN.
+
+Spawns two CLI processes with separate config dirs, waits for them to
+discover each other over UDP, then sends a message from each side and checks
+both arrive. Mirrors the npm project's cli end-to-end test.
+"""
+
+import os
+import subprocess
+import threading
+import sys
+import tempfile
+import time
+
+
+def _find_exe():
+    """The installed CLI: env override, then common venv spots, then PATH."""
+    override = os.environ.get("ZAPCHAT_EXE")
+    if override:
+        return override
+    candidates = [
+        os.path.join(sys.prefix, "Scripts", "zapchat.exe"),
+        os.path.join(sys.prefix, "bin", "zapchat"),
+    ]
+    for candidate in candidates:
+        if os.path.exists(candidate):
+            return candidate
+    return "zapchat"
+
+
+EXE = _find_exe()
+
+
+class Instance:
+    """One spawned zapchat process with a single reader thread.
+
+    Exactly one thread consumes the process's stdout into a shared list —
+    a second iterating reader would steal lines and starve later assertions.
+    """
+
+    def __init__(self, name, room, config_dir):
+        self.name = name
+        self.process = subprocess.Popen(
+            [EXE, "--name", name, "--room", room],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            env={**os.environ, "ZAPCHAT_CONFIG_DIR": config_dir, "PYTHONUNBUFFERED": "1"},
+        )
+        self.lines = []
+        threading.Thread(target=self._reader, daemon=True).start()
+
+    def _reader(self):
+        for line in self.process.stdout:
+            self.lines.append(line)
+
+    def output(self):
+        return "".join(self.lines)
+
+    def wait_for(self, needle, timeout=20.0):
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            if needle in self.output():
+                return True
+            time.sleep(0.2)
+        return False
+
+    def send(self, text):
+        self.process.stdin.write(text + "\n")
+        self.process.stdin.flush()
+
+    def stop(self):
+        try:
+            self.process.stdin.close()
+        except OSError:
+            pass
+        self.process.terminate()
+
+
+def test_two_instances_chat():
+    # The live test needs a runnable CLI. When ZAPCHAT_EXE is unset and the
+    # resolved default is not our own Python CLI (e.g. the npm shim on PATH),
+    # skip rather than test the wrong binary.
+    import shutil
+
+    resolved = os.environ.get("ZAPCHAT_EXE") or shutil.which("zapchat")
+    if resolved is None or resolved.lower().endswith(".cmd"):
+        import pytest
+
+        pytest.skip("no Python zapchat CLI on PATH; set ZAPCHAT_EXE to run the live test")
+
+    with tempfile.TemporaryDirectory() as tmp:
+        alice = Instance("alice", "general", os.path.join(tmp, "a"))
+        bob = Instance("bob", "general", os.path.join(tmp, "b"))
+
+        try:
+            # Discovery: each side should connect to the other within seconds.
+            assert alice.wait_for("connected", timeout=30), f"alice never saw bob: {alice.output()!r}"
+            assert bob.wait_for("connected", timeout=10), f"bob never saw alice: {bob.output()!r}"
+
+            # Messages in both directions.
+            alice.send("hello from alice")
+            assert bob.wait_for("hello from alice", timeout=10), f"bob output: {bob.output()!r}"
+
+            bob.send("hi alice, this is bob")
+            assert alice.wait_for("hi alice, this is bob", timeout=10), f"alice output: {alice.output()!r}"
+
+            # A /command runs locally without being sent as chat.
+            alice.send("/rooms")
+            assert alice.wait_for("general", timeout=5), f"alice output: {alice.output()!r}"
+        finally:
+            alice.stop()
+            bob.stop()
+
+
+if __name__ == "__main__":
+    test_two_instances_chat()
+    print("TWO-INSTANCE CHAT OK")

zapchat-3.0.0/zapchat/__init__.py

@@ -0,0 +1,3 @@
+"""zapchat: terminal-native LAN chat with no accounts and no server."""
+
+__version__ = "3.0.0"