tempo-cli-100 1.0.0__tar.gz

tempo_cli_100-1.0.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: tempo-cli-100
+Version: 1.0.0
+Summary: A fast, minimal LAN file-sharing CLI and web server.
+Author: Tempo contributors
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Tempo
+
+Tempo เป็น CLI สำหรับแชร์ไฟล์ในวง LAN ที่เร็วและมีฟีเจอร์มากกว่า
+`python -m http.server` ธรรมดา:
+
+- **Threaded server** (`ThreadingHTTPServer`) รองรับหลาย client พร้อมกัน
+- **HTTP Range requests** — เล่นวิดีโอ/เสียงแบบ stream/scrub ได้ ไม่ต้องโหลดทั้งไฟล์
+- **โหมดสิทธิ์ (permission)**: `download` / `upload` / `full`
+- **Upload ผ่านเว็บ** ด้วย multipart/form-data (ไม่พึ่ง dependency ภายนอก)
+- **Direct download/upload** จาก command line โดยไม่ต้องเปิดเบราว์เซอร์
+- **LAN scanner** หา Tempo server อื่นในวงแลน ด้วย thread pool
+- **หน้าเว็บมินิมอล** สไตล์ file manager ยุค Windows แรกๆ
+
+เขียนด้วย Python standard library ล้วน ไม่มี dependency ภายนอก
+
+## ติดตั้ง
+
+```bash
+pip install .
+# หรือระหว่างพัฒนา:
+pip install -e .
+```
+
+หลังติดตั้งจะได้คำสั่ง `tempo` ในเครื่อง หรือจะรันตรงโดยไม่ติดตั้งก็ได้:
+
+```bash
+python3 -m tempo_cli [options] [host]
+```
+
+## Syntax
+
+```
+tempo [OPTION]... [HOST]
+```
+
+| ตัวเลือก | รูปแบบ | ความหมาย |
+|---|---|---|
+| `-h`, `--help` | | แสดงข้อความช่วยเหลือแล้วออก |
+| `-v`, `--version` | | แสดงเวอร์ชันแล้วออก |
+| `-p`, `--port` | `PORT` | พอร์ต 0-65535 (default: 8000) |
+| `-pm`, `--permission` | `download\|upload\|full` | โหมดสิทธิ์ (default: full) |
+| `-d`, `--download` | `[HOST]:[PORT]/[FILEPATH]` | โหลดไฟล์จาก Tempo server ทันที |
+| `-u`, `--upload` | `FILEPATH:[HOST]:[PORT]` | อัปโหลดไฟล์ไปยัง Tempo server ทันที |
+| `-s`, `--scan` | `[TIMEOUT] [PORT] [IP]` | สแกนหา Tempo server ในวงแลน (`IP=auto` เพื่อสแกนทั้ง subnet) |
+
+รองรับทั้งรูปแบบ `--option value` และ `--option=value` ตาม GNU Coding Standards
+
+## ตัวอย่างการใช้งาน
+
+```bash
+# แชร์โฟลเดอร์ปัจจุบัน พอร์ต 8000 ทุก interface
+tempo
+
+# ระบุพอร์ตและ host ที่จะ bind
+tempo -p 9000 0.0.0.0
+
+# โหมดอ่านอย่างเดียว (ไม่มีปุ่ม upload)
+tempo --permission=download
+
+# โหมด upload อย่างเดียว (มีแค่หน้า upload)
+tempo -pm upload
+
+# โหลดไฟล์ทันทีจาก server ที่รู้จักอยู่แล้ว
+tempo -d 192.168.1.5:8000/movie.mp4
+
+# อัปโหลดไฟล์ทันที ไปยัง server ที่อนุญาต upload
+tempo -u ./photo.png:192.168.1.5:8000
+
+# สแกนทั้ง subnet หา Tempo server อื่น (timeout เริ่มต้น 1s, port 8000)
+tempo -s
+
+# สแกนแบบระบุ timeout/port/target เอง
+tempo -s 0.5 8000 auto
+tempo -s 1.0 8000 192.168.1.20
+```
+
+## หมายเหตุด้านความปลอดภัย
+
+Tempo ไม่มีระบบ authentication ใดๆ — ใครก็ตามที่เข้าถึงวงแลนเดียวกัน
+และรู้ IP:PORT จะสามารถเข้าถึง (หรืออัปโหลด/ดาวน์โหลด ตามโหมดสิทธิ์) ได้ทันที
+เหมาะสำหรับใช้งานในเครือข่ายที่เชื่อถือได้เท่านั้น (บ้าน/ออฟฟิศ/ทีมเดียวกัน)
+ไม่แนะนำให้เปิดออก public internet

tempo_cli_100-1.0.0/README.md

