Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++
19.8 KB
Raw Blame
"""Who can reach the server: this computer, the local network, a Cloudflare quick tunnel, Tailscale.

Strata starts the server; this module only works out the addresses, checks that the helper programs exist (and says in plain
words how to install them when they do not), and runs/stops the one helper Strata starts itself: the cloudflared quick tunnel.
Nothing here changes a firewall, a router or a Tailscale setting. The cloudflared output is filtered: only the public address
is ever kept or shown (a login or certificate line is dropped, never printed).
"""

from __future__ import annotations

import json
import os
import re
import shutil
import socket
import subprocess
import sys
import time
from dataclasses import dataclass
from pathlib import Path

from strata_cli.launch.settings import ACCESS_KINDS, LaunchSettings

TUNNEL_URL = re.compile(r"https://[a-z0-9-]+\.trycloudflare\.com")
WINDOWS = os.name == "nt"


def host_for(kind: str) -> str:
    """The address the server listens on: loopback for this computer only, every address for the rest.

    Cloudflare's tunnel connects from the same computer, so it too can stay on loopback."""
    return "127.0.0.1" if kind in ("local", "cloudflare") else "0.0.0.0"


def lan_ips() -> list[str]:
    """This computer's private IPv4 addresses, the one used for the default route first."""
    found: list[str] = []
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.settimeout(0.2)
        s.connect(("10.255.255.255", 1))          # no packet is sent; it picks the interface of the default route
        found.append(s.getsockname()[0])
        s.close()
    except OSError:
        pass
    try:
        import psutil
        for infos in psutil.net_if_addrs().values():
            for i in infos:
                if i.family == socket.AF_INET:
                    found.append(i.address)
    except Exception:                                      # noqa: BLE001
        pass
    private = [a for a in dict.fromkeys(found) if _is_private(a) and not a.startswith("127.") and not a.startswith("169.254.")]
    return private


def _is_private(address: str) -> bool:
    try:
        a, b = (int(x) for x in address.split(".")[:2])
    except ValueError:
        return False
    return a == 10 or (a == 172 and 16 <= b <= 31) or (a == 192 and b == 168) or (a == 100 and 64 <= b <= 127)


CLOUDFLARED_MIN = (2022, 1, 0)   # the quick-tunnel flags and the "Registered tunnel connection" line Strata waits for
_cf_seen: dict[tuple[str, float], str | None] = {}


def _cloudflared_places() -> list[str]:
    """Where a cloudflared might be: STRATA_CLOUDFLARED if set, then PATH, then the usual install places."""
    explicit = os.environ.get("STRATA_CLOUDFLARED", "").strip()
    if explicit:
        return [explicit]
    name = "cloudflared.exe" if WINDOWS else "cloudflared"
    out: list[str] = []
    for d in os.environ.get("PATH", "").split(os.pathsep):
        if d.strip():
            out.append(str(Path(d.strip().strip('"')) / name))
    home = Path.home()
    if WINDOWS:
        env = os.environ
        for root in (env.get("ProgramFiles", r"C:\Program Files"), env.get("ProgramFiles(x86)", r"C:\Program Files (x86)")):
            out.append(str(Path(root) / "cloudflared" / name))
        if env.get("LOCALAPPDATA"):
            out.append(str(Path(env["LOCALAPPDATA"]) / "Microsoft" / "WinGet" / "Links" / name))
        out.append(str(Path(env.get("ProgramData", r"C:\ProgramData")) / "chocolatey" / "bin" / name))
        out.append(str(home / "scoop" / "shims" / name))
    else:
        for d in ("/usr/bin", "/usr/local/bin", "/opt/homebrew/bin", "/home/linuxbrew/.linuxbrew/bin", "/snap/bin",
                  str(home / ".local" / "bin"), str(home / "bin")):
            out.append(str(Path(d) / name))
    seen: set[str] = set()
    return [p for p in out if not (p in seen or seen.add(p))]


def cloudflared_version(path: str) -> str | None:
    """`cloudflared --version` of this file as 'YYYY.M.P', '' when it runs but prints no version, None when it does not run."""
    try:
        key = (path, os.stat(path).st_mtime)
    except OSError:
        return None
    if key in _cf_seen:
        return _cf_seen[key]
    try:
        r = subprocess.run([path, "--version"], capture_output=True, text=True, timeout=10,
                           creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0) if WINDOWS else 0)
        text = (r.stdout or "") + (r.stderr or "")
    except (OSError, subprocess.SubprocessError):
        _cf_seen[key] = None
        return None
    m = re.search(r"(\d{4})\.(\d{1,2})\.(\d{1,3})", text)
    ok = r.returncode == 0 and ("cloudflared" in text.lower() or bool(m))
    _cf_seen[key] = (".".join(m.groups()) if m else "") if ok else None
    return _cf_seen[key]


