tmpcli

#!/usr/bin/env python3
"""
tmpcli: Universal command-line file uploader/downloader for temporary file hosts.
Project: tmp-cli  —  CLI binary: tmpcli
Supports 16+ services. No accounts required.
"""

import argparse
import hashlib
import json
import os
import random
import re
import shutil
import string
import subprocess
import sys
import time
import urllib.request
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from pathlib import Path
from typing import Dict, List, Optional, Tuple
from urllib.parse import urlparse

CATALOG = {
    "catbox":       {"upload":"✓","download":"✓","max_mb":200,   "expiry":"permanent","notes":"Most reliable"},
    "litterbox":    {"upload":"✓","download":"✓","max_mb":1024,  "expiry":"1h–72h", "notes":"Catbox temp sister"},
    "temp.sh":      {"upload":"✓","download":"✓","max_mb":4096,  "expiry":"3 days", "notes":"Simple API"},
    "gofile":       {"upload":"✓","download":"✓","max_mb":0,     "expiry":"variable","notes":"Dynamic token auth"},
    "pixeldrain":   {"upload":"🔑","download":"✓","max_mb":10240, "expiry":"60 days","notes":"Upload needs API key"},
    "0x0":          {"upload":"✓*","download":"✓","max_mb":512,   "expiry":"30d–1y","notes":"Uploads often disabled by operator"},
    "termbin":      {"upload":"✗","download":"✓","max_mb":0,     "expiry":"unknown","notes":"TCP 9999 often firewalled; service is intermittently down"},
    "drop.plz.ac":  {"upload":"✓","download":"✓","max_mb":100,   "expiry":"60 min","notes":"Cloudflare-backed"},
    "sharenation":  {"upload":"✓","download":"✓","max_mb":250,   "expiry":"1 min–1 day","notes":"+5-download safeguard"},
    "x0.at":        {"upload":"✓","download":"✓","max_mb":1024,  "expiry":"unknown","notes":"CLI-friendly Austria host"},
    "uguu":         {"upload":"✓","download":"✓","max_mb":128,   "expiry":"3 hours","notes":"Pomf.se fork"},
    "tmpfiles":     {"upload":"✓","download":"✓","max_mb":100,   "expiry":"1 min–48h","notes":"/tmp/files rebrand"},
    "filebin":      {"upload":"✓","download":"✓","max_mb":0,     "expiry":"unknown","notes":"Raw PUT, no expiry"},
    "send.vis.ee":  {"upload":"✓","download":"✓","max_mb":2500, "expiry":"1d/20dl","notes":"Requires ffsend CLI"},
    "wormhole":     {"upload":"✗","download":"✓","max_mb":10000, "expiry":"session","notes":"Interactive only; receive via wormhole receive <code>"},
    "isrv":         {"upload":"✓","download":"✓","max_mb":1024, "expiry":"7d–365d","notes":"Open source (isrv.nl); expiration auto-scaled by file size"},
    "tempfile.org": {"upload":"✓","download":"✓","max_mb":100,  "expiry":"1h–48h", "notes":"REST API; field name is 'files' not 'file'"},
    "tmpfile.link": {"upload":"✓","download":"✓","max_mb":100,  "expiry":"7 days", "notes":"Cloudflare Workers CDN; multi-host d1-d10.tfdl.net for binaries"},
    "box.juicey.dev": {"upload":"✓","download":"✓","max_mb":2048, "expiry":"3 days", "notes":"Open-source; content-addressed (SHA-256 dedup); 10-files-per-IP cap"},
    "originless":   {"upload":"✓","download":"✓","max_mb":50,   "expiry":"permanent","notes":"IPFS-backed (originless.gupt.app); CID = SHA-256; accessible via any IPFS gateway"},
    "paste.rs":     {"upload":"✓","download":"✓","max_mb":4,    "expiry":"unknown","notes":"Text-only; raw POST body; modern termbin replacement"},
    "fsend.me":     {"upload":"✓","download":"✓","max_mb":200,  "expiry":"7 days", "notes":"PUT-style upload; 200MB nginx cap; supports Max-Downloads/Max-Days headers"},
    "fars.ee":      {"upload":"✓","download":"✓","max_mb":10,   "expiry":"unknown","notes":"pb fork; content-addressed; field=c; ?u=1 returns URL only"},
}

UPLOAD_SERVICES = [k for k in CATALOG if not k.startswith("_") and CATALOG[k]["upload"] != "✗"]

@dataclass
class UploadResult:
    url: str
    delete_url: Optional[str] = None
    expires_in: str = ""
    service: str = ""
    file_id: str = ""
    token: str = ""
    size_mb: float = 0.0
    elapsed: float = 0.0

def _fmt_size(size_mb: float) -> str:
    if size_mb < 0.01:
        return f"{size_mb*1024:.1f}KB"
    if size_mb < 1024:
        return f"{size_mb:.1f}MB"
    return f"{size_mb/1024:.1f}GB"

def _fmt_time(s: float) -> str:
    if s < 1:
        return f"{s*1000:.0f}ms"
    if s < 60:
        return f"{s:.1f}s"
    return f"{s/60:.1f}m"

def _fmt_speed(mbps: float) -> str:
    if mbps < 0.01:
        return f"{mbps*1024:.1f}KB/s"
    return f"{mbps:.1f}MB/s"

@dataclass
class PerfRecord:
    upload_times: List[float] = field(default_factory=list)
    success_count: int = 0
    failure_count: int = 0
    avg_speed_mbps: float = 0.0

