py-ftpchat 0.2.0__py3-none-any.whl

ftpchat/__init__.py

@@ -0,0 +1 @@
+"""FTP chat: a messenger where messages are files on an FTP server."""

ftpchat/client/__init__.py

@@ -0,0 +1 @@
+"""FTP client core: the messenger logic over ftplib."""

ftpchat/client/core.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import ftplib
+import io
+import time
+
+from ..protocol import Message, encode, filename, parse, safe_part, seq_of_filename
+
+
+def _recursive_mkdir(ftp: ftplib.FTP, path: str) -> None:
+    parts = [p for p in path.split("/") if p]
+    current = ""
+    for part in parts:
+        current = f"{current}/{part}".lstrip("/")
+        try:
+            ftp.mkd(current)
+        except ftplib.error_perm:
+            pass
+
+
+def _read_text(ftp: ftplib.FTP, path: str) -> bytes:
+    buffer = io.BytesIO()
+    ftp.retrbinary(f"RETR {path}", buffer.write)
+    return buffer.getvalue()
+
+
+class FtpChat:
+    def __init__(
+        self,
+        host: str,
+        port: int = 2121,
+        user: str = "",
+        password: str = "",
+        timeout: float = 5.0,
+    ) -> None:
+        self.ftp = ftplib.FTP()
+        self.ftp.connect(host, port, timeout=timeout)
+        self.ftp.login(user, password)
+        self.user = safe_part(user)
+
+    def inbox_path(self, user: str | None = None) -> str:
+        return f"users/{safe_part(user or self.user)}/inbox"
+
+    def outbox_path(self, user: str | None = None) -> str:
+        return f"users/{safe_part(user or self.user)}/outbox"
+
+    def inbox_of(self, user: str) -> str:
+        return self.inbox_path(user)
+
+    def add_user(self, user: str) -> None:
+        for path in (self.inbox_of(user), f"users/{safe_part(user)}/outbox"):
+            _recursive_mkdir(self.ftp, path)
+
+    def send_dm(self, to: str, text: str) -> int:
+        to = safe_part(to)
+        self.add_user(to)
+        seq = int(time.time() * 1000)
+        payload = encode(self.user, text, recipient=to, at_ms=seq)
+        self.ftp.storbinary(f"STOR {self.inbox_of(to)}/{filename(seq, self.user)}", io.BytesIO(payload))
+        self.ftp.storbinary(f"STOR {self.outbox_path()}/{filename(seq, self.user)}", io.BytesIO(payload))
+        return seq
+
+    def send_room(self, room: str, text: str) -> int:
+        room = safe_part(room)
+        path = f"rooms/{room}"
+        _recursive_mkdir(self.ftp, path)
+        seq = int(time.time() * 1000)
+        payload = encode(self.user, text, room=room, at_ms=seq)
+        self.ftp.storbinary(f"STOR {path}/{filename(seq, self.user)}", io.BytesIO(payload))
+        self.ftp.storbinary(f"STOR {self.outbox_path()}/{filename(seq, self.user)}", io.BytesIO(payload))
+        return seq
+
+    def _list_messages(self, path: str) -> list[Message]:
+        try:
+            names = self.ftp.nlst(path)
+        except ftplib.error_perm:
+            return []
+        messages: list[Message] = []
+        for name in names:
+            seq = seq_of_filename(name)
+            if seq <= 0:
+                continue
+            try:
+                raw = _read_text(self.ftp, f"{path}/{name}")
+            except ftplib.error_perm:
+                continue
+            messages.append(parse(seq, raw))
+        messages.sort(key=lambda m: m.seq)
+        return messages
+
+    def list_inbox(self) -> list[Message]:
+        return self._list_messages(self.inbox_path())
+
+    def list_outbox(self) -> list[Message]:
+        return self._list_messages(self.outbox_path())
+
+    def list_room(self, room: str) -> list[Message]:
+        return self._list_messages(f"rooms/{safe_part(room)}")
+
+    def list_rooms(self) -> list[str]:
+        try:
+            names = self.ftp.nlst("rooms")
+        except ftplib.error_perm:
+            return []
+        return [n for n in names if n and not n.startswith(".")]
+
+    def list_users(self) -> list[str]:
+        try:
+            names = self.ftp.nlst("users")
+        except ftplib.error_perm:
+            return []
+        return [n for n in names if n and not n.startswith(".")]
+
+    def close(self) -> None:
+        try:
+            self.ftp.quit()
+        except (ftplib.error_perm, OSError):
+            try:
+                self.ftp.close()
+            except OSError:
+                pass