@@ -0,0 +1,82 @@
+# Tempo
+
+Tempo เป็น CLI สำหรับแชร์ไฟล์ในวง LAN ที่เร็วและมีฟีเจอร์มากกว่า
+`python -m http.server` ธรรมดา:
+
+- **Threaded server** (`ThreadingHTTPServer`) รองรับหลาย client พร้อมกัน
+- **HTTP Range requests** — เล่นวิดีโอ/เสียงแบบ stream/scrub ได้ ไม่ต้องโหลดทั้งไฟล์
+- **โหมดสิทธิ์ (permission)**: `download` / `upload` / `full`
+- **Upload ผ่านเว็บ** ด้วย multipart/form-data (ไม่พึ่ง dependency ภายนอก)
+- **Direct download/upload** จาก command line โดยไม่ต้องเปิดเบราว์เซอร์
+- **LAN scanner** หา Tempo server อื่นในวงแลน ด้วย thread pool
+- **หน้าเว็บมินิมอล** สไตล์ file manager ยุค Windows แรกๆ
+
+เขียนด้วย Python standard library ล้วน ไม่มี dependency ภายนอก
+
+## ติดตั้ง
+
+```bash
+pip install .
+# หรือระหว่างพัฒนา:
+pip install -e .
+```
+
+หลังติดตั้งจะได้คำสั่ง `tempo` ในเครื่อง หรือจะรันตรงโดยไม่ติดตั้งก็ได้:
+
+```bash
+python3 -m tempo_cli [options] [host]
+```
+
+## Syntax
+
+```
+tempo [OPTION]... [HOST]
+```
+
+| ตัวเลือก | รูปแบบ | ความหมาย |
+|---|---|---|
+| `-h`, `--help` | | แสดงข้อความช่วยเหลือแล้วออก |
+| `-v`, `--version` | | แสดงเวอร์ชันแล้วออก |
+| `-p`, `--port` | `PORT` | พอร์ต 0-65535 (default: 8000) |
+| `-pm`, `--permission` | `download\|upload\|full` | โหมดสิทธิ์ (default: full) |
+| `-d`, `--download` | `[HOST]:[PORT]/[FILEPATH]` | โหลดไฟล์จาก Tempo server ทันที |
+| `-u`, `--upload` | `FILEPATH:[HOST]:[PORT]` | อัปโหลดไฟล์ไปยัง Tempo server ทันที |
+| `-s`, `--scan` | `[TIMEOUT] [PORT] [IP]` | สแกนหา Tempo server ในวงแลน (`IP=auto` เพื่อสแกนทั้ง subnet) |
+
+รองรับทั้งรูปแบบ `--option value` และ `--option=value` ตาม GNU Coding Standards
+
+## ตัวอย่างการใช้งาน
+
+```bash
+# แชร์โฟลเดอร์ปัจจุบัน พอร์ต 8000 ทุก interface
+tempo
+
+# ระบุพอร์ตและ host ที่จะ bind
+tempo -p 9000 0.0.0.0
+
+# โหมดอ่านอย่างเดียว (ไม่มีปุ่ม upload)
+tempo --permission=download
+
+# โหมด upload อย่างเดียว (มีแค่หน้า upload)
+tempo -pm upload
+
+# โหลดไฟล์ทันทีจาก server ที่รู้จักอยู่แล้ว
+tempo -d 192.168.1.5:8000/movie.mp4
+
+# อัปโหลดไฟล์ทันที ไปยัง server ที่อนุญาต upload
+tempo -u ./photo.png:192.168.1.5:8000
+
+# สแกนทั้ง subnet หา Tempo server อื่น (timeout เริ่มต้น 1s, port 8000)
+tempo -s
+
+# สแกนแบบระบุ timeout/port/target เอง
+tempo -s 0.5 8000 auto
+tempo -s 1.0 8000 192.168.1.20
+```
+
+## หมายเหตุด้านความปลอดภัย
+
+Tempo ไม่มีระบบ authentication ใดๆ — ใครก็ตามที่เข้าถึงวงแลนเดียวกัน
+และรู้ IP:PORT จะสามารถเข้าถึง (หรืออัปโหลด/ดาวน์โหลด ตามโหมดสิทธิ์) ได้ทันที
+เหมาะสำหรับใช้งานในเครือข่ายที่เชื่อถือได้เท่านั้น (บ้าน/ออฟฟิศ/ทีมเดียวกัน)
+ไม่แนะนำให้เปิดออก public internet

tempo_cli_100-1.0.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tempo-cli-100"
+version = "1.0.0"
+description = "A fast, minimal LAN file-sharing CLI and web server."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Tempo contributors" }]
+
+[project.scripts]
+tempo = "tempo_cli.cli:main"
+
+[tool.setuptools]
+packages = ["tempo_cli"]

tempo_cli_100-1.0.0/setup.cfg

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