def _cf_new_enough(version: str) -> bool:
    if not version:
        return True                      # a custom build with no readable version is not refused
    return tuple(int(x) for x in version.split(".")) >= CLOUDFLARED_MIN


def cloudflared_info() -> dict | None:
    """The cloudflared Strata would use: {'path', 'version'}, found on PATH or in the usual places and new enough."""
    for place in _cloudflared_places():
        if not os.path.isfile(place) or (not WINDOWS and not os.access(place, os.X_OK)):
            continue
        version = cloudflared_version(place)
        if version is not None and _cf_new_enough(version):
            return {"path": place, "version": version}
    return None


def find_cloudflared() -> str | None:
    info = cloudflared_info()
    return info["path"] if info else None


def cloudflared_procs(exclude: tuple[int, ...] = ()) -> list[tuple[int, str]]:
    """Every cloudflared running on this computer as (pid, command line), without the pids in `exclude`. The command line is for
    matching only (it can hold a tunnel token) and is never shown. A failed look is an empty list: it never blocks a tunnel."""
    out: list[tuple[int, str]] = []
    try:
        if WINDOWS:
            text = subprocess.run(["powershell.exe", "-NoProfile", "-NonInteractive", "-Command",
                                   "Get-CimInstance Win32_Process -Filter \"Name='cloudflared.exe'\" | ForEach-Object { \"$($_.ProcessId)`t$($_.CommandLine)\" }"],
                                  capture_output=True, text=True, timeout=15, creationflags=subprocess.CREATE_NO_WINDOW).stdout
            for line in text.splitlines():
                m = re.match(r"(\d+)\t(.*)$", line)
                if m:
                    out.append((int(m.group(1)), m.group(2)))
        else:
            text = subprocess.run(["ps", "-axo", "pid=,comm=,args="], capture_output=True, text=True, timeout=5).stdout
            for line in text.splitlines():
                m = re.match(r"\s*(\d+)\s+(\S+)\s*(.*)$", line)
                if m and re.search(r"(^|/)cloudflared$", m.group(2)):
                    out.append((int(m.group(1)), m.group(3)))
    except (OSError, subprocess.SubprocessError):
        return []
    return [(pid, cmd) for pid, cmd in out if pid not in exclude]


def own_tunnel_pids(procs: list[tuple[int, str]], port: int) -> list[int]:
    """The processes that are clearly this server's own tunnel: their --url points at its port. The others serve other tunnels."""
    pat = re.compile(rf"--url[= ]\S*:{int(port)}(?:/|\s|$)")
    return [pid for pid, cmd in procs if pat.search(cmd)]


def other_tunnel_note(pids: list[int]) -> str:
    return (f"cloudflared is already running for another tunnel (PID {pids[0]})." if len(pids) == 1
            else f"cloudflared is already running for other tunnels (PIDs {', '.join(map(str, pids))}).")


def find_tailscale() -> str | None:
    found = shutil.which("tailscale")
    if found:
        return found
    for guess in ("/usr/bin/tailscale", "/usr/local/bin/tailscale", "/Applications/Tailscale.app/Contents/MacOS/Tailscale",
                  r"C:\Program Files\Tailscale\tailscale.exe"):
        if Path(guess).is_file():
            return guess
    return None


def _run(argv: list[str], timeout: float = 8.0) -> str:
    try:
        r = subprocess.run(argv, capture_output=True, text=True, timeout=timeout)
        return r.stdout or ""
    except (OSError, subprocess.SubprocessError):
        return ""


def tailscale_status() -> dict:
    """{"installed", "running", "ip", "name"}: the tailnet address of this computer when Tailscale is up."""
    exe = find_tailscale()
    out = {"installed": bool(exe), "running": False, "ip": None, "name": None}
    if not exe:
        return out
    ip = _run([exe, "ip", "-4"]).strip().splitlines()
    if ip and re.fullmatch(r"\d+\.\d+\.\d+\.\d+", ip[0].strip()):
        out["running"], out["ip"] = True, ip[0].strip()
        try:
            data = json.loads(_run([exe, "status", "--json"]) or "{}")
            name = (data.get("Self") or {}).get("DNSName")
            out["name"] = name.rstrip(".") if isinstance(name, str) and name else None
        except ValueError:
            pass
    return out


INSTALL_HELP = {
    "cloudflared": {
        "linux": "Install cloudflared: https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/ "
                 "(on Debian/Ubuntu download the .deb and run: sudo dpkg -i cloudflared-linux-amd64.deb). No account is needed for a quick tunnel.",
        "windows": "Install cloudflared: winget install --id Cloudflare.cloudflared  (no account is needed for a quick tunnel).",
        "darwin": "Install cloudflared: brew install cloudflared  (no account is needed for a quick tunnel).",
    },
    "tailscale": {
        "linux": "Install Tailscale: curl -fsSL https://tailscale.com/install.sh | sh, then run: sudo tailscale up",
        "windows": "Install Tailscale from https://tailscale.com/download, sign in, and leave it running.",
        "darwin": "Install Tailscale from https://tailscale.com/download, sign in, and leave it running.",
    },
}