ftpchat/client/terminal.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import argparse
+import sys
+import threading
+import time
+
+from ..protocol import Message
+from .core import FtpChat
+
+
+class Pr(threading.Thread):
+    def __init__(self, chat: FtpChat) -> None:
+        super().__init__(daemon=True)
+        self.chat = chat
+        self._print_lock = threading.Lock()
+        self._max: int = 0
+        self._scope = "room:general"
+        self._stop = threading.Event()
+
+    def out(self, line: str) -> None:
+        with self._print_lock:
+            print(line, flush=True)
+
+    @staticmethod
+    def _hm(seq: int) -> str:
+        return time.strftime("%H:%M:%S", time.localtime(seq / 1000)) if seq else "--:--:--"
+
+    @staticmethod
+    def _fmt(msg: Message) -> str:
+        if msg.room:
+            return f"[{Pr._hm(msg.seq)}] room#{msg.room} <{msg.sender}> {msg.text}"
+        return f"[{Pr._hm(msg.seq)}] {msg.sender}: {msg.text}"
+
+    def set_scope(self, scope: str) -> None:
+        self._max = 0
+        self._scope = scope
+
+    def _fetch(self) -> list[Message]:
+        scope = self._scope
+        if scope.startswith("room:"):
+            return self.chat.list_room(scope.split(":", 1)[1])
+        if scope.startswith("dm:"):
+            return self.chat.list_inbox()
+        return []
+
+    def snapshot(self) -> None:
+        msgs = self._fetch()
+        for m in msgs:
+            self.out(Pr._fmt(m))
+        self._max = max((m.seq for m in msgs), default=self._max)
+
+    def poll_once(self) -> None:
+        try:
+            msgs = self._fetch()
+        except Exception as exc:  # noqa: BLE001
+            self.out(f"! poll failed: {exc}")
+            return
+        new_max = self._max
+        for m in msgs:
+            if m.seq > new_max:
+                self.out(Pr._fmt(m) + "  <new>")
+                new_max = m.seq
+        self._max = new_max
+
+    def run(self) -> None:
+        while not self._stop.wait(2.0):
+            self.poll_once()
+
+
+class TerminalApp:
+    def __init__(self, args) -> None:
+        self.args = args
+        self.chat = FtpChat(args.host, args.port, args.user, args.password)
+        self.room = "general"
+        self.dm_to: str | None = None
+        self.pr = Pr(self.chat)
+
+    @property
+    def scope(self) -> str:
+        return f"room:{self.room}" if self.room else f"dm:{self.dm_to}"
+
+    def run(self) -> None:
+        self.pr.start()
+        self.pr.snapshot()
+        self.pr.out(f"connected as {self.chat.user}; scope: {self.scope}")
+        self.pr.out("/r <room> | /to <user> | /inbox | /outbox | /users | /rooms | /refresh | /quit")
+        try:
+            while True:
+                line = input("> ").strip()
+                if not line:
+                    continue
+                if line.startswith("/"):
+                    if not self._cmd(line):
+                        break
+                else:
+                    self._send(line)
+        except (KeyboardInterrupt, EOFError):
+            self.pr.out("bye")
+        finally:
+            self.pr._stop.set()
+            self.chat.close()
+
+    def _send(self, text: str) -> None:
+        try:
+            if self.room:
+                self.chat.send_room(self.room, text)
+            elif self.dm_to:
+                self.chat.send_dm(self.dm_to, text)
+                self.pr.out(f"[{Pr._hm(int(time.time() * 1000))}] -> {self.dm_to}: {text}")
+            else:
+                self.pr.out("! pick scope: /r <room> or /to <user>")
+        except Exception as exc:  # noqa: BLE001
+            self.pr.out(f"! send failed: {exc}")
+
+    def _cmd(self, line: str) -> bool:
+        parts = line.split()
+        cmd, rest = parts[0], " ".join(parts[1:])
+        try:
+            if cmd in ("/q", "/quit", "/exit"):
+                self.pr.out("bye")
+                return False
+            if cmd in ("/r", "/room"):
+                self.room = rest or self.room
+                self.dm_to = None
+                self.pr.set_scope(self.scope)
+                self.pr.snapshot()
+                self.pr.out(f"now on room '{self.room}'")
+            elif cmd == "/to":
+                self.dm_to = rest or None
+                if self.dm_to:
+                    self.chat.add_user(self.dm_to)
+                self.room = ""
+                self.pr.set_scope(self.scope)
+                self.pr.snapshot()
+                self.pr.out(f"dm with {self.dm_to}" if self.dm_to else "dm off")
+            elif cmd == "/inbox":
+                msgs = self.chat.list_inbox()
+                if not msgs:
+                    self.pr.out("inbox empty")
+                for m in msgs:
+                    self.pr.out(Pr._fmt(m))
+            elif cmd == "/outbox":
+                msgs = self.chat.list_outbox()
+                if not msgs:
+                    self.pr.out("outbox empty")
+                for m in msgs:
+                    r = m.recipient or m.room
+                    self.pr.out(f"[{Pr._hm(m.seq)}] -> {r}: {m.text}")
+            elif cmd == "/users":
+                users = self.chat.list_users()
+                self.pr.out("users: " + (", ".join(users) if users else "none yet"))
+            elif cmd == "/rooms":
+                rooms = self.chat.list_rooms()
+                self.pr.out("rooms: " + (", ".join(rooms) if rooms else "none yet"))
+            elif cmd == "/refresh":
+                self.pr.snapshot()
+            elif cmd == "/help":
+                self.pr.out("/r <room> | /to <user> | /inbox | /outbox | /users | /rooms | /refresh | /quit")
+            else:
+                self.pr.out(f"! unknown: {cmd}")
+        except Exception as exc:  # noqa: BLE001
+            self.pr.out(f"! {exc}")
+        return True
+
+
+def _use_utf8() -> None:
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            try:
+                stream.reconfigure(encoding="utf-8", errors="replace")
+            except (OSError, ValueError):
+                pass
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="ftpchat", description="FTP messenger: terminal client.")
+    parser.add_argument("--host", default="127.0.0.1", help="FTP server host")
+    parser.add_argument("--port", type=int, default=2121, help="FTP server port")
+    parser.add_argument("--user", required=True, help="your username")
+    parser.add_argument("--password", default="", help="your password")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    _use_utf8()
+    args = _build_parser().parse_args(argv)
+    try:
+        TerminalApp(args).run()
+    except Exception as exc:  # noqa: BLE001
+        print(f"! cannot connect: {exc}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

ftpchat/protocol.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Message:
+    seq: int
+    sender: str
+    recipient: str | None
+    room: str | None
+    at_ms: int
+    text: str
+
+
+def encode(
+    sender: str,
+    text: str,
+    recipient: str | None = None,
+    room: str | None = None,
+    at_ms: int | None = None,
+) -> bytes:
+    at_ms = int(at_ms) if at_ms is not None else int(time.time() * 1000)
+    lines = [f"from: {sender}", f"at: {at_ms}"]
+    if recipient:
+        lines.append(f"to: {recipient}")
+    if room:
+        lines.append(f"room: {room}")
+    return ("\n".join(lines) + "\n\n" + text).encode("utf-8")
+
+
+def parse(seq: int, raw: bytes) -> Message:
+    text_part = raw.decode("utf-8", "replace")
+    heads, _, body = text_part.partition("\n\n")
+    headers: dict[str, str] = {}
+    for line in heads.splitlines():
+        if ":" in line:
+            key, _, value = line.partition(":")
+            headers[key.strip()] = value.strip()
+    return Message(
+        seq=seq,
+        sender=headers.get("from", "?"),
+        recipient=headers.get("to"),
+        room=headers.get("room"),
+        at_ms=int(headers.get("at") or 0),
+        text=body.strip("\ufeff\n"),
+    )
+
+
+def filename(at_ms: int, sender: str) -> str:
+    return f"{at_ms}-{sender}.txt"
+
+
+def seq_of_filename(name: str) -> int:
+    try:
+        return int(name.split("-", 1)[0])
+    except ValueError:
+        return 0
+
+
+def safe_part(name: str, max_len: int = 32) -> str:
+    cleaned = "".join(ch for ch in name if ch.isalnum() or ch in "_-")
+    return cleaned[:max_len].strip("-_") or "guest"

ftpchat/server/__init__.py

@@ -0,0 +1 @@
+"""FTP server side of ftpchat."""

ftpchat/server/app.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import os
+
+from pyftpdlib.authorizers import DummyAuthorizer
+from pyftpdlib.handlers import FTPHandler
+from pyftpdlib.servers import ThreadedFTPServer
+
+
+def _ensure_user_tree(root: str, user: str) -> None:
+    os.makedirs(os.path.join(root, "users", user, "inbox"), exist_ok=True)
+    os.makedirs(os.path.join(root, "users", user, "outbox"), exist_ok=True)
+    os.makedirs(os.path.join(root, "rooms"), exist_ok=True)
+
+
+class MessengerAuthorizer(DummyAuthorizer):
+    def __init__(self, root: str, auto_register: bool = True) -> None:
+        super().__init__()
+        self.root = root
+        self.auto_register = auto_register
+
+    def validate_authentication(self, username: str, password: str, handler) -> bool:
+        if username not in self.user_table:
+            if not self.auto_register:
+                raise KeyError("unknown user")
+            self.add_user(
+                username,
+                password,
+                self.root,
+                perm="elradfmwMT",
+                msg_login=f"welcome to ftpchat, {username}",
+            )
+            _ensure_user_tree(self.root, username)
+        return super().validate_authentication(username, password, handler)
+
+
+class MessengerHandler(FTPHandler):
+    authorizer: MessengerAuthorizer
+
+    def on_login(self, username: str) -> None:
+        _ensure_user_tree(self.authorizer.root, username)
+
+
+class MessengerServer:
+    def __init__(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 2121,
+        root: str = ".",
+        auto_register: bool = True,
+    ) -> None:
+        os.makedirs(root, exist_ok=True)
+        os.makedirs(os.path.join(root, "rooms"), exist_ok=True)
+        authorizer = MessengerAuthorizer(root, auto_register)
+        MessengerHandler.authorizer = authorizer
+        self.server = ThreadedFTPServer((host, port), MessengerHandler)
+
+    @property
+    def port(self) -> int:
+        return self.server.socket.getsockname()[1]
+
+    @property
+    def host(self) -> str:
+        return self.server.socket.getsockname()[0]
+
+    def serve_forever(self, poll_interval: float = 0.5) -> None:
+        self.server.serve_forever(timeout=poll_interval)
+
+    def close(self) -> None:
+        self.server.close_all()

ftpchat/server/cli.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import argparse
+import sys
+
+
+def _use_utf8() -> None:
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            try:
+                stream.reconfigure(encoding="utf-8", errors="replace")
+            except (OSError, ValueError):
+                pass
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="ftpchat-server", description="FTP chat server: messages are files.")
+    parser.add_argument("--host", default="0.0.0.0", help="bind address (default: 0.0.0.0)")
+    parser.add_argument("--port", type=int, default=2121, help="FTP port (default: 2121)")
+    parser.add_argument("--root", default=".ftpchat", help="storage directory (default: .ftpchat)")
+    parser.add_argument("--no-auto-register", action="store_false", dest="auto_register", help="reject unknown users")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    _use_utf8()
+    args = _build_parser().parse_args(argv)
+    from .app import MessengerServer
+
+    server = MessengerServer(
+        host=args.host,
+        port=args.port,
+        root=args.root,
+        auto_register=args.auto_register,
+    )
+    print(f"ftpchat server on {args.host}:{server.port}, storage: {args.root}", flush=True)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\nstop")
+    finally:
+        server.close()

