frutebox-node 0.1.0__py3-none-any.whl

frutebox/gui.py

@@ -0,0 +1,270 @@
+"""A modern, local web dashboard the node software serves to its owner.
+
+This is deliberately a *web* GUI (served on localhost), not a desktop-widget
+toolkit — so it looks clean and modern in any browser, matching the website, and
+never resembles an old Tkinter/Swing window. The contributor opens it to see, in
+plain terms: is my machine running, what is it doing, and what have I earned.
+
+  start_gui(stats_fn, kill_fn, port) -> runs a tiny HTTP server in a daemon
+  thread. stats_fn() returns a dict; kill_fn() stops the node (the "kill switch").
+"""
+from __future__ import annotations
+
+import hmac
+import ipaddress
+import json
+import secrets
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Callable
+
+# CSRF token for the destructive endpoint. `POST /kill` used to be unauthenticated on
+# a predictable loopback port, so ANY web page the owner happened to visit could stop
+# their node with a cross-origin form/fetch — no reply needed, so the same-origin
+# policy did not help. The token is rendered into the page the server itself serves;
+# a foreign page can issue the POST but cannot read the token to put in it.
+#
+# The token alone was not enough. A browser will happily treat a page on `evil.tld` as
+# same-origin with this server once `evil.tld` re-resolves to 127.0.0.1 (DNS rebinding),
+# and at that point it can simply READ the token out of the page the server renders. So
+# every request is first pinned to a loopback `Host` — see `_loopback_host`.
+#
+# Scope, honestly: this stops drive-by CSRF and rebinding from the browser. It does NOT
+# stop another process already running as the same user — that process can read the page
+# (or just signal the node), and no token can change that.
+_KILL_TOKEN_HEADER = "X-Stevai-Kill"
+
+_PAGE = """<!doctype html>
+<html lang="en"><head>
+<meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Frutebox — your machine</title>
+<style>
+  :root{--indigo:#4f46e5;--green:#22c55e;--ink:#10233b;--muted:#5b6b80}
+  *{box-sizing:border-box;margin:0;padding:0}
+  body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;
+       color:var(--ink);background:linear-gradient(160deg,#eef2ff 0%,#f7f9fc 40%,#ecfdf5 100%);
+       min-height:100vh;padding:32px 20px}
+  .wrap{max-width:920px;margin:0 auto}
+  .top{display:flex;align-items:center;justify-content:space-between;gap:16px;flex-wrap:wrap;margin-bottom:28px}
+  .brand{font-weight:800;font-size:22px;letter-spacing:-.02em;
+    background:linear-gradient(90deg,#4f46e5,#22c55e);-webkit-background-clip:text;background-clip:text;color:transparent}
+  .pill{display:inline-flex;align-items:center;gap:8px;font-size:13px;font-weight:600;
+    padding:7px 14px;border-radius:999px;background:#fff;border:1px solid rgba(16,35,59,.1)}
+  .dot{width:9px;height:9px;border-radius:50%;background:#cbd5e1}
+  .dot.on{background:var(--green);box-shadow:0 0 0 4px rgba(34,197,94,.18)}
+  .grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:16px}
+  .card{background:rgba(255,255,255,.72);backdrop-filter:blur(10px);border:1px solid rgba(16,35,59,.08);
+    border-radius:20px;padding:22px;box-shadow:0 12px 40px -24px rgba(16,35,59,.4)}
+  .label{font-size:12px;font-weight:600;text-transform:uppercase;letter-spacing:.04em;color:var(--muted)}
+  .big{font-size:34px;font-weight:800;letter-spacing:-.02em;margin-top:6px}
+  .sub{font-size:13px;color:var(--muted);margin-top:4px}
+  .row{display:flex;justify-content:space-between;font-size:14px;padding:7px 0;border-bottom:1px solid rgba(16,35,59,.06)}
+  .row:last-child{border-bottom:0}
+  .row b{font-weight:600}
+  .earn{grid-column:1/-1;background:linear-gradient(120deg,#4f46e5,#22c55e);color:#fff;border:0}
+  .earn .label{color:rgba(255,255,255,.85)}
+  .earn .sub{color:rgba(255,255,255,.85)}
+  .kill{grid-column:1/-1;display:flex;align-items:center;justify-content:space-between;gap:16px;flex-wrap:wrap}
+  .kill h3{font-size:17px}.kill p{font-size:13px;color:var(--muted);margin-top:4px;max-width:52ch}
+  .kbtn{border:0;cursor:pointer;font-weight:700;font-size:14px;color:#fff;padding:13px 22px;border-radius:999px;
+    background:linear-gradient(90deg,#ef4444,#dc2626);box-shadow:0 10px 24px -12px rgba(220,38,38,.8)}
+  .kbtn:disabled{opacity:.5;cursor:default}
+  .foot{text-align:center;color:var(--muted);font-size:12px;margin-top:26px}
+</style></head>
+<body><div class="wrap">
+  <div class="top">
+    <div class="brand">frutebox</div>
+    <div class="pill"><span id="dot" class="dot"></span><span id="statusText">Connecting…</span></div>
+  </div>
+  <div class="grid">
+    <div class="card">
+      <div class="label">This machine</div>
+      <div class="big" id="name">—</div>
+      <div class="sub" id="hw">—</div>
+      <div style="margin-top:14px">
+        <div class="row"><span>Location</span><b id="region">—</b></div>
+        <div class="row"><span>Type</span><b id="type">—</b></div>
+        <div class="row"><span>Current load</span><b id="load">—</b></div>
+      </div>
+    </div>
+    <div class="card">
+      <div class="label">Activity</div>
+      <div class="big" id="jobs">0</div>
+      <div class="sub">tasks completed</div>
+      <div style="margin-top:14px">
+        <div class="row"><span>Running right now</span><b id="active">0</b></div>
+        <div class="row"><span>Work processed</span><b id="tokens">0</b></div>
+        <div class="row"><span>Uptime</span><b id="uptime">—</b></div>
+      </div>
+    </div>
+    <div class="card earn">
+      <div class="label">Earned so far (estimate)</div>
+      <div class="big" id="earn">0.00</div>
+      <div class="sub">Based on the power &amp; internet your machine has contributed. Payouts switch on soon.</div>
+    </div>
+    <div class="card kill">
+      <div>
+        <h3>Stop sharing</h3>
+        <p>Instantly stop this machine and clear its workspace. You&apos;re always in control — turn it back on whenever you like.</p>
+      </div>
+      <button class="kbtn" id="kill" onclick="kill()">Stop &amp; clear now</button>
+    </div>
+  </div>
+  <div class="foot">Runs only on this machine. It reaches out to the network — it never opens your computer to the outside.</div>
+</div>
+<script>
+  const KILL_TOKEN=__KILL_TOKEN__;
+  function fmtUptime(s){s=Math.floor(s);const h=Math.floor(s/3600),m=Math.floor(s%3600/60);return h+"h "+m+"m"}
+  async function tick(){
+    try{
+      const r=await fetch('/status',{cache:'no-store'});const d=await r.json();
+      document.getElementById('name').textContent=d.name;
+      document.getElementById('hw').textContent=d.hardware;
+      document.getElementById('region').textContent=d.region;
+      document.getElementById('type').textContent=d.type;
+      document.getElementById('load').textContent=Math.round(d.load*100)+'%';
+      document.getElementById('jobs').textContent=d.jobs;
+      document.getElementById('active').textContent=d.active;
+      document.getElementById('tokens').textContent=d.tokens.toLocaleString();
+      document.getElementById('uptime').textContent=fmtUptime(d.uptime);
+      document.getElementById('earn').textContent=d.earnings.toFixed(2);
+      const on=d.connected;
+      document.getElementById('dot').className='dot'+(on?' on':'');
+      document.getElementById('statusText').textContent=on?'Live — earning':'Connecting…';
+    }catch(e){document.getElementById('statusText').textContent='Offline'}
+  }
+  async function kill(){
+    if(!confirm('Stop sharing this machine now? It will disconnect and clear its workspace.'))return;
+    document.getElementById('kill').disabled=true;
+    document.getElementById('kill').textContent='Stopping…';
+    try{await fetch('/kill',{method:'POST',headers:{'X-Stevai-Kill':KILL_TOKEN}})}catch(e){}
+    document.getElementById('statusText').textContent='Stopped';
+    document.getElementById('dot').className='dot';
+  }
+  tick();setInterval(tick,2000);
+</script>
+</body></html>"""
+
+
+class _Handler(BaseHTTPRequestHandler):
+    stats_fn: Callable[[], dict]
+    kill_fn: Callable[[], None]
+    kill_token: str = ""
+
+    def _send(self, code: int, body: bytes, ctype: str) -> None:
+        self.send_response(code)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Cache-Control", "no-store")
+        # No CORS headers on purpose: a foreign page may fire a request but must never
+        # be able to read this server's replies.
+        self.send_header("X-Content-Type-Options", "nosniff")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _loopback_host(self) -> bool:
+        """Is the request addressed to this server by a LOOPBACK name?
+
+        This is the DNS-rebinding defence, and it has to come before everything else,
+        because everything else is derived from the request's own headers. `evil.tld`
+        with a 1-second TTL that re-resolves to 127.0.0.1 is *same-origin to the
+        browser*: the page could fetch `/`, read `const KILL_TOKEN=…` straight out of
+        the HTML this server renders, and POST it back — the token and the Origin check
+        both pass, because `_same_origin` built the expected origin from the attacker's
+        own Host header. The browser will not lie about Host, so this is the one header
+        that pins the request to the address the owner's own tab uses.
+        """
+        raw = (self.headers.get("Host") or "").strip()
+        if not raw:
+            return False                       # HTTP/1.1 requires Host; no Host, no service
+        if raw.startswith("["):                # [::1]:8790
+            host = raw[1:raw.index("]")] if "]" in raw else ""
+        else:
+            host = raw.rsplit(":", 1)[0] if ":" in raw else raw
+        host = host.lower()
+        if host in ("localhost", "localhost.localdomain"):
+            return True
+        try:
+            return ipaddress.ip_address(host).is_loopback
+        except ValueError:
+            return False                       # any other name → rebinding, refuse
+
+    def _same_origin(self) -> bool:
+        """Reject a cross-site Origin outright. Belt to the token's braces, and it also
+        covers the no-preflight form-POST shape a CSRF page would use.
+
+        Only meaningful once `_loopback_host` has passed — the expected origin is built
+        from the request's Host, so an unpinned Host makes this check self-satisfying.
+        """
+        origin = self.headers.get("Origin")
+        if not origin:
+            return True   # non-browser client (curl, the desktop shell) — token still required
+        want = f"http://{self.headers.get('Host', '')}"
+        return origin == want or origin == want.replace("http://", "https://")
+
+    def _kill_authorized(self) -> bool:
+        supplied = self.headers.get(_KILL_TOKEN_HEADER, "")
+        return bool(self.kill_token) and hmac.compare_digest(supplied, self.kill_token)
+
+    def do_GET(self) -> None:  # noqa: N802
+        # Before ANYTHING is served — the page carries the kill token, and /status
+        # carries earnings, load and the trust label.
+        if not self._loopback_host():
+            self._send(403, b"bad host", "text/plain")
+            return
+        if self.path.startswith("/status"):
+            self._send(200, json.dumps(self.stats_fn()).encode(), "application/json")
+        elif self.path in ("/", "/index.html"):
+            page = _PAGE.replace("__KILL_TOKEN__", json.dumps(self.kill_token))
+            self._send(200, page.encode(), "text/html; charset=utf-8")
+        else:
+            self._send(404, b"not found", "text/plain")
+
+    def do_POST(self) -> None:  # noqa: N802
+        if not self._loopback_host():
+            self._send(403, b"bad host", "text/plain")
+            return
+        if not self.path.startswith("/kill"):
+            self._send(404, b"not found", "text/plain")
+            return
+        if not self._same_origin() or not self._kill_authorized():
+            self._send(403, b'{"ok":false,"error":"kill token required"}', "application/json")
+            return
+        # STOP FIRST, THEN SAY SO. This used to answer `{"ok":true}` and call `kill_fn()` afterwards,
+        # which is the wrong order for the one control where it matters most: the owner was told their
+        # node had stopped sharing BEFORE anything had stopped, and if the stop then raised they were
+        # told it succeeded anyway. A kill switch that reports success it has not achieved is worse
+        # than one that fails loudly.
+        #
+        # It was also a race the tests saw: the client could read the 200 and check the flag before
+        # the server thread reached the call. That flakiness was the defect showing itself.
+        try:
+            self.kill_fn()
+        except Exception as e:                       # noqa: BLE001 - the owner must hear about this
+            self._send(500, json.dumps(
+                {"ok": False, "error": f"could not stop sharing: {type(e).__name__}"}).encode(),
+                "application/json")
+            return
+        self._send(200, b'{"ok":true}', "application/json")
+
+    def log_message(self, *args) -> None:  # keep the console quiet
+        pass
+
+
+def start_gui(stats_fn: Callable[[], dict], kill_fn: Callable[[], None], port: int,
+              host: str = "127.0.0.1") -> str:
+    """Serve the owner's dashboard on loopback and return its URL.
+
+    The kill token is minted per process and rendered into the page, never put in the
+    URL (URLs leak through history, referrers and shoulders).
+    """
+    token = secrets.token_urlsafe(24)
+    handler = type("Handler", (_Handler,), {
+        "stats_fn": staticmethod(stats_fn),
+        "kill_fn": staticmethod(kill_fn),
+        "kill_token": token,
+    })
+    server = ThreadingHTTPServer((host, port), handler)
+    actual_port = server.server_address[1]  # resolves port 0 to the real one
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    return f"http://{host}:{actual_port}"

