exchangertool 0.1.1__tar.gz

exchangertool-0.1.1/LICENSE

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

exchangertool-0.1.1/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: exchangertool
+Version: 0.1.1
+Summary: Minimal CLI to send or receive files over HTTP or SMB.
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: smbprotocol
+Dynamic: license-file
+
+# exchanger
+
+Serve files or listen to receive (target POSTs file to host). Default port 8080.
+
+## Installation
+
+```bash
+pipx install exchangertool
+```
+
+## Usage
+
+```bash
+exchanger
+```
+
+## Help menu
+
+```bash
+___________             .__                                        
+\_   _____/__  ___ ____ |  |__ _____    ____    ____   ___________ 
+ |    __)_\  \/  // ___\|  |  \\__  \  /    \  / ___\_/ __ \_  __ \
+ |        \>    <\  \___|   Y  \/ __ \|   |  \/ /_/  >  ___/|  | \/
+/_______  /__/\_ \\___  >___|  (____  /___|  /\___  / \___  >__|   
+        \/      \/    \/     \/     \/     \//_____/      \/       
+
+Serve files or listen to receive (target POSTs to host). Default port 8080.
+
+positional arguments:
+  {serve,receive}
+                 command (default:
+                 serve)
+    serve        serve current
+                 directory; others
+                 can send/receive
+                 (default)
+    receive      listen for target to
+                 POST file to you
+
+options:
+  -h, --help     show this help
+                 message and exit
+
+examples:
+  exchanger                    (same as serve)
+  exchanger serve              (target can GET or POST)
+  exchanger receive            (host listens; target POSTs file to you)
+  exchanger receive --dir /tmp --port 8080
+```

exchangertool-0.1.1/README.md

@@ -0,0 +1,49 @@
+# exchanger
+
+Serve files or listen to receive (target POSTs file to host). Default port 8080.
+
+## Installation
+
+```bash
+pipx install exchangertool
+```
+
+## Usage
+
+```bash
+exchanger
+```
+
+## Help menu
+
+```bash
+___________             .__                                        
+\_   _____/__  ___ ____ |  |__ _____    ____    ____   ___________ 
+ |    __)_\  \/  // ___\|  |  \\__  \  /    \  / ___\_/ __ \_  __ \
+ |        \>    <\  \___|   Y  \/ __ \|   |  \/ /_/  >  ___/|  | \/
+/_______  /__/\_ \\___  >___|  (____  /___|  /\___  / \___  >__|   
+        \/      \/    \/     \/     \/     \//_____/      \/       
+
+Serve files or listen to receive (target POSTs to host). Default port 8080.
+
+positional arguments:
+  {serve,receive}
+                 command (default:
+                 serve)
+    serve        serve current
+                 directory; others
+                 can send/receive
+                 (default)
+    receive      listen for target to
+                 POST file to you
+
+options:
+  -h, --help     show this help
+                 message and exit
+
+examples:
+  exchanger                    (same as serve)
+  exchanger serve              (target can GET or POST)
+  exchanger receive            (host listens; target POSTs file to you)
+  exchanger receive --dir /tmp --port 8080
+```

exchangertool-0.1.1/exchanger/__init__.py

@@ -0,0 +1,3 @@
+"""exchanger - minimal file send/receive over HTTP or SMB."""
+
+__version__ = "0.1.0"

exchangertool-0.1.1/exchanger/__main__.py