ftpchat/web/__init__.py

@@ -0,0 +1,2 @@
+"""Browser gateway: HTTP in, FTP out. The chat page talks JSON to this server,
+which reads/writes messages through the FTP server (messages stay files)."""

ftpchat/web/gateway.py

@@ -0,0 +1,346 @@
+from __future__ import annotations
+
+import argparse
+import ftplib
+import io
+import json
+import socket
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import parse_qs, urlparse
+
+from ..protocol import filename, safe_part, seq_of_filename
+
+GATEWAY_USER = "web"
+GATEWAY_PASSWORD = "web"
+ROOM = "general"
+
+PAGE = """<!doctype html>
+<html lang="ru">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>FTP Chat</title>
+<style>
+  :root { --bg:#0d1117; --panel:#161b22; --line:#30363d; --txt:#e6edf3; --dim:#8b949e;
+          --me:#1f6feb; --them:#21262d; --acc:#58a6ff; }
+  * { box-sizing:border-box; }
+  body { margin:0; font-family:-apple-system,Segoe UI,Roboto,Arial,sans-serif;
+         background:var(--bg); color:var(--txt); height:100vh; display:flex; flex-direction:column; }
+  header { padding:10px 14px; background:var(--panel); border-bottom:1px solid var(--line);
+           display:flex; align-items:center; justify-content:space-between; gap:8px; }
+  header h1 { font-size:16px; margin:0; color:var(--acc); }
+  header span { font-size:12px; color:var(--dim); }
+  #nick { background:transparent; border:1px solid var(--line); color:var(--txt);
+          border-radius:6px; padding:4px 8px; font-size:13px; width:120px; }
+  #log { flex:1; overflow-y:auto; padding:12px; display:flex; flex-direction:column; gap:6px; }
+  .msg { max-width:78%; padding:7px 10px; border-radius:12px; font-size:14px; line-height:1.35;
+         overflow-wrap:anywhere; }
+  .msg.me { align-self:flex-end; background:var(--me); }
+  .msg.them { align-self:flex-start; background:var(--them); }
+  .msg .meta { font-size:11px; color:var(--dim); display:block; margin-bottom:2px; }
+  .msg.me .meta { color:#c9dcff; }
+  .sys { align-self:center; font-size:12px; color:var(--dim); }
+  footer { display:flex; gap:8px; padding:10px 14px; background:var(--panel);
+           border-top:1px solid var(--line); }
+  #text { flex:1; background:#0d1117; border:1px solid var(--line); color:var(--txt);
+          border-radius:8px; padding:9px 12px; font-size:14px; }
+  #send { background:var(--me); border:none; color:#fff; border-radius:8px; padding:0 18px;
+          font-size:14px; cursor:pointer; }
+  #send:active { opacity:.8; }
+</style>
+</head>
+<body>
+<header>
+  <h1>FTP Chat <span id="room"></span></h1>
+  <input id="nick" placeholder="никнейм" autocomplete="off">
+</header>
+<div id="log"></div>
+<footer>
+  <input id="text" placeholder="написать сообщение..." autocomplete="off">
+  <button id="send">Отправить</button>
+</footer>
+<script>
+const log = () => document.getElementById('log');
+const roomEl = () => document.getElementById('room');
+const nickEl = () => document.getElementById('nick');
+const textEl = () => document.getElementById('text');
+let nick = localStorage.getItem('ftpchat.nick') || '';
+nickEl().value = nick;
+roomEl().textContent = '#' + '""" + ROOM + """';
+
+function say(text) {
+  const d = document.createElement('div');
+  d.className = 'sys';
+  d.textContent = text;
+  log().appendChild(d);
+  log().scrollTop = log().scrollHeight;
+}
+function addMessage(m) {
+  const isMe = m.sender === nick;
+  const d = document.createElement('div');
+  d.className = 'msg ' + (isMe ? 'me' : 'them');
+  const meta = document.createElement('span');
+  meta.className = 'meta';
+  const t = new Date(m.seq).toLocaleTimeString([], {hour:'2-digit', minute:'2-digit'});
+  meta.textContent = (isMe ? 'вы' : m.sender) + ' · ' + t;
+  const body = document.createElement('span');
+  body.textContent = m.text;
+  d.appendChild(meta);
+  d.appendChild(body);
+  log().appendChild(d);
+  log().scrollTop = log().scrollHeight;
+}
+let lastSeq = 0;
+async function poll() {
+  try {
+    const r = await fetch('/api/messages?after=' + lastSeq);
+    const data = await r.json();
+    for (const m of data.messages) addMessage(m);
+    lastSeq = data.seq || lastSeq;
+  } catch (e) { /* server briefly down, retry */ }
+}
+async function send() {
+  const text = textEl().value.trim();
+  if (!text) return;
+  nick = nickEl().value.trim();
+  if (!nick) { nickEl().focus(); return; }
+  localStorage.setItem('ftpchat.nick', nick);
+  textEl().value = '';
+  try {
+    await fetch('/api/send', {
+      method: 'POST',
+      headers: {'Content-Type':'application/json'},
+      body: JSON.stringify({nick: nick, text: text})
+    });
+  } catch (e) { say('ошибка отправки'); }
+}
+document.getElementById('send').onclick = send;
+textEl().addEventListener('keydown', e => { if (e.key === 'Enter') send(); });
+nickEl().addEventListener('change', () => localStorage.setItem('ftpchat.nick', nickEl().value.trim()));
+setInterval(poll, 2000);
+poll();
+</script>
+</body>
+</html>
+"""
+
+
+class GatewayHandler(BaseHTTPRequestHandler):
+    gateway: WebGateway
+    server_version = "FTPChat/0.2"
+
+    def log_message(self, fmt: str, *args) -> None:  # keep the console quiet
+        pass
+
+    def _json(self, code: int, payload: dict) -> None:
+        body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _ftp(self) -> ftplib.FTP:
+        ftp = ftplib.FTP()
+        ftp.connect(self.gateway.ftp_host, self.gateway.ftp_port, timeout=5)
+        ftp.login(self.gateway.user, self.gateway.password)
+        return ftp
+
+    def _recursive_mkdir(self, ftp: ftplib.FTP, path: str) -> None:
+        current = ""
+        for part in [p for p in path.split("/") if p]:
+            current = f"{current}/{part}".lstrip("/")
+            try:
+                ftp.mkd(current)
+            except ftplib.error_perm:
+                pass
+
+    def _room_files(self) -> list[dict]:
+        ftp = self._ftp()
+        try:
+            try:
+                names = ftp.nlst(f"rooms/{ROOM}")
+            except ftplib.error_perm:
+                return []
+            messages = []
+            for name in names:
+                seq = seq_of_filename(name)
+                if seq <= 0:
+                    continue
+                buf = io.BytesIO()
+                try:
+                    ftp.retrbinary(f"RETR rooms/{ROOM}/{name}", buf.write)
+                except ftplib.error_perm:
+                    continue
+                blocks = buf.getvalue().decode("utf-8", "replace").split("\n\n", 1)
+                head = {
+                    k.strip(): v.strip()
+                    for line in blocks[0].splitlines()
+                    if ":" in line
+                    for k, _, v in [line.partition(":")]
+                }
+                sender = head.get("from", "?")
+                try:
+                    at = int(head.get("at") or seq)
+                except ValueError:
+                    at = seq
+                text = blocks[1].strip("\ufeff\n") if len(blocks) > 1 else ""
+                messages.append({"seq": at, "sender": sender, "text": text})
+            messages.sort(key=lambda m: m["seq"])
+            return messages
+        finally:
+            try:
+                ftp.quit()
+            except (ftplib.error_perm, OSError):
+                ftp.close()
+
+    def do_GET(self) -> None:
+        url = urlparse(self.path)
+        if url.path == "/":
+            body = PAGE.encode("utf-8")
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+            return
+        if url.path == "/api/messages":
+            params = parse_qs(url.query)
+            after = int(params.get("after", ["0"])[0] or 0)
+            try:
+                all_msgs = self._room_files()
+            except ftplib.all_errors as exc:
+                self._json(503, {"error": f"ftp unavailable: {exc}"})
+                return
+            messages = [m for m in all_msgs if m["seq"] > after]
+            self._json(200, {"messages": messages, "seq": max((m["seq"] for m in all_msgs), default=0)})
+            return
+        self._json(404, {"error": "not found"})
+
+    def do_POST(self) -> None:
+        url = urlparse(self.path)
+        if url.path != "/api/send":
+            self._json(404, {"error": "not found"})
+            return
+        length = int(self.headers.get("Content-Length") or 0)
+        try:
+            data = json.loads(self.rfile.read(length).decode("utf-8"))
+            nick = safe_part(data.get("nick") or "guest")
+            text = str(data.get("text") or "").strip()
+        except (ValueError, TypeError):
+            self._json(400, {"error": "bad json"})
+            return
+        if not text or len(text) > 4000:
+            self._json(400, {"error": "empty or too long"})
+            return
+        seq = int(time.time() * 1000)
+        ftp: ftplib.FTP | None = None
+        try:
+            ftp = self._ftp()
+            self._recursive_mkdir(ftp, f"rooms/{ROOM}")
+            payload = (
+                f"from: {nick}\nat: {seq}\nroom: {ROOM}\n\n{text}"
+            ).encode()
+            ftp.storbinary(f"STOR rooms/{ROOM}/{filename(seq, nick)}", io.BytesIO(payload))
+        except ftplib.all_errors as exc:
+            self._json(503, {"error": f"ftp error: {exc}"})
+            return
+        finally:
+            if ftp is not None:
+                try:
+                    ftp.quit()
+                except (ftplib.error_perm, OSError):
+                    ftp.close()
+        self._json(200, {"ok": True, "seq": seq})
+
+
+class WebGateway:
+    def __init__(
+        self,
+        ftp_host: str = "127.0.0.1",
+        ftp_port: int = 2121,
+        web_port: int = 8080,
+        web_host: str = "0.0.0.0",
+        user: str = GATEWAY_USER,
+        password: str = GATEWAY_PASSWORD,
+    ) -> None:
+        self.ftp_host = ftp_host
+        self.ftp_port = ftp_port
+        self.user = user
+        self.password = password
+        self.httpd = ThreadingHTTPServer((web_host, web_port), GatewayHandler)
+        GatewayHandler.gateway = self
+
+    @property
+    def port(self) -> int:
+        return self.httpd.server_address[1]
+
+    def close(self) -> None:
+        self.httpd.shutdown()
+        self.httpd.server_close()
+
+    def serve_forever(self) -> None:
+        self.httpd.serve_forever()
+
+
+def _local_ips() -> list[str]:
+    ips: set[str] = set()
+    try:
+        hostname = socket.gethostname()
+        for info in socket.getaddrinfo(hostname, None, socket.AF_INET):
+            addr = info[4][0]
+            if not addr.startswith("127."):
+                ips.add(addr)
+    except OSError:
+        pass
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ips.add(s.getsockname()[0])
+        s.close()
+    except OSError:
+        pass
+    return sorted(ips)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(prog="ftpchat-web", description="FTP chat: browser gateway (starts FTP + HTTP).")
+    parser.add_argument("--web-port", type=int, default=8080, help="browser port (default: 8080)")
+    parser.add_argument("--ftp-port", type=int, default=2121, help="FTP port (default: 2121)")
+    parser.add_argument("--host", default="0.0.0.0", help="bind address (default: 0.0.0.0)")
+    parser.add_argument("--root", default=".ftpchat", help="storage directory (default: .ftpchat)")
+    args = parser.parse_args(argv)
+
+    ftp_server, gateway = _start_host(args)
+
+    print(f"ftp (store):   127.0.0.1:{ftp_server.port}", flush=True)
+    addrs = _local_ips() or ["<local-ip>"]
+    for addr in addrs:
+        print(f"browser:       http://{addr}:{gateway.port}", flush=True)
+    print(f"terminal:      ftpchat --host <local-ip> --port {ftp_server.port} --user name", flush=True)
+    try:
+        while True:
+            time.sleep(3600)
+    except KeyboardInterrupt:
+        print("\nstop")
+    finally:
+        ftp_server.close()
+        gateway.close()
+
+
+def _start_host(args) -> tuple[object, WebGateway]:
+    from ..server.app import MessengerServer
+
+    ftp_server = MessengerServer(host=args.host, port=args.ftp_port, root=args.root)
+    gateway = WebGateway(ftp_host="127.0.0.1", ftp_port=ftp_server.port, web_port=args.web_port, web_host=args.host)
+    threading.Thread(target=ftp_server.serve_forever, kwargs={"poll_interval": 0.5}, daemon=True).start()
+    threading.Thread(target=gateway.serve_forever, daemon=True).start()
+    return ftp_server, gateway
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())