class BaseService(ABC):
    name: str = ""
    max_size_mb: int = 0
    default_expiry: str = ""
    supports_anon: bool = True
    needs_key: bool = False

    @abstractmethod
    def upload(self, file_path: str, **kwargs) -> UploadResult:
        pass

    @abstractmethod
    def download(self, url: str, output_path: str) -> bool:
        pass

    def _upload_timeout(self, file_path: str, min_t: int = 120, mbps: float = 1.5) -> int:
        """Size-aware upload timeout. min_t covers the 0-byte case; mbps is a
        conservative worst-case upload speed (1.5 MB/s ≈ 12 Mbps). Used by every
        service that uploads via _curl/_curl_browser, so a 1.4GB file gets a
        ~16min budget rather than the previous 120s hard cap that aborted every
        large upload with a confusing "timeout" error."""
        try:
            size_mb = os.path.getsize(file_path) / (1024 * 1024)
        except OSError:
            return min_t
        return max(min_t, int(size_mb / mbps) + 30)  # +30s for connect/handshake

    def _curl(self, args: List[str], capture_output=True, timeout=120) -> Tuple[int, str, str]:
        # filebin's Varnish layer returns a 5KB anti-bot interstitial when it sees
        # the bare tmpcli/1.1 UA. Most other services work fine with it, so the
        # override is a per-call concern in filebin's service class.
        cmd = ["curl", "-s", "-L", "-A", "tmpcli/1.1"] + args
        try:
            result = subprocess.run(cmd, capture_output=capture_output, text=True, timeout=timeout)
            return result.returncode, result.stdout, result.stderr
        except subprocess.TimeoutExpired:
            return -1, "", "timeout"
        except Exception as e:
            return -1, "", str(e)

    def _curl_browser(self, args: List[str], capture_output=True, timeout=120) -> Tuple[int, str, str]:
        """Variant that uses a real browser User-Agent — needed for filebin's Varnish bot filter."""
        cmd = ["curl", "-s", "-L",
               "-A", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"] + args
        try:
            result = subprocess.run(cmd, capture_output=capture_output, text=True, timeout=timeout)
            return result.returncode, result.stdout, result.stderr
        except subprocess.TimeoutExpired:
            return -1, "", "timeout"
        except Exception as e:
            return -1, "", str(e)

    def _req(self, url: str, method="GET", data=None, headers=None, json_resp=False, timeout=30):
        """Lightweight urllib wrapper for simple GET/POST."""
        import json as _json
        import urllib.request as _req
        h = {"User-Agent": "tmpcli/1.1"}
        if headers:
            h.update(headers)
        bod = data if data else None
        rq = _req.Request(url, data=bod, headers=h, method=method)
        try:
            with _req.urlopen(rq, timeout=timeout) as resp:
                body = resp.read()
                if json_resp:
                    return True, _json.loads(body.decode())
                return True, body.decode()
        except Exception as e:
            return False, str(e)

    def _url_read(self, url: str, timeout=20) -> str:
        """Simple GET returning body text."""
        return self._req(url, timeout=timeout)[1]

# ─── Services ──────────────────────────────────────────────────────────────

class CatboxService(BaseService):
    name = "catbox"
    max_size_mb = 200
    default_expiry = "permanent"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        code, out, err = self._curl([
            "-F", "reqtype=fileupload",
            "-F", f"fileToUpload=@{file_path}",
            "https://catbox.moe/user/api.php"
        ], timeout=self._upload_timeout(file_path))
        if code != 0 or not out.startswith("http"):
            raise RuntimeError(f"Catbox upload failed: {err or out}")
        return UploadResult(url=out.strip(), service="catbox", expires_in="permanent")

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0

class LitterboxService(BaseService):
    name = "litterbox"
    max_size_mb = 1024
    default_expiry = "72h"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        time_param = kwargs.get("time_param", "72h")
        code, out, err = self._curl([
            "-F", "reqtype=fileupload",
            "-F", f"time={time_param}",
            "-F", f"fileToUpload=@{file_path}",
            "https://litterbox.catbox.moe/resources/internals/api.php"
        ], timeout=self._upload_timeout(file_path))
        if code != 0 or not out.startswith("http"):
            raise RuntimeError(f"Litterbox upload failed: {err or out}")
        return UploadResult(url=out.strip(), service="litterbox", expires_in=time_param)

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0

class TempShService(BaseService):
    name = "temp.sh"
    max_size_mb = 4096
    default_expiry = "3d"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        code, out, err = self._curl([
            "-F", f"file=@{file_path}",
            "https://temp.sh/upload"
        ], timeout=self._upload_timeout(file_path))
        if code != 0 or not out.startswith(("https://", "http://")):
            raise RuntimeError(f"temp.sh upload failed: {err or out}")
        return UploadResult(url=out.strip().split()[0], service="temp.sh", expires_in="3 days")

    def download(self, url: str, output_path: str) -> bool:
        code, _, err = self._curl(["-X", "POST", "-o", output_path, url])
        ok = code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0
        if not ok:
            code2, _, _ = self._curl(["-o", output_path, "-L", url])
            ok = code2 == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0
        return ok

class GofileService(BaseService):
    name = "gofile"
    max_size_mb = 0
    default_expiry = "variable"
    API_SALT = "g4f8fd9f12h14g"
    UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"

    def _create_account(self) -> str:
        import json as _json
        import urllib.request as _req
        rq = _req.Request(
            "https://api.gofile.io/accounts",
            data=b"",
            headers={"Accept": "*/*", "User-Agent": self.UA, "Origin": "https://gofile.io", "Referer": "https://gofile.io/"},
            method="POST",
        )
        try:
            with _req.urlopen(rq, timeout=15) as resp:
                data = _json.loads(resp.read().decode())
                if data.get("status") == "ok":
                    return data["data"]["token"]
        except Exception:
            pass
        return ""

    def _generate_website_token(self, account_token: str) -> str:
        timeslot = int(time.time()) // 14400
        raw = f"{self.UA}::en-US::{account_token}::{timeslot}::{self.API_SALT}"
        return hashlib.sha256(raw.encode()).hexdigest()

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        _, serv_json, _ = self._curl(["-H", "Accept: application/json", "https://api.gofile.io/servers"])
        server = "store-eu-par-2"
        try:
            data = json.loads(serv_json)
            server = data["data"]["servers"][0]["name"]
        except:
            pass
        code, out, err = self._curl(["-F", f"file=@{file_path}", f"https://{server}.gofile.io/contents/uploadfile"],
                                     timeout=self._upload_timeout(file_path))
        if code != 0:
            raise RuntimeError(f"Gofile upload failed: {err}")
        try:
            resp = json.loads(out)
            if resp.get("status") != "ok":
                raise RuntimeError(f"Gofile API error: {resp}")
            d = resp["data"]
            return UploadResult(url=d["downloadPage"], service="gofile", expires_in="varies",
                                file_id=d["id"], token=d.get("guestToken", ""))
        except json.JSONDecodeError:
            raise RuntimeError(f"Gofile bad JSON: {out[:200]}")

    def download(self, url: str, output_path: str) -> bool:
        parsed = urlparse(url)
        code = parsed.path.split("/")[-1]
        account_token = self._create_account()
        if not account_token:
            return self._download_from_page(url, output_path, "")
        wt = self._generate_website_token(account_token)
        api_url = f"https://api.gofile.io/contents/{code}?cache=true"
        jargs = ["-H", f"Authorization: Bearer {account_token}",
                 "-H", f"X-Website-Token: {wt}",
                 "-H", "X-Version: 2",
                 "-H", "X-BL: en-US",
                 "-H", f"User-Agent: {self.UA}",
                 "-H", "Origin: https://gofile.io",
                 "-H", "Referer: https://gofile.io/",
                 api_url]
        _, api_json, _ = self._curl(jargs)
        direct_link = ""
        try:
            api_resp = json.loads(api_json)
            if api_resp.get("status") == "ok":
                children = api_resp["data"].get("children", {})
                if children:
                    fi = list(children.values())[0]
                    direct_link = fi.get("link", "")
        except Exception as e:
            print(f"[warn] gofile API parse error: {e}", file=sys.stderr)
        if direct_link:
            dl_args = ["-o", output_path,
                       "-H", f"Authorization: Bearer {account_token}",
                        "-H", f"X-Website-Token: {wt}",
                        "-H", f"User-Agent: {self.UA}",
                        "-H", "Origin: https://gofile.io",
                        "-H", "Referer: https://gofile.io/",
                        "-H", "Accept: */*",
                        "-b", f"accountToken={account_token}",
                        "-L", direct_link]
            d_code, _, _ = self._curl(dl_args)
            ok = d_code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0
            if ok:
                return True
        return self._download_from_page(url, output_path, "")

    def _download_from_page(self, url: str, output_path: str, page_html: str) -> bool:
        parsed = urlparse(url)
        code = parsed.path.split("/")[-1]
        patterns = [f"https://store1.gofile.io/download/{code}",
                    f"https://store-eu-par-2.gofile.io/download/{code}"]
        for pat in patterns:
            d_code, _, _ = self._curl(["-o", output_path, pat])
            if d_code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0:
                return True
        return False

class NullPointerService(BaseService):
    name = "0x0"
    max_size_mb = 512
    default_expiry = "30d-1y"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        args = ["-F", f"file=@{file_path}"]
        if kwargs.get("secret"):
            args += ["-F", "secret="]
        if kwargs.get("expires"):
            args += ["-F", f"expires={kwargs['expires']}"]
        args += ["https://0x0.st"]
        code, out, err = self._curl(args)
        if "disabled" in (out + err).lower() or "botnet" in (out + err).lower():
            raise RuntimeError("0x0.st: uploads temporarily disabled by operator")
        if code != 0 or not out.startswith("http"):
            raise RuntimeError(f"0x0.st upload failed: {err or out}")
        url = out.strip().split()[0]
        expires = f"~{kwargs.get('expires')}h" if kwargs.get("expires") else "auto"
        return UploadResult(url=url, service="0x0", expires_in=expires)

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0

class PixeldrainService(BaseService):
    name = "pixeldrain"
    max_size_mb = 10240
    default_expiry = "60dl"
    needs_key = True

    def __init__(self, api_key: str = "", **kwargs):
        self.api_key = api_key
        if not self.api_key:
            self.api_key = os.environ.get("PIXELDRAIN_API_KEY", "")

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        if not self.api_key:
            raise RuntimeError("pixeldrain upload requires API key. Get one at https://pixeldrain.com/user/api_keys")
        code, out, err = self._curl(["-u", f"{self.api_key}:", "-F", f"file=@{file_path}", "https://pixeldrain.com/api/file"])
        if code != 0:
            raise RuntimeError(f"pixeldrain upload failed: {err}")
        try:
            resp = json.loads(out)
            if not resp.get("success", True):
                raise RuntimeError(f"pixeldrain API: {resp}")
            fid = resp["id"]
            return UploadResult(url=f"https://pixeldrain.com/u/{fid}", service="pixeldrain",
                                expires_in="60 days", file_id=fid)
        except json.JSONDecodeError:
            raise RuntimeError(f"pixeldrain bad JSON: {out[:200]}")

    def download(self, url: str, output_path: str) -> bool:
        m = re.search(r'pixeldrain\.com/u?/([A-Za-z0-9]+)', url)
        if not m:
            return False
        fid = m.group(1)
        dl_url = f"https://pixeldrain.com/api/file/{fid}"
        code, _, _ = self._curl(["-o", output_path, dl_url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0

class TermbinService(BaseService):
    name = "termbin"
    max_size_mb = 0
    default_expiry = "unknown (text only)"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        # Termbin exposes a TCP paste service on port 9999. As of mid-2026 the
        # TCP endpoint is often firewalled or unreachable from residential / cloud
        # IPs, and the HTTPS endpoint returns 405 (legacy /upload route removed).
        # We still try the TCP path first; if it fails we surface a clear error
        # rather than silently failing.
        with open(file_path, "rb") as f:
            data = f.read()
        if len(data) > 1024 * 512:
            raise RuntimeError("termbin: file too large (>512KB text)")
        import socket
        s = None
        try:
            s = socket.create_connection(("termbin.com", 9999), timeout=15)
            s.sendall(data + b"\n")
            s.settimeout(15)
            buf = b""
            while True:
                try:
                    chunk = s.recv(4096)
                except socket.timeout:
                    break
                if not chunk:
                    break
                buf += chunk
                if b"\n" in buf:
                    break
            url = buf.decode().strip().split()[0] if buf else ""
            if url.startswith("http"):
                return UploadResult(url=url, service="termbin", expires_in="unknown")
        except Exception as e:
            last_err = str(e)
        finally:
            if s:
                try: s.close()
                except: pass
        raise RuntimeError(
            f"termbin unreachable (TCP 9999 timed out, HTTP /upload returns 405). "
            f"Service is intermittently down — try again later. Last err: {last_err if 'last_err' in dir() else 'unknown'}"
        )

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0

class DropPlzAcService(BaseService):
    name = "drop.plz.ac"
    max_size_mb = 100
    default_expiry = "60 min"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        code, out, err = self._curl(["-F", f"file=@{file_path}", "https://drop.plz.ac/upload"])
        if code != 0:
            raise RuntimeError(f"drop.plz.ac upload failed: {err}")
        try:
            resp = json.loads(out)
            if not resp.get("success"):
                raise RuntimeError(f"drop.plz.ac error: {resp}")
            return UploadResult(url=resp["downloadUrl"], service="drop.plz.ac",
                                expires_in="60 min", file_id=resp.get("fileId", ""))
        except json.JSONDecodeError:
            raise RuntimeError(f"drop.plz.ac bad JSON: {out[:200]}")

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0

class ShareNationService(BaseService):
    name = "sharenation"
    max_size_mb = 250
    default_expiry = "1 min–1 day"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        import re
        # sharenation `time` field is a Unix timestamp (seconds since epoch), NOT a duration.
        # Passing 3600 (1970-01-01) instantly expires. Compute future timestamp.
        expires_seconds = kwargs.get("expires_seconds", 86400)  # default 1 day
        # Cap to sharenation's apparent max window (~1 day)
        expires_seconds = min(expires_seconds, 86400)
        expires_ts = int(time.time()) + expires_seconds
        code, out, err = self._curl([
            "-F", f"file=@{file_path}",
            "-F", f"time={expires_ts}",
            "https://sharenation.org/upload"
        ])
        # ShareNation returns HTML page with URL embedded; extract it
        url_match = re.search(r'https://sharenation\.org/[a-zA-Z0-9_.-]+\.bin', out)
        if code != 0 or not url_match:
            raise RuntimeError(f"sharenation upload failed: {err or out[:200]}")
        return UploadResult(url=url_match.group(0), service="sharenation",
                            expires_in=f"{expires_seconds}s")

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0

class X0AtService(BaseService):
    name = "x0.at"
    max_size_mb = 1024
    default_expiry = "unknown"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        code, out, err = self._curl(["-F", f"file=@{file_path}", "https://x0.at/"])
        if code != 0 or not out.startswith("http"):
            raise RuntimeError(f"x0.at upload failed: {err or out}")
        return UploadResult(url=out.strip().split()[0], service="x0.at", expires_in="unknown")

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0

class UguuService(BaseService):
    name = "uguu"
    max_size_mb = 128
    default_expiry = "3 hours"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        code, out, err = self._curl(["-F", f"files[]=@{file_path}", "https://uguu.se/upload.php"])
        if code != 0:
            raise RuntimeError(f"uguu upload failed: {err}")
        try:
            resp = json.loads(out)
            if not resp.get("success"):
                raise RuntimeError(f"uguu error: {resp}")
            files = resp.get("files", [])
            if not files:
                raise RuntimeError("uguu: no files in response")
            return UploadResult(url=files[0]["url"], service="uguu",
                                expires_in="3 hours", file_id=files[0].get("hash", ""))
        except json.JSONDecodeError:
            raise RuntimeError(f"uguu bad JSON: {out[:200]}")

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0

class TmpfilesService(BaseService):
    name = "tmpfiles"
    max_size_mb = 100
    default_expiry = "1 min–48h"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        expires = kwargs.get("tmpfiles_expire", 3600)
        code, out, err = self._curl([
            "-F", f"file=@{file_path}",
            "-F", f"expire={expires}",
            "https://tmpfiles.org/api/v1/upload"
        ])
        if code != 0:
            raise RuntimeError(f"tmpfiles upload failed: {err}")
        try:
            resp = json.loads(out)
            if resp.get("status") != "success":
                raise RuntimeError(f"tmpfiles error: {resp}")
            # API returns preview page URL (https://tmpfiles.org/<id>/<filename>)
            # Direct download requires /dl/ prefix
            preview_url = resp["data"]["url"]
            direct_url = preview_url.replace("://tmpfiles.org/", "://tmpfiles.org/dl/", 1)
            return UploadResult(url=direct_url, service="tmpfiles",
                                expires_in=f"{expires}s")
        except json.JSONDecodeError:
            raise RuntimeError(f"tmpfiles bad JSON: {out[:200]}")

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-L", "-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0

class FilebinService(BaseService):
    name = "filebin"
    max_size_mb = 0
    default_expiry = "unknown"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        bin_id = kwargs.get("filebin_bin") or "tmpcli" + "".join(random.choices(string.ascii_lowercase, k=6))
        fname = kwargs.get("filename") or os.path.basename(file_path)
        code, out, err = self._curl_browser([
            "-X", "PUT",
            "-H", "Content-type: application/octet-stream",
            "--data-binary", f"@{file_path}",
            f"https://filebin.net/{bin_id}/{fname}"
        ], timeout=self._upload_timeout(file_path))
        if code not in (0,):
            raise RuntimeError(f"filebin upload failed: {err}")
        try:
            resp = json.loads(out)
            if resp.get("error"):
                raise RuntimeError(f"filebin API error: {resp['error']}")
            dl = f"https://filebin.net/{bin_id}/{fname}"
            return UploadResult(url=dl, service="filebin", expires_in="unknown", file_id=bin_id)
        except json.JSONDecodeError:
            dl = f"https://filebin.net/{bin_id}/{fname}"
            return UploadResult(url=dl, service="filebin", expires_in="unknown", file_id=bin_id)

    def download(self, url: str, output_path: str) -> bool:
        # Use browser UA — filebin's Varnish front returns an interstitial otherwise
        code, _, _ = self._curl_browser(["-L", "-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0

class SendVisEeService(BaseService):
    """send.vis.ee wrapper — delegates to `ffsend` CLI."""
    name = "send.vis.ee"
    max_size_mb = 2500
    default_expiry = "1d/20dl"
    needs_key = False

    def _ffsend(self) -> str:
        """Find ffsend executable."""
        for cmd in ["ffsend"]:
            if shutil.which(cmd):
                return cmd
        return ""

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        ffs = self._ffsend()
        if not ffs:
            raise RuntimeError("send.vis.ee requires `ffsend` CLI. Install: cargo install ffsend || brew install ffsend")
        expires = kwargs.get("expires_hours", 24)
        # ffsend args: `upload -c <FILE> --host <URL>`. Old code had `upload --copy file <FILE>`
        # which is wrong on two counts: --copy takes no value, and "file" was treated as a path.
        # Also use -I (--no-interact) to suppress prompts.
        try:
            result = subprocess.run(
                [ffs, "upload", "-I", "-c", file_path,
                 "--host", "https://send.vis.ee",
                 "-e", str(expires)],
                capture_output=True, text=True, timeout=120
            )
            if result.returncode != 0:
                raise RuntimeError(f"ffsend failed: {result.stderr}")
            # URL is on stdout, but progress UI may also emit text. Find a line starting with http.
            url = ""
            for line in result.stdout.splitlines():
                line = line.strip()
                if line.startswith("http"):
                    # First token on the URL line
                    url = line.split()[0]
                    break
            if not url:
                raise RuntimeError(f"ffsend: no URL in output:\nstdout={result.stdout}\nstderr={result.stderr[:300]}")
            return UploadResult(url=url, service="send.vis.ee", expires_in=f"{expires}h")
        except subprocess.TimeoutExpired:
            raise RuntimeError("ffsend upload timed out")

    def download(self, url: str, output_path: str) -> bool:
        ffs = self._ffsend()
        if not ffs:
            raise RuntimeError("send.vis.ee download requires `ffsend` CLI")
        try:
            result = subprocess.run(
                [ffs, "download", url, "-o", output_path],
                capture_output=True, text=True, timeout=120
            )
            return result.returncode == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0
        except subprocess.TimeoutExpired:
            return False

class WormholeService(BaseService):
    """wormhole.app — interactive end-to-end encrypted transfer.

    NOTE: Wormhole is fundamentally interactive. The sender generates a one-time
    code, prints it to stdout, then blocks waiting for a receiver to enter it
    on the other end. There is no persistent URL — once both sides have the
    code, they negotiate a direct (or relayed) transfer. As such:
      - `upload` here just produces the code and prints it. The transfer
        completes only when a receiver uses `wormhole receive <code>`.
      - `download` accepts a code and receives the file.
    We surface this clearly in the error message and CLI output.
    """
    name = "wormhole"
    max_size_mb = 10000
    default_expiry = "session-based"
    needs_key = False

    def _wh(self) -> str:
        for cmd in ["wormhole", "wormhole-cli"]:
            if shutil.which(cmd):
                return cmd
        return ""

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        wh = self._wh()
        if not wh:
            raise RuntimeError("wormhole requires `wormhole` CLI. Install: pip install magic-wormhole")
        # wormhole send prints a code and BLOCKS waiting for a receiver. We can't
        # capture a URL — only the code. The right way to use this is interactive.
        # For scripting, surface a clear error and let the user invoke it manually.
        raise RuntimeError(
            "wormhole is interactive-only: it generates a one-time code and waits "
            "for a receiver to enter it. There is no URL to return. Run "
            f"`{wh} send {file_path}` manually, share the code with the recipient, "
            "and have them run `wormhole receive <code>`. For automated pipelines "
            "use a real host (catbox, filebin, temp.sh, etc.) instead."
        )

    def download(self, url: str, output_path: str) -> bool:
        # Accept either a code directly (e.g. "3-cactus-pelican") or a full wormhole.app URL.
        wh = self._wh()
        if not wh:
            raise RuntimeError("wormhole download requires `wormhole` CLI")
        code_match = re.search(r'#?(\d+-[a-z]+-[a-z]+)', url)
        if not code_match:
            return False
        code = code_match.group(1)
        try:
            result = subprocess.run(
                [wh, "receive", code, "-o", output_path],
                capture_output=True, text=True, timeout=120
            )
            return result.returncode == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0
        except subprocess.TimeoutExpired:
            return False


class IsrvService(BaseService):
    """isrv.nl — open-source anonymous file sharing.

    Expiration semantics: default is auto-calculated from file size (7d for small
    files up to 365d for tiny files, scaled by size). The `expires` form field
    can be either hours (e.g. "24") or a Unix timestamp. Capped at 365d.
    Returns JSON: {"status":"success","filename":"<url>","expiration":"<iso8601>"}.
    """
    name = "isrv"
    max_size_mb = 1024
    default_expiry = "7d–365d"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        # expires can be hours (e.g. 24) or a unix timestamp. Default to 24h
        # (86400 seconds) for predictable behavior; the server's auto-scaling
        # may produce longer defaults.
        expires = kwargs.get("expires_seconds", 86400)
        # Cap to 365 days (isrv's documented max)
        expires = min(expires, 365 * 86400)
        code, out, err = self._curl([
            "-F", f"file=@{file_path}",
            "-F", f"expires={expires}",
            "https://isrv.nl/"
        ])
        if code != 0:
            raise RuntimeError(f"isrv upload failed: {err}")
        try:
            resp = json.loads(out)
        except json.JSONDecodeError:
            raise RuntimeError(f"isrv bad JSON: {out[:200]}")
        if resp.get("status") != "success":
            raise RuntimeError(f"isrv API error: {resp}")
        url = resp.get("filename", "")
        if not url.startswith("http"):
            raise RuntimeError(f"isrv: no filename in response: {resp}")
        return UploadResult(url=url, service="isrv",
                            expires_in=resp.get("expiration", ""))

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-L", "-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0


class TmpfileOrgService(BaseService):
    """tempfile.org — REST API, no account, 100MB cap, 1-48h expiry.

    Important: multipart field name is `files` (not `file` or `files[]`).
    Server returns JSON: {"success":true,"files":[{"id":..,"url":"https://tempfile.org/<id>/",..}]}.
    Direct download URL is `<page_url>/download` (NOT the page itself).
    """
    name = "tempfile.org"
    max_size_mb = 100
    default_expiry = "1h–48h"

    # API endpoint
    _API = "https://tempfile.org/api/upload/local"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        # Default 24h; valid values per API docs are 1, 6, 24, 48
        hours = int(kwargs.get("expires_hours", 24))
        if hours not in (1, 6, 24, 48):
            hours = 24
        code, out, err = self._curl([
            "-F", f"files=@{file_path}",  # NOTE: field is "files", not "file"
            "-F", f"expiryHours={hours}",
            self._API
        ])
        if code != 0:
            raise RuntimeError(f"tempfile.org upload failed: {err}")
        try:
            resp = json.loads(out)
        except json.JSONDecodeError:
            raise RuntimeError(f"tempfile.org bad JSON: {out[:200]}")
        if not resp.get("success"):
            raise RuntimeError(f"tempfile.org API error: {resp}")
        files = resp.get("files", [])
        if not files:
            raise RuntimeError(f"tempfile.org: no files in response: {resp}")
        f = files[0]
        page_url = f.get("url", "")
        # Direct download URL is the page URL + "download" (not the page itself
        # which is an HTML preview)
        direct_url = page_url.rstrip("/") + "/download"
        return UploadResult(url=direct_url, service="tempfile.org",
                            expires_in=f"{hours}h", file_id=f.get("id", ""))

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-L", "-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0


class FsendMeService(BaseService):
    """fsend.me — transfer.sh-inspired, 7-day default retention, raw PUT upload.

    API is a single PUT to https://fsend.me/<filename> where the request body
    is the file content (NOT multipart/form-data). Server returns the URL on
    the response body. Optional headers:
      - Max-Downloads: N (delete after N downloads)
      - Max-Days: N (delete after N days, default 7)
    The file path in the URL is the original filename; the server picks a
    short hash prefix.
    """
    name = "fsend.me"
    max_size_mb = 200  # server-side nginx limit: 200MB passes, 201MB gets 413. Probed 2026-06-04.
    default_expiry = "7 days"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        # Map our kwargs to fsend.me headers
        # Default: no download cap, 7 days retention
        max_downloads = kwargs.get("max_downloads", "")
        max_days = kwargs.get("max_days", "")
        filename = os.path.basename(file_path)
        headers = ["-H", "Content-Type: application/octet-stream"]
        if max_downloads:
            headers += ["-H", f"Max-Downloads: {max_downloads}"]
        if max_days:
            headers += ["-H", f"Max-Days: {max_days}"]
        # Use --upload-file (PUT) NOT -F (multipart)
        cmd = ["curl", "-sS", "--upload-file", file_path] + headers + [f"https://fsend.me/{filename}"]
        try:
            r = subprocess.run(cmd, capture_output=True, text=True,
                               timeout=self._upload_timeout(file_path))
        except subprocess.TimeoutExpired:
            raise RuntimeError("fsend.me upload timed out")
        url = r.stdout.strip()
        if not url.startswith("http"):
            raise RuntimeError(f"fsend.me bad response: {r.stdout[:200]}")
        return UploadResult(url=url, service="fsend.me",
                            expires_in=f"{max_days or 7} days")

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0


class FarsEeService(BaseService):
    """fars.ee — pb/pastebin fork, content-addressed (SHA1-keyed) storage.

    API: POST https://fars.ee/ with multipart field `c=<file>`.
    Response is NOT JSON — it's a line-separated key:value text:
        date: <iso8601>
        digest: <sha1 of file>
        long: <base64 long id>
        short: <short id>
        size: <bytes>
        status: <created|already exists|expired>
        url: https://fars.ee/<short>.bin
        uuid: <uuid>
    Use ?u=1 query param to get URL-only response (single line).
    Optional fields: p=1 (private, uses long URL), sunset=<seconds> (self-destruct).
    Append .<ext> to URL for proper mimetype hint.
    Server explicitly warns: "Please do NOT post large files" — so keep <=10MB.
    """
    name = "fars.ee"
    max_size_mb = 10
    default_expiry = "unknown"

    _API = "https://fars.ee/"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        # Build form fields. Field name is "c", not "file".
        args = ["-F", f"c=@{file_path}"]
        # Sunset (self-destruct) in seconds
        sunset = kwargs.get("sunset_seconds", "")
        if sunset:
            args += ["-F", f"sunset={sunset}"]
        # Private paste flag
        if kwargs.get("private"):
            args += ["-F", "p=1"]
        # ?u=1 returns URL only, simpler to parse
        url_only = "1"
        code, out, err = self._curl(args + [f"{self._API}?u={url_only}"])
        if code != 0:
            raise RuntimeError(f"fars.ee upload failed: {err}")
        url = out.strip()
        if not url.startswith("http"):
            # fars.ee is content-addressed (SHA1) — if the same file was already
            # uploaded, the server returns just the status line without the
            # URL. The file is still retrievable, but the server won't tell us
            # where. The caller can retry with different content if they need
            # a fresh URL; the service itself doesn't try to recover the URL
            # because the server has no digest-lookup API.
            raise RuntimeError(
                f"fars.ee: {url!r} (file already uploaded to fars.ee with this "
                f"exact content; no way to recover the existing URL. Use a "
                f"different file or add a unique suffix.)"
            )
        return UploadResult(url=url, service="fars.ee",
                            expires_in=f"{sunset}s" if sunset else "unknown")

    def download(self, url: str, output_path: str) -> bool:
        # fars.ee serves the file directly at the URL
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0


class TmpfileLinkService(BaseService):
    """tmpfile.link — Cloudflare Workers-backed temp file host, no auth, 100MB.

    API: POST https://tmpfile.link/api/upload with multipart field `file=@...`.
    Response JSON: {"fileName": ..., "downloadLink": "https://d1-d10.tfdl.net/...",
                    "downloadLinkEncoded": ..., "size": ..., "type": ...}.
    "Safe" types (images, docs) are served from `d.tmpfile.link`; "unsafe" types
    (archives, binaries) are served from `d1-d10.tfdl.net`. Both hostnames serve
    the raw file at the URL. 7-day auto-deletion for anonymous uploads; no
    client-controllable expiry (expiry is server-side fixed). 100MB max.
    """
    name = "tmpfile.link"
    max_size_mb = 100
    default_expiry = "7 days"

    _API = "https://tmpfile.link/api/upload"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        code, out, err = self._curl(["-F", f"file=@{file_path}", self._API])
        if code != 0:
            raise RuntimeError(f"tmpfile.link upload failed: {err}")
        try:
            resp = json.loads(out)
        except json.JSONDecodeError:
            raise RuntimeError(f"tmpfile.link bad JSON: {out[:200]}")
        url = resp.get("downloadLink", "")
        if not url.startswith("http"):
            raise RuntimeError(f"tmpfile.link: no downloadLink in response: {resp}")
        return UploadResult(url=url, service="tmpfile.link",
                            expires_in="7 days",
                            file_id=resp.get("fileName", ""))

    def download(self, url: str, output_path: str) -> bool:
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0


class PasteRsService(BaseService):
    """paste.rs — minimal text-only paste service, 4MB cap, no auth.

    API: `POST https://paste.rs/` with the raw text as the request body
    (NOT multipart/form-data). Server returns the URL directly, e.g.
    `https://paste.rs/AEZu7`. GET on the URL returns the text as-is.

    This is the modern replacement for termbin (which is firewalled from
    most residential / cloud IPs as of mid-2026). Marked text-only because
    the server treats the body as UTF-8 text — uploading a binary file
    will technically work for raw bytes but the URL is intended for
    sharing text snippets, logs, code, etc.
    """
    name = "paste.rs"
    max_size_mb = 4
    default_expiry = "unknown (text only)"

    _API = "https://paste.rs/"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        size = os.path.getsize(file_path)
        if size > self.max_size_mb * 1024 * 1024:
            raise RuntimeError(
                f"paste.rs: file too large ({size} bytes > {self.max_size_mb}MB). "
                f"paste.rs is text-only with a 4MB cap."
            )
        # Raw body upload via curl --data-binary @file. We use a fresh
        # subprocess here (not self._curl) because the body is the file
        # itself, not a multipart field.
        cmd = ["curl", "-sS", "--max-time", "60", "-X", "POST",
               "--data-binary", f"@{file_path}", self._API]
        try:
            r = subprocess.run(cmd, capture_output=True, text=True, timeout=70)
        except subprocess.TimeoutExpired:
            raise RuntimeError("paste.rs upload timed out")
        url = r.stdout.strip()
        if not url.startswith("http"):
            # Common failure: 413 (file too large) returns HTML
            if "413" in (r.stderr or "") or "Request Entity Too Large" in r.stdout:
                raise RuntimeError(
                    f"paste.rs: file exceeds server limit (~4MB). "
                    f"Response: {r.stdout[:200]}"
                )
            raise RuntimeError(f"paste.rs bad response: {r.stdout[:200]}")
        return UploadResult(url=url, service="paste.rs", expires_in="unknown")

    def download(self, url: str, output_path: str) -> bool:
        # paste.rs serves the text directly at the URL
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0


class JuiceboxService(BaseService):
    """box.juicey.dev — open-source temp file host, content-addressed, 2GB max.

    API: POST https://box.juicey.dev/upload with multipart field `file=@...`.
    Response JSON has two shapes:
      - new file: {"files":["<id>.bin"],"truncated":bool,"remaining":N,
                              "limit_reached":bool}
      - duplicate (same SHA-256 already on server): {"duplicate":true,
                              "file":"<id>.bin","meta":{...,"hash":...}}
    Either way, the download URL is `https://box.juicey.dev/f/<filename>`.
    Verified: SHA-256 of uploaded file == SHA-256 of downloaded file (roundtrip).

    Caveats:
      - 10 active files per IP (server-enforced; extras get 413). For tmpcli
        automation this is rarely a problem.
      - Default retention is 3 days; users select 1h-14d via web UI.
        No client-controllable retention via the multipart API.
      - max_file_bytes=2GB per /api/config. Streaming upload not enabled,
        so large files use the same single multipart POST.
    """
    name = "box.juicey.dev"
    max_size_mb = 2048
    default_expiry = "3 days (1h-14d selectable)"

    _API = "https://box.juicey.dev/upload"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        code, out, err = self._curl(["-F", f"file=@{file_path}", self._API])
        if code != 0:
            raise RuntimeError(f"box.juicey.dev upload failed: {err}")
        try:
            resp = json.loads(out)
        except json.JSONDecodeError:
            # 413 (oversize) returns HTML
            if "413" in out or "Payload Too Large" in out:
                raise RuntimeError(
                    "box.juicey.dev: 413 — file exceeds 2GB limit. "
                    "Note: 413 also returned for the per-IP file cap; the JSON "
                    "form is preferred (see below)."
                )
            raise RuntimeError(f"box.juicey.dev bad JSON: {out[:200]}")
        # Handle the structured file_limit error (clearer than the 413 HTML)
        if isinstance(resp, dict) and resp.get("code") == "file_limit":
            msg = resp.get("message", "file limit reached")
            # Avoid double period if server message already ends in one
            suffix = "." if not msg.rstrip().endswith(".") else ""
            raise RuntimeError(
                f"box.juicey.dev: {msg}{suffix} Delete an older upload via the "
                f"web UI (https://box.juicey.dev/mine) and retry."
            )
        # Both new and duplicate responses have a "file" or "files" key
        fname = resp.get("file") or (resp.get("files", [None])[0])
        if not fname:
            raise RuntimeError(f"box.juicey.dev: no filename in response: {resp}")
        url = f"https://box.juicey.dev/f/{fname}"
        # If duplicate, prefer the meta hash for verification
        meta = resp.get("meta", {})
        is_dup = resp.get("duplicate", False)
        expires_in = "unknown"
        if meta.get("expires") and meta.get("set"):
            import time as _t
            secs = int(meta["expires"]) - int(_t.time())
            if secs > 0:
                days = secs // 86400
                hours = (secs % 86400) // 3600
                expires_in = f"{days}d{hours}h"
        return UploadResult(
            url=url, service="box.juicey.dev",
            expires_in=expires_in,
            file_id=fname,
            token="" if not is_dup else "dedup"
        )

    def download(self, url: str, output_path: str) -> bool:
        # box.juicey.dev serves the file directly at /f/<filename>
        code, _, _ = self._curl(["-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0


class OriginlessService(BaseService):
    """originless.gupt.app — IPFS-backed file host (Originless public gateway).

    API: POST https://originless.gupt.app/upload with multipart field `file=@...`.
    Also supports /uploadzip for zip uploads.
    Response JSON: {"status":"success","url":"https://dweb.link/ipfs/<CID>?filename=...",
                    "cid":"Qm...","size":N,"type":"...","filename":"..."}.

    The CID IS the SHA-256 of the file (IPFS uses the same content-addressing).
    Files are pinned to IPFS and accessible via any IPFS gateway (dweb.link,
    cloudflare-ipfs.com, ipfs.io, etc.). Effectively permanent.

    Caveats:
      - Cloudflare's default 100MB request-body limit (returns 413 HTML).
      - Single public instance (originless.gupt.app); not a "service" per se.
        If that gateway dies, the IPFS content is still accessible via the
        CID, but the upload endpoint is gone.
    """
    name = "originless"
    max_size_mb = 50
    default_expiry = "permanent (IPFS)"

    _API = "https://originless.gupt.app/upload"

    def upload(self, file_path: str, **kwargs) -> UploadResult:
        code, out, err = self._curl(["-F", f"file=@{file_path}", self._API])
        if code != 0:
            raise RuntimeError(f"originless upload failed: {err}")
        try:
            resp = json.loads(out)
        except json.JSONDecodeError:
            if "413" in out or "Payload Too Large" in out:
                raise RuntimeError(
                    "originless: 413 — file exceeds Cloudflare's request-body "
                    "limit (~100MB). Try a smaller file or a different service."
                )
            raise RuntimeError(f"originless bad JSON: {out[:200]}")
        if resp.get("status") != "success":
            raise RuntimeError(f"originless API error: {resp}")
        url = resp.get("url", "")
        cid = resp.get("cid", "")
        if not url or not cid:
            raise RuntimeError(f"originless: missing url/cid in response: {resp}")
        return UploadResult(
            url=url, service="originless",
            expires_in="permanent",
            file_id=cid
        )

    def download(self, url: str, output_path: str) -> bool:
        # originless serves the file at dweb.link/ipfs/<CID>
        code, _, _ = self._curl(["-L", "-o", output_path, url])
        return code == 0 and os.path.exists(output_path) and os.path.getsize(output_path) > 0


# ─── Core CLI ──────────────────────────────────────────────────────────────

class TmpCli:
    def __init__(self):
        self.perf: Dict[str, PerfRecord] = {}
        self.config_dir = Path.home() / ".config" / "tmp-cli"
        self.config_dir.mkdir(parents=True, exist_ok=True)
        self.perf_file = self.config_dir / "perf.json"
        self.load_perf()

        self.services: Dict[str, BaseService] = {
            "catbox": CatboxService(),
            "litterbox": LitterboxService(),
            "temp.sh": TempShService(),
            "gofile": GofileService(),
            "0x0": NullPointerService(),
            "pixeldrain": PixeldrainService(os.environ.get("PIXELDRAIN_API_KEY", "")),
            "termbin": TermbinService(),
            "drop.plz.ac": DropPlzAcService(),
            "sharenation": ShareNationService(),
            "x0.at": X0AtService(),
            "uguu": UguuService(),
            "tmpfiles": TmpfilesService(),
            "filebin": FilebinService(),
            "send.vis.ee": SendVisEeService(),
            "wormhole": WormholeService(),
            "isrv": IsrvService(),
            "tempfile.org": TmpfileOrgService(),
            "tmpfile.link": TmpfileLinkService(),
            "box.juicey.dev": JuiceboxService(),
            "originless": OriginlessService(),
            "paste.rs": PasteRsService(),
            "fsend.me": FsendMeService(),
            "fars.ee": FarsEeService(),
        }

    def load_perf(self):
        if self.perf_file.exists():
            try:
                data = json.loads(self.perf_file.read_text())
                for svc, rec in data.items():
                    self.perf[svc] = PerfRecord(
                        upload_times=rec.get("upload_times", []),
                        success_count=rec.get("success_count", 0),
                        failure_count=rec.get("failure_count", 0),
                        avg_speed_mbps=rec.get("avg_speed_mbps", 0.0)
                    )
            except:
                pass

    def save_perf(self):
        data = {}
        for svc, rec in self.perf.items():
            data[svc] = {
                "upload_times": rec.upload_times[-10:],
                "success_count": rec.success_count,
                "failure_count": rec.failure_count,
                "avg_speed_mbps": rec.avg_speed_mbps,
            }
        self.perf_file.write_text(json.dumps(data, indent=2))

    def record_upload(self, svc: str, elapsed: float, success: bool, size_mb: float):
        if svc not in self.perf:
            self.perf[svc] = PerfRecord()
        rec = self.perf[svc]
        rec.upload_times.append(elapsed)
        rec.upload_times = rec.upload_times[-10:]
        if success:
            rec.success_count += 1
            if elapsed > 0:
                speed = size_mb / elapsed
                rec.avg_speed_mbps = 0.7 * rec.avg_speed_mbps + 0.3 * speed if rec.avg_speed_mbps else speed
        else:
            rec.failure_count += 1
        self.save_perf()

    def smart_select(self, file_path: str, preferred: Optional[List[str]] = None) -> str:
        size_mb = os.path.getsize(file_path) / (1024 * 1024)
        candidates = preferred or UPLOAD_SERVICES

        eligible = []
        for svc in candidates:
            s = self.services.get(svc)
            if not s or s.name == "termbin":  # exclude termbin from smart routing
                continue
            if s.max_size_mb > 0 and size_mb > s.max_size_mb:
                continue
            if s.needs_key and not os.environ.get("PIXELDRAIN_API_KEY"):
                continue
            eligible.append(svc)

        if not eligible:
            raise RuntimeError(f"No service can handle {size_mb:.1f}MB file")

        def score(svc_name: str) -> float:
            rec = self.perf.get(svc_name, PerfRecord())
            speed = rec.avg_speed_mbps if rec.avg_speed_mbps else 1.0
            total = rec.success_count + rec.failure_count
            rate = rec.success_count / total if total > 0 else 0.5
            penalty = rec.failure_count * 0.3
            return speed * 3 + rate * 2 - penalty

        eligible.sort(key=score, reverse=True)
        return eligible[0]

    def upload(self, file_path: str, service: str = None, _tried: Optional[set] = None, **kwargs) -> UploadResult:
        path = Path(file_path)
        if not path.exists():
            raise FileNotFoundError(file_path)
        # Reject empty files immediately — every host rejects 0-byte uploads and
        # trying them all spins the fallback loop.
        size = os.path.getsize(file_path)
        if size == 0:
            raise ValueError(f"refusing to upload empty file: {file_path}")

        # Track which services have been tried in this call chain to prevent the
        # recursive fallback loop from re-trying the same service (catbox → litterbox
        # → catbox → ...). Only relevant when service is None (smart-select with
        # fallback); explicit -s service is single-shot, no fallback.
        if _tried is None:
            _tried = set()

        if service:
            if service not in self.services:
                raise ValueError(f"Unknown service: {service}")
            svc_name = service
        else:
            svc_name = self.smart_select(file_path)
            _tried.add(svc_name)

        svc = self.services[svc_name]
        size_mb = size / (1024 * 1024)
        print(f"[*] {svc_name} upload {_fmt_size(size_mb)}...", end="", file=sys.stderr)

        t0 = time.time()
        success = False
        try:
            result = svc.upload(file_path, **kwargs)
            success = True
            elapsed = time.time() - t0
            result.elapsed = elapsed
            result.size_mb = size_mb
            self.record_upload(svc_name, elapsed, True, size_mb)
            return result
        except Exception as e:
            elapsed = time.time() - t0
            self.record_upload(svc_name, elapsed, False, size_mb)
            print(f"[!] {svc_name} failed: {e}", file=sys.stderr)
            # Only fall back when this was a smart-select call (service=None);
            # when the user explicitly named a service with -s, fail immediately.
            if service is not None:
                raise
            # Try remaining services in score order, skipping any already tried.
            fallback = [s for s in UPLOAD_SERVICES
                        if s not in _tried
                        and not self.services[s].needs_key]
            for fb in fallback[:3]:
                print(f"[*] Trying fallback: {fb}...", file=sys.stderr)
                _tried.add(fb)
                try:
                    return self.upload(file_path, service=fb, _tried=_tried, **kwargs)
                except Exception as e2:
                    print(f"[!] {fb} also failed: {e2}", file=sys.stderr)
            raise RuntimeError(f"All services failed. Last error: {e}")

    def download(self, url: str, output_path: str = None) -> bool:
        parsed = urlparse(url)
        domain = parsed.netloc.lower()

        svc_name = None
        for name in self.services:
            key = name.replace(".", "")
            if key in domain or name in domain:
                svc_name = name
                break

        if not svc_name:
            # Try generic direct download
            out = output_path or str(Path(os.getcwd()) / "downloaded_file")
            code, _, _ = self.services["catbox"]._curl(["-o", str(out), url])
            return code == 0 and os.path.exists(out) and os.path.getsize(out) > 0

        svc = self.services[svc_name]
        if not output_path:
            out = Path(os.getcwd()) / Path(url).name
            if not out.name or out.name in ["", "/"]:
                out = Path(os.getcwd()) / "downloaded_file"
            output_path = str(out)

        print(f"[*] Downloading from {svc_name}...", file=sys.stderr)
        return svc.download(url, output_path)

    def update(self):
        """Self-update via git pull from GitHub raw URLs.

        Windows note: the currently-executing file is locked for execution
        even when it could in theory be renamed (the running Python process
        holds a non-FILE_SHARE_DELETE handle). The previous version of this
        method used Path.replace/rename in a 4-step sequence, which fails
        on Windows with WinError 32 ("file in use") and leaves .new files
        behind, then a second run fails with WinError 183 on the leftover
        install.sh.new. The fix is:

        1. Clean up any leftover .new files from a previous aborted run.
        2. Move the running script to .bak FIRST (rename of a file with a
           running handle works on NTFS; deletion doesn't, but rename does).
        3. Then move the freshly-downloaded .new into place.
        4. Catch OSError/WinError and unlink-then-retry (worst case).
        5. Print success only after every swap has actually happened.
        """
        raw_base = "https://raw.githubusercontent.com/evangit2/tmp-cli/master"
        script_dir = self.config_dir.parent / "tmp-cli" if hasattr(self.config_dir, "parent") else Path.home() / ".tmp-cli"
        # Common install locations
        for cand in [Path.home() / ".tmp-cli", Path.home() / ".config" / "tmp-cli", Path.home() / ".local" / "share" / "tmp-cli"]:
            if (cand / "tmpcli").exists() or (cand / "tmp").exists():
                script_dir = cand
                break

        # Clean up any leftover .new files from a previous aborted run.
        # Without this, the second attempt hits WinError 183 on the existing
        # install.sh.new.
        for stale in (script_dir / "tmpcli.new", script_dir / "install.sh.new"):
            if stale.exists():
                try:
                    stale.unlink()
                except OSError:
                    pass

        print(f"[*] tmpcli update — checking {raw_base} ...", file=sys.stderr)
        # Download latest tmpcli
        _, out, err = self.services["catbox"]._curl([
            "-o", str(script_dir / "tmpcli.new"),
            f"{raw_base}/tmpcli"
        ])
        if _ != 0:
            raise RuntimeError(f"Failed to fetch latest tmpcli: {err}")
        # Download latest install.sh for metadata
        _, out2, _ = self.services["catbox"]._curl([
            "-o", str(script_dir / "install.sh.new"),
            f"{raw_base}/install.sh"
        ])
        # Verify new script is valid Python
        new_path = script_dir / "tmpcli.new"
        try:
            content = new_path.read_text()
        except OSError as e:
            raise RuntimeError(f"Failed to read downloaded tmpcli.new: {e}")
        if "#!/usr/bin/env python3" not in content or "def main():" not in content:
            new_path.unlink(missing_ok=True)
            (script_dir / "install.sh.new").unlink(missing_ok=True)
            raise RuntimeError("Downloaded file does not look like tmpcli — update aborted")
        # Backup and swap. The two renames below are the ones Windows hates —
        # on POSIX they always work; on Windows the running file is locked
        # for execution so a plain rename may fail with WinError 32/183.
        # Path.replace() on Windows uses MoveFileEx(MOVEFILE_REPLACE_EXISTING)
        # which IS supposed to overwrite, but if the destination exists and
        # is locked, the kernel refuses. Defensive order:
        #   1. unlink any existing bak (so the .bak rename below has a free target)
        #   2. try replace(); on OSError, unlink destination and retry
        #   3. print success only if BOTH swaps actually completed
        old_path = script_dir / "tmpcli"
        bak_path = script_dir / "tmpcli.bak"
        # Step 1: clear any leftover .bak from a previous update so the rename below can land
        if bak_path.exists() or bak_path.is_symlink():
            try:
                bak_path.unlink()
            except OSError as e:
                raise RuntimeError(f"Cannot remove stale {bak_path}: {e} — please delete it manually and re-run update")
        # Step 2: rename old tmpcli -> tmpcli.bak. The script is still running
        # from this file; on Windows the rename of an open file is permitted
        # (it just changes the directory entry), but a subsequent unlink would
        # fail. We're renaming, not unlinking, so this should succeed on NTFS.
        try:
            old_path.replace(bak_path)
        except OSError as e:
            # Last resort: unlink the .new files and re-raise with a clearer message
            new_path.unlink(missing_ok=True)
            (script_dir / "install.sh.new").unlink(missing_ok=True)
            raise RuntimeError(
                f"Cannot rename {old_path} -> {bak_path}: {e}. "
                "This usually means another process is holding the file open. "
                "Close any open PowerShell windows pointed at this directory, "
                "or run update again — the .new files have been cleaned up."
            )
        # Step 3: rename the freshly downloaded .new into place. Now that the
        # original tmpcli is gone (moved to .bak), this should always succeed.
        try:
            new_path.rename(old_path)
        except OSError as e:
            # Try to restore the backup so the user isn't left without a working tmpcli
            try:
                bak_path.rename(old_path)
            except OSError:
                pass
            raise RuntimeError(f"Cannot move tmpcli.new into place: {e}")
        # Step 4: chmod (no-op on Windows)
        try:
            old_path.chmod(0o755)
        except OSError:
            pass
        # Step 5: install.sh.new -> install.sh. install.sh may not exist on
        # Windows (it's a Linux-only file in the Windows install) so a plain
        # rename is fine; if it does exist, Path.replace handles the swap.
        try:
            (script_dir / "install.sh.new").replace(script_dir / "install.sh")
        except OSError as e:
            # Non-fatal — install.sh is just used for re-install reference
            print(f"[!] Updated tmpcli but could not refresh install.sh: {e}", file=sys.stderr)
            (script_dir / "install.sh.new").unlink(missing_ok=True)
        print("[+] tmpcli updated successfully.", file=sys.stderr)
        print("    Backup: tmpcli.bak", file=sys.stderr)
        return True


# ─── Argparse ──────────────────────────────────────────────────────────────

SERVICE_CHOICES = list(TmpCli().services.keys())

def main():
    parser = argparse.ArgumentParser(prog="tmpcli", description="Universal temp file uploader/downloader")
    subparsers = parser.add_subparsers(dest="command", help="Commands")

    # upload
    up = subparsers.add_parser("up", help="Upload file")
    up.add_argument("file", help="File to upload")
    up.add_argument("-s", "--service", choices=SERVICE_CHOICES, help="Target service")
    up.add_argument("-t", "--time", default="72h", help="Expire time (litterbox: 1h/12h/24h/72h)")
    up.add_argument("-n", "--name", help="Custom filename on server")
    up.add_argument("--secret", action="store_true", help="Use secret URL (0x0.st)")
    up.add_argument("--expires", type=int, default=3600, help="Seconds until expiry (sharenation/tmpfiles)")
    up.add_argument("--filebin-bin", help="Bin ID for filebin.net uploads")
    up.add_argument("--pixeldrain-key", help="Pixeldrain API key")
    up.add_argument("-q", "--quiet", action="store_true", help="Only print URL to stdout")

    # download
    dl = subparsers.add_parser("dl", help="Download file")
    dl.add_argument("url", help="URL to download")
    dl.add_argument("-o", "--output", help="Output path")

    # list / catalog
    ls = subparsers.add_parser("list", help="List services and status")
    ls.add_argument("--perf", action="store_true", help="Show performance stats")
    cat = subparsers.add_parser("catalog", help="Show service catalog with verified limits")
    cat.add_argument("--json", action="store_true", help="JSON output for scripts")

    # update
    upd = subparsers.add_parser("update", help="Update tmpcli from GitHub")

    # uninstall
    uns = subparsers.add_parser("uninstall", help="Remove tmpcli from system")

    # ── auto-detect: bare file path or URL as first arg ──
    if len(sys.argv) >= 2:
        first = sys.argv[1]
        if first not in ("up", "dl", "list", "catalog", "update", "uninstall", "-h", "--help") and not first.startswith("-"):
            if re.match(r"^https?://", first):
                sys.argv[1:2] = ["dl", first]
            elif Path(first).exists():
                sys.argv[1:2] = ["up", first]

    args = parser.parse_args()
    cli = TmpCli()
    if args.command in ("up",):
        kwargs = {}
        if args.service == "litterbox":
            kwargs["time_param"] = args.time
        if args.service == "0x0" and args.secret:
            kwargs["secret"] = True
        if args.expires:
            kwargs["expires_seconds"] = args.expires
            kwargs["tmpfiles_expire"] = args.expires
        if args.filebin_bin:
            kwargs["filebin_bin"] = args.filebin_bin
        if args.name:
            kwargs["filename"] = args.name
        if args.pixeldrain_key:
            os.environ["PIXELDRAIN_API_KEY"] = args.pixeldrain_key
        try:
            result = cli.upload(args.file, service=args.service, **kwargs)
        except FileNotFoundError:
            print(f"[!] File not found: {args.file}", file=sys.stderr)
            sys.exit(1)
        except ValueError as e:
            # Empty file, unknown service, etc.
            print(f"[!] {e}", file=sys.stderr)
            sys.exit(1)
        except RuntimeError as e:
            print(f"[!] {e}", file=sys.stderr)
            sys.exit(1)
        if args.quiet:
            print(result.url)
        else:
            speed = result.size_mb / result.elapsed if result.elapsed > 0 else 0
            stats = f"{_fmt_size(result.size_mb)} in {_fmt_time(result.elapsed)} ({_fmt_speed(speed)})"
            print(f"[+] {result.service} → {stats}", file=sys.stderr)
            print(result.url)

    elif args.command in ("dl",):
        url = args.url
        parsed = urllib.parse.urlparse(url)
        domain = parsed.netloc.lower()
        svc_name = None
        for name in cli.services:
            key = name.replace(".", "")
            if key in domain or name in domain:
                svc_name = name
                break

        out = args.output
        if not out:
            fname = Path(url).name or "downloaded_file"
            out = str(Path(os.getcwd()) / fname)

        size_str = ""
        t0 = time.time()
        if svc_name:
            print(f"[*] {svc_name} download...", file=sys.stderr, end="")
            ok = cli.services[svc_name].download(url, out)
        else:
            print(f"[*] direct download...", file=sys.stderr, end="")
            code, _, _ = cli.services["catbox"]._curl(["-o", str(out), url])
            ok = code == 0 and os.path.exists(out) and os.path.getsize(out) > 0
        elapsed = time.time() - t0

        if ok and os.path.exists(out):
            sz = os.path.getsize(out) / (1024*1024)
            speed = sz / elapsed if elapsed > 0 else 0
            stats = f"{_fmt_size(sz)} in {_fmt_time(elapsed)} ({_fmt_speed(speed)})"
            print(f"\r[+] {svc_name or 'direct'} → {stats}  → {out}", file=sys.stderr)
            sys.exit(0)
        else:
            print(f"\r[!] download failed", file=sys.stderr)
            sys.exit(1)

    elif args.command == "list":
        print(f"{'Service':<16} {'Upload':<7} {'Download':<9} {'Max':<8} {'Expiry':<14} Notes")
        print("-" * 70)
        for name, info in CATALOG.items():
            if name.startswith("_"):
                continue
            mb = f"{info['max_mb']}MB" if info['max_mb'] else 'unltd'
            print(f"{name:<16} {info['upload']:<7} {info['download']:<9} {mb:<8} {info['expiry']:<14} {info['notes']}")
        if args.perf:
            print("\nPerformance:")
            for name, rec in cli.perf.items():
                print(f"  {name}: avg={rec.avg_speed_mbps:.2f}MB/s  succ={rec.success_count}  fail={rec.failure_count}")

    elif args.command == "catalog":
        if args.json:
            clean = {k: v for k, v in CATALOG.items() if not k.startswith("_")}
            print(json.dumps(clean, indent=2))
        else:
            W = 70
            print(f"{'Service':^16} │ {'Upload':^6} │ {'Download':^8} │ {'Max':^8} │ {'Expiry':^12}")
            print("─" * W)
            for name, info in CATALOG.items():
                if name.startswith("_"):
                    continue
                mb = f"{info['max_mb']}MB" if info['max_mb'] else "unlimited"
                print(f"{name:<16} │ {info['upload']:^6} │ {info['download']:^8} │ {mb:^8} │ {info['expiry']:<12}")

    elif args.command == "update":
        try:
            cli.update()
        except Exception as e:
            print(f"[!] Update failed: {e}", file=sys.stderr)
            sys.exit(1)

    elif args.command == "uninstall":
        import shutil
        removed = []
        # Remove wrapper scripts
        for cand in [Path.home() / ".local/bin/tmpcli",
                       Path.home() / "bin/tmpcli",
                       Path("/usr/local/bin/tmpcli")]:
            if cand.is_file() or cand.is_symlink():
                cand.unlink(missing_ok=True)
                removed.append(str(cand))
        # Remove installed source
        for inst_dir in [Path.home() / ".tmp-cli",
                         Path.home() / ".config/tmp-cli",
                         Path.home() / ".local/share/tmp-cli"]:
            if inst_dir.exists():
                for f in ("tmpcli", "install.sh", "tmpcli.bak"):
                    fp = inst_dir / f
                    if fp.exists():
                        fp.unlink(missing_ok=True)
                # Remove dir if empty
                if inst_dir.exists() and not any(inst_dir.iterdir()):
                    inst_dir.rmdir()
                removed.append(str(inst_dir))
        # Remove perf cache
        perf_file = Path.home() / ".config/tmp-cli/perf.json"
        if perf_file.exists():
            perf_file.unlink(missing_ok=True)
            removed.append(str(perf_file))
        print(f"[+] Uninstalled. Removed:", file=sys.stderr)
        for r in removed:
            print(f"    {r}", file=sys.stderr)
        sys.exit(0)

    else:
        parser.print_help()

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        # Ctrl-C should exit cleanly, not dump a Python traceback.
        print("\n[!] Aborted.", file=sys.stderr)
        sys.exit(130)  # 130 is the conventional exit code for SIGINT