abstract-securefiles 0.1.0__py3-none-any.whl

abstract_securefiles/__init__.py

@@ -0,0 +1,3 @@
+"""Secure Files: shared core, desktop agent and server relay."""
+
+__version__ = "0.1.0"

abstract_securefiles/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

abstract_securefiles/agent/autostart.py

@@ -0,0 +1,86 @@
+"""Start the agent at login: systemd --user (Linux), launchd (macOS), Task Scheduler (Windows)."""
+from __future__ import annotations
+
+import os
+import plistlib
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+LABEL = "com.abstractendeavors.securefiles"
+UNIT = "securefiles-agent.service"
+TASK = "SecureFilesAgent"
+
+
+def _python(windowless: bool = False) -> str:
+    exe = sys.executable
+    if windowless and sys.platform == "win32":
+        candidate = Path(exe).with_name("pythonw.exe")
+        if candidate.exists():
+            return str(candidate)
+    return exe
+
+
+def _run(cmd, check=True):
+    return subprocess.run(cmd, check=check, capture_output=True, text=True)
+
+
+def install() -> str:
+    if sys.platform.startswith("linux"):
+        unit_dir = Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config") / "systemd" / "user"
+        unit_dir.mkdir(parents=True, exist_ok=True)
+        (unit_dir / UNIT).write_text(
+            "[Unit]\nDescription=Secure Files agent\nAfter=network-online.target\n\n"
+            f"[Service]\nExecStart=\"{_python()}\" -m abstract_securefiles serve\n"
+            "Restart=on-failure\nRestartSec=5\n\n[Install]\nWantedBy=default.target\n",
+            encoding="utf-8",
+        )
+        if not shutil.which("systemctl"):
+            return f"Wrote {unit_dir / UNIT}, but systemctl is missing; start it with: securefiles serve"
+        _run(["systemctl", "--user", "daemon-reload"])
+        _run(["systemctl", "--user", "enable", "--now", UNIT])
+        return f"Enabled systemd user service {UNIT} (starts at login)."
+    if sys.platform == "darwin":
+        agents = Path.home() / "Library" / "LaunchAgents"
+        agents.mkdir(parents=True, exist_ok=True)
+        plist = agents / f"{LABEL}.plist"
+        logs = Path.home() / "Library" / "Logs"
+        plist.write_bytes(plistlib.dumps({
+            "Label": LABEL,
+            "ProgramArguments": [_python(), "-m", "abstract_securefiles", "serve"],
+            "RunAtLoad": True,
+            "KeepAlive": True,
+            "StandardOutPath": str(logs / "securefiles-agent.log"),
+            "StandardErrorPath": str(logs / "securefiles-agent.log"),
+        }))
+        _run(["launchctl", "unload", str(plist)], check=False)
+        _run(["launchctl", "load", "-w", str(plist)])
+        return f"Installed LaunchAgent {plist} (starts at login)."
+    if sys.platform == "win32":
+        command = f'"{_python(windowless=True)}" -m abstract_securefiles serve'
+        _run(["schtasks", "/Create", "/F", "/SC", "ONLOGON", "/RL", "LIMITED", "/TN", TASK, "/TR", command])
+        _run(["schtasks", "/Run", "/TN", TASK], check=False)
+        return f"Created scheduled task {TASK} (starts at logon)."
+    raise RuntimeError(f"Unsupported platform: {sys.platform}")
+
+
+def uninstall() -> str:
+    if sys.platform.startswith("linux"):
+        unit = Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config") / "systemd" / "user" / UNIT
+        if shutil.which("systemctl"):
+            _run(["systemctl", "--user", "disable", "--now", UNIT], check=False)
+        unit.unlink(missing_ok=True)
+        if shutil.which("systemctl"):
+            _run(["systemctl", "--user", "daemon-reload"], check=False)
+        return "Removed the systemd user service."
+    if sys.platform == "darwin":
+        plist = Path.home() / "Library" / "LaunchAgents" / f"{LABEL}.plist"
+        _run(["launchctl", "unload", "-w", str(plist)], check=False)
+        plist.unlink(missing_ok=True)
+        return "Removed the LaunchAgent."
+    if sys.platform == "win32":
+        _run(["schtasks", "/End", "/TN", TASK], check=False)
+        _run(["schtasks", "/Delete", "/F", "/TN", TASK], check=False)
+        return "Removed the scheduled task."
+    raise RuntimeError(f"Unsupported platform: {sys.platform}")

abstract_securefiles/agent/config.py

@@ -0,0 +1,99 @@
+"""Per-user agent configuration (JSON) in the platform's config directory."""
+from __future__ import annotations
+
+import json
+import os
+import platform
+import secrets
+import socket
+import sys
+import threading
+from pathlib import Path
+
+DEFAULT_SERVER = "https://api.abstractendeavors.com"
+DEFAULT_PORT = 47821
+
+
+def config_dir() -> Path:
+    if sys.platform == "win32":
+        base = Path(os.environ.get("APPDATA") or Path.home() / "AppData" / "Roaming")
+        return base / "SecureFiles"
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support" / "SecureFiles"
+    return Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config") / "securefiles"
+
+
+def platform_label() -> str:
+    return f"{platform.system()} {platform.release()} ({platform.machine()})"
+
+
+class Config:
+    """Thread-safe JSON config: server, pairing token, published items, UI port."""
+
+    def __init__(self, path: Path = None):
+        self.path = path or config_dir() / "config.json"
+        self._lock = threading.Lock()
+        self.data = {
+            "server": DEFAULT_SERVER,
+            "port": DEFAULT_PORT,
+            "device_name": socket.gethostname()[:60] or "my-computer",
+            "device_id": None,
+            "token": None,
+            "username": None,
+            "items": [],
+        }
+        if self.path.exists():
+            self.data.update(json.loads(self.path.read_text(encoding="utf-8")))
+
+    def save(self):
+        with self._lock:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            tmp = self.path.with_suffix(".tmp")
+            tmp.write_text(json.dumps(self.data, indent=2), encoding="utf-8")
+            if os.name == "posix":
+                os.chmod(tmp, 0o600)
+            os.replace(tmp, self.path)
+
+    @property
+    def paired(self) -> bool:
+        return bool(self.data.get("token"))
+
+    def add_item(self, path: str) -> dict:
+        real = os.path.realpath(path)
+        if not (os.path.isfile(real) or os.path.isdir(real)):
+            raise ValueError("Not a file or folder")
+        for item in self.data["items"]:
+            if item["path"] == real:
+                return item
+        item = {
+            "id": secrets.token_urlsafe(9),
+            "path": real,
+            "name": os.path.basename(real.rstrip("/\\")) or real,
+            "kind": "folder" if os.path.isdir(real) else "file",
+        }
+        self.data["items"].append(item)
+        self.save()
+        return item
+
+    def remove_item(self, item_id: str) -> bool:
+        before = len(self.data["items"])
+        self.data["items"] = [i for i in self.data["items"] if i["id"] != item_id]
+        self.save()
+        return len(self.data["items"]) != before
+
+    def item(self, item_id: str):
+        return next((i for i in self.data["items"] if i["id"] == item_id), None)
+
+    def catalog(self) -> list:
+        out = []
+        for item in self.data["items"]:
+            size = None
+            if item["kind"] == "file":
+                try:
+                    size = os.path.getsize(item["path"])
+                except OSError:
+                    continue
+            elif not os.path.isdir(item["path"]):
+                continue
+            out.append({"id": item["id"], "name": item["name"], "kind": item["kind"], "size": size})
+        return out