def install_help(tool: str) -> str:
    plat = "windows" if WINDOWS else "darwin" if sys.platform == "darwin" else "linux"
    return INSTALL_HELP[tool][plat]


@dataclass
class AccessOption:
    kind: str
    label: str
    url: str
    note: str
    ready: bool          # the helper it needs is there (or none is needed)
    warn: bool = False


def options(port: int, *, tunnel_url: str | None = None) -> list[AccessOption]:
    """The four ways to share, with the address each would give and what is missing for it."""
    ips = lan_ips()
    lan = ips[0] if ips else None
    cf = find_cloudflared()
    ts = tailscale_status()
    out = [AccessOption("local", "This computer only", f"http://127.0.0.1:{port}",
                        "for apps on this computer", True)]
    out.append(AccessOption("lan", "My local network", f"http://{lan or '<network address>'}:{port}",
                            "other computers at home or the office" if lan else
                            "no network address found on this computer", bool(lan), warn=not lan))
    out.append(AccessOption("cloudflare", "Cloudflare tunnel", tunnel_url or "https://<random>.trycloudflare.com",
                            "from anywhere · cloudflared found" if cf else "cloudflared is not installed",
                            bool(cf), warn=not cf))
    if ts["running"]:
        out.append(AccessOption("tailscale", "Tailscale", f"http://{ts['name'] or ts['ip']}:{port}",
                                "your Tailscale devices", True))
    else:
        out.append(AccessOption("tailscale", "Tailscale", f"http://<tailnet address>:{port}",
                                "Tailscale is not connected" if ts["installed"] else
                                "Tailscale is not installed", False, warn=True))
    return out


def option_for(kind: str, port: int) -> AccessOption:
    return next(o for o in options(port) if o.kind == kind)


def missing_helper(kind: str) -> str | None:
    """Plain words about what to install before this access kind works, or None when it is ready."""
    if kind == "cloudflare" and not find_cloudflared():
        return "cloudflared is not installed on this computer. " + install_help("cloudflared")
    if kind == "tailscale":
        ts = tailscale_status()
        if not ts["installed"]:
            return "Tailscale is not installed on this computer. " + install_help("tailscale")
        if not ts["running"]:
            return "Tailscale is installed but not connected. Run: tailscale up"
    if kind == "lan" and not lan_ips():
        return "No local network address was found on this computer. Check that it is connected to your network."
    return None


def urls_for(s: LaunchSettings, *, tunnel_url: str | None = None) -> list[str]:
    """The addresses a client can use for these choices (the first is the main one)."""
    base = [f"http://127.0.0.1:{s.port}"]
    if s.access == "lan":
        base += [f"http://{ip}:{s.port}" for ip in lan_ips()[:1]]
    elif s.access == "cloudflare" and tunnel_url:
        base = [tunnel_url] + base
    elif s.access == "tailscale":
        ts = tailscale_status()
        if ts["running"]:
            base += [f"http://{ts['name'] or ts['ip']}:{s.port}"] + ([f"http://{ts['ip']}:{s.port}"] if ts["name"] else [])
    return base


def firewall_note(kind: str) -> str | None:
    """Windows asks the first time a program listens for other computers: say so before it happens, in plain words."""
    if WINDOWS and kind in ("lan", "tailscale"):
        return ("Windows may ask whether to allow Strata (python.exe) on your network: choose Allow for private networks. "
                "If you choose Cancel, the model still works on this computer.")
    return None


def new_key() -> str:
    import secrets
    return "sk-strata-" + secrets.token_urlsafe(24)


def _config_key(path) -> str | None:
    try:
        key = str(json.loads(Path(path).read_text(encoding="utf-8-sig")).get("api_key") or "").strip()
    except (OSError, ValueError, AttributeError):
        return None
    return key if key and key.lower() != "none" else None


def kept_key(name: str | None = None) -> str | None:
    """The API key an earlier launch already made, so a restart does not invalidate the apps set up with it (E05/G01): the key in this launch's
    own config (profile `launch-<name>`), the saved preset's, else the one in the newest launch config. None when there is none; `--new-key`
    and the key button are the only ways to rotate it."""
    try:
        from strata_control import profiles
        from strata_cli.launch import settings as S, store
        if name:
            try:
                prof, _rev = profiles.load("launch-" + S.slug(name))
                key = _config_key(prof.get("source_config"))
                if key:
                    return key
            except Exception:                                  # noqa: BLE001 - no such profile yet
                pass
            preset = store.load(name, missing_ok=True)
            if preset and preset.api_key:
                return preset.api_key
        newest, found = -1.0, None
        for row in profiles.list_profiles():
            if not row["id"].startswith("launch-"):
                continue
            key = _config_key(row["source_config"])
            if not key:
                continue
            try:
                stamp = Path(row["source_config"]).stat().st_mtime
            except OSError:
                continue
            if stamp > newest:
                newest, found = stamp, key
        return found
    except Exception:                                          # noqa: BLE001 - never block a launch over the lookup
        return None