py_ftpchat-0.2.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: py-ftpchat
+Version: 0.2.0
+Summary: A messenger where messages are literally files on an FTP server. Terminal client + browser gateway on one LAN host.
+Author: ftpchat contributors
+License-Expression: MIT
+Keywords: ftp,messenger,chat,networking,browser,lan
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications :: Chat
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: server
+Requires-Dist: pyftpdlib>=1.5; extra == "server"
+Dynamic: license-file
+
+# FTP Chat
+
+A messenger where messages are literally **files on an FTP server**. One
+device on the LAN hosts the chat; every other device joins from a **browser**
+(or the terminal client) — everything on the wire is FTP into that store.
+
+## How it works
+
+```
+        browser on phone/PC                 terminal client
+             │  HTTP/JSON                         │ ftplib
+             ▼                                   ▼
+      ftpchat-web (HTTP gateway)          ftpchat (terminal)
+             │  FTP (ftplib -> localhost)         │
+             ▼                                   ▼
+        ┌────────────────────────┐
+        │  pyftpdlib FTP server  │   storage = files:
+        │  rooms/general/*.txt   │   rooms/general/<ms>-<nick>.txt
+        │  users/<name>/*.txt    │
+        └────────────────────────┘
+```
+
+The host runs **one process** (`ftpchat-web`) that starts the FTP server and
+the browser gateway. The gateway itself speaks FTP to the local FTP server, so
+even the browser traffic becomes FTP file reads/writes.
+
+## Run (host PC)
+
+```
+pip install -e ".[server]"
+ftpchat-web
+```
+
+It prints the addresses to use, e.g.:
+
+```
+ftp (store):   127.0.0.1:2121
+browser:       http://192.168.0.5:8080
+terminal:      ftpchat --host <local-ip> --port 2121 --user name
+```
+
+* **Browser**: open `http://<host-ip>:8080` on any device in the network —
+  type a nickname and chat. No apps, no installs.
+* **Terminal client**: `ftpchat --host <host-ip> --user alice` (auto-registers
+  on first login). Commands: `/r <room>` `/to <user>` `/inbox` `/outbox`
+  `/users` `/rooms` `/refresh` `/quit`.
+
+Windows: double-click `ftpchat-web.bat` (from the launcher) to run the host.
+
+## Storage
+
+Messages are plain files named `<milliseconds>-<nick>.txt`:
+
+```
+from: phone
+at: 1789234637227
+room: general
+
+привет с браузера
+```
+
+Inspect the host folder (default `.ftpchat/rooms/general/`) to see every
+message as a file; edit/delete files there if you like.
+
+## Notes / security
+
+* Toy for a trusted LAN. New FTP users auto-register with any password, and the
+  authorizer hands everyone full access to the shared tree.
+* No TLS on FTP or HTTP. Do not expose to the internet.
+* Message text goes through FTP storage; the web page renders it with
+  `textContent` (no HTML injection).
+* Polling: browsers poll the gateway every 2 s, terminal polls the FTP store
+  every 2 s.
+
+## Tests
+
+```
+pip install -e ".[server]" pytest
+pytest            # 20 tests: protocol, FTP core, web gateway
+```