@@ -0,0 +1,6 @@
+"""Run exchanger as python -m exchanger."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

exchangertool-0.1.1/exchanger/cli.py

@@ -0,0 +1,105 @@
+"""CLI argument parsing and dispatch."""
+
+import argparse
+import os
+import sys
+
+
+_BANNER = r"""
+___________             .__                                        
+\_   _____/__  ___ ____ |  |__ _____    ____    ____   ___________ 
+ |    __)_\  \/  // ___\|  |  \\__  \  /    \  / ___\_/ __ \_  __ \
+ |        \>    <\  \___|   Y  \/ __ \|   |  \/ /_/  >  ___/|  | \/
+/_______  /__/\_ \\___  >___|  (____  /___|  /\___  / \___  >__|   
+        \/      \/    \/     \/     \/     \//_____/      \/       
+"""
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog="exchanger",
+        description=_BANNER + "\nServe files or listen to receive (target POSTs to host). Default port 8080.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+examples:
+  %(prog)s                    (same as serve)
+  %(prog)s serve              (target can GET or POST)
+  %(prog)s receive            (host listens; target POSTs file to you)
+  %(prog)s receive --dir /tmp --port 8080
+        """,
+    )
+    def add_protocol_port(sp):
+        sp.add_argument(
+            "--protocol",
+            choices=("http", "smb"),
+            default="http",
+            help="protocol (default: http)",
+        )
+        sp.add_argument(
+            "-p", "--port",
+            type=int,
+            default=8080,
+            help="port (default: 8080)",
+        )
+
+    sub = parser.add_subparsers(dest="command", help="command (default: serve)")
+
+    # serve (default when no command)
+    serve_p = sub.add_parser("serve", help="serve current directory; others can send/receive (default)")
+    add_protocol_port(serve_p)
+    serve_p.add_argument(
+        "-d", "--dir",
+        default=".",
+        metavar="DIR",
+        help="directory to serve (default: current directory)",
+    )
+    serve_p.add_argument(
+        "--bind",
+        default="0.0.0.0",
+        metavar="ADDR",
+        help="address to bind (default: 0.0.0.0)",
+    )
+    serve_p.set_defaults(func=_cmd_serve)
+
+    # receive (host listens; target POSTs to host)
+    recv_p = sub.add_parser("receive", help="listen for target to POST file to you")
+    add_protocol_port(recv_p)
+    recv_p.add_argument(
+        "-d", "--dir",
+        default=".",
+        metavar="DIR",
+        help="directory to save received files (default: current directory)",
+    )
+    recv_p.add_argument(
+        "--bind",
+        default="0.0.0.0",
+        metavar="ADDR",
+        help="address to bind (default: 0.0.0.0)",
+    )
+    recv_p.set_defaults(func=_cmd_receive)
+
+    return parser
+
+
+def _cmd_serve(args):
+    if args.protocol == "smb":
+        from .smb_ import serve_smb
+        serve_smb(args)
+    else:
+        from .http_ import serve_http
+        serve_http(args)
+
+
+def _cmd_receive(args):
+    if args.protocol == "smb":
+        sys.exit("exchanger: receive is listen-only; use --protocol http.")
+    from .http_ import serve_http
+    serve_http(args, receive_only=True)
+
+
+def main():
+    parser = build_parser()
+    args = parser.parse_args()
+    if args.command is None:
+        args = parser.parse_args(["serve"] + [a for a in sys.argv[1:] if a not in ("-h", "--help")])
+    args.func(args)

exchangertool-0.1.1/exchanger/http_.py