def mask_key(key: str | None) -> str:
    if not key:
        return "off"
    return key[:10] + "•" * 8 if len(key) > 12 else "•" * 8


# ----------------------------------------------------------------------------------------------- the quick tunnel

def _state_dir() -> Path:
    from strata_control import paths
    d = paths.state_base() / "launch"
    d.mkdir(parents=True, exist_ok=True)
    return d


def _tunnel_state(name: str) -> Path:
    from strata_cli.launch.settings import slug
    return _state_dir() / f"{slug(name)}.tunnel.json"


def start_tunnel(name: str, port: int, *, wait: float = 45.0) -> tuple[str | None, str]:
    """Start `cloudflared tunnel --url` for the local server; returns (public url or None, plain message).

    The process is detached (it keeps running after this terminal closes, like the server) and recorded with its start token so
    `stop_tunnel` ends exactly this process and nothing else. Only the public address is read from its output."""
    exe = find_cloudflared()
    if not exe:
        return None, missing_helper("cloudflare") or "cloudflared is not installed."
    existing = tunnel_info(name)
    if existing and existing.get("url") and existing.get("port") == port:
        return existing["url"], "The tunnel was already running."
    running = cloudflared_procs(exclude=(int(existing["pid"]),) if existing else ())
    own = own_tunnel_pids(running, port)
    if own:
        return None, (f"Strata’s tunnel for this address is already running (PID {', '.join(map(str, own))}), so Strata did not start a "
                      "second one. Stop it first (or use it as it is), then connect again here.")
    note = other_tunnel_note([pid for pid, _ in running]) if running else ""
    stop_tunnel(name)
    log = _state_dir() / f"{Path(name).name}.tunnel.log"
    argv = [exe, "tunnel", "--no-autoupdate", "--url", f"http://127.0.0.1:{port}"]
    with open(log, "wb") as out:
        kw = ({"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.CREATE_NO_WINDOW} if WINDOWS
              else {"start_new_session": True})
        proc = subprocess.Popen(argv, stdin=subprocess.DEVNULL, stdout=out, stderr=subprocess.STDOUT, **kw)
    from strata_control import procs
    token = procs.start_token(proc.pid)
    url = None
    deadline = time.monotonic() + wait
    while time.monotonic() < deadline and url is None and proc.poll() is None:
        try:
            m = TUNNEL_URL.search(log.read_text(encoding="utf-8", errors="replace"))
        except OSError:
            m = None
        if m:
            url = m.group(0)
            break
        time.sleep(0.4)
    state = {"pid": proc.pid, "token": token, "cmd": list(procs.command_line(proc.pid) or argv), "url": url, "port": port}
    _tunnel_state(name).write_text(json.dumps(state), encoding="utf-8")
    try:
        log.write_bytes(b"")                       # keep no log text: the address is all anyone needs from it
    except OSError:
        pass
    if url is None:
        stop_tunnel(name)
        return None, ("The Cloudflare tunnel did not come up in time. Check your internet connection and try again; "
                      "the server itself is running and still works on this computer.")
    return url, "The Cloudflare tunnel is up. Anyone with the address can reach the server; an API key keeps others out." + (" " + note if note else "")


def tunnel_info(name: str) -> dict | None:
    try:
        state = json.loads(_tunnel_state(name).read_text(encoding="utf-8"))
    except (OSError, ValueError):
        return None
    from strata_control import procs
    if isinstance(state, dict) and procs.is_same(int(state.get("pid", 0)), state.get("token") or "", state.get("cmd")):
        return state
    return None


def stop_tunnel(name: str) -> bool:
    """End this launch's tunnel, only if the recorded process is still exactly the one Strata started."""
    state = tunnel_info(name)
    ok = False
    if state:
        from strata_control import procs
        outcome = procs.end_one({"pid": state["pid"], "token": state["token"], "cmd": state["cmd"]}, grace=5.0)
        ok = outcome in ("ended", "gone")
    try:
        _tunnel_state(name).unlink()
    except OSError:
        pass
    return ok


def filter_line(line: str) -> str:
    """For any helper output shown to a person: drop login/certificate/token lines, keep the rest."""
    low = line.lower()
    if any(w in low for w in ("token", "cert", "login", "secret", "authorize", "credential")):
        return ""
    return line