py_ftpchat-0.2.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+ftpchat/__init__.py,sha256=3hlYV-2L5g7EC4cDWwb9XaYYZrdV-WcDLcKgEDziX-s,70
+ftpchat/protocol.py,sha256=DajKseEOwF0FWe9B_FmXFmSVslAevpVbc-pz3Alulgs,1630
+ftpchat/client/__init__.py,sha256=QyOv7Qevl2-2t_2PwYL5_iE9RaIiShDL6-GMBh3i8xM,55
+ftpchat/client/core.py,sha256=5VNi7y2v7uSvKRZZida98P_ZwyeIRawIv28-c74pyMk,3900
+ftpchat/client/terminal.py,sha256=3LyJijxQYorQ6fAXV6CGDgdftW0nrg9L2SjcN0rxRQE,6665
+ftpchat/server/__init__.py,sha256=k542GtUMEH8caX8kTEjgWJMhnWs62s7gasI3HvqSK7Y,33
+ftpchat/server/app.py,sha256=h0bsgYWb6ckncHbAup1ZgVKFpI8LMF1cQKy9Qp_afco,2253
+ftpchat/server/cli.py,sha256=iikuXOzhGkCg15vYFXw35PJo6Vx59HIe-ihKsEug_oQ,1431
+ftpchat/web/__init__.py,sha256=0Z13ffuvsU9u-IIBBwUhD27wnns4_S2pMKnFH1tMcqo,155
+ftpchat/web/gateway.py,sha256=Rd_f-rcgOcdke7m0incJC8Xls_sciS6kM1DJutgzoww,12674
+py_ftpchat-0.2.0.dist-info/licenses/LICENSE,sha256=OHT5E6joJedbu6YzxmMd3v-oUOrWVdrePVngwwLYwuQ,1074
+py_ftpchat-0.2.0.dist-info/METADATA,sha256=XbnxXrb8jIDrRRVJ11q0vNOo_odwwrYIX4m1kUEYu08,3325
+py_ftpchat-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+py_ftpchat-0.2.0.dist-info/entry_points.txt,sha256=pOphU0UuWYFRaXwWqu14aaNJwcmF-AN-k3qycp5nLQQ,137
+py_ftpchat-0.2.0.dist-info/top_level.txt,sha256=PkEOqbziWsa3Sc0zM9DYxSXIaZw5ysGtknI01aiGUbk,8
+py_ftpchat-0.2.0.dist-info/RECORD,,

py_ftpchat-0.2.0.dist-info/WHEEL

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

py_ftpchat-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+ftpchat = ftpchat.client.terminal:main
+ftpchat-server = ftpchat.server.cli:main
+ftpchat-web = ftpchat.web.gateway:main

py_ftpchat-0.2.0.dist-info/licenses/LICENSE

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

py_ftpchat-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ftpchat