@@ -0,0 +1,219 @@
+"""HTTP server and client for file exchange."""
+
+import http.server
+import mimetypes
+import os
+import threading
+import time
+import urllib.parse
+import urllib.request
+import ssl
+import sys
+
+_SPINNER = (".", "\\", "/", "-")
+_SPINNER_INTERVAL = 0.12
+
+
+def _spinner_loop(stop: threading.Event) -> None:
+    i = 0
+    while not stop.is_set():
+        sys.stderr.write(f"\r  {_SPINNER[i % len(_SPINNER)]} ")
+        sys.stderr.flush()
+        i += 1
+        stop.wait(_SPINNER_INTERVAL)
+    sys.stderr.write("\r   \r")
+    sys.stderr.flush()
+
+
+def _safe_join(base: str, path: str) -> str | None:
+    """Resolve path under base; return None if path escapes base."""
+    base = os.path.abspath(base)
+    full = os.path.abspath(os.path.join(base, path.lstrip("/")))
+    if not full.startswith(base):
+        return None
+    return full
+
+
+class ExchangeHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
+    """Serves directory (GET) and accepts file uploads (POST)."""
+
+    def __init__(self, *args, directory=None, **kwargs):
+        self.directory = directory or os.getcwd()
+        super().__init__(*args, directory=self.directory, **kwargs)
+
+    def do_GET(self):
+        path = urllib.parse.unquote(self.path)
+        if path == "/" or path == "":
+            path = "/"
+            self.send_response(200)
+            self.send_header("Content-type", "text/plain; charset=utf-8")
+            self.end_headers()
+            self.wfile.write(b"exchanger: GET /path/to/file to download, POST to upload\n")
+            return
+        if "?" in path:
+            path = path.split("?")[0]
+        local = _safe_join(self.directory, path)
+        if local is None:
+            self.send_error(403, "Forbidden")
+            return
+        if not os.path.isfile(local):
+            self.send_error(404, "Not Found")
+            return
+        size = os.path.getsize(local)
+        ctype, _ = mimetypes.guess_type(local)
+        ctype = ctype or "application/octet-stream"
+        self.send_response(200)
+        self.send_header("Content-type", ctype)
+        self.send_header("Content-Length", str(size))
+        self.end_headers()
+        with open(local, "rb") as f:
+            self.wfile.write(f.read())
+
+    def do_POST(self):
+        path = urllib.parse.unquote(self.path)
+        if path == "/" or path == "":
+            path = "/"
+        if "?" in path:
+            path = path.split("?")[0]
+        local = _safe_join(self.directory, path)
+        if local is None:
+            self.send_error(403, "Forbidden")
+            return
+        dirpath = os.path.dirname(local)
+        if dirpath and not os.path.isdir(dirpath):
+            try:
+                os.makedirs(dirpath, exist_ok=True)
+            except OSError:
+                self.send_error(500, "Cannot create directory")
+                return
+        content_type = self.headers.get("Content-Type", "")
+        length = self.headers.get("Content-Length")
+        if length is None:
+            self.send_error(411, "Content-Length required")
+            return
+        try:
+            length = int(length)
+        except ValueError:
+            self.send_error(400, "Invalid Content-Length")
+            return
+        if "multipart/form-data" in content_type:
+            boundary = None
+            for part in content_type.split(";"):
+                part = part.strip()
+                if part.startswith("boundary="):
+                    boundary = part[9:].strip().strip('"')
+                    break
+            if not boundary:
+                self.send_error(400, "Missing boundary")
+                return
+            data = self.rfile.read(length)
+            try:
+                body = _parse_multipart(data, boundary)
+            except ValueError:
+                self.send_error(400, "Invalid multipart")
+                return
+            if "file" in body:
+                payload = body["file"]
+            else:
+                keys = [k for k in body if k != "path"]
+                payload = body[keys[0]] if keys else b""
+            out_path = local if local != self.directory else os.path.join(self.directory, "upload")
+            if os.path.isdir(out_path):
+                out_path = os.path.join(out_path, "upload")
+        else:
+            payload = self.rfile.read(length)
+            if path == "/" or path == "" or (local and os.path.isdir(local)):
+                x_fn = self.headers.get("X-Filename", "").strip()
+                if x_fn:
+                    safe = os.path.basename(x_fn.replace("\\", "/"))
+                    if safe and "/" not in safe and ".." not in safe:
+                        out_path = os.path.join(self.directory, safe)
+                    else:
+                        out_path = os.path.join(self.directory, "upload")
+                else:
+                    out_path = os.path.join(self.directory, "upload")
+            else:
+                out_path = local
+                if os.path.isdir(out_path):
+                    out_path = os.path.join(out_path, "upload")
+        try:
+            with open(out_path, "wb") as f:
+                f.write(payload)
+        except OSError as e:
+            self.send_error(500, str(e))
+            return
+        self.send_response(201)
+        self.send_header("Content-type", "text/plain; charset=utf-8")
+        self.end_headers()
+        self.wfile.write(f"created {out_path}\n".encode())
+
+
+def _parse_multipart(data: bytes, boundary: bytes) -> dict:
+    if isinstance(boundary, str):
+        boundary = boundary.encode()
+    parts = data.split(b"--" + boundary)
+    out = {}
+    for part in parts:
+        part = part.strip()
+        if not part or part == b"--":
+            continue
+        if b"\r\n\r\n" not in part:
+            continue
+        head, body = part.split(b"\r\n\r\n", 1)
+        if body.endswith(b"\r\n"):
+            body = body[:-2]
+        name = None
+        for line in head.split(b"\r\n"):
+            if line.lower().startswith(b"content-disposition:"):
+                for token in line.split(b";")[1:]:
+                    token = token.strip()
+                    if token.lower().startswith(b"name="):
+                        name = token[5:].strip(b'"').decode("utf-8", "replace")
+                        break
+                break
+        if name is not None:
+            out[name] = body
+    return out
+
+
+def serve_http(args, receive_only: bool = False):
+    os.chdir(args.dir)
+    dir_abs = os.path.abspath(args.dir)
+    if not os.path.isdir(dir_abs):
+        sys.exit(f"exchanger: not a directory: {args.dir}")
+    handler = lambda *a, **k: ExchangeHTTPRequestHandler(*a, directory=dir_abs, **k)
+    server = http.server.HTTPServer((args.bind, args.port), handler)
+    if args.port == 443:
+        try:
+            ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+            ctx.load_cert_chain(
+                os.path.expanduser("~/.exchanger/cert.pem"),
+                os.path.expanduser("~/.exchanger/key.pem"),
+            )
+            server.socket = ctx.wrap_socket(server.socket, server_side=True)
+        except FileNotFoundError:
+            print("exchanger: port 443 requires TLS; no cert at ~/.exchanger/cert.pem", file=sys.stderr)
+            print("exchanger: use --port 8443 for plain HTTP or provide certs.", file=sys.stderr)
+            sys.exit(1)
+    if receive_only:
+        print(f"exchanger: listening to receive (target POSTs to you) on {args.bind}:{args.port}")
+        from .net_ import print_commands_receive_listen
+        print_commands_receive_listen(args.port, getattr(args, "protocol", "http"))
+    else:
+        print(f"exchanger: serving {dir_abs} on {args.bind}:{args.port} (protocol http)")
+        from .net_ import print_commands_serve
+        print_commands_serve(args.port, getattr(args, "protocol", "http"))
+    stop = threading.Event()
+    spinner = threading.Thread(target=_spinner_loop, args=(stop,), daemon=True)
+    spinner.start()
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        stop.set()
+        spinner.join(timeout=0.5)
+        sys.stderr.write("\r   \r")
+        sys.stderr.flush()
+
+