abstract_securefiles/agent/relay_client.py

@@ -0,0 +1,139 @@
+"""Outbound connection to the Secure Files relay.
+
+Keeps one WebSocket open (control only), publishes the catalog of shared
+items, and answers each "send" request by streaming the item (honouring the
+downloader's Range) as an HTTPS upload. Reconnects with backoff forever.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+from typing import Optional
+
+import aiohttp
+
+from .. import __version__
+from ..core import build_payload
+from .config import Config, platform_label
+
+log = logging.getLogger("securefiles.agent")
+
+PROTOCOL = 1
+
+
+class RelayClient:
+    def __init__(self, config: Config):
+        self.config = config
+        self.state = "not paired"
+        self.last_error: Optional[str] = None
+        self.ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self.session: Optional[aiohttp.ClientSession] = None
+        self._wake = asyncio.Event()
+        self._task: Optional[asyncio.Task] = None
+        self.active_transfers = 0
+
+    def start(self):
+        self._task = asyncio.get_running_loop().create_task(self._run())
+
+    def reconnect(self):
+        """Drop the current connection (e.g. after pairing/unpairing) and connect again."""
+        self._wake.set()
+        if self.ws is not None and not self.ws.closed:
+            asyncio.get_running_loop().create_task(self.ws.close())
+
+    async def publish_catalog(self):
+        if self.ws is not None and not self.ws.closed:
+            await self.ws.send_str(json.dumps({"type": "catalog", "items": self.config.catalog()}))
+
+    async def _run(self):
+        backoff = 2
+        timeout = aiohttp.ClientTimeout(total=None, sock_connect=20)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            self.session = session
+            while True:
+                if not self.config.paired:
+                    self.state = "not paired"
+                    self._wake.clear()
+                    await self._wake.wait()
+                    continue
+                server = self.config.data["server"].rstrip("/")
+                url = server.replace("https://", "wss://", 1).replace("http://", "ws://", 1) + "/secure-files/relay/agent"
+                try:
+                    self.state = "connecting"
+                    async with session.ws_connect(url, headers=self._auth(), heartbeat=30) as ws:
+                        self.ws = ws
+                        self.state = "connected"
+                        self.last_error = None
+                        backoff = 2
+                        await ws.send_str(json.dumps({
+                            "type": "hello", "protocol": PROTOCOL, "version": __version__,
+                            "platform": platform_label(), "items": self.config.catalog(),
+                        }))
+                        async for msg in ws:
+                            if msg.type != aiohttp.WSMsgType.TEXT:
+                                continue
+                            data = json.loads(msg.data)
+                            if data.get("type") == "send":
+                                asyncio.get_running_loop().create_task(self._transfer(data))
+                except aiohttp.WSServerHandshakeError as exc:
+                    self.last_error = "This device was removed from your account; pair it again." \
+                        if exc.status == 401 else f"Relay refused the connection ({exc.status})"
+                except (aiohttp.ClientError, OSError, asyncio.TimeoutError) as exc:
+                    self.last_error = f"Cannot reach {server}: {exc}"
+                finally:
+                    self.ws = None
+                if self.config.paired:
+                    self.state = "reconnecting"
+                    self._wake.clear()
+                    try:
+                        await asyncio.wait_for(self._wake.wait(), backoff)
+                    except asyncio.TimeoutError:
+                        pass
+                    backoff = min(backoff * 2, 60)
+
+    def _auth(self) -> dict:
+        return {"Authorization": f"Bearer {self.config.data['token']}"}
+
+    async def _report(self, transfer: str, status: int, message: str):
+        if self.ws is not None and not self.ws.closed:
+            await self.ws.send_str(json.dumps({"type": "error", "transfer": transfer,
+                                               "status": status, "message": message}))
+
+    async def _transfer(self, request: dict):
+        transfer = str(request.get("transfer"))
+        item = self.config.item(str(request.get("item")))
+        if not item or not os.path.exists(item["path"]):
+            await self._report(transfer, 404, "This item is no longer shared from that computer.")
+            return
+        name = f"{item['name']}.tar" if item["kind"] == "folder" else item["name"]
+        loop = asyncio.get_running_loop()
+        try:
+            payload = await loop.run_in_executor(
+                None, build_payload, item["path"], name, request.get("range"), request.get("if_range"))
+        except OSError as exc:
+            await self._report(transfer, 500, f"Could not read the item: {exc}")
+            return
+
+        async def body():
+            iterator = iter(payload.body)
+            while True:
+                chunk = await loop.run_in_executor(None, next, iterator, None)
+                if chunk is None:
+                    return
+                yield chunk
+
+        headers = dict(self._auth())
+        headers["X-SF-Status"] = str(payload.status)
+        for key, value in payload.headers.items():
+            headers[f"X-SF-{key}"] = value
+        url = f"{self.config.data['server'].rstrip('/')}/secure-files/relay/upload/{transfer}"
+        self.active_transfers += 1
+        try:
+            async with self.session.post(url, data=body(), headers=headers) as resp:
+                await resp.read()
+        except (aiohttp.ClientError, OSError) as exc:
+            log.info("transfer %s ended early: %s", transfer, exc)
+        finally:
+            self.active_transfers -= 1

abstract_securefiles/agent/server.py

@@ -0,0 +1,156 @@
+"""Local control panel for the desktop agent (127.0.0.1 only)."""
+from __future__ import annotations
+
+import logging
+import os
+import string
+import sys
+from importlib import resources
+
+import aiohttp
+from aiohttp import web
+
+from .. import __version__
+from .config import Config, platform_label
+from .relay_client import RelayClient
+
+log = logging.getLogger("securefiles.agent")
+
+MAX_LIST = 3000
+
+
+def _local_only(port: int):
+    allowed = {f"127.0.0.1:{port}", f"localhost:{port}", f"[::1]:{port}"}
+
+    @web.middleware
+    async def guard(request: web.Request, handler):
+        # Host check defeats DNS rebinding; the custom header on writes defeats
+        # cross-site form posts (browsers can't add it without a CORS preflight).
+        if request.host not in allowed:
+            return web.Response(status=403, text="Secure Files agent: local access only")
+        if request.method not in ("GET", "HEAD") and request.headers.get("X-SF-Local") != "1":
+            return web.Response(status=403, text="missing X-SF-Local header")
+        return await handler(request)
+
+    return guard
+
+
+def _roots() -> list:
+    if sys.platform == "win32":
+        return [f"{d}:\\" for d in string.ascii_uppercase if os.path.exists(f"{d}:\\")]
+    roots = ["/"]
+    for extra in ("/media", "/mnt", "/Volumes"):
+        if os.path.isdir(extra):
+            roots.append(extra)
+    return roots
+
+
+def make_app(config: Config, relay: RelayClient) -> web.Application:
+    app = web.Application(middlewares=[_local_only(config.data["port"])])
+
+    async def index(_request):
+        html = resources.files("abstract_securefiles").joinpath("agent/ui/index.html").read_text(encoding="utf-8")
+        return web.Response(text=html, content_type="text/html")
+
+    async def state(_request):
+        d = config.data
+        return web.json_response({
+            "version": __version__,
+            "platform": platform_label(),
+            "server": d["server"],
+            "device_name": d["device_name"],
+            "username": d.get("username"),
+            "paired": config.paired,
+            "connection": relay.state,
+            "error": relay.last_error,
+            "active_transfers": relay.active_transfers,
+            "items": d["items"],
+            "home": os.path.expanduser("~"),
+            "roots": _roots(),
+        })
+
+    async def pair(request):
+        body = await request.json()
+        code = str(body.get("code") or "").strip().upper().replace(" ", "").replace("-", "")
+        server = str(body.get("server") or config.data["server"]).strip().rstrip("/")
+        name = str(body.get("device_name") or config.data["device_name"]).strip()[:60]
+        if not code:
+            return web.json_response({"message": "Enter the pairing code from the website"}, status=400)
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(f"{server}/secure-files/devices/claim",
+                                        json={"code": code, "name": name, "platform": platform_label()}) as resp:
+                    data = await resp.json(content_type=None)
+                    if resp.status != 200:
+                        return web.json_response({"message": data.get("message") or f"Pairing failed ({resp.status})"},
+                                                 status=400)
+        except aiohttp.ClientError as exc:
+            return web.json_response({"message": f"Cannot reach {server}: {exc}"}, status=502)
+        config.data.update(server=server, device_name=data.get("device_name") or name,
+                           device_id=data["device_id"], token=data["token"], username=data.get("username"))
+        config.save()
+        relay.reconnect()
+        return await state(request)
+
+    async def unpair(request):
+        config.data.update(device_id=None, token=None, username=None)
+        config.save()
+        relay.reconnect()
+        return await state(request)
+
+    async def browse(request):
+        path = request.query.get("path") or os.path.expanduser("~")
+        real = os.path.realpath(path)
+        if not os.path.isdir(real):
+            return web.json_response({"message": "Not a folder"}, status=400)
+        dirs, files = [], []
+        try:
+            entries = sorted(os.scandir(real), key=lambda e: e.name.lower())
+        except OSError as exc:
+            return web.json_response({"message": str(exc)}, status=403)
+        for entry in entries[:MAX_LIST]:
+            try:
+                if entry.is_dir():
+                    dirs.append({"name": entry.name, "path": entry.path})
+                elif entry.is_file():
+                    files.append({"name": entry.name, "path": entry.path, "size": entry.stat().st_size})
+            except OSError:
+                continue
+        parent = os.path.dirname(real)
+        return web.json_response({"path": real, "parent": parent if parent != real else None,
+                                  "dirs": dirs, "files": files, "truncated": len(entries) > MAX_LIST})
+
+    async def share(request):
+        body = await request.json()
+        try:
+            config.add_item(str(body.get("path") or ""))
+        except ValueError as exc:
+            return web.json_response({"message": str(exc)}, status=400)
+        await relay.publish_catalog()
+        return await state(request)
+
+    async def unshare(request):
+        config.remove_item(request.match_info["item_id"])
+        await relay.publish_catalog()
+        return await state(request)
+
+    app.router.add_get("/", index)
+    app.router.add_get("/api/state", state)
+    app.router.add_post("/api/pair", pair)
+    app.router.add_post("/api/unpair", unpair)
+    app.router.add_get("/api/browse", browse)
+    app.router.add_post("/api/items", share)
+    app.router.add_delete("/api/items/{item_id}", unshare)
+    return app
+
+
+async def run(config: Config):
+    relay = RelayClient(config)
+    relay.start()
+    runner = web.AppRunner(make_app(config, relay), access_log=None)
+    await runner.setup()
+    site = web.TCPSite(runner, "127.0.0.1", config.data["port"])
+    await site.start()
+    log.info("Secure Files agent %s on http://127.0.0.1:%s", __version__, config.data["port"])
+    import asyncio
+    await asyncio.Event().wait()

abstract_securefiles/agent/ui/index.html

@@ -0,0 +1,125 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Secure Files — this computer</title>
+<style>
+  :root { color-scheme: light dark; --b: color-mix(in srgb, currentColor 20%, transparent); --s: color-mix(in srgb, currentColor 6%, transparent); --a: #2563eb; --d: #dc2626; --ok: #16a34a; }
+  body { font: 14px/1.45 system-ui, sans-serif; max-width: 900px; margin: 0 auto; padding: 20px; }
+  h1 { font-size: 1.4em; margin: 0 0 4px; } h2 { font-size: 1.1em; margin: 0 0 10px; }
+  .muted { opacity: .7; } .err { color: var(--d); }
+  section { border: 1px solid var(--b); border-radius: 10px; padding: 14px 16px; margin: 14px 0; }
+  .row { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+  input { font: inherit; color: inherit; background: var(--s); border: 1px solid var(--b); border-radius: 6px; padding: 6px 10px; }
+  button { font: inherit; color: inherit; background: var(--s); border: 1px solid var(--b); border-radius: 6px; padding: 5px 12px; cursor: pointer; }
+  button.primary { background: var(--a); border-color: var(--a); color: #fff; }
+  button:disabled { opacity: .45; cursor: default; }
+  .dot { display: inline-block; width: 9px; height: 9px; border-radius: 50%; background: var(--d); margin-right: 6px; }
+  .dot.on { background: var(--ok); } .dot.mid { background: #ca8a04; }
+  ul { list-style: none; margin: 0; padding: 0; }
+  li { display: flex; gap: 10px; align-items: center; padding: 6px 4px; border-bottom: 1px solid var(--b); }
+  li:last-child { border-bottom: none; }
+  .grow { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .tag { font-size: 11px; border: 1px solid var(--b); border-radius: 999px; padding: 0 7px; }
+  .browser { max-height: 380px; overflow: auto; border: 1px solid var(--b); border-radius: 6px; }
+  .browser li { padding: 4px 8px; }
+  .link { background: none; border: none; padding: 0; text-align: left; cursor: pointer; }
+  .link:hover { text-decoration: underline; }
+  code { font-size: 12px; }
+</style>
+</head>
+<body>
+<h1>Secure Files — this computer</h1>
+<p class="muted">Share files and folders straight from this computer through your Secure Files account. Nothing is uploaded; when someone downloads, it streams from here through the relay.</p>
+
+<section id="conn"></section>
+<section id="shared"></section>
+<section id="add"></section>
+
+<script>
+const api = async (path, opts = {}) => {
+  const res = await fetch(path, { ...opts, headers: { "Content-Type": "application/json", "X-SF-Local": "1", ...(opts.headers || {}) } });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.message || res.statusText);
+  return data;
+};
+const esc = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+const size = (n) => { if (n == null) return ""; const u = ["B","KB","MB","GB","TB"]; let i = 0; while (n >= 1024 && i < u.length - 1) { n /= 1024; i++; } return `${n.toFixed(i ? 1 : 0)} ${u[i]}`; };
+let state = null, browsePath = null;
+
+function renderConn() {
+  const s = state, el = document.getElementById("conn");
+  if (!s.paired) {
+    el.innerHTML = `<h2><span class="dot"></span>Not connected to an account</h2>
+      <p>On <b>${esc(s.server.replace("api.", ""))}/secure-files</b>, open <i>My computers</i> → <i>Add a computer</i> and enter the code here.</p>
+      <div class="row"><input id="code" placeholder="Pairing code" size="12" autocomplete="off">
+      <input id="dname" value="${esc(s.device_name)}" placeholder="Name for this computer" size="22">
+      <button class="primary" id="pairBtn">Connect</button></div>
+      <details class="muted" style="margin-top:8px"><summary>Server</summary><input id="server" value="${esc(s.server)}" size="40"></details>
+      <p class="err" id="pairErr"></p>`;
+    document.getElementById("pairBtn").onclick = async () => {
+      try {
+        state = await api("/api/pair", { method: "POST", body: JSON.stringify({ code: document.getElementById("code").value, device_name: document.getElementById("dname").value, server: document.getElementById("server").value }) });
+        render();
+      } catch (e) { document.getElementById("pairErr").textContent = e.message; }
+    };
+    return;
+  }
+  const dot = s.connection === "connected" ? "on" : (s.connection === "connecting" || s.connection === "reconnecting") ? "mid" : "";
+  el.innerHTML = `<h2><span class="dot ${dot}"></span>${s.connection === "connected" ? "Connected" : esc(s.connection)}</h2>
+    <p>Account <b>${esc(s.username || "?")}</b> · this computer appears as <b>devices/${esc(s.device_name)}</b> in your Secure Files list.
+    Manage sharing (links, passwords, limits) at <a href="${esc(s.server.replace("api.", ""))}/secure-files" target="_blank" rel="noopener">${esc(s.server.replace("api.", "").replace("https://", ""))}/secure-files</a>.</p>
+    ${s.error ? `<p class="err">${esc(s.error)}</p>` : ""}
+    <p class="muted">${s.active_transfers ? `${s.active_transfers} download(s) in progress · ` : ""}${esc(s.platform)} · agent ${esc(s.version)}</p>
+    <button id="unpair">Disconnect this computer</button>`;
+  document.getElementById("unpair").onclick = async () => { if (confirm("Disconnect this computer from your account?")) { state = await api("/api/unpair", { method: "POST" }); render(); } };
+}
+
+function renderShared() {
+  const el = document.getElementById("shared"), items = state.items;
+  el.innerHTML = `<h2>Shared from this computer</h2>` + (items.length ? `<ul>${items.map((i) => `
+    <li><span>${i.kind === "folder" ? "📁" : "📄"}</span><span class="grow" title="${esc(i.path)}"><b>${esc(i.name)}</b> <span class="muted">${esc(i.path)}</span></span>
+    ${i.kind === "folder" ? `<span class="tag">downloads as .tar</span>` : ""}<button data-id="${esc(i.id)}">Stop sharing</button></li>`).join("")}</ul>`
+    : `<p class="muted">Nothing yet — pick files or folders below.</p>`);
+  el.querySelectorAll("button[data-id]").forEach((b) => b.onclick = async () => { state = await api(`/api/items/${b.dataset.id}`, { method: "DELETE" }); render(); });
+}
+
+async function renderAdd() {
+  const el = document.getElementById("add");
+  browsePath = browsePath || state.home;
+  let listing;
+  try { listing = await api(`/api/browse?path=${encodeURIComponent(browsePath)}`); }
+  catch (e) { el.innerHTML = `<h2>Add from this computer</h2><p class="err">${esc(e.message)}</p>`; browsePath = state.home; return; }
+  const shared = new Set(state.items.map((i) => i.path));
+  el.innerHTML = `<h2>Add from this computer</h2>
+    <div class="row" style="margin-bottom:8px"><input id="pathIn" class="grow" value="${esc(listing.path)}">
+      <button id="go">Go</button><button id="shareHere" class="primary" ${shared.has(listing.path) ? "disabled" : ""}>Share this folder</button></div>
+    <div class="row muted" style="margin-bottom:8px">${state.roots.map((r) => `<button class="link" data-path="${esc(r)}">${esc(r)}</button>`).join(" · ")} · <button class="link" data-path="${esc(state.home)}">Home</button></div>
+    <ul class="browser">
+      ${listing.parent ? `<li><button class="link" data-path="${esc(listing.parent)}">↩ ..</button></li>` : ""}
+      ${listing.dirs.map((d) => `<li><span>📁</span><button class="link grow" data-path="${esc(d.path)}">${esc(d.name)}</button>
+        <button data-share="${esc(d.path)}" ${shared.has(d.path) ? "disabled" : ""}>${shared.has(d.path) ? "Shared" : "Share folder"}</button></li>`).join("")}
+      ${listing.files.map((f) => `<li><span>📄</span><span class="grow">${esc(f.name)}</span><span class="muted">${size(f.size)}</span>
+        <button data-share="${esc(f.path)}" ${shared.has(f.path) ? "disabled" : ""}>${shared.has(f.path) ? "Shared" : "Share"}</button></li>`).join("")}
+      ${!listing.dirs.length && !listing.files.length ? `<li class="muted">Empty folder</li>` : ""}
+    </ul>${listing.truncated ? `<p class="muted">Showing the first 3000 entries.</p>` : ""}`;
+  el.querySelectorAll("[data-path]").forEach((b) => b.onclick = () => { browsePath = b.dataset.path; renderAdd(); });
+  el.querySelectorAll("[data-share]").forEach((b) => b.onclick = async () => { state = await api("/api/items", { method: "POST", body: JSON.stringify({ path: b.dataset.share }) }); render(); });
+  document.getElementById("go").onclick = () => { browsePath = document.getElementById("pathIn").value; renderAdd(); };
+  document.getElementById("shareHere").onclick = async () => { state = await api("/api/items", { method: "POST", body: JSON.stringify({ path: listing.path }) }); render(); };
+}
+
+async function render() { renderConn(); renderShared(); await renderAdd(); }
+async function refresh() {
+  try {
+    const next = await api("/api/state");
+    const wasPaired = state && state.paired;
+    state = next;
+    if (state.paired || wasPaired) renderConn();
+  } catch (e) {}
+}
+(async () => { state = await api("/api/state"); await render(); setInterval(refresh, 3000); })();
+</script>
+</body>
+</html>

abstract_securefiles/cli.py

@@ -0,0 +1,147 @@
+"""`securefiles` command line."""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import logging
+import sys
+import time
+import urllib.error
+import urllib.request
+import webbrowser
+
+from . import __version__
+from .agent.config import Config, config_dir
+
+
+def _ui_url(config: Config) -> str:
+    return f"http://127.0.0.1:{config.data['port']}/"
+
+
+def _local(config: Config, path: str, body=None):
+    req = urllib.request.Request(
+        _ui_url(config).rstrip("/") + path,
+        data=json.dumps(body).encode() if body is not None else None,
+        headers={"Content-Type": "application/json", "X-SF-Local": "1"},
+        method="POST" if body is not None else "GET",
+    )
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        return json.loads(resp.read())
+
+
+def _running(config: Config) -> bool:
+    try:
+        _local(config, "/api/state")
+        return True
+    except (urllib.error.URLError, OSError):
+        return False
+
+
+def cmd_serve(config: Config, _args):
+    from .agent.server import run
+
+    log_file = config_dir() / "agent.log"
+    log_file.parent.mkdir(parents=True, exist_ok=True)
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+        handlers=[logging.FileHandler(log_file, encoding="utf-8"), logging.StreamHandler()],
+    )
+    if _running(config):
+        print(f"Already running at {_ui_url(config)}")
+        return
+    try:
+        asyncio.run(run(config))
+    except KeyboardInterrupt:
+        pass
+
+
+def cmd_setup(config: Config, args):
+    from .agent import autostart
+
+    config.save()
+    print(autostart.install())
+    for _ in range(30):
+        if _running(config):
+            break
+        time.sleep(0.5)
+    print(f"Secure Files agent: {_ui_url(config)}")
+    if not args.no_browser:
+        webbrowser.open(_ui_url(config))
+
+
+def cmd_uninstall(_config: Config, _args):
+    from .agent import autostart
+
+    print(autostart.uninstall())
+
+
+def cmd_open(config: Config, _args):
+    webbrowser.open(_ui_url(config))
+    print(_ui_url(config))
+
+
+def cmd_pair(config: Config, args):
+    body = {"code": args.code}
+    if args.server:
+        body["server"] = args.server
+    if args.name:
+        body["device_name"] = args.name
+    if not _running(config):
+        sys.exit("The agent isn't running; start it with `securefiles setup` (or `securefiles serve`).")
+    try:
+        state = _local(config, "/api/pair", body)
+    except urllib.error.HTTPError as exc:
+        sys.exit(json.loads(exc.read() or b"{}").get("message") or str(exc))
+    print(f"Paired as {state['username']} / {state['device_name']}")
+
+
+def cmd_unpair(config: Config, _args):
+    if _running(config):
+        _local(config, "/api/unpair", {})
+    else:
+        config.data.update(device_id=None, token=None, username=None)
+        config.save()
+    print("This computer is no longer connected to an account.")
+
+
+def cmd_status(config: Config, _args):
+    if not _running(config):
+        print(f"Agent not running (config: {config.path})")
+        return
+    s = _local(config, "/api/state")
+    print(f"Agent {s['version']} at {_ui_url(config)}")
+    print(f"Account: {s['username'] or '-'}  Device: {s['device_name']}  Connection: {s['connection']}")
+    if s.get("error"):
+        print(f"Last error: {s['error']}")
+    for item in s["items"]:
+        print(f"  shared {item['kind']:6} {item['path']}")
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="securefiles", description="Secure Files desktop agent")
+    parser.add_argument("--version", action="version", version=__version__)
+    sub = parser.add_subparsers(dest="command")
+    sub.add_parser("serve", help="run the agent in the foreground")
+    setup = sub.add_parser("setup", help="start at login, start now and open the control panel")
+    setup.add_argument("--no-browser", action="store_true")
+    sub.add_parser("uninstall", help="stop starting at login")
+    sub.add_parser("open", help="open the control panel")
+    pair = sub.add_parser("pair", help="connect this computer to your account")
+    pair.add_argument("code")
+    pair.add_argument("--server")
+    pair.add_argument("--name")
+    sub.add_parser("unpair", help="disconnect this computer from your account")
+    sub.add_parser("status", help="show connection and shared items")
+    args = parser.parse_args(argv)
+    config = Config()
+    handler = {
+        "serve": cmd_serve, "setup": cmd_setup, "uninstall": cmd_uninstall, "open": cmd_open,
+        "pair": cmd_pair, "unpair": cmd_unpair, "status": cmd_status,
+    }.get(args.command or "status")
+    handler(config, args)
+
+
+if __name__ == "__main__":
+    main()

abstract_securefiles/core.py

@@ -0,0 +1,184 @@
+"""Transport core shared by the server and the desktop agent.
+
+Folders are delivered as a deterministic, uncompressed PAX tar whose every byte
+position is known up front, so responses carry an exact length and support
+HTTP Range (resume). Single files are served as plain byte ranges.
+"""
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import tarfile
+from typing import Callable, Iterator, List, Optional, Tuple
+from urllib.parse import quote
+
+CHUNK = 1 << 20
+
+Entry = Tuple[str, str]  # (absolute path, archive name)
+
+
+class RangeNotSatisfiable(Exception):
+    pass
+
+
+class TarLayout:
+    """A deterministic, uncompressed tar of a fixed file list."""
+
+    def __init__(self, entries: List[Entry]):
+        self.segments: List[Tuple[int, int, Optional[bytes], Optional[str]]] = []
+        offset = 0
+        digest = hashlib.sha256()
+        for path, arcname in entries:
+            st = os.stat(path)
+            info = tarfile.TarInfo(arcname)
+            info.size = st.st_size
+            info.mtime = int(st.st_mtime)
+            info.mode = 0o644
+            info.uid = info.gid = 0
+            info.uname = info.gname = ""
+            header = info.tobuf(format=tarfile.PAX_FORMAT, encoding="utf-8", errors="surrogateescape")
+            for length, data, src in ((len(header), header, None), (st.st_size, None, path),
+                                      ((-st.st_size) % 512, None, None)):
+                if length:
+                    self.segments.append((offset, length, data, src))
+                    offset += length
+            digest.update(f"{arcname}\0{st.st_size}\0{int(st.st_mtime)}\n".encode("utf-8", "surrogateescape"))
+        self.segments.append((offset, 1024, None, None))
+        self.size = offset + 1024
+        self.etag = digest.hexdigest()[:32]
+
+    def iter_range(self, start: int, stop: int) -> Iterator[bytes]:
+        for seg_start, length, data, path in self.segments:
+            seg_stop = seg_start + length
+            if seg_stop <= start or seg_start >= stop:
+                continue
+            lo, hi = max(start, seg_start) - seg_start, min(stop, seg_stop) - seg_start
+            if path is None:
+                yield data[lo:hi] if data is not None else bytes(hi - lo)
+                continue
+            with open(path, "rb") as fh:
+                if os.fstat(fh.fileno()).st_size != length:
+                    raise IOError(f"{path} changed size during download")
+                fh.seek(lo)
+                remaining = hi - lo
+                while remaining:
+                    buf = fh.read(min(CHUNK, remaining))
+                    if not buf:
+                        raise IOError(f"{path} truncated during download")
+                    remaining -= len(buf)
+                    yield buf
+
+
+def walk_files(folder: str, arc_prefix: str, allow: Optional[Callable[[str], bool]] = None) -> List[Entry]:
+    """Every regular file under folder in a stable order, as (real path, archive name).
+
+    Entries that resolve outside the folder (symlinks), fail allow(), or are
+    unreadable are skipped, so a shared folder never leaks anything else.
+    """
+    base = os.path.realpath(folder)
+    entries: List[Entry] = []
+    for dirpath, dirnames, filenames in os.walk(folder, followlinks=False):
+        dirnames.sort()
+        for name in sorted(filenames):
+            full = os.path.join(dirpath, name)
+            real = os.path.realpath(full)
+            if not (allow(real) if allow else within(base, real)):
+                continue
+            if not os.path.isfile(real) or not os.access(real, os.R_OK):
+                continue
+            rel = os.path.relpath(full, folder).replace(os.sep, "/")
+            entries.append((real, f"{arc_prefix}/{rel}" if arc_prefix else rel))
+    return entries
+
+
+def within(base: str, path: str) -> bool:
+    try:
+        return os.path.commonpath([base, path]) == base
+    except ValueError:  # different drives on Windows
+        return False
+
+
+_RANGE_RE = re.compile(r"^bytes=(\d*)-(\d*)$")
+
+
+def parse_range(header: Optional[str], size: int) -> Optional[Tuple[int, int]]:
+    """Parse a single-range Range header into [start, stop). None = whole body."""
+    if not header:
+        return None
+    m = _RANGE_RE.match(header.strip())
+    if not m or (m.group(1) == "" and m.group(2) == ""):
+        return None
+    if m.group(1) == "":
+        length = int(m.group(2))
+        if length == 0:
+            raise RangeNotSatisfiable()
+        return max(0, size - length), size
+    start = int(m.group(1))
+    stop = int(m.group(2)) + 1 if m.group(2) else size
+    if start >= size:
+        raise RangeNotSatisfiable()
+    return start, min(stop, size)
+
+
+def iter_file(path: str, start: int, stop: int) -> Iterator[bytes]:
+    with open(path, "rb") as fh:
+        fh.seek(start)
+        remaining = stop - start
+        while remaining:
+            buf = fh.read(min(CHUNK, remaining))
+            if not buf:
+                raise IOError(f"{path} truncated during download")
+            remaining -= len(buf)
+            yield buf
+
+
+def content_disposition(name: str) -> str:
+    ascii_name = name.encode("ascii", "replace").decode().replace('"', "_").replace("?", "_")
+    return f"attachment; filename=\"{ascii_name}\"; filename*=UTF-8''{quote(name)}"
+
+
+class Payload:
+    """Everything needed to answer a (possibly ranged) download of a file or folder."""
+
+    def __init__(self, status: int, headers: dict, body: Iterator[bytes]):
+        self.status = status
+        self.headers = headers
+        self.body = body
+
+
+def build_payload(path: str, download_name: str, range_header: Optional[str],
+                  if_range: Optional[str] = None,
+                  allow: Optional[Callable[[str], bool]] = None) -> Payload:
+    """Response for a file (plain bytes) or a folder (deterministic tar), honouring Range."""
+    if os.path.isdir(path):
+        prefix = download_name[:-4] if download_name.lower().endswith(".tar") else download_name
+        layout = TarLayout(walk_files(path, prefix, allow))
+        size, etag, ctype = layout.size, layout.etag, "application/x-tar"
+        reader = layout.iter_range
+        name = prefix + ".tar"
+    else:
+        st = os.stat(path)
+        size, ctype, name = st.st_size, "application/octet-stream", download_name
+        etag = hashlib.sha256(f"{path}\0{st.st_size}\0{st.st_mtime_ns}".encode("utf-8", "surrogateescape")).hexdigest()[:32]
+        reader = lambda a, b: iter_file(path, a, b)  # noqa: E731
+    headers = {
+        "Content-Type": ctype,
+        "Content-Disposition": content_disposition(name),
+        "Accept-Ranges": "bytes",
+        "ETag": f'"{etag}"',
+    }
+    use_range = range_header if (not if_range or if_range.strip('"') == etag) else None
+    try:
+        bounds = parse_range(use_range, size)
+    except RangeNotSatisfiable:
+        headers["Content-Range"] = f"bytes */{size}"
+        headers["Content-Length"] = "0"
+        return Payload(416, headers, iter(()))
+    if bounds is None:
+        headers["Content-Length"] = str(size)
+        return Payload(200, headers, reader(0, size))
+    start, stop = bounds
+    headers["Content-Range"] = f"bytes {start}-{stop - 1}/{size}"
+    headers["Content-Length"] = str(stop - start)
+    return Payload(206, headers, reader(start, stop))

abstract_securefiles/relay/server.py

@@ -0,0 +1,239 @@
+"""Secure Files relay.
+
+Paired desktop agents keep one outbound WebSocket here (control only). When a
+download of an agent-hosted item arrives, the API calls /internal/fetch; the
+relay asks the agent to stream that item (with the caller's Range) as an HTTPS
+upload to /secure-files/relay/upload/<transfer>, and pipes the upload straight
+into the waiting response. Nothing is stored on the server.
+
+Public routes (proxied by nginx):  /secure-files/relay/agent   (WebSocket)
+                                    /secure-files/relay/upload/<transfer>
+Internal routes (127.0.0.1 only):  /internal/fetch, /internal/kick/<id>
+"""
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+import logging
+import os
+import re
+import secrets
+from typing import Dict, Optional
+
+from aiohttp import WSMsgType, web
+
+log = logging.getLogger("securefiles.relay")
+
+DSN = os.environ.get("SECURE_FILES_DB_DSN") or os.environ.get("AUTH_DB_DSN") or "postgresql:///auth_v2"
+HOST = os.environ.get("SECURE_FILES_RELAY_HOST", "127.0.0.1")
+PORT = int(os.environ.get("SECURE_FILES_RELAY_PORT", "6013"))
+TRANSFER_WAIT = 60
+PASS_HEADERS = ("Content-Type", "Content-Disposition", "Content-Length", "Content-Range", "Accept-Ranges", "ETag")
+ITEM_ID_RE = re.compile(r"^[A-Za-z0-9_-]{1,128}$")
+
+
+def _db(sql: str, params=(), fetch: bool = False):
+    import psycopg
+    from psycopg.rows import dict_row
+
+    with psycopg.connect(DSN, autocommit=True, row_factory=dict_row) as conn:
+        cur = conn.execute(sql, params)
+        return cur.fetchall() if fetch else None
+
+
+async def db(sql: str, params=(), fetch: bool = False):
+    return await asyncio.to_thread(_db, sql, params, fetch)
+
+
+def token_hash(token: str) -> str:
+    return hashlib.sha256(token.encode()).hexdigest()
+
+
+def _safe_segment(name: str) -> str:
+    cleaned = re.sub(r"[\\/\x00-\x1f]+", "_", name).strip().strip(".")
+    return cleaned[:120] or "item"
+
+
+class Agent:
+    def __init__(self, ws: web.WebSocketResponse, device: dict):
+        self.ws = ws
+        self.device = device
+        self.lock = asyncio.Lock()
+
+    async def send(self, message: dict):
+        async with self.lock:
+            await self.ws.send_str(json.dumps(message))
+
+
+class Relay:
+    def __init__(self):
+        self.agents: Dict[int, Agent] = {}
+        self.pending: Dict[str, tuple] = {}  # transfer -> (device_id, future)
+
+    async def authenticate(self, request: web.Request) -> Optional[dict]:
+        auth = request.headers.get("Authorization", "")
+        if not auth.lower().startswith("bearer "):
+            return None
+        rows = await db(
+            "SELECT id, username, name FROM secure_file_devices WHERE token_hash = %s AND revoked_at IS NULL",
+            (token_hash(auth[7:].strip()),),
+            fetch=True,
+        )
+        return rows[0] if rows else None
+
+    # --- agent control channel ------------------------------------------------------------
+    async def agent_ws(self, request: web.Request):
+        device = await self.authenticate(request)
+        if not device:
+            return web.json_response({"message": "unknown or revoked device"}, status=401)
+        ws = web.WebSocketResponse(heartbeat=30, max_msg_size=8 * 1024 * 1024)
+        await ws.prepare(request)
+        old = self.agents.get(device["id"])
+        if old:
+            await old.ws.close(message=b"replaced by a newer connection")
+        agent = Agent(ws, device)
+        self.agents[device["id"]] = agent
+        await db("UPDATE secure_file_devices SET online = TRUE, last_seen = NOW() WHERE id = %s", (device["id"],))
+        log.info("agent online: device %s (%s/%s)", device["id"], device["username"], device["name"])
+        try:
+            async for msg in ws:
+                if msg.type != WSMsgType.TEXT:
+                    continue
+                try:
+                    data = json.loads(msg.data)
+                except ValueError:
+                    continue
+                kind = data.get("type")
+                if kind in ("hello", "catalog"):
+                    await self.sync_catalog(device, data.get("items") or [], data)
+                elif kind == "error":
+                    entry = self.pending.pop(str(data.get("transfer")), None)
+                    if entry and entry[0] == device["id"] and not entry[1].done():
+                        entry[1].set_result({"error": True, "status": int(data.get("status") or 502),
+                                             "message": str(data.get("message") or "agent error")[:500]})
+                elif kind == "ping":
+                    await agent.send({"type": "pong"})
+        finally:
+            if self.agents.get(device["id"]) is agent:
+                del self.agents[device["id"]]
+                await db("UPDATE secure_file_devices SET online = FALSE, last_seen = NOW() WHERE id = %s",
+                         (device["id"],))
+                log.info("agent offline: device %s", device["id"])
+        return ws
+
+    async def sync_catalog(self, device: dict, items: list, hello: dict):
+        """Mirror the agent's published items as uploads rows owned by the device's user."""
+        if hello.get("type") == "hello":
+            await db(
+                "UPDATE secure_file_devices SET platform = %s, agent_version = %s WHERE id = %s",
+                (str(hello.get("platform") or "")[:64], str(hello.get("version") or "")[:32], device["id"]),
+            )
+        folder = f"devices/{_safe_segment(device['name'])}"
+        existing = {r["device_item"]: r["id"] for r in await db(
+            "SELECT id, device_item FROM uploads WHERE device_id = %s", (device["id"],), fetch=True)}
+        seen = set()
+        for item in items[:5000]:
+            item_id = str(item.get("id") or "")
+            kind = "folder" if item.get("kind") == "folder" else "file"
+            if not ITEM_ID_RE.match(item_id) or item_id in seen:
+                continue
+            seen.add(item_id)
+            name = _safe_segment(str(item.get("name") or item_id))
+            filename = f"{name}.tar" if kind == "folder" else name
+            size = item.get("size") if isinstance(item.get("size"), int) else None
+            if item_id in existing:
+                await db(
+                    "UPDATE uploads SET filename = %s, filepath = %s, device_kind = %s, size_bytes = %s WHERE id = %s",
+                    (filename, f"{folder}/{filename}", kind, size, existing[item_id]),
+                )
+            else:
+                await db(
+                    "INSERT INTO uploads (filename, filepath, uploader_id, shareable, download_count, "
+                    "device_id, device_item, device_kind, size_bytes) VALUES (%s, %s, %s, FALSE, 0, %s, %s, %s, %s)",
+                    (filename, f"{folder}/{filename}", device["username"], device["id"], item_id, kind, size),
+                )
+        gone = [rid for item_id, rid in existing.items() if item_id not in seen]
+        if gone:
+            await db("DELETE FROM uploads WHERE id = ANY(%s)", (gone,))
+
+    # --- transfers ---------------------------------------------------------------------------
+    async def fetch(self, request: web.Request):
+        """Internal: called by the API after it has enforced share rules."""
+        body = await request.json()
+        device_id, item = int(body.get("device_id") or 0), str(body.get("item") or "")
+        agent = self.agents.get(device_id)
+        if not agent:
+            return web.Response(status=503, text="The computer hosting this file is offline.")
+        transfer = secrets.token_urlsafe(18)
+        future = asyncio.get_running_loop().create_future()
+        self.pending[transfer] = (device_id, future)
+        try:
+            await agent.send({"type": "send", "transfer": transfer, "item": item,
+                              "range": body.get("range"), "if_range": body.get("if_range")})
+            result = await asyncio.wait_for(future, TRANSFER_WAIT)
+        except asyncio.TimeoutError:
+            return web.Response(status=504, text="The computer hosting this file did not respond.")
+        finally:
+            self.pending.pop(transfer, None)
+        if isinstance(result, dict):
+            return web.Response(status=result["status"], text=result["message"])
+        upload, done = result
+        status = int(upload.headers.get("X-SF-Status") or 200)
+        response = web.StreamResponse(status=status)
+        for name in PASS_HEADERS:
+            value = upload.headers.get(f"X-SF-{name}")
+            if value:
+                response.headers[name] = value
+        try:
+            await response.prepare(request)
+            async for chunk in upload.content.iter_chunked(1 << 20):
+                await response.write(chunk)
+            await response.write_eof()
+            done.set_result(True)
+        except Exception as exc:  # downloader or agent went away
+            if not done.done():
+                done.set_result(False)
+            log.info("transfer %s aborted: %s", transfer, exc)
+        return response
+
+    async def upload(self, request: web.Request):
+        """Public: the agent streams the requested bytes here."""
+        device = await self.authenticate(request)
+        entry = self.pending.get(request.match_info["transfer"])
+        if not device or not entry or entry[0] != device["id"] or entry[1].done():
+            return web.json_response({"message": "unknown transfer"}, status=404)
+        done = asyncio.get_running_loop().create_future()
+        entry[1].set_result((request, done))
+        ok = await done
+        return web.json_response({"ok": ok}, status=200 if ok else 499)
+
+    async def kick(self, request: web.Request):
+        agent = self.agents.get(int(request.match_info["device_id"]))
+        if agent:
+            await agent.ws.close(message=b"device revoked")
+        return web.json_response({"ok": True})
+
+
+def make_app() -> web.Application:
+    relay = Relay()
+    app = web.Application(client_max_size=0)
+    app.router.add_get("/secure-files/relay/agent", relay.agent_ws)
+    app.router.add_post("/secure-files/relay/upload/{transfer}", relay.upload)
+    app.router.add_post("/internal/fetch", relay.fetch)
+    app.router.add_post("/internal/kick/{device_id}", relay.kick)
+
+    async def on_startup(_app):
+        await db("UPDATE secure_file_devices SET online = FALSE")
+
+    app.on_startup.append(on_startup)
+    return app
+
+
+def main():
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
+    web.run_app(make_app(), host=HOST, port=PORT, access_log=None)
+
+
+if __name__ == "__main__":
+    main()

abstract_securefiles-0.1.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: abstract_securefiles
+Version: 0.1.0
+Summary: Secure Files: share local files and folders through abstractendeavors.com (or your own server) without uploading them. Includes the desktop agent, the shared tar/resume core and the server relay.
+Author-email: putkoff <partners@abstractendeavors.com>
+License: MIT
+Project-URL: Homepage, https://abstractendeavors.com/secure-files
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.9
+Provides-Extra: relay
+Requires-Dist: psycopg[binary]>=3.1; extra == "relay"
+
+# abstract_securefiles
+
+Share files and whole folders **straight from your own computer** through
+[Secure Files](https://abstractendeavors.com/secure-files) — nothing is uploaded.
+When someone opens your share link, the file streams from your computer through
+the relay, with the same passwords, download limits and resumable downloads as
+files hosted on the server. Folders download as one uncompressed `.tar`.
+
+## Install (Linux, macOS, Windows)
+
+```bash
+pipx install abstract-securefiles      # or: python -m pip install --user abstract-securefiles
+securefiles setup                      # start at login, start now, open http://127.0.0.1:47821
+```
+
+Then, on abstractendeavors.com/secure-files → **My computers** → **Add a computer**,
+enter the pairing code in the control panel (or `securefiles pair CODE`).
+Pick files/folders to share in the control panel; they appear on the website under
+`devices/<computer name>/`, where you create links, passwords and limits.
+
+Commands: `securefiles setup | serve | open | pair CODE | status | unpair | uninstall`.
+
+Secure Files is invite-only; ask the administrator for access.
+
+## Contents
+
+- `abstract_securefiles.core` — deterministic tar + HTTP Range transport shared by server and agent.
+- `abstract_securefiles.agent` — the desktop agent (local control panel on 127.0.0.1 only).
+- `abstract_securefiles.relay` — the server relay (`pip install abstract-securefiles[relay]`, run `securefiles-relay`).

abstract_securefiles-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+abstract_securefiles/__init__.py,sha256=uHj2wVS0RtNc1BwbLe2EofqKfvE17WTGNOgA_216Lq8,88
+abstract_securefiles/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+abstract_securefiles/cli.py,sha256=JCcELzb40KxpTslrLF7C6Z_mOAM6JJjfehw2esZq9Sk,4693
+abstract_securefiles/core.py,sha256=eMpksdoy5s9fvrYGBQBrqbI-GUSxtjMuVbnb0U3hGr4,7297
+abstract_securefiles/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+abstract_securefiles/agent/autostart.py,sha256=Ox4cja42vV7-ScTLHqGKqIAnro9ecbofyOKl9e5mvfI,3813
+abstract_securefiles/agent/config.py,sha256=koDEn1u8tZhum44ZMw7LnGUPdOfe-1YS5pIDHyWGDSk,3335
+abstract_securefiles/agent/relay_client.py,sha256=9C0As96r7O2NOT3pd8pVfE7lChVK6bkfCPE5jXJPU68,6003
+abstract_securefiles/agent/server.py,sha256=P3aftjILW4gmSGtsGmlfUNbEjwjtj5akm2vttiRj-KM,6242
+abstract_securefiles/agent/ui/index.html,sha256=CtzUhAhgk016Tz0CRg0zjbkZUirprGf_KjtdZ2eWT3k,9084
+abstract_securefiles/relay/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+abstract_securefiles/relay/server.py,sha256=-HiiAqB_XNK7hGNWLtqpcvgg2XDW2DGObr1aFV2JAHw,10594
+abstract_securefiles-0.1.0.dist-info/METADATA,sha256=c3ijGjZHNWV_0rA4xEUzOey-qNgaP8h8jKoYwHtBUKE,2269
+abstract_securefiles-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+abstract_securefiles-0.1.0.dist-info/entry_points.txt,sha256=n_nfpF4ECD-TAiBb8pBaedqZGvN4lyy9enn6fesxJCA,121
+abstract_securefiles-0.1.0.dist-info/top_level.txt,sha256=fUttafCR3EOs4ZuQ5DoZuZyDC863kQBN1DzvmTsbbJM,21
+abstract_securefiles-0.1.0.dist-info/RECORD,,

abstract_securefiles-0.1.0.dist-info/WHEEL

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

abstract_securefiles-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+securefiles = abstract_securefiles.cli:main
+securefiles-relay = abstract_securefiles.relay.server:main

abstract_securefiles-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+abstract_securefiles