frutebox/imagegen.py

@@ -0,0 +1,152 @@
+"""Image generation — runs on a GPU node. Diffusers/torch are heavy and only present
+on an image-capable node, so they're imported lazily; on any other machine `available()`
+is False and the gateway simply never routes image jobs here.
+
+WHICH model runs is not decided here. `mediaserving.resolve_media_model("image", ...)` answers
+that from the file-09 registry, licence-gated and sized to THIS card's VRAM — so a 12 GB
+contributor GPU runs the 10 GB model locally and free (plan 23 §B3) instead of failing to load
+the 24 GB primary. This module used to hardcode `stabilityai/stable-diffusion-xl-base-1.0` as
+`IMAGE_MODEL`'s default and say "Flux etc. can be swapped via env", which was an invitation to
+put a non-commercial model on a GPU: FLUX.1 [dev] is exactly one of the five exclusions in plan
+23 §A. The env override still exists and is now VALIDATED rather than trusted.
+
+`AutoPipelineForText2Image`, not a model-specific class: the resolver may legitimately return
+Qwen-Image, SDXL or a later primary, and each needs a different pipeline class. The Auto classes
+read the repo's `model_index.json` and pick it, which is why plan 23 §B1 names `diffusers` as
+the core serving path rather than one model's pipeline.
+
+Defence in depth against NSFW (on top of the safety INPUT/OUTPUT gates in `safety.py`): a
+strong default NEGATIVE prompt steers the model away from nudity/sexual content at
+generation time. The authoritative blocks remain the gates — this just makes the generator
+itself disinclined to produce it.
+"""
+from __future__ import annotations
+
+import io
+
+from . import mediaserving
+
+# Baked-in safety negative prompt — always applied, appended to any caller negative.
+_SAFETY_NEGATIVE = "nsfw, nude, nudity, naked, sexual, explicit, pornographic, erotic, gore"
+
+_pipe = None
+_img2img = None
+_loaded_ref = ""
+
+
+def device_vram_gb() -> float:
+    """Usable VRAM on this node's first GPU, 0.0 where there is none.
+
+    This is what makes §B3's local-first path real: the resolver needs to know what actually
+    fits here, or "local-first" means "load the primary and crash".
+    """
+    try:
+        import torch  # type: ignore
+        if not torch.cuda.is_available():
+            return 0.0
+        return torch.cuda.get_device_properties(0).total_memory / (1024 ** 3)
+    except Exception:
+        return 0.0
+
+
+def available() -> bool:
+    """True iff this node can actually generate images (diffusers + torch + CUDA + a model
+    it is allowed to run). The last clause matters: a node with a working GPU and no
+    commercial-safe model that fits it cannot serve image jobs, and advertising the modality
+    would have the gateway route work it must then refuse."""
+    try:
+        import torch  # type: ignore
+        import diffusers  # type: ignore  # noqa: F401
+        if not torch.cuda.is_available():
+            return False
+    except Exception:
+        return False
+    try:
+        resolved_model()
+        return True
+    except mediaserving.MediaUnavailable:
+        return False
+
+
+def resolved_model(*, node_region: str = "", user_region: str = ""):
+    """The registry-declared, licence-gated image model this node will run, sized to its card.
+
+    Raises `mediaserving.MediaUnavailable` naming every candidate and why it was rejected.
+    """
+    return mediaserving.resolve_media_model(
+        "image",
+        node_region=node_region, user_region=user_region,
+        override=mediaserving.model_override("IMAGE_MODEL"),
+        max_vram_gb=device_vram_gb(),
+    )
+
+
+def _load(spec):
+    """Load (once) the text-to-image pipeline for `spec`. Reloads if the resolver's answer
+    changed — an operator flipping IMAGE_MODEL must not keep getting the old weights."""
+    global _pipe, _img2img, _loaded_ref
+    if _pipe is None or _loaded_ref != spec.ref:
+        import torch  # type: ignore
+        from diffusers import AutoPipelineForText2Image  # type: ignore
+        _pipe = AutoPipelineForText2Image.from_pretrained(
+            spec.repo, revision=spec.revision, torch_dtype=torch.float16).to("cuda")
+        _img2img = None          # the cached img2img shared the OLD pipeline's components
+        _loaded_ref = spec.ref
+    return _pipe
+
+
+def _load_img2img(spec):
+    """The img2img pipeline, sharing the text pipeline's already-loaded components.
+
+    `from_pipe` reuses the same UNet/VAE/text encoders rather than loading a second ~7 GB copy —
+    conditioning is the SAME model applied differently, not a different model.
+    """
+    global _img2img
+    base = _load(spec)
+    if _img2img is None:
+        from diffusers import AutoPipelineForImage2Image  # type: ignore
+        _img2img = AutoPipelineForImage2Image.from_pipe(base)
+    return _img2img
+
+
+def generate_image(prompt: str, *, steps: int = 30, width: int = 1024, height: int = 1024,
+                   negative: str = "", init: bytes = b"", strength: float = 0.4,
+                   node_region: str = "", user_region: str = "") -> bytes:
+    """Generate a PNG (bytes) from a text prompt. Raises RuntimeError where no allowed model
+    can run here; the safety negative prompt is always applied.
+
+    ENHANCE RATHER THAN RE-ROLL (file 03-E2). When `init` carries the user's local sketch this
+    runs img2img at `strength` (0.4 by default, the plan's decision) instead of generating from
+    the prompt alone. That distinction is the whole paid feature: the user has already SEEN the
+    local sketch and chose to improve THAT image. Regenerating from the prompt would hand back a
+    different composition with a different subject placement — not an enhancement of the thing
+    they paid to enhance, just a second, unrelated picture.
+    """
+    if not prompt or not prompt.strip():
+        raise ValueError("empty image prompt")
+    try:
+        import torch  # type: ignore
+        import diffusers  # type: ignore  # noqa: F401
+        if not torch.cuda.is_available():
+            raise RuntimeError("image generation is not available on this node: no CUDA GPU")
+    except ImportError as e:
+        raise RuntimeError(f"image generation is not available on this node: {e}") from e
+    spec = resolved_model(node_region=node_region, user_region=user_region)
+
+    neg = f"{negative}, {_SAFETY_NEGATIVE}".strip(", ") if negative else _SAFETY_NEGATIVE
+    steps = max(1, min(steps, 60))
+
+    if init:
+        from PIL import Image  # type: ignore
+        # Strength is clamped, not trusted: 0 would return the sketch untouched (the user paid for
+        # nothing) and 1 discards it entirely (a re-roll wearing the name "enhance").
+        s = min(0.95, max(0.05, float(strength)))
+        sketch = Image.open(io.BytesIO(init)).convert("RGB")
+        image = _load_img2img(spec)(prompt=prompt, negative_prompt=neg, image=sketch,
+                                    strength=s, num_inference_steps=steps).images[0]
+    else:
+        image = _load(spec)(prompt=prompt, negative_prompt=neg, num_inference_steps=steps,
+                            width=width, height=height).images[0]
+    buf = io.BytesIO()
+    image.save(buf, format="PNG")
+    return buf.getvalue()