exchangertool-0.1.1/exchanger/net_.py

@@ -0,0 +1,172 @@
+"""Local IP detection and interface picker."""
+
+import re
+import subprocess
+import sys
+
+
+def get_all_interfaces() -> list[tuple[str, str]]:
+    """Return list of (interface_name, ipv4) excluding lo."""
+    out = subprocess.run(
+        ["ip", "-4", "addr", "show"],
+        capture_output=True,
+        text=True,
+        timeout=2,
+    )
+    if out.returncode != 0:
+        return []
+    current_iface = None
+    result = []
+    for line in out.stdout.splitlines():
+        if line and not line[0].isspace():
+            parts = line.split(":", 2)
+            current_iface = parts[1].strip() if len(parts) > 1 else None
+        if current_iface and current_iface != "lo":
+            m = re.search(r"inet\s+(\d+\.\d+\.\d+\.\d+)", line)
+            if m:
+                result.append((current_iface, m.group(1)))
+    return result
+
+
+def _pick_interface_fzf(choices: list[tuple[str, str]]) -> str | None:
+    """Use fzf to pick one; return selected ip or None."""
+    lines = [f"{name}  {ip}" for name, ip in choices]
+    try:
+        p = subprocess.run(
+            ["fzf", "--height", "10", "-1"],
+            input="\n".join(lines),
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if p.returncode != 0 or not p.stdout.strip():
+            return None
+        selected = p.stdout.strip()
+        for name, ip in choices:
+            if f"{name}  {ip}" == selected or ip == selected:
+                return ip
+        if re.match(r"^\d+\.\d+\.\d+\.\d+$", selected):
+            return selected
+        parts = selected.split()
+        return parts[-1] if parts and re.match(r"^\d+\.\d+\.\d+\.\d+$", parts[-1]) else None
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return None
+
+
+def _pick_interface_menu(choices: list[tuple[str, str]]) -> str | None:
+    """Numbered menu on stderr; return selected ip or None."""
+    for i, (name, ip) in enumerate(choices, 1):
+        sys.stderr.write(f"  {i}) {name}  {ip}\n")
+    sys.stderr.write("  choice (1-{}): ".format(len(choices)))
+    sys.stderr.flush()
+    try:
+        line = input().strip()
+        idx = int(line)
+        if 1 <= idx <= len(choices):
+            return choices[idx - 1][1]
+    except (ValueError, EOFError):
+        pass
+    return None
+
+
+def pick_interface() -> str | None:
+    """Show fuzzy finder or menu to select interface; return its IPv4 or None."""
+    choices = get_all_interfaces()
+    if not choices:
+        return None
+    if len(choices) == 1:
+        return choices[0][1]
+    if not sys.stderr.isatty():
+        return get_local_ip()
+    sys.stderr.write("\n  select interface (for command box):\n")
+    return _pick_interface_fzf(choices) or _pick_interface_menu(choices)
+
+
+def get_local_ip() -> str | None:
+    """Return preferred local IPv4 (tun0 first, then first non-lo), or None."""
+    ifaces = get_all_interfaces()
+    for name, ip in ifaces:
+        if name == "tun0":
+            return ip
+    return ifaces[0][1] if ifaces else None
+
+
+def _port_proto(port: int, protocol: str) -> tuple[str, str]:
+    port_opt = "" if port == 8080 else f" -p {port}"
+    proto_opt = "" if protocol == "http" else f" --protocol {protocol}"
+    return port_opt, proto_opt
+
+
+def _base_url(ip: str, port: int) -> str:
+    scheme = "https" if port == 443 else "http"
+    if port in (80, 443):
+        return f"{scheme}://{ip}"
+    return f"{scheme}://{ip}:{port}"
+
+
+def _target_receive_linux(base: str, path: str = "/path/to/file", out: str = "out") -> str:
+    return f"curl -o {out} {base}{path}\nwget -O {out} {base}{path}"
+
+
+def _target_receive_win(base: str, path: str = "/path/to/file", out: str = "out") -> str:
+    return f"curl -o {out} {base}{path}\ncertutil -urlcache -split -f {base}{path} {out}"
+
+
+def _target_send_linux(base: str, path: str = "./file", name: str = "file") -> str:
+    return f"curl -X POST --data-binary @{path} {base}/{name}"
+
+
+def _target_send_win(base: str, path: str = "file", name: str = "file") -> str:
+    return f"curl -X POST --data-binary @{path} {base}/{name}"
+
+
+_WIDTH = 56
+
+
+def _box_line(text: str) -> str:
+    return "  |  " + text.ljust(_WIDTH) + "  |\n"
+
+
+def _section(title: str, lines: list[str]) -> str:
+    out = ["", f"  {title}", "  " + "-" * (len(title) + 2)]
+    for line in lines:
+        out.append(f"  {line}")
+    return "\n".join(out) + "\n"
+
+
+def print_commands_serve(port: int, protocol: str = "http") -> None:
+    """Print copy-paste commands for target (curl/wget/certutil) when we are serving."""
+    my_ip = pick_interface()
+    if not my_ip or protocol != "http":
+        return
+    base = _base_url(my_ip, port)
+    recv_linux = _target_receive_linux(base).split("\n")
+    send_linux = _target_send_linux(base).split("\n")
+    recv_win = _target_receive_win(base).split("\n")
+    send_win = _target_send_win(base).split("\n")
+    sys.stderr.write("\n")
+    sys.stderr.write("  +" + "-" * (_WIDTH + 4) + "+\n")
+    sys.stderr.write(_box_line("run on target (copy-paste)"))
+    sys.stderr.write("  +" + "-" * (_WIDTH + 4) + "+\n")
+    sys.stderr.write(_section("linux: receive from you", recv_linux))
+    sys.stderr.write(_section("linux: send to you", send_linux))
+    sys.stderr.write(_section("windows: receive from you", recv_win))
+    sys.stderr.write(_section("windows: send to you", send_win))
+    sys.stderr.write("\n")
+
+
+def print_commands_receive_listen(port: int, protocol: str = "http") -> None:
+    """Print copy-paste for target to POST file to you (host is listening)."""
+    my_ip = pick_interface()
+    if not my_ip or protocol != "http":
+        return
+    base = _base_url(my_ip, port)
+    send_linux = _target_send_linux(base).split("\n")
+    send_win = _target_send_win(base).split("\n")
+    sys.stderr.write("\n")
+    sys.stderr.write("  +" + "-" * (_WIDTH + 4) + "+\n")
+    sys.stderr.write(_box_line("run on target (POST file to you)"))
+    sys.stderr.write("  +" + "-" * (_WIDTH + 4) + "+\n")
+    sys.stderr.write(_section("linux", send_linux))
+    sys.stderr.write(_section("windows", send_win))
+    sys.stderr.write("\n")

exchangertool-0.1.1/exchanger/smb_.py

@@ -0,0 +1,7 @@
+"""SMB: serve not supported; receive is listen-only (HTTP)."""
+
+import sys
+
+
+def serve_smb(args):
+    sys.exit("exchanger: SMB serve not supported on this platform; use --protocol http to serve.")

exchangertool-0.1.1/exchangertool.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: exchangertool
+Version: 0.1.1
+Summary: Minimal CLI to send or receive files over HTTP or SMB.
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: smbprotocol
+Dynamic: license-file
+
+# exchanger
+
+Serve files or listen to receive (target POSTs file to host). Default port 8080.
+
+## Installation
+
+```bash
+pipx install exchangertool
+```
+
+## Usage
+
+```bash
+exchanger
+```
+
+## Help menu
+
+```bash
+___________             .__                                        
+\_   _____/__  ___ ____ |  |__ _____    ____    ____   ___________ 
+ |    __)_\  \/  // ___\|  |  \\__  \  /    \  / ___\_/ __ \_  __ \
+ |        \>    <\  \___|   Y  \/ __ \|   |  \/ /_/  >  ___/|  | \/
+/_______  /__/\_ \\___  >___|  (____  /___|  /\___  / \___  >__|   
+        \/      \/    \/     \/     \/     \//_____/      \/       
+
+Serve files or listen to receive (target POSTs to host). Default port 8080.
+
+positional arguments:
+  {serve,receive}
+                 command (default:
+                 serve)
+    serve        serve current
+                 directory; others
+                 can send/receive
+                 (default)
+    receive      listen for target to
+                 POST file to you
+
+options:
+  -h, --help     show this help
+                 message and exit
+
+examples:
+  exchanger                    (same as serve)
+  exchanger serve              (target can GET or POST)
+  exchanger receive            (host listens; target POSTs file to you)
+  exchanger receive --dir /tmp --port 8080
+```

exchangertool-0.1.1/exchangertool.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+exchanger/__init__.py
+exchanger/__main__.py
+exchanger/cli.py
+exchanger/http_.py
+exchanger/net_.py
+exchanger/smb_.py
+exchangertool.egg-info/PKG-INFO
+exchangertool.egg-info/SOURCES.txt
+exchangertool.egg-info/dependency_links.txt
+exchangertool.egg-info/entry_points.txt
+exchangertool.egg-info/requires.txt
+exchangertool.egg-info/top_level.txt

exchangertool-0.1.1/exchangertool.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

exchangertool-0.1.1/exchangertool.egg-info/entry_points.txt

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

exchangertool-0.1.1/exchangertool.egg-info/requires.txt

@@ -0,0 +1 @@
+smbprotocol

exchangertool-0.1.1/exchangertool.egg-info/top_level.txt

@@ -0,0 +1 @@
+exchanger

exchangertool-0.1.1/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "exchangertool"
+version = "0.1.1"
+description = "Minimal CLI to send or receive files over HTTP or SMB."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = ["smbprotocol"]
+
+[project.scripts]
+exchanger = "exchanger.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["exchanger*"]

exchangertool-0.1.1/setup.cfg

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