tempo_cli_100-1.0.0/tempo_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Tempo - a fast, minimal LAN file-sharing server and client."""
+
+__version__ = "1.0.0"

tempo_cli_100-1.0.0/tempo_cli/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

tempo_cli_100-1.0.0/tempo_cli/cli.py

@@ -0,0 +1,178 @@
+"""tempo(1) -- fast, minimal LAN file sharing.
+
+Argument handling follows the POSIX Utility Syntax Guidelines (short
+options bundle-able, '--' ends option parsing, '-' alone is meaningful)
+and the GNU Coding Standards (every short option has a long equivalent,
+'--help' and '--version' behave as specified, '--opt=value' is accepted).
+"""
+
+import argparse
+import sys
+
+from . import __version__
+from . import client
+from . import scanner
+from . import server
+from .utils import valid_port
+
+PROG = "tempo"
+
+USAGE = f"{PROG} [OPTION]... [HOST]"
+
+DESCRIPTION = (
+    "Tempo shares files over the local network: a lightweight, threaded "
+    "replacement for `python -m http.server` with a minimal browsable UI, "
+    "video/audio/text preview, uploads, and LAN discovery."
+)
+
+EPILOG = """\
+Examples:
+  tempo                              serve the current directory on all interfaces, port 8000
+  tempo -p 9000 0.0.0.0              serve on port 9000, bound to 0.0.0.0
+  tempo --permission=download        read-only file browser (no upload button)
+  tempo -pm upload                   upload-only mode (no browsing/download)
+  tempo -d 192.168.1.5:8000/movie.mp4    download a file directly, no browser needed
+  tempo -u ./photo.png:192.168.1.5:8000  upload a file directly, no browser needed
+  tempo -s                           scan the local /24 subnet for Tempo servers
+  tempo -s 0.5 8000 auto             same, with an explicit timeout/port/target
+
+Report bugs to your local network administrator, or the project issue tracker.
+"""
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog=PROG,
+        usage=USAGE,
+        description=DESCRIPTION,
+        epilog=EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        add_help=False,  # we add -h/--help manually to control ordering/wording
+    )
+
+    parser.add_argument(
+        "host",
+        nargs="?",
+        default="0.0.0.0",
+        metavar="HOST",
+        help="address to bind the server to (default: 0.0.0.0, i.e. all interfaces)",
+    )
+
+    parser.add_argument(
+        "-h", "--help",
+        action="help",
+        default=argparse.SUPPRESS,
+        help="display this help text and exit",
+    )
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"{PROG} {__version__}",
+        help="output version information and exit",
+    )
+    parser.add_argument(
+        "-p", "--port",
+        metavar="PORT",
+        default=8000,
+        type=int,
+        help="TCP port to listen on, 0-65535 (default: 8000)",
+    )
+    parser.add_argument(
+        "-pm", "--permission",
+        metavar="MODE",
+        choices=("download", "upload", "full"),
+        default="full",
+        help="access mode: 'download' (browse/read/download only), "
+             "'upload' (upload only), or 'full' (both; default)",
+    )
+    parser.add_argument(
+        "-d", "--download",
+        metavar="[HOST]:[PORT]/[FILEPATH]",
+        help="fetch FILEPATH from a running Tempo server directly, no browser needed",
+    )
+    parser.add_argument(
+        "-u", "--upload",
+        metavar="FILEPATH:[HOST]:[PORT]",
+        help="push FILEPATH to a running Tempo server directly, "
+             "if that server's permission mode allows uploads",
+    )
+    parser.add_argument(
+        "-s", "--scan",
+        nargs="*",
+        metavar="[TIMEOUT] [PORT] [IP]",
+        help="scan for Tempo servers on the LAN; IP may be a single address "
+             "or 'auto' to sweep the local /24 subnet (default: 1.0 8000 auto)",
+    )
+
+    return parser
+
+
+def _dispatch_scan(scan_args):
+    timeout, port, ip = scanner.DEFAULT_TIMEOUT, scanner.DEFAULT_PORT, "auto"
+    if len(scan_args) >= 1 and scan_args[0]:
+        try:
+            timeout = float(scan_args[0])
+        except ValueError:
+            print(f"tempo: invalid timeout: {scan_args[0]!r}", file=sys.stderr)
+            return 1
+    if len(scan_args) >= 2 and scan_args[1]:
+        try:
+            port = valid_port(scan_args[1])
+        except ValueError as exc:
+            print(f"tempo: {exc}", file=sys.stderr)
+            return 1
+    if len(scan_args) >= 3 and scan_args[2]:
+        ip = scan_args[2]
+    if len(scan_args) > 3:
+        print("tempo: --scan takes at most 3 arguments: [timeout] [port] [ip]", file=sys.stderr)
+        return 1
+
+    scanner.scan(ip, port=port, timeout=timeout)
+    return 0
+
+
+def _dispatch_download(spec):
+    try:
+        host, port, filepath = client.parse_download_spec(spec)
+    except ValueError as exc:
+        print(f"tempo: {exc}", file=sys.stderr)
+        return 1
+    ok = client.download_file(host, port, filepath)
+    return 0 if ok else 1
+
+
+def _dispatch_upload(spec):
+    try:
+        filepath, host, port = client.parse_upload_spec(spec)
+    except ValueError as exc:
+        print(f"tempo: {exc}", file=sys.stderr)
+        return 1
+    ok = client.upload_file(filepath, host, port)
+    return 0 if ok else 1
+
+
+def main(argv=None):
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if not (0 <= args.port <= 65535):
+        parser.error(f"argument -p/--port: port out of range (0-65535): {args.port}")
+
+    # Mutually-exclusive "action" modes: scan / download / upload / serve.
+    if args.scan is not None:
+        return _dispatch_scan(args.scan)
+    if args.download:
+        return _dispatch_download(args.download)
+    if args.upload:
+        return _dispatch_upload(args.upload)
+
+    try:
+        server.run_server(args.host, args.port, args.permission)
+    except OSError as exc:
+        print(f"tempo: cannot bind to {args.host}:{args.port}: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tempo_cli_100-1.0.0/tempo_cli/client.py

@@ -0,0 +1,115 @@
+"""Client-side shortcuts: fetch a file from a Tempo server, or push one to it,
+without opening a browser.
+"""
+
+import http.client
+import mimetypes
+import os
+import re
+import sys
+import urllib.parse
+import uuid
+
+DOWNLOAD_RE = re.compile(r"^(?P<host>[^:/]+):(?P<port>\d+)/(?P<filepath>.+)$")
+UPLOAD_RE = re.compile(r"^(?P<filepath>.+):(?P<host>[^:]+):(?P<port>\d+)$")
+
+CHUNK_SIZE = 256 * 1024
+
+
+def parse_download_spec(spec):
+    match = DOWNLOAD_RE.match(spec)
+    if not match:
+        raise ValueError(
+            "invalid --download format, expected [host]:[port]/[filepath]"
+        )
+    return match.group("host"), int(match.group("port")), match.group("filepath")
+
+
+def parse_upload_spec(spec):
+    match = UPLOAD_RE.match(spec)
+    if not match:
+        raise ValueError(
+            "invalid --upload format, expected filepath:[host]:[port]"
+        )
+    return match.group("filepath"), match.group("host"), int(match.group("port"))
+
+
+def _progress(done, total, label):
+    if total:
+        pct = done * 100 // total
+        bar = "#" * (pct // 4)
+        sys.stdout.write(f"\r{label} [{bar:<25}] {pct:3d}%")
+    else:
+        sys.stdout.write(f"\r{label} {done} bytes")
+    sys.stdout.flush()
+
+
+def download_file(host, port, filepath, dest_dir="."):
+    quoted_path = "/" + urllib.parse.quote(filepath.lstrip("/")) + "?dl=1"
+    conn = http.client.HTTPConnection(host, port, timeout=15)
+    try:
+        conn.request("GET", quoted_path)
+        resp = conn.getresponse()
+        if resp.status not in (200,):
+            print(f"Download failed: HTTP {resp.status} {resp.reason}")
+            return False
+        total = int(resp.getheader("Content-Length", 0))
+        name = os.path.basename(filepath) or "download.bin"
+        dest = os.path.join(dest_dir, name)
+        done = 0
+        with open(dest, "wb") as fh:
+            while True:
+                chunk = resp.read(CHUNK_SIZE)
+                if not chunk:
+                    break
+                fh.write(chunk)
+                done += len(chunk)
+                _progress(done, total, "Downloading")
+        print(f"\nSaved to {os.path.abspath(dest)}")
+        return True
+    except (OSError, http.client.HTTPException) as exc:
+        print(f"Download failed: {exc}")
+        return False
+    finally:
+        conn.close()
+
+
+def upload_file(filepath, host, port):
+    if not os.path.isfile(filepath):
+        print(f"Upload failed: no such file: {filepath}")
+        return False
+
+    boundary = uuid.uuid4().hex
+    name = os.path.basename(filepath)
+    mime_type = mimetypes.guess_type(name)[0] or "application/octet-stream"
+
+    with open(filepath, "rb") as fh:
+        file_data = fh.read()
+
+    pre = (
+        f"--{boundary}\r\n"
+        f'Content-Disposition: form-data; name="file"; filename="{name}"\r\n'
+        f"Content-Type: {mime_type}\r\n\r\n"
+    ).encode()
+    post = f"\r\n--{boundary}--\r\n".encode()
+    body = pre + file_data + post
+
+    conn = http.client.HTTPConnection(host, port, timeout=30)
+    try:
+        headers = {
+            "Content-Type": f"multipart/form-data; boundary={boundary}",
+            "Content-Length": str(len(body)),
+        }
+        conn.request("POST", "/upload", body=body, headers=headers)
+        resp = conn.getresponse()
+        resp.read()
+        if resp.status == 200:
+            print(f"Uploaded '{name}' to {host}:{port} successfully.")
+            return True
+        print(f"Upload failed: HTTP {resp.status} {resp.reason}")
+        return False
+    except (OSError, http.client.HTTPException) as exc:
+        print(f"Upload failed: {exc}")
+        return False
+    finally:
+        conn.close()

tempo_cli_100-1.0.0/tempo_cli/scanner.py

@@ -0,0 +1,70 @@
+"""Scan the LAN for other running Tempo servers.
+
+Two-stage check per host: (1) can we open a TCP connection to the port
+within the timeout, and (2) does an HTTP GET / to that host answer with the
+'X-Tempo-Server' marker header that only Tempo sets. Both stages run under a
+shared timeout and are dispatched across a thread pool for speed.
+"""
+
+import concurrent.futures
+import http.client
+import socket
+
+from .utils import get_local_ip, guess_subnet_hosts
+
+DEFAULT_TIMEOUT = 1.0
+DEFAULT_PORT = 8000
+DEFAULT_MAX_WORKERS = 100
+
+
+def probe_host(ip, port, timeout):
+    """Return True if a Tempo server is confirmed running at ip:port."""
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.settimeout(timeout)
+    try:
+        if sock.connect_ex((ip, port)) != 0:
+            return False
+    except OSError:
+        return False
+    finally:
+        sock.close()
+
+    try:
+        conn = http.client.HTTPConnection(ip, port, timeout=timeout)
+        conn.request("GET", "/")
+        resp = conn.getresponse()
+        resp.read()
+        conn.close()
+        return resp.getheader("X-Tempo-Server") == "1"
+    except (OSError, http.client.HTTPException):
+        return False
+
+
+def scan(ip_arg, port=DEFAULT_PORT, timeout=DEFAULT_TIMEOUT, max_workers=DEFAULT_MAX_WORKERS):
+    """Scan one host or the whole /24 subnet ('auto') for Tempo servers."""
+    if ip_arg in (None, "auto"):
+        local_ip = get_local_ip()
+        targets = guess_subnet_hosts(local_ip)
+        print(f"Scanning subnet around {local_ip}/24 ({len(targets)} hosts), "
+              f"port {port}, timeout {timeout}s ...")
+    else:
+        targets = [ip_arg]
+        print(f"Scanning {ip_arg}, port {port}, timeout {timeout}s ...")
+
+    found = []
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as pool:
+        future_map = {pool.submit(probe_host, ip, port, timeout): ip for ip in targets}
+        for future in concurrent.futures.as_completed(future_map):
+            ip = future_map[future]
+            try:
+                if future.result():
+                    found.append(ip)
+                    print(f"  \u2713 Tempo server found: http://{ip}:{port}/")
+            except Exception:
+                continue
+
+    if not found:
+        print("No Tempo servers found.")
+    else:
+        print(f"\nDone. {len(found)} Tempo server(s) found.")
+    return found

tempo_cli_100-1.0.0/tempo_cli/server.py

@@ -0,0 +1,330 @@
+"""Threaded HTTP server for Tempo.
+
+Deliberately dependency-free (stdlib only) but faster and more capable than
+``python -m http.server``: it serves multiple clients concurrently
+(ThreadingHTTPServer), supports HTTP Range requests so videos can be
+scrubbed/streamed instead of downloaded whole, and supports permission-gated
+uploads via a hand-rolled multipart/form-data parser.
+"""
+
+import datetime
+import mimetypes
+import os
+import re
+import socketserver
+import sys
+import urllib.parse
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from . import templates
+from .utils import file_kind
+
+CHUNK_SIZE = 256 * 1024
+RANGE_RE = re.compile(r"bytes=(\d*)-(\d*)")
+
+
+def _iso(ts):
+    return datetime.datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M")
+
+
+class TempoRequestHandler(BaseHTTPRequestHandler):
+    server_version = "Tempo/1.0"
+    protocol_version = "HTTP/1.1"
+
+    # These are set on the class by make_handler_class() below.
+    root_dir = "."
+    permission = "full"
+
+    # -- helpers ---------------------------------------------------------
+
+    @property
+    def can_download(self):
+        return self.permission in ("download", "full")
+
+    @property
+    def can_upload(self):
+        return self.permission in ("upload", "full")
+
+    def _safe_path(self, url_path):
+        """Resolve a URL path to a filesystem path confined to root_dir."""
+        path = urllib.parse.unquote(url_path.split("?", 1)[0])
+        path = path.lstrip("/")
+        full = os.path.normpath(os.path.join(self.root_dir, path))
+        root_abs = os.path.abspath(self.root_dir)
+        full_abs = os.path.abspath(full)
+        if not (full_abs == root_abs or full_abs.startswith(root_abs + os.sep)):
+            return None
+        return full_abs
+
+    def _send_html(self, html_text, status=HTTPStatus.OK):
+        data = html_text.encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(data)))
+        self.send_header("X-Tempo-Server", "1")
+        self.end_headers()
+        self.wfile.write(data)
+
+    def _send_forbidden(self, reason="Not permitted."):
+        self._send_html(templates.render_forbidden(reason), status=HTTPStatus.FORBIDDEN)
+
+    def _send_not_found(self):
+        self._send_html(
+            templates._page("Tempo :: 404", '<div class="notice">404 Not Found</div>'),
+            status=HTTPStatus.NOT_FOUND,
+        )
+
+    def log_message(self, fmt, *args):
+        sys.stderr.write("[tempo] %s - %s\n" % (self.address_string(), fmt % args))
+
+    # -- GET ---------------------------------------------------------------
+
+    def do_GET(self):
+        self.send_header  # no-op reference to silence linters on some setups
+        parsed = urllib.parse.urlsplit(self.path)
+        url_path = parsed.path
+        query = urllib.parse.parse_qs(parsed.query)
+
+        if url_path == "/upload":
+            if not self.can_upload:
+                self._send_forbidden("Upload is disabled on this server.")
+                return
+            self._send_html(templates.render_upload_page(url_path))
+            return
+
+        if not self.can_download:
+            self._send_forbidden("Browsing/download is disabled on this server.")
+            return
+
+        fs_path = self._safe_path(url_path)
+        if fs_path is None or not os.path.exists(fs_path):
+            self._send_not_found()
+            return
+
+        if os.path.isdir(fs_path):
+            self._list_directory(url_path, fs_path)
+            return
+
+        # It's a file.
+        ext = os.path.splitext(fs_path)[1]
+        kind = file_kind(ext)
+        name = os.path.basename(fs_path)
+
+        if "view" in query and kind:
+            if kind == "text":
+                try:
+                    with open(fs_path, "r", encoding="utf-8", errors="replace") as fh:
+                        text = fh.read(2_000_000)  # cap huge files
+                except OSError:
+                    self._send_not_found()
+                    return
+                self._send_html(templates.render_text_viewer(url_path, name, text))
+            else:
+                self._send_html(templates.render_viewer(url_path, name, kind))
+            return
+
+        force_download = "dl" in query
+        self._serve_file(fs_path, name, force_download)
+
+    def _list_directory(self, url_path, fs_path):
+        try:
+            names = sorted(os.listdir(fs_path), key=str.lower)
+        except OSError:
+            self._send_forbidden("Cannot read this directory.")
+            return
+        entries = []
+        for name in names:
+            full = os.path.join(fs_path, name)
+            try:
+                stat_res = os.stat(full)
+            except OSError:
+                continue
+            entries.append(
+                {
+                    "name": name,
+                    "is_dir": os.path.isdir(full),
+                    "size": stat_res.st_size,
+                    "mtime": _iso(stat_res.st_mtime),
+                }
+            )
+        entries.sort(key=lambda item: (not item["is_dir"], item["name"].lower()))
+        self._send_html(
+            templates.render_directory(url_path, entries, self.can_download, self.can_upload)
+        )
+
+    def _serve_file(self, fs_path, name, force_download):
+        try:
+            file_size = os.path.getsize(fs_path)
+        except OSError:
+            self._send_not_found()
+            return
+        mime_type = mimetypes.guess_type(fs_path)[0] or "application/octet-stream"
+
+        range_header = self.headers.get("Range")
+        start, end = 0, file_size - 1
+        status = HTTPStatus.OK
+        if range_header:
+            match = RANGE_RE.match(range_header)
+            if match:
+                if match.group(1):
+                    start = int(match.group(1))
+                if match.group(2):
+                    end = int(match.group(2))
+                else:
+                    end = file_size - 1
+                status = HTTPStatus.PARTIAL_CONTENT
+
+        if start >= file_size or end >= file_size or start > end:
+            self.send_response(HTTPStatus.REQUESTED_RANGE_NOT_SATISFIABLE)
+            self.send_header("Content-Range", f"bytes */{file_size}")
+            self.send_header("X-Tempo-Server", "1")
+            self.end_headers()
+            return
+
+        length = end - start + 1
+        self.send_response(status)
+        self.send_header("Content-Type", mime_type)
+        self.send_header("Content-Length", str(length))
+        self.send_header("Accept-Ranges", "bytes")
+        self.send_header("X-Tempo-Server", "1")
+        if force_download:
+            self.send_header(
+                "Content-Disposition", f'attachment; filename="{name}"'
+            )
+        if status == HTTPStatus.PARTIAL_CONTENT:
+            self.send_header("Content-Range", f"bytes {start}-{end}/{file_size}")
+        self.end_headers()
+
+        try:
+            with open(fs_path, "rb") as fh:
+                fh.seek(start)
+                remaining = length
+                while remaining > 0:
+                    chunk = fh.read(min(CHUNK_SIZE, remaining))
+                    if not chunk:
+                        break
+                    self.wfile.write(chunk)
+                    remaining -= len(chunk)
+        except (BrokenPipeError, ConnectionResetError):
+            pass
+
+    # -- POST (upload) -------------------------------------------------------
+
+    def do_POST(self):
+        if self.path.rstrip("/") != "/upload" and not self.path.startswith("/upload?"):
+            self._send_not_found()
+            return
+        if not self.can_upload:
+            self._send_forbidden("Upload is disabled on this server.")
+            return
+
+        content_type = self.headers.get("Content-Type", "")
+        if "multipart/form-data" not in content_type:
+            self._send_html(
+                templates.render_upload_page("/upload", "Invalid request (expected multipart/form-data)."),
+                status=HTTPStatus.BAD_REQUEST,
+            )
+            return
+
+        match = re.search(r'boundary="?([^";]+)"?', content_type)
+        if not match:
+            self._send_html(
+                templates.render_upload_page("/upload", "Missing multipart boundary."),
+                status=HTTPStatus.BAD_REQUEST,
+            )
+            return
+        boundary = match.group(1).encode()
+        content_length = int(self.headers.get("Content-Length", 0))
+        body = self.rfile.read(content_length)
+
+        filename, file_data = self._parse_multipart(body, boundary)
+        if not filename or file_data is None:
+            self._send_html(
+                templates.render_upload_page("/upload", "No file received."),
+                status=HTTPStatus.BAD_REQUEST,
+            )
+            return
+
+        safe_name = os.path.basename(filename)
+        dest = os.path.join(self.root_dir, safe_name)
+        dest = self._deduplicate_path(dest)
+        try:
+            with open(dest, "wb") as fh:
+                fh.write(file_data)
+        except OSError as exc:
+            self._send_html(
+                templates.render_upload_page("/upload", f"Failed to save file: {exc}"),
+                status=HTTPStatus.INTERNAL_SERVER_ERROR,
+            )
+            return
+
+        self._send_html(
+            templates.render_upload_page(
+                "/upload", f"\u2713 Uploaded '{os.path.basename(dest)}' successfully."
+            )
+        )
+
+    @staticmethod
+    def _deduplicate_path(path):
+        if not os.path.exists(path):
+            return path
+        base, ext = os.path.splitext(path)
+        counter = 1
+        while True:
+            candidate = f"{base} ({counter}){ext}"
+            if not os.path.exists(candidate):
+                return candidate
+            counter += 1
+
+    @staticmethod
+    def _parse_multipart(body, boundary):
+        """Minimal multipart/form-data parser: extracts the first file part."""
+        delimiter = b"--" + boundary
+        parts = body.split(delimiter)
+        for part in parts:
+            part = part.strip(b"\r\n")
+            if not part or part == b"--":
+                continue
+            if b"\r\n\r\n" not in part:
+                continue
+            header_blob, _, content = part.partition(b"\r\n\r\n")
+            headers = header_blob.decode(errors="replace")
+            if "filename=" not in headers:
+                continue
+            fname_match = re.search(r'filename="([^"]*)"', headers)
+            if not fname_match or not fname_match.group(1):
+                continue
+            filename = fname_match.group(1)
+            # Strip trailing CRLF that precedes the next boundary marker.
+            if content.endswith(b"\r\n"):
+                content = content[:-2]
+            return filename, content
+        return None, None
+
+
+def make_handler_class(root_dir, permission):
+    return type(
+        "BoundTempoRequestHandler",
+        (TempoRequestHandler,),
+        {"root_dir": os.path.abspath(root_dir), "permission": permission},
+    )
+
+
+class TempoServer(ThreadingHTTPServer):
+    daemon_threads = True
+    allow_reuse_address = True
+
+
+def run_server(host, port, permission, root_dir="."):
+    handler_cls = make_handler_class(root_dir, permission)
+    httpd = TempoServer((host, port), handler_cls)
+    bound_host, bound_port = httpd.server_address
+    print(f"Tempo serving '{os.path.abspath(root_dir)}' ({permission}) "
+          f"at http://{bound_host}:{bound_port}/  (Ctrl+C to stop)")
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        print("\nShutting down.")
+    finally:
+        httpd.server_close()

tempo_cli_100-1.0.0/tempo_cli/templates.py

@@ -0,0 +1,224 @@
+"""Minimal, low-fidelity HTML templates.
+
+Styled loosely after early-Windows file managers: a grey chrome, a sunken
+"panel" for the listing, a plain sans-serif font, and just enough CSS to
+keep things readable -- nothing decorative.
+"""
+
+import html
+import urllib.parse
+
+from .utils import file_icon, file_kind, human_size
+
+PAGE_CSS = """
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  font-family: Tahoma, "Segoe UI", Verdana, sans-serif;
+  font-size: 13px;
+  background: #c3c7cb;
+  color: #000;
+}
+.titlebar {
+  background: linear-gradient(180deg, #4a6ea9 0%, #2f4d7a 100%);
+  color: #fff;
+  padding: 6px 10px;
+  font-weight: bold;
+  font-size: 14px;
+  border-bottom: 2px solid #1b2f4d;
+}
+.toolbar {
+  background: #d4d7dc;
+  border-bottom: 1px solid #8f959e;
+  padding: 6px 10px;
+  display: flex;
+  gap: 8px;
+  align-items: center;
+  flex-wrap: wrap;
+}
+.toolbar a, .toolbar span.path {
+  color: #000;
+  text-decoration: none;
+  padding: 3px 8px;
+  border: 1px solid #8f959e;
+  background: #eceef1;
+}
+.toolbar a:hover { background: #dfe6f0; }
+.path {
+  font-family: "Courier New", monospace;
+  background: #fff !important;
+  flex: 1;
+  min-width: 200px;
+}
+.panel {
+  margin: 10px;
+  background: #fff;
+  border: 2px inset #8f959e;
+}
+table { width: 100%; border-collapse: collapse; }
+th {
+  text-align: left;
+  background: #d4d7dc;
+  border-bottom: 1px solid #8f959e;
+  padding: 4px 8px;
+  font-weight: bold;
+}
+td {
+  padding: 3px 8px;
+  border-bottom: 1px solid #e6e8eb;
+  white-space: nowrap;
+}
+tr:hover td { background: #dfe6f0; }
+td.name { width: 60%; }
+td.actions a {
+  margin-right: 8px;
+  color: #1a3f7a;
+}
+.col-size, .col-modified { color: #444; font-family: "Courier New", monospace; }
+.statusbar {
+  background: #d4d7dc;
+  border-top: 1px solid #8f959e;
+  padding: 4px 10px;
+  color: #333;
+}
+.upload-box {
+  margin: 10px;
+  padding: 14px;
+  background: #eceef1;
+  border: 2px inset #8f959e;
+}
+.upload-box input[type=file] { margin-bottom: 8px; }
+.upload-box input[type=submit] {
+  padding: 4px 14px;
+  border: 1px solid #8f959e;
+  background: #d4d7dc;
+  cursor: pointer;
+}
+.viewer { margin: 10px; }
+.viewer video, .viewer audio, .viewer img { max-width: 100%; }
+.viewer pre {
+  background: #fff;
+  border: 2px inset #8f959e;
+  padding: 10px;
+  overflow: auto;
+  max-height: 70vh;
+  font-family: "Courier New", monospace;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+.notice { padding: 10px; margin: 10px; background: #fff8d6; border: 1px solid #cbb658; }
+"""
+
+
+def _page(title, body):
+    return f"""<!DOCTYPE html>
+<html lang="th">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>{html.escape(title)}</title>
+<style>{PAGE_CSS}</style>
+</head>
+<body>
+<div class="titlebar">Tempo File Server</div>
+{body}
+</body>
+</html>"""
+
+
+def _toolbar(url_path, can_download, can_upload):
+    parts = [p for p in url_path.split("/") if p]
+    up_link = ""
+    if parts:
+        parent = "/" + "/".join(parts[:-1])
+        up_link = f'<a href="{html.escape(parent)}">\u2b06 Up</a>'
+    links = []
+    if can_download:
+        links.append(up_link)
+    if can_upload:
+        links.append('<a href="/upload">\u2191 Upload</a>')
+    links = [item for item in links if item]
+    return (
+        '<div class="toolbar">'
+        + "".join(links)
+        + f'<span class="path">{html.escape("/" + "/".join(parts))}</span>'
+        + "</div>"
+    )
+
+
+def render_directory(url_path, entries, can_download, can_upload):
+    """entries: list of dict(name, is_dir, size, mtime)"""
+    rows = []
+    for entry in entries:
+        name = entry["name"]
+        href = urllib.parse.quote(name) + ("/" if entry["is_dir"] else "")
+        ext = "" if entry["is_dir"] else "." + name.rsplit(".", 1)[-1] if "." in name else ""
+        icon = file_icon(ext, entry["is_dir"])
+        size = "" if entry["is_dir"] else human_size(entry["size"])
+        modified = entry["mtime"]
+        actions = ""
+        if not entry["is_dir"] and can_download:
+            kind = file_kind(ext)
+            if kind:
+                actions += f'<a href="{href}?view=1">View</a>'
+            actions += f'<a href="{href}?dl=1">Download</a>'
+        display_name = f'<a href="{href}">{icon} {html.escape(name)}</a>' if (entry["is_dir"] or can_download) else f'{icon} {html.escape(name)}'
+        rows.append(
+            f"<tr><td class='name'>{display_name}</td>"
+            f"<td class='col-size'>{size}</td>"
+            f"<td class='col-modified'>{html.escape(modified)}</td>"
+            f"<td class='actions'>{actions}</td></tr>"
+        )
+    if not rows:
+        rows.append('<tr><td colspan="4" style="text-align:center;color:#888;padding:20px;">(\u0e42\u0e1f\u0e25\u0e14\u0e40\u0e21\u0e2d\u0e23\u0e4c\u0e19\u0e35\u0e49\u0e27\u0e48\u0e32\u0e07\u0e40\u0e1b\u0e25\u0e48\u0e32)</td></tr>')
+
+    body = _toolbar(url_path, can_download, can_upload)
+    body += (
+        '<div class="panel"><table>'
+        "<tr><th>\u0e0a\u0e37\u0e48\u0e2d (Name)</th><th>\u0e02\u0e19\u0e32\u0e14 (Size)</th>"
+        "<th>\u0e41\u0e01\u0e49\u0e44\u0e02\u0e25\u0e48\u0e32\u0e2a\u0e38\u0e14 (Modified)</th><th>\u0e01\u0e32\u0e23\u0e01\u0e23\u0e30\u0e17\u0e33 (Action)</th></tr>"
+        + "".join(rows)
+        + "</table></div>"
+        f'<div class="statusbar">{len(entries)} item(s) &mdash; Tempo</div>'
+    )
+    return _page(f"Tempo :: {url_path}", body)
+
+
+def render_upload_page(url_path, message=None):
+    notice = f'<div class="notice">{html.escape(message)}</div>' if message else ""
+    body = _toolbar(url_path, can_download=True, can_upload=True)
+    body += notice
+    body += f"""
+<div class="upload-box">
+  <form method="post" action="/upload" enctype="multipart/form-data">
+    <div><input type="file" name="file" required></div>
+    <div><input type="submit" value="Upload"></div>
+  </form>
+</div>
+"""
+    return _page("Tempo :: Upload", body)
+
+
+def render_forbidden(reason="Access is not permitted on this server."):
+    body = f'<div class="notice">403 Forbidden &mdash; {html.escape(reason)}</div>'
+    return _page("Tempo :: 403 Forbidden", body)
+
+
+def render_viewer(url_path, name, kind):
+    href = urllib.parse.quote(name)
+    body = f'<div class="toolbar"><span class="path">{html.escape(url_path)}</span></div>'
+    body += '<div class="viewer">'
+    if kind == "video":
+        body += f'<video controls autoplay src="{href}"></video>'
+    elif kind == "audio":
+        body += f'<audio controls autoplay src="{href}"></audio>'
+    elif kind == "image":
+        body += f'<img src="{href}" alt="{html.escape(name)}">'
+    body += "</div>"
+    return _page(f"Tempo :: {name}", body)
+
+
+def render_text_viewer(url_path, name, text):
+    body = f'<div class="toolbar"><span class="path">{html.escape(url_path)}</span></div>'
+    body += f'<div class="viewer"><pre>{html.escape(text)}</pre></div>'
+    return _page(f"Tempo :: {name}", body)

tempo_cli_100-1.0.0/tempo_cli/utils.py

@@ -0,0 +1,85 @@
+"""Small shared helpers: local IP discovery, subnet enumeration, formatting."""
+
+import ipaddress
+import socket
+
+
+VIEWABLE_TEXT_EXT = {
+    ".txt", ".md", ".log", ".cfg", ".ini", ".json", ".yaml", ".yml",
+    ".py", ".c", ".h", ".cpp", ".js", ".ts", ".css", ".html", ".sh",
+    ".csv", ".conf",
+}
+VIEWABLE_VIDEO_EXT = {".mp4", ".webm", ".ogv", ".mov", ".mkv"}
+VIEWABLE_AUDIO_EXT = {".mp3", ".wav", ".ogg", ".flac", ".m4a"}
+VIEWABLE_IMAGE_EXT = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".svg"}
+
+
+def human_size(num_bytes):
+    """Return a human readable file size, e.g. '12.3 MB'."""
+    step = 1024.0
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if num_bytes < step:
+            return f"{num_bytes:.0f} {unit}" if unit == "B" else f"{num_bytes:.1f} {unit}"
+        num_bytes /= step
+    return f"{num_bytes:.1f} PB"
+
+
+def file_kind(ext):
+    """Classify a file extension into a viewer kind, or None if not viewable inline."""
+    ext = ext.lower()
+    if ext in VIEWABLE_TEXT_EXT:
+        return "text"
+    if ext in VIEWABLE_VIDEO_EXT:
+        return "video"
+    if ext in VIEWABLE_AUDIO_EXT:
+        return "audio"
+    if ext in VIEWABLE_IMAGE_EXT:
+        return "image"
+    return None
+
+
+def file_icon(ext, is_dir=False):
+    """Return a small unicode glyph used as a retro-style file icon."""
+    if is_dir:
+        return "\U0001F4C1"  # folder
+    kind = file_kind(ext)
+    return {
+        "text": "\U0001F4C4",
+        "video": "\U0001F3AC",
+        "audio": "\U0001F3B5",
+        "image": "\U0001F5BC",
+    }.get(kind, "\U0001F4E6")
+
+
+def get_local_ip():
+    """Best-effort discovery of this machine's LAN IP address.
+
+    Uses a UDP 'connect' (no packets actually sent) to force the OS to pick
+    the outbound interface, then reads back the local address it chose.
+    """
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        sock.connect(("8.8.8.8", 80))
+        return sock.getsockname()[0]
+    except OSError:
+        return "127.0.0.1"
+    finally:
+        sock.close()
+
+
+def guess_subnet_hosts(local_ip=None):
+    """Guess every host address on the local /24 subnet, excluding our own IP."""
+    local_ip = local_ip or get_local_ip()
+    network = ipaddress.ip_network(f"{local_ip}/24", strict=False)
+    return [str(host) for host in network.hosts() if str(host) != local_ip]
+
+
+def valid_port(value):
+    """argparse type= helper: validate a TCP port number in [0, 65535]."""
+    try:
+        port = int(value)
+    except ValueError as exc:
+        raise ValueError(f"invalid port: {value!r}") from exc
+    if not (0 <= port <= 65535):
+        raise ValueError(f"port out of range (0-65535): {port}")
+    return port

tempo_cli_100-1.0.0/tempo_cli_100.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: tempo-cli-100
+Version: 1.0.0
+Summary: A fast, minimal LAN file-sharing CLI and web server.
+Author: Tempo contributors
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Tempo
+
+Tempo เป็น CLI สำหรับแชร์ไฟล์ในวง LAN ที่เร็วและมีฟีเจอร์มากกว่า
+`python -m http.server` ธรรมดา:
+
+- **Threaded server** (`ThreadingHTTPServer`) รองรับหลาย client พร้อมกัน
+- **HTTP Range requests** — เล่นวิดีโอ/เสียงแบบ stream/scrub ได้ ไม่ต้องโหลดทั้งไฟล์
+- **โหมดสิทธิ์ (permission)**: `download` / `upload` / `full`
+- **Upload ผ่านเว็บ** ด้วย multipart/form-data (ไม่พึ่ง dependency ภายนอก)
+- **Direct download/upload** จาก command line โดยไม่ต้องเปิดเบราว์เซอร์
+- **LAN scanner** หา Tempo server อื่นในวงแลน ด้วย thread pool
+- **หน้าเว็บมินิมอล** สไตล์ file manager ยุค Windows แรกๆ
+
+เขียนด้วย Python standard library ล้วน ไม่มี dependency ภายนอก
+
+## ติดตั้ง
+
+```bash
+pip install .
+# หรือระหว่างพัฒนา:
+pip install -e .
+```
+
+หลังติดตั้งจะได้คำสั่ง `tempo` ในเครื่อง หรือจะรันตรงโดยไม่ติดตั้งก็ได้:
+
+```bash
+python3 -m tempo_cli [options] [host]
+```
+
+## Syntax
+
+```
+tempo [OPTION]... [HOST]
+```
+
+| ตัวเลือก | รูปแบบ | ความหมาย |
+|---|---|---|
+| `-h`, `--help` | | แสดงข้อความช่วยเหลือแล้วออก |
+| `-v`, `--version` | | แสดงเวอร์ชันแล้วออก |
+| `-p`, `--port` | `PORT` | พอร์ต 0-65535 (default: 8000) |
+| `-pm`, `--permission` | `download\|upload\|full` | โหมดสิทธิ์ (default: full) |
+| `-d`, `--download` | `[HOST]:[PORT]/[FILEPATH]` | โหลดไฟล์จาก Tempo server ทันที |
+| `-u`, `--upload` | `FILEPATH:[HOST]:[PORT]` | อัปโหลดไฟล์ไปยัง Tempo server ทันที |
+| `-s`, `--scan` | `[TIMEOUT] [PORT] [IP]` | สแกนหา Tempo server ในวงแลน (`IP=auto` เพื่อสแกนทั้ง subnet) |
+
+รองรับทั้งรูปแบบ `--option value` และ `--option=value` ตาม GNU Coding Standards
+
+## ตัวอย่างการใช้งาน
+
+```bash
+# แชร์โฟลเดอร์ปัจจุบัน พอร์ต 8000 ทุก interface
+tempo
+
+# ระบุพอร์ตและ host ที่จะ bind
+tempo -p 9000 0.0.0.0
+
+# โหมดอ่านอย่างเดียว (ไม่มีปุ่ม upload)
+tempo --permission=download
+
+# โหมด upload อย่างเดียว (มีแค่หน้า upload)
+tempo -pm upload
+
+# โหลดไฟล์ทันทีจาก server ที่รู้จักอยู่แล้ว
+tempo -d 192.168.1.5:8000/movie.mp4
+
+# อัปโหลดไฟล์ทันที ไปยัง server ที่อนุญาต upload
+tempo -u ./photo.png:192.168.1.5:8000
+
+# สแกนทั้ง subnet หา Tempo server อื่น (timeout เริ่มต้น 1s, port 8000)
+tempo -s
+
+# สแกนแบบระบุ timeout/port/target เอง
+tempo -s 0.5 8000 auto
+tempo -s 1.0 8000 192.168.1.20
+```
+
+## หมายเหตุด้านความปลอดภัย
+
+Tempo ไม่มีระบบ authentication ใดๆ — ใครก็ตามที่เข้าถึงวงแลนเดียวกัน
+และรู้ IP:PORT จะสามารถเข้าถึง (หรืออัปโหลด/ดาวน์โหลด ตามโหมดสิทธิ์) ได้ทันที
+เหมาะสำหรับใช้งานในเครือข่ายที่เชื่อถือได้เท่านั้น (บ้าน/ออฟฟิศ/ทีมเดียวกัน)
+ไม่แนะนำให้เปิดออก public internet

tempo_cli_100-1.0.0/tempo_cli_100.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+tempo_cli/__init__.py
+tempo_cli/__main__.py
+tempo_cli/cli.py
+tempo_cli/client.py
+tempo_cli/scanner.py
+tempo_cli/server.py
+tempo_cli/templates.py
+tempo_cli/utils.py
+tempo_cli_100.egg-info/PKG-INFO
+tempo_cli_100.egg-info/SOURCES.txt
+tempo_cli_100.egg-info/dependency_links.txt
+tempo_cli_100.egg-info/entry_points.txt
+tempo_cli_100.egg-info/top_level.txt

tempo_cli_100-1.0.0/tempo_cli_100.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tempo_cli_100-1.0.0/tempo_cli_100.egg-info/entry_points.txt

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

tempo_cli_100-1.0.0/tempo_cli_100.egg-info/top_level.txt

@@ -0,0 +1 @@
+tempo_cli