v2: complete redesign — single entrypoint, tar.zst persistence

Replace 13 scripts with 3 files (+ Dockerfile):
- entrypoint.py: single Python PID 1 (init, sync, services, log streamer)
- nginx.conf: reverse proxy (7860 → ttyd, ssh, logs)
- ws_ssh_bridge.py: WebSocket-to-SSH bridge (unchanged)

Key changes:
- Persistence: tar.zst of /home + /root via upload_file (not folder sync)
- No more rsync permission corruption (tar -p preserves modes)
- No more .cache path rejections (single archive file)
- No more upload_large_folder hangs (upload_file is fast)
- Log streamer runs as thread (not separate process)
- Sync runs as thread (not separate daemon)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Dockerfile

@@ -1,32 +1,26 @@
-# Ubuntu 24.04 Server on HuggingRun
+# HuggingRun v2 — Ubuntu Server on HuggingFace Spaces
 # Single port 7860: nginx → ttyd (web terminal) + SSH-over-WebSocket
-# Full disk persistence: dataset = exact mirror of entire filesystem
+# Persistence: tar.zst archive of /home + /root → HF Dataset
 FROM ubuntu:24.04
 
 ENV DEBIAN_FRONTEND=noninteractive
 
-# System + Python + git-lfs (for HuggingRun git-based persistence)
+# System + Python + tools (single layer)
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    ca-certificates curl wget python3 python3-pip python3-venv git git-lfs \
+    ca-certificates curl wget git git-lfs \
+    python3 python3-pip python3-venv \
+    openssh-server nginx ttyd rsync zstd \
+    procps htop vim nano less tmux build-essential \
     && pip3 install --no-cache-dir --break-system-packages huggingface_hub websockets \
     && git lfs install \
     && rm -rf /var/lib/apt/lists/*
 
-# Server: SSH + nginx + ttyd + tools
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    openssh-server openssh-client \
-    nginx \
-    ttyd \
-    procps htop vim nano less tmux \
-    build-essential rsync \
-    && rm -rf /var/lib/apt/lists/*
-
 # Node.js 20 LTS (for Claude Code)
 RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
     && apt-get install -y nodejs \
     && rm -rf /var/lib/apt/lists/*
 
-# Claude Code (install globally so all users can access)
+# Claude Code
 RUN npm install -g @anthropic-ai/claude-code 2>/dev/null \
     || (curl -fsSL https://claude.ai/install.sh | bash && \
         cp /root/.local/bin/claude /usr/local/bin/claude 2>/dev/null || true)
@@ -34,30 +28,23 @@ RUN npm install -g @anthropic-ai/claude-code 2>/dev/null \
 # Snapshot base package list (to detect user-added packages later)
 RUN dpkg-query -W -f='${Package}\n' | sort > /etc/base-packages.list
 
-# SSH: host keys + privilege separation directory
+# SSH host keys
 RUN ssh-keygen -A && mkdir -p /run/sshd
 
-# User account (for SSH login); container runs as root for system persistence
-RUN useradd -m -u 1000 -s /bin/bash -p "$(openssl passwd -6 huggingrun)" user 2>/dev/null || true
-# Root password for SSH login as root
-RUN usermod -p "$(openssl passwd -6 huggingrun)" root
+# User account
+RUN useradd -m -u 1000 -s /bin/bash user 2>/dev/null || true \
+    && echo "user:huggingrun" | chpasswd \
+    && echo "root:huggingrun" | chpasswd
+
 RUN mkdir -p /data
 
-# All app scripts go to /scripts/ — OUTSIDE persist dirs (/opt, /etc get
-# restored from dataset, which would overwrite Docker image files with stale versions)
-COPY scripts /scripts
-COPY ubuntu-server/nginx.conf /scripts/nginx.conf
-COPY ubuntu-server/ws-ssh-bridge.py /scripts/ws-ssh-bridge.py
-COPY ubuntu-server/git_sync_daemon.py /scripts/git_sync_daemon.py
-COPY ubuntu-server/log_streamer.py /scripts/log_streamer.py
-COPY ubuntu-server/start-server.sh /scripts/start-server.sh
-RUN chmod +x /scripts/entrypoint.sh /scripts/start-server.sh
+# v2: only 3 files
+COPY entrypoint.py /entrypoint.py
+COPY nginx.conf /etc/nginx/nginx.conf
+COPY ws_ssh_bridge.py /ws_ssh_bridge.py
 
 ENV PERSIST_PATH=/data
 ENV PYTHONUNBUFFERED=1
-ENV RUN_CMD="stdbuf -oL -eL /scripts/start-server.sh"
-ENV SSH_PORT=2222
-
-# Run as root (needed for: apt install persistence, bind mounts, sshd)
 EXPOSE 7860
-ENTRYPOINT ["/scripts/entrypoint.sh"]
+
+ENTRYPOINT ["python3", "-u", "/entrypoint.py"]

entrypoint.py

@@ -0,0 +1,456 @@
+#!/usr/bin/env python3
+"""
+HuggingRun v2 — Single entrypoint for Ubuntu Server on HuggingFace Spaces.
+
+Replaces: entrypoint.sh, start-server.sh, git_sync_daemon.py, log_streamer.py
+
+Lifecycle:
+  1. Resolve config (HF_TOKEN, dataset repo)
+  2. Download state.tar.zst from HF Dataset → extract /home, /root
+  3. Reinstall user-added packages
+  4. Start services (sshd, ttyd, ws-bridge, log streamer, sync thread)
+  5. exec nginx (becomes PID 1, opens port 7860)
+"""
+
+import http.server
+import json
+import os
+import signal
+import subprocess
+import sys
+import threading
+import time
+from datetime import datetime, timezone
+
+# ── Config ────────────────────────────────────────────────────────────
+PERSIST_PATH = os.environ.get("PERSIST_PATH", "/data")
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+HF_DATASET_REPO = os.environ.get("HF_DATASET_REPO", "")
+SYNC_INTERVAL = int(os.environ.get("SYNC_INTERVAL", "120"))
+SSH_PORT = os.environ.get("SSH_PORT", "2222")
+TTYD_PORT = os.environ.get("TTYD_PORT", "7681")
+LOGFILE = "/var/log/huggingrun.log"
+STATE_FILE = os.path.join(PERSIST_PATH, "state.tar.zst")
+PKG_FILE = os.path.join(PERSIST_PATH, "user-packages.list")
+BASE_PKG_FILE = "/etc/base-packages.list"
+
+
+def log(msg):
+    ts = time.strftime("%H:%M:%S", time.gmtime())
+    line = f"[{ts}] {msg}"
+    print(line, file=sys.stderr, flush=True)
+    try:
+        with open(LOGFILE, "a") as f:
+            f.write(line + "\n")
+    except Exception:
+        pass
+
+
+def run(cmd):
+    log(f"  $ {cmd}")
+    t0 = time.time()
+    r = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE,
+                       stderr=subprocess.STDOUT, text=True)
+    elapsed = time.time() - t0
+    if r.returncode != 0:
+        log(f"  exit={r.returncode} ({elapsed:.1f}s)")
+        for line in (r.stdout or "").strip().split("\n")[:5]:
+            if line.strip():
+                log(f"    {line}")
+    else:
+        log(f"  ok ({elapsed:.1f}s)")
+    return r.returncode, (r.stdout or "").strip()
+
+
+# ── Config Resolution ─────────────────────────────────────────────────
+def resolve_config():
+    global HF_TOKEN, HF_DATASET_REPO
+
+    HF_TOKEN = os.environ.get("HF_TOKEN", "")
+    space_id = os.environ.get("SPACE_ID", "")
+
+    if not HF_DATASET_REPO:
+        if space_id:
+            HF_DATASET_REPO = f"{space_id}-data"
+        elif HF_TOKEN:
+            try:
+                from huggingface_hub import HfApi
+                name = HfApi(token=HF_TOKEN).whoami()["name"]
+                HF_DATASET_REPO = f"{name}/HuggingRun-data"
+            except Exception:
+                pass
+        os.environ["HF_DATASET_REPO"] = HF_DATASET_REPO
+
+    log("========================================")
+    log("HuggingRun v2 starting")
+    log(f"  Date: {datetime.now(timezone.utc).isoformat()}")
+    log(f"  HF_TOKEN: {'set (' + str(len(HF_TOKEN)) + ' chars)' if HF_TOKEN else 'NOT SET'}")
+    log(f"  HF_DATASET_REPO: {HF_DATASET_REPO or 'NOT SET'}")
+    log(f"  PERSIST_PATH: {PERSIST_PATH}")
+    log(f"  SYNC_INTERVAL: {SYNC_INTERVAL}s")
+    log("========================================")
+
+
+def ensure_dataset_repo():
+    if not HF_TOKEN or not HF_DATASET_REPO:
+        log("persistence disabled (no token/repo)")
+        return
+    try:
+        from huggingface_hub import HfApi
+        api = HfApi(token=HF_TOKEN)
+        try:
+            api.repo_info(repo_id=HF_DATASET_REPO, repo_type="dataset")
+            log(f"dataset exists: {HF_DATASET_REPO}")
+        except Exception:
+            api.create_repo(repo_id=HF_DATASET_REPO, repo_type="dataset", private=True)
+            log(f"created dataset: {HF_DATASET_REPO}")
+    except Exception as e:
+        log(f"dataset check failed: {e}")
+
+
+# ── Restore ───────────────────────────────────────────────────────────
+def restore_state():
+    if not HF_TOKEN or not HF_DATASET_REPO:
+        os.makedirs(PERSIST_PATH, exist_ok=True)
+        return
+
+    log("── RESTORE: downloading state")
+    os.makedirs(PERSIST_PATH, exist_ok=True)
+    t0 = time.time()
+    try:
+        from huggingface_hub import hf_hub_download
+        path = hf_hub_download(
+            repo_id=HF_DATASET_REPO,
+            filename="state.tar.zst",
+            repo_type="dataset",
+            local_dir=PERSIST_PATH,
+            token=HF_TOKEN,
+        )
+        elapsed = time.time() - t0
+        size_mb = os.path.getsize(path) / 1024 / 1024
+        log(f"  downloaded {size_mb:.1f}MB ({elapsed:.1f}s)")
+    except Exception as e:
+        log(f"  no state to restore: {e}")
+        return
+
+    log("── RESTORE: extracting state.tar.zst")
+    t0 = time.time()
+    rc, out = run(f"tar --zstd -xpf {STATE_FILE} -C /")
+    elapsed = time.time() - t0
+    if rc == 0:
+        log(f"  extracted ({elapsed:.1f}s)")
+    else:
+        log(f"  extraction failed ({elapsed:.1f}s)")
+
+    # Also download package list if it exists
+    try:
+        from huggingface_hub import hf_hub_download
+        hf_hub_download(
+            repo_id=HF_DATASET_REPO,
+            filename="user-packages.list",
+            repo_type="dataset",
+            local_dir=PERSIST_PATH,
+            token=HF_TOKEN,
+        )
+    except Exception:
+        pass
+
+
+def restore_packages():
+    if not os.path.exists(PKG_FILE) or not os.path.exists(BASE_PKG_FILE):
+        log("── PACKAGES: no saved list, skipping")
+        return
+    try:
+        with open(BASE_PKG_FILE) as f:
+            base = set(f.read().strip().split("\n"))
+        with open(PKG_FILE) as f:
+            saved = set(f.read().strip().split("\n"))
+        to_install = sorted(saved - base)
+        if not to_install:
+            log("── PACKAGES: no extra packages to install")
+            return
+        log(f"── PACKAGES: reinstalling {len(to_install)} packages")
+        run(f"apt-get update -qq && apt-get install -y --no-install-recommends {' '.join(to_install)}")
+    except Exception as e:
+        log(f"── PACKAGES: error: {e}")
+
+
+def ensure_passwords():
+    log("── PASSWORDS")
+    run("id user >/dev/null 2>&1 || useradd -m -s /bin/bash user")
+    run('echo "user:huggingrun" | chpasswd')
+    run('echo "root:huggingrun" | chpasswd')
+    run("ldconfig 2>/dev/null || true")
+
+
+# ── Save + Upload ─────────────────────────────────────────────────────
+def save_and_upload():
+    if not HF_TOKEN or not HF_DATASET_REPO:
+        return
+    from huggingface_hub import HfApi
+
+    log("══ SYNC: save + upload ══")
+    os.makedirs(PERSIST_PATH, exist_ok=True)
+
+    # Save package list
+    try:
+        rc, out = run("dpkg-query -W -f='${Package}\\n'")
+        if rc == 0 and out:
+            with open(PKG_FILE, "w") as f:
+                f.write(out + "\n")
+    except Exception:
+        pass
+
+    # Create tar.zst of /home and /root
+    t0 = time.time()
+    dirs_to_persist = []
+    for d in ["home", "root"]:
+        if os.path.isdir(f"/{d}"):
+            dirs_to_persist.append(d)
+    if not dirs_to_persist:
+        log("  nothing to persist")
+        return
+
+    rc, out = run(f"tar --zstd -cpf {STATE_FILE} -C / {' '.join(dirs_to_persist)}")
+    elapsed = time.time() - t0
+    if rc != 0:
+        log(f"  tar failed ({elapsed:.1f}s)")
+        return
+
+    size_mb = os.path.getsize(STATE_FILE) / 1024 / 1024
+    log(f"  tar: {size_mb:.1f}MB ({elapsed:.1f}s)")
+
+    # Upload both files
+    api = HfApi(token=HF_TOKEN)
+    ts = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
+
+    t0 = time.time()
+    try:
+        api.upload_file(
+            path_or_fileobj=STATE_FILE,
+            path_in_repo="state.tar.zst",
+            repo_id=HF_DATASET_REPO,
+            repo_type="dataset",
+            commit_message=f"sync {ts}",
+        )
+        elapsed = time.time() - t0
+        log(f"  uploaded state.tar.zst ({elapsed:.1f}s)")
+    except Exception as e:
+        log(f"  upload state.tar.zst failed: {e}")
+
+    # Upload package list (separate commit to avoid conflicts)
+    if os.path.exists(PKG_FILE):
+        try:
+            api.upload_file(
+                path_or_fileobj=PKG_FILE,
+                path_in_repo="user-packages.list",
+                repo_id=HF_DATASET_REPO,
+                repo_type="dataset",
+                commit_message=f"packages {ts}",
+            )
+            log("  uploaded user-packages.list")
+        except Exception as e:
+            log(f"  upload packages failed: {e}")
+
+    log("══ SYNC: done ══")
+
+
+# ── Sync Thread ───────────────────────────────────────────────────────
+def sync_loop():
+    log("sync thread: waiting 60s before first sync")
+    time.sleep(60)
+    cycle = 0
+    while True:
+        cycle += 1
+        log(f"── sync cycle #{cycle}")
+        try:
+            save_and_upload()
+        except Exception as e:
+            log(f"  sync error: {e}")
+        time.sleep(SYNC_INTERVAL)
+
+
+# ── Log Streamer (SSE) ───────────────────────────────────────────────
+class LogSSEHandler(http.server.BaseHTTPRequestHandler):
+    def log_message(self, format, *args):
+        pass
+
+    def do_GET(self):
+        if self.path == "/stream":
+            self.send_response(200)
+            self.send_header("Content-Type", "text/event-stream")
+            self.send_header("Cache-Control", "no-cache")
+            self.send_header("Connection", "keep-alive")
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.end_headers()
+            try:
+                if os.path.exists(LOGFILE):
+                    with open(LOGFILE) as f:
+                        for line in f:
+                            line = line.rstrip("\n")
+                            if line:
+                                event = json.dumps({
+                                    "data": line + "\n",
+                                    "timestamp": datetime.now(timezone.utc).isoformat()
+                                })
+                                self.wfile.write(f"data: {event}\n\n".encode())
+                                self.wfile.flush()
+                with open(LOGFILE) as f:
+                    f.seek(0, 2)
+                    while True:
+                        line = f.readline()
+                        if line:
+                            line = line.rstrip("\n")
+                            if line:
+                                event = json.dumps({
+                                    "data": line + "\n",
+                                    "timestamp": datetime.now(timezone.utc).isoformat()
+                                })
+                                self.wfile.write(f"data: {event}\n\n".encode())
+                                self.wfile.flush()
+                        else:
+                            self.wfile.write(b": keep-alive\n\n")
+                            self.wfile.flush()
+                            time.sleep(1)
+            except (BrokenPipeError, ConnectionResetError):
+                pass
+        else:
+            self.send_response(404)
+            self.end_headers()
+
+
+def start_log_streamer():
+    server = http.server.HTTPServer(("127.0.0.1", 7863), LogSSEHandler)
+    t = threading.Thread(target=server.serve_forever, daemon=True)
+    t.start()
+    log("[  OK  ] log streamer on 127.0.0.1:7863")
+
+
+# ── Service Management ────────────────────────────────────────────────
+def start_sshd():
+    log("starting sshd on 127.0.0.1:{} ...".format(SSH_PORT))
+    os.makedirs("/run/sshd", exist_ok=True)
+    proc = subprocess.Popen([
+        "/usr/sbin/sshd", "-D", "-e",
+        "-o", f"Port={SSH_PORT}",
+        "-o", "ListenAddress=127.0.0.1",
+        "-o", "PermitRootLogin=yes",
+        "-o", "PasswordAuthentication=yes",
+        "-o", "PermitEmptyPasswords=no",
+        "-o", "UsePAM=yes",
+    ])
+    time.sleep(1)
+    if proc.poll() is None:
+        log(f"[  OK  ] sshd PID={proc.pid}")
+    else:
+        log("[FAILED] sshd")
+    return proc
+
+
+def start_ttyd():
+    log(f"starting ttyd on 127.0.0.1:{TTYD_PORT} ...")
+    proc = subprocess.Popen([
+        "ttyd", "--port", TTYD_PORT, "--writable", "--base-path", "/",
+        "bash", "--login"
+    ])
+    time.sleep(1)
+    if proc.poll() is None:
+        log(f"[  OK  ] ttyd PID={proc.pid}")
+    else:
+        log("[FAILED] ttyd")
+    return proc
+
+
+def start_ws_bridge():
+    log("starting ws-ssh-bridge on 127.0.0.1:7862 ...")
+    proc = subprocess.Popen([sys.executable, "/ws_ssh_bridge.py"])
+    time.sleep(1)
+    if proc.poll() is None:
+        log(f"[  OK  ] ws-bridge PID={proc.pid}")
+    else:
+        log("[FAILED] ws-bridge")
+    return proc
+
+
+def system_info():
+    log("── System Info ──")
+    rc, out = run("uname -r")
+    if rc == 0:
+        log(f"  Kernel: {out}")
+    rc, out = run("nproc")
+    if rc == 0:
+        log(f"  CPU: {out} cores")
+    rc, out = run("free -h 2>/dev/null | grep Mem: | tr -s ' ' | cut -d' ' -f2")
+    if rc == 0 and out:
+        log(f"  Memory: {out}")
+    rc, out = run("df -h / 2>/dev/null | tail -1 | tr -s ' ' | cut -d' ' -f2,4 | sed 's/ / total, /;s/$/ free/'")
+    if rc == 0 and out:
+        log(f"  Disk: {out}")
+
+
+# ── Heartbeat ─────────────────────────────────────────────────────────
+def heartbeat_loop():
+    while True:
+        time.sleep(60)
+        try:
+            rc, loadavg = run("cat /proc/loadavg 2>/dev/null | cut -d' ' -f1-3")
+            rc2, mem = run("free -h 2>/dev/null | grep Mem: | tr -s ' ' | cut -d' ' -f3,2 | sed 's/ /\\//'")
+            log(f"heartbeat: load={loadavg} mem={mem}")
+        except Exception:
+            log("heartbeat: ok")
+
+
+# ── Main ──────────────────────────────────────────────────────────────
+def main():
+    os.makedirs(PERSIST_PATH, exist_ok=True)
+    open(LOGFILE, "a").close()
+
+    resolve_config()
+    system_info()
+    ensure_dataset_repo()
+    restore_state()
+    restore_packages()
+    ensure_passwords()
+
+    # Write env for other processes
+    with open("/etc/huggingrun.env", "w") as f:
+        f.write(f'export HF_TOKEN="{HF_TOKEN}"\n')
+        f.write(f'export HF_DATASET_REPO="{HF_DATASET_REPO}"\n')
+        f.write(f'export PERSIST_PATH="{PERSIST_PATH}"\n')
+
+    # Start services
+    start_sshd()
+    start_ws_bridge()
+    start_ttyd()
+    start_log_streamer()
+
+    # Background threads
+    threading.Thread(target=sync_loop, daemon=True).start()
+    threading.Thread(target=heartbeat_loop, daemon=True).start()
+
+    log("========================================")
+    log("system ready")
+    log(f"  Terminal: https://<space>.hf.space/")
+    log(f"  Logs:    https://<space>.hf.space/runlog")
+    log(f"  SSE:     https://<space>.hf.space/runlog/stream")
+    log("========================================")
+
+    # Final save on SIGTERM
+    def on_sigterm(sig, frame):
+        log(f"signal {sig} — final save ...")
+        try:
+            save_and_upload()
+        except Exception as e:
+            log(f"final save error: {e}")
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, on_sigterm)
+    signal.signal(signal.SIGINT, on_sigterm)
+
+    # exec nginx — becomes PID 1, opens port 7860
+    log("starting nginx on 0.0.0.0:7860 ...")
+    os.execvp("nginx", ["nginx", "-c", "/etc/nginx/nginx.conf", "-g", "daemon off;"])
+
+
+if __name__ == "__main__":
+    main()

ubuntu-server/nginx.conf → nginx.conf

@@ -22,7 +22,7 @@ http {
     server {
         listen 7860;
 
-        # /ssh → WebSocket-to-SSH bridge (Python asyncio on 7862)
+        # /ssh → WebSocket-to-SSH bridge
         location /ssh {
             proxy_pass http://127.0.0.1:7862;
             proxy_http_version 1.1;
@@ -34,7 +34,6 @@ http {
         }
 
         # /runlog → full log file (static)
-        # Note: /logs and /api/* are intercepted by HF's proxy
         location = /runlog {
             default_type text/plain;
             add_header Cache-Control "no-cache, no-store";
@@ -52,7 +51,7 @@ http {
             proxy_read_timeout 86400;
         }
 
-        # Everything else → ttyd web terminal (on 7681)
+        # Everything else → ttyd web terminal
         location / {
             proxy_pass http://127.0.0.1:7681;
             proxy_http_version 1.1;

scripts/curl_logs.sh

@@ -1,33 +0,0 @@
-#!/bin/bash
-# Stream HF Space runtime/build logs via JWT-based SSE endpoint
-# Usage: ./scripts/curl_logs.sh [run|build]  (default: run)
-# Requires HF_TOKEN in .env or environment
-
-set -e
-cd "$(dirname "$0")/.."
-if [ -f .env ]; then
-  HF_TOKEN="${HF_TOKEN:-$(awk -F= '/^HF_TOKEN=/ {print $2; exit}' .env | tr -d '\r\n" ')}"
-  export HF_TOKEN
-fi
-# Fallback to cached token
-if [ -z "$HF_TOKEN" ] && [ -f ~/.cache/huggingface/token ]; then
-  HF_TOKEN="$(cat ~/.cache/huggingface/token)"
-  export HF_TOKEN
-fi
-if [ -z "$HF_TOKEN" ]; then
-  echo "HF_TOKEN not set (add to .env or export)" >&2
-  exit 1
-fi
-
-SPACE_ID="${SPACE_ID:-tao-shen/HuggingRun}"
-LOG="${1:-run}"
-
-echo "=== Streaming ${LOG} logs for ${SPACE_ID} ===" >&2
-echo "=== Method 1: Direct API (huggingface.co) ===" >&2
-echo "=== Press Ctrl+C to stop ===" >&2
-echo "" >&2
-
-# Method 1: Direct HF API (works for most cases)
-curl -sN \
-  -H "Authorization: Bearer $HF_TOKEN" \
-  "https://huggingface.co/api/spaces/$SPACE_ID/logs/$LOG"

scripts/entrypoint.sh

@@ -1,92 +0,0 @@
-#!/bin/bash
-# ─────────────────────────────────────────────────────────────────────
-# HuggingRun Entrypoint
-# 1. Init: download dataset + restore filesystem (foreground, logs visible)
-# 2. Start sync-loop daemon in background
-# 3. exec user command (start-server.sh opens port 7860)
-# ─────────────────────────────────────────────────────────────────────
-set -e
-
-LOGFILE="/var/log/huggingrun.log"
-touch "$LOGFILE"
-
-# Log to stderr (HF captures stderr for Docker SDK spaces) + logfile
-log() {
-    echo "$@" >&2
-    echo "$@" >> "$LOGFILE"
-}
-
-log "========================================"
-log "[entrypoint] HuggingRun starting ..."
-log "[entrypoint] Date: $(date -u)"
-log "[entrypoint] SPACE_ID=${SPACE_ID:-not set}"
-log "[entrypoint] HF_TOKEN=${HF_TOKEN:+set (${#HF_TOKEN} chars)}${HF_TOKEN:-NOT SET}"
-log "[entrypoint] HF_DATASET_REPO=${HF_DATASET_REPO:-not set}"
-log "[entrypoint] PERSIST_PATH=${PERSIST_PATH:-/data}"
-log "[entrypoint] RUN_CMD=${RUN_CMD:-default}"
-log "========================================"
-
-# Determine dataset repo
-if [ -z "$HF_DATASET_REPO" ]; then
-    if [ -n "$SPACE_ID" ]; then
-        export HF_DATASET_REPO="${SPACE_ID}-data"
-        log "[entrypoint] Auto-set HF_DATASET_REPO=${HF_DATASET_REPO}"
-    elif [ -n "$HF_TOKEN" ]; then
-        log "[entrypoint] Resolving HF_DATASET_REPO from token ..."
-        export HF_DATASET_REPO=$(python3 -c "
-from huggingface_hub import HfApi
-import os
-try:
-    name = HfApi(token=os.environ['HF_TOKEN']).whoami()['name']
-    print(name + '/HuggingRun-data')
-except:
-    print('')
-" 2>/dev/null)
-        log "[entrypoint] Resolved: ${HF_DATASET_REPO}"
-    fi
-fi
-
-# Ensure dataset repo exists
-if [ -n "$HF_TOKEN" ] && [ -n "$HF_DATASET_REPO" ]; then
-    log "[entrypoint] Verifying dataset: ${HF_DATASET_REPO} ..."
-    python3 -c "
-from huggingface_hub import HfApi
-import os
-api = HfApi(token=os.environ['HF_TOKEN'])
-repo = os.environ['HF_DATASET_REPO']
-try:
-    api.repo_info(repo_id=repo, repo_type='dataset')
-    print(f'[entrypoint] Dataset exists: {repo}', flush=True)
-except:
-    api.create_repo(repo_id=repo, repo_type='dataset', private=True)
-    print(f'[entrypoint] Created dataset: {repo}', flush=True)
-" 2>&1 || echo "[entrypoint] WARNING: Could not verify dataset" >&2
-else
-    log "[entrypoint] WARNING: persistence disabled (no token/repo)"
-fi
-
-# Write env for other processes
-cat > /etc/huggingrun.env << ENVEOF
-export HF_TOKEN="${HF_TOKEN}"
-export HF_DATASET_REPO="${HF_DATASET_REPO}"
-export PERSIST_PATH="${PERSIST_PATH:-/data}"
-ENVEOF
-log "[entrypoint] Wrote /etc/huggingrun.env"
-
-# Step 1: Init — download dataset + restore filesystem (foreground so logs are visible)
-log "[entrypoint] ── Step 1: Init (download + restore) ──"
-python3 -u /scripts/git_sync_daemon.py init
-log "[entrypoint] ── Init done ──"
-
-# Step 2: Start background sync-loop daemon
-log "[entrypoint] ── Step 2: Starting sync-loop daemon ──"
-python3 -u /scripts/git_sync_daemon.py sync-loop &
-SYNC_PID=$!
-log "[entrypoint] Sync daemon PID=${SYNC_PID}"
-
-# Step 3: Run user command (opens port 7860)
-CMD="${RUN_CMD:-python3 /app/demo_app.py}"
-log "[entrypoint] ── Step 3: exec user command ──"
-log "[entrypoint] CMD=${CMD}"
-log "========================================"
-exec $CMD

scripts/entrypoint_wrapper.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-"""PID 1 wrapper for HuggingRun.
-
-HF's runtime log SSE captures stdout from PID 1. Gradio (Python) apps work.
-Bash entrypoints do not. This Python wrapper becomes PID 1 and ensures all
-subprocess output is captured and forwarded to stdout.
-"""
-import os
-import signal
-import subprocess
-import sys
-import threading
-
-def stream_pipe(pipe, prefix=""):
-    """Read lines from a pipe and print them to stdout (flushed)."""
-    for line in iter(pipe.readline, b""):
-        text = line.decode("utf-8", errors="replace").rstrip("\n")
-        print(f"{prefix}{text}", flush=True)
-    pipe.close()
-
-def main():
-    print("[wrapper] PID 1 Python wrapper starting", flush=True)
-    print(f"[wrapper] Python {sys.version}", flush=True)
-    print(f"[wrapper] PID={os.getpid()}", flush=True)
-
-    # Run the real entrypoint as a subprocess, capture its output
-    proc = subprocess.Popen(
-        ["/bin/bash", "/scripts/entrypoint.sh"],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,  # merge stderr into stdout
-        bufsize=0,  # unbuffered
-    )
-
-    # Forward signals
-    def forward_signal(sig, frame):
-        print(f"[wrapper] Forwarding signal {sig} to PID {proc.pid}", flush=True)
-        proc.send_signal(sig)
-
-    signal.signal(signal.SIGTERM, forward_signal)
-    signal.signal(signal.SIGINT, forward_signal)
-
-    # Stream output in a thread
-    t = threading.Thread(target=stream_pipe, args=(proc.stdout,), daemon=True)
-    t.start()
-
-    # Wait for process
-    proc.wait()
-    t.join(timeout=2)
-    print(f"[wrapper] entrypoint.sh exited with code {proc.returncode}", flush=True)
-    sys.exit(proc.returncode)
-
-if __name__ == "__main__":
-    main()

scripts/ssh_connect.sh

@@ -1,38 +0,0 @@
-#!/usr/bin/env bash
-# ─────────────────────────────────────────────────────────────────────
-# SSH into HuggingRun via WebSocket (single port 7860)
-# No jumphost needed — SSH tunnels through the HF Space's web port.
-#
-# Prerequisites:
-#   brew install websocat        # macOS
-#   # or download from https://github.com/nicehash/websocat/releases
-#
-# Usage:
-#   bash scripts/ssh_connect.sh                    # default: tao-shen-huggingrun.hf.space
-#   bash scripts/ssh_connect.sh my-space.hf.space  # custom space URL
-#   SSH_USER=root bash scripts/ssh_connect.sh      # login as root
-# ─────────────────────────────────────────────────────────────────────
-set -euo pipefail
-
-SPACE_HOST="${1:-tao-shen-huggingrun.hf.space}"
-SSH_USER="${SSH_USER:-user}"
-WS_URL="wss://${SPACE_HOST}/ssh"
-
-# Check websocat
-if ! command -v websocat &>/dev/null; then
-    echo "websocat not found. Install it:"
-    echo "  macOS:  brew install websocat"
-    echo "  Linux:  curl -L -o ~/.local/bin/websocat https://github.com/nicehash/websocat/releases/latest/download/websocat.x86_64-unknown-linux-musl && chmod +x ~/.local/bin/websocat"
-    exit 1
-fi
-
-echo "Connecting to ${SSH_USER}@${SPACE_HOST} via WebSocket SSH ..."
-echo "  WebSocket: ${WS_URL}"
-echo "  Password:  huggingrun"
-echo ""
-
-# SSH with WebSocket as ProxyCommand
-ssh -o "ProxyCommand=websocat --binary ${WS_URL}" \
-    -o StrictHostKeyChecking=no \
-    -o UserKnownHostsFile=/dev/null \
-    "${SSH_USER}@huggingrun"

scripts/stream_logs.py

@@ -1,105 +0,0 @@
-#!/usr/bin/env python3
-"""Stream HF Space runtime logs via JWT-authenticated SSE endpoint.
-
-Usage:
-    python3 scripts/stream_logs.py [run|build]
-
-This uses the same endpoint as the HF web UI's "Container logs" tab:
-  1. Fetch JWT from https://huggingface.co/api/spaces/{id}/jwt
-  2. Stream SSE from https://api.hf.space/v1/{id}/logs/{level}
-"""
-import json
-import os
-import sys
-
-def get_token():
-    """Get HF token from env, .env file, or cached token."""
-    token = os.environ.get("HF_TOKEN", "")
-    if not token:
-        env_file = os.path.join(os.path.dirname(__file__), "..", ".env")
-        if os.path.exists(env_file):
-            for line in open(env_file):
-                if line.startswith("HF_TOKEN="):
-                    token = line.split("=", 1)[1].strip().strip('"').strip("'")
-                    break
-    if not token:
-        cached = os.path.expanduser("~/.cache/huggingface/token")
-        if os.path.exists(cached):
-            token = open(cached).read().strip()
-    return token
-
-def stream_logs(space_id, level="run"):
-    import requests
-
-    token = get_token()
-    if not token:
-        print("ERROR: HF_TOKEN not found", file=sys.stderr)
-        sys.exit(1)
-
-    print(f"=== Streaming {level} logs for {space_id} ===", file=sys.stderr)
-
-    # Step 1: Get JWT token
-    print("Fetching JWT token...", file=sys.stderr)
-    resp = requests.get(
-        f"https://huggingface.co/api/spaces/{space_id}/jwt",
-        headers={"Authorization": f"Bearer {token}"},
-    )
-    if resp.status_code != 200:
-        print(f"JWT fetch failed ({resp.status_code}): {resp.text}", file=sys.stderr)
-        print("Falling back to direct API...", file=sys.stderr)
-        # Fallback to direct API
-        resp = requests.get(
-            f"https://huggingface.co/api/spaces/{space_id}/logs/{level}",
-            headers={"Authorization": f"Bearer {token}"},
-            stream=True,
-        )
-        for line in resp.iter_lines():
-            if line:
-                line = line.decode("utf-8", errors="replace")
-                if line.startswith("data: "):
-                    try:
-                        event = json.loads(line[6:])
-                        ts = event.get("timestamp", "")
-                        data = event.get("data", "")
-                        print(f"[{ts}] {data}", end="", flush=True)
-                    except json.JSONDecodeError:
-                        print(line, flush=True)
-                else:
-                    print(line, flush=True)
-        return
-
-    jwt = resp.json()["token"]
-    print(f"JWT obtained (expires in token payload)", file=sys.stderr)
-
-    # Step 2: Stream logs via SSE
-    print(f"Connecting to api.hf.space SSE stream...", file=sys.stderr)
-    print("---", file=sys.stderr)
-
-    resp = requests.get(
-        f"https://api.hf.space/v1/{space_id}/logs/{level}",
-        headers={"Authorization": f"Bearer {jwt}"},
-        stream=True,
-    )
-
-    if resp.status_code != 200:
-        print(f"SSE stream failed ({resp.status_code}): {resp.text}", file=sys.stderr)
-        sys.exit(1)
-
-    for line in resp.iter_lines():
-        if line:
-            line = line.decode("utf-8", errors="replace")
-            if line.startswith("data: "):
-                try:
-                    event = json.loads(line[6:])
-                    ts = event.get("timestamp", "")
-                    data = event.get("data", "")
-                    print(f"[{ts}] {data}", end="", flush=True)
-                except json.JSONDecodeError:
-                    print(line, flush=True)
-            else:
-                print(line, flush=True)
-
-if __name__ == "__main__":
-    space_id = os.environ.get("SPACE_ID", "tao-shen/HuggingRun")
-    level = sys.argv[1] if len(sys.argv) > 1 else "run"
-    stream_logs(space_id, level)

scripts/sync_hf.py

@@ -1,233 +0,0 @@
-#!/usr/bin/env python3
-"""
-HuggingRun — Generic persistence for any app on Hugging Face Spaces
-====================================================================
-
-- Startup: snapshot_download from HF Dataset → PERSIST_PATH
-- Periodic: upload_folder PERSIST_PATH → dataset
-- Shutdown: final upload
-- Then: exec user's RUN_CMD (or default demo app)
-"""
-
-import os
-import sys
-import time
-import threading
-import subprocess
-import signal
-import shutil
-import tempfile
-import traceback
-from pathlib import Path
-from datetime import datetime
-
-os.environ.setdefault("HF_HUB_DOWNLOAD_TIMEOUT", "300")
-os.environ.setdefault("HF_HUB_UPLOAD_TIMEOUT", "600")
-
-from huggingface_hub import HfApi, snapshot_download
-
-# ── Configuration ───────────────────────────────────────────────────────────
-# See docs/HF_LIMITATIONS.md for how HuggingRun addresses HF Spaces limits.
-
-HF_TOKEN = os.environ.get("HF_TOKEN")
-PERSIST_PATH = Path(os.environ.get("PERSIST_PATH", "/data"))
-RUN_CMD = os.environ.get("RUN_CMD", "")
-APP_PORT = os.environ.get("APP_PORT", os.environ.get("PORT", "7860"))  # Single port exposed by HF
-SYNC_INTERVAL = int(os.environ.get("SYNC_INTERVAL", "60"))
-AUTO_CREATE_DATASET = os.environ.get("AUTO_CREATE_DATASET", "false").lower() in ("true", "1", "yes")
-# Store directly at dataset root (no subfolder)
-DATASET_SUBFOLDER = ""
-
-SPACE_ID = os.environ.get("SPACE_ID", "")
-HF_REPO_ID = os.environ.get("HF_DATASET_REPO", "")
-if not HF_REPO_ID and SPACE_ID:
-    HF_REPO_ID = f"{SPACE_ID}-data"
-if not HF_REPO_ID and HF_TOKEN:
-    try:
-        api = HfApi(token=HF_TOKEN)
-        uname = api.whoami()["name"]
-        HF_REPO_ID = f"{uname}/HuggingRun-data"
-        del api, uname
-    except Exception:
-        HF_REPO_ID = ""
-
-
-class GenericSync:
-    """Upload/download PERSIST_PATH to/from HF Dataset."""
-
-    def __init__(self):
-        self.enabled = False
-        self.dataset_exists = False
-        self.api = None
-
-        if not HF_TOKEN:
-            print("[HuggingRun] HF_TOKEN not set. Persistence disabled.")
-            return
-        if not HF_REPO_ID:
-            print("[HuggingRun] HF_DATASET_REPO/SPACE_ID not set. Persistence disabled.")
-            return
-
-        self.enabled = True
-        self.api = HfApi(token=HF_TOKEN)
-        self.dataset_exists = self._ensure_repo_exists()
-
-    def _ensure_repo_exists(self):
-        try:
-            self.api.repo_info(repo_id=HF_REPO_ID, repo_type="dataset")
-            print(f"[HuggingRun] Dataset found: {HF_REPO_ID}")
-            return True
-        except Exception:
-            if not AUTO_CREATE_DATASET:
-                print(f"[HuggingRun] Dataset not found: {HF_REPO_ID}. Set AUTO_CREATE_DATASET=true to create.")
-                return False
-            try:
-                self.api.create_repo(
-                    repo_id=HF_REPO_ID,
-                    repo_type="dataset",
-                    private=True,
-                )
-                print(f"[HuggingRun] Created dataset: {HF_REPO_ID}")
-                return True
-            except Exception as e:
-                print(f"[HuggingRun] Failed to create dataset: {e}")
-                return False
-
-    def load_from_repo(self):
-        """Download dataset → PERSIST_PATH."""
-        if not self.enabled or not self.dataset_exists:
-            PERSIST_PATH.mkdir(parents=True, exist_ok=True)
-            return
-
-        try:
-            files = self.api.list_repo_files(repo_id=HF_REPO_ID, repo_type="dataset")
-            # Filter out metadata files (.gitattributes, README.md, etc.)
-            data_files = [f for f in files if not f.startswith(".") and f != "README.md"]
-            if not data_files:
-                print(f"[HuggingRun] Dataset empty. Starting fresh.")
-                PERSIST_PATH.mkdir(parents=True, exist_ok=True)
-                return
-
-            print(f"[HuggingRun] Restoring {PERSIST_PATH} from {HF_REPO_ID} ({len(data_files)} files) ...")
-            PERSIST_PATH.mkdir(parents=True, exist_ok=True)
-            for attempt in range(2):
-                try:
-                    snapshot_download(
-                        repo_id=HF_REPO_ID,
-                        repo_type="dataset",
-                        local_dir=str(PERSIST_PATH),
-                        token=HF_TOKEN,
-                        ignore_patterns=[".git*", "README.md"],
-                    )
-                    break
-                except Exception as e:
-                    if attempt == 0:
-                        print(f"[HuggingRun] Restore attempt {attempt + 1} failed: {e}. Retrying...")
-                        time.sleep(3)
-                    else:
-                        raise
-            print("[HuggingRun] Restore completed.")
-        except Exception as e:
-            print(f"[HuggingRun] Restore failed: {e}")
-            traceback.print_exc()
-            PERSIST_PATH.mkdir(parents=True, exist_ok=True)
-
-    def save_to_repo(self):
-        """Upload PERSIST_PATH → dataset root."""
-        if not self.enabled or not self.dataset_exists:
-            return
-        if not PERSIST_PATH.exists():
-            return
-
-        try:
-            if not self._ensure_repo_exists():
-                return
-            self.api.upload_folder(
-                folder_path=str(PERSIST_PATH),
-                path_in_repo="",  # directly at dataset root
-                repo_id=HF_REPO_ID,
-                repo_type="dataset",
-                token=HF_TOKEN,
-                commit_message=f"HuggingRun sync — {datetime.now().isoformat()}",
-                ignore_patterns=["__pycache__", "*.pyc", ".git", ".git*"],
-            )
-            print(f"[HuggingRun] Upload completed.")
-        except Exception as e:
-            print(f"[HuggingRun] Upload failed: {e}")
-            traceback.print_exc()
-
-    def background_sync_loop(self, stop_event):
-        while not stop_event.is_set():
-            if stop_event.wait(timeout=SYNC_INTERVAL):
-                break
-            self.save_to_repo()
-
-    def run_user_cmd(self):
-        """Run RUN_CMD (or default demo). Returns Popen process or None."""
-        cmd = (RUN_CMD or "python3 /app/demo_app.py").strip()
-        if not cmd:
-            print("[HuggingRun] RUN_CMD empty and no default demo. Exiting.")
-            return None
-        print(f"[HuggingRun] Running: {cmd}")
-        try:
-            env = os.environ.copy()
-            env.setdefault("PORT", APP_PORT)
-            env.setdefault("APP_PORT", APP_PORT)
-            process = subprocess.Popen(
-                cmd,
-                shell=True,
-                env=env,
-                stdout=sys.stdout,
-                stderr=sys.stderr,
-            )
-            print(f"[HuggingRun] Process started PID={process.pid}")
-            return process
-        except Exception as e:
-            print(f"[HuggingRun] Failed to start: {e}")
-            traceback.print_exc()
-            return None
-
-
-def main():
-    try:
-        sync = GenericSync()
-        sync.load_from_repo()
-
-        stop_event = threading.Event()
-        t = threading.Thread(target=sync.background_sync_loop, args=(stop_event,), daemon=True)
-        t.start()
-
-        process = sync.run_user_cmd()
-        if process is None:
-            stop_event.set()
-            t.join(timeout=5)
-            sys.exit(1)
-
-        def on_signal(sig, frame):
-            print(f"\n[HuggingRun] Signal {sig}. Shutting down...")
-            stop_event.set()
-            t.join(timeout=10)
-            if process.poll() is None:
-                process.terminate()
-                try:
-                    process.wait(timeout=5)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-            sync.save_to_repo()
-            sys.exit(0)
-
-        signal.signal(signal.SIGINT, on_signal)
-        signal.signal(signal.SIGTERM, on_signal)
-
-        code = process.wait()
-        stop_event.set()
-        t.join(timeout=10)
-        sync.save_to_repo()
-        sys.exit(code)
-    except Exception as e:
-        print(f"[HuggingRun] FATAL: {e}")
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

scripts/test_local.sh

@@ -1,143 +0,0 @@
-#!/usr/bin/env bash
-# ─────────────────────────────────────────────────────────────────────
-# HuggingRun: Local integration test for Ubuntu Server
-# Build Docker → run container → wait → test ttyd + SSH + persistence stress → cleanup
-# Exit 0 only when ALL tests pass. Iterative TDD style.
-#
-# Usage:
-#   bash scripts/test_local.sh              # full run
-#   SKIP_BUILD=1 bash scripts/test_local.sh # reuse existing image
-# ─────────────────────────────────────────────────────────────────────
-set -euo pipefail
-
-REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-cd "$REPO_ROOT"
-
-IMAGE_NAME="huggingrun-ubuntu-server-test"
-CONTAINER_NAME="huggingrun-test-$$"
-TTYD_PORT=7860
-SSH_PORT=2222
-HOST_TTYD_PORT="${HOST_TTYD_PORT:-17860}"
-HOST_SSH_PORT="${HOST_SSH_PORT:-12222}"
-MAX_WAIT=120  # seconds to wait for services to be ready
-SSH_USER="user"
-SSH_STRESS_N="${SSH_STRESS_N:-30}"
-SSH_CONCURRENCY="${SSH_CONCURRENCY:-10}"
-
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m'
-
-cleanup() {
-    echo ""
-    echo -e "${YELLOW}[cleanup] Stopping and removing container ${CONTAINER_NAME}...${NC}"
-    docker stop "$CONTAINER_NAME" 2>/dev/null || true
-    docker rm -f "$CONTAINER_NAME" 2>/dev/null || true
-}
-trap cleanup EXIT
-
-# ── Phase 0: Build ──────────────────────────────────────────────────
-if [ "${SKIP_BUILD:-}" != "1" ]; then
-    echo -e "${YELLOW}[build] Building Docker image: ${IMAGE_NAME}${NC}"
-    docker build -t "$IMAGE_NAME" . 2>&1 | tail -20
-    echo -e "${GREEN}[build] Image built successfully${NC}"
-else
-    echo -e "${YELLOW}[build] SKIP_BUILD=1, using existing image${NC}"
-fi
-
-# ── Phase 1: Run container ──────────────────────────────────────────
-echo ""
-echo -e "${YELLOW}[run] Starting container: ${CONTAINER_NAME}${NC}"
-echo -e "${YELLOW}[run]   ttyd: localhost:${HOST_TTYD_PORT} → :${TTYD_PORT}${NC}"
-echo -e "${YELLOW}[run]   SSH:  localhost:${HOST_SSH_PORT} → :${SSH_PORT}${NC}"
-
-docker run -d \
-    --name "$CONTAINER_NAME" \
-    -p "${HOST_TTYD_PORT}:${TTYD_PORT}" \
-    -p "${HOST_SSH_PORT}:${SSH_PORT}" \
-    -e SSH_LISTEN=0.0.0.0 \
-    -e SSH_PORT=${SSH_PORT} \
-    "$IMAGE_NAME"
-
-echo -e "${GREEN}[run] Container started${NC}"
-
-# ── Phase 2: Wait for ttyd web terminal ──────────────────────────────
-echo ""
-echo -e "${YELLOW}[wait] Waiting for ttyd on localhost:${HOST_TTYD_PORT} (max ${MAX_WAIT}s)...${NC}"
-START=$(date +%s)
-TTYD_READY=false
-while [ $(($(date +%s) - START)) -lt "$MAX_WAIT" ]; do
-    HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" "http://localhost:${HOST_TTYD_PORT}/" 2>/dev/null || echo "000")
-    if [ "$HTTP_CODE" = "200" ]; then
-        TTYD_READY=true
-        break
-    fi
-    echo -e "  ttyd not ready (HTTP ${HTTP_CODE}), waiting 3s..."
-    sleep 3
-done
-
-if [ "$TTYD_READY" = false ]; then
-    echo -e "${RED}[FAIL] ttyd did not become ready within ${MAX_WAIT}s${NC}"
-    echo ""
-    echo "=== Container logs (last 50 lines) ==="
-    docker logs --tail 50 "$CONTAINER_NAME" 2>&1
-    exit 1
-fi
-echo -e "${GREEN}[wait] ttyd is ready (HTTP 200)${NC}"
-
-# ── Phase 3: Wait for SSH ───────────────────────────────────────────
-echo ""
-echo -e "${YELLOW}[wait] Waiting for SSH on localhost:${HOST_SSH_PORT} (max 60s)...${NC}"
-START=$(date +%s)
-SSH_READY=false
-while [ $(($(date +%s) - START)) -lt 60 ]; do
-    if ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
-           -o ConnectTimeout=3 -o LogLevel=ERROR \
-           -p "$HOST_SSH_PORT" "${SSH_USER}@localhost" "echo ok" 2>/dev/null | grep -q "ok"; then
-        SSH_READY=true
-        break
-    fi
-    echo "  SSH not ready, waiting 3s..."
-    sleep 3
-done
-
-if [ "$SSH_READY" = false ]; then
-    echo -e "${RED}[FAIL] SSH did not become ready within 60s${NC}"
-    echo ""
-    echo "=== Container logs (last 50 lines) ==="
-    docker logs --tail 50 "$CONTAINER_NAME" 2>&1
-    exit 1
-fi
-echo -e "${GREEN}[wait] SSH is ready${NC}"
-
-# ── Phase 4: Run HTTP tests (ttyd) ──────────────────────────────────
-echo ""
-echo -e "${YELLOW}[test] Phase 4: HTTP basic + stress test on ttyd${NC}"
-python3 scripts/monitor_and_test.py \
-    --test \
-    --url "http://localhost:${HOST_TTYD_PORT}" \
-    --expect "ttyd" --expect "terminal" \
-    --stress-n 50
-echo -e "${GREEN}[test] HTTP tests PASSED${NC}"
-
-# ── Phase 5: Run SSH + persistence stress tests ─────────────────────
-echo ""
-echo -e "${YELLOW}[test] Phase 5: SSH connect + command + stress + persistence${NC}"
-python3 scripts/monitor_and_test.py \
-    --ssh-test \
-    --ssh-host localhost \
-    --ssh-port "$HOST_SSH_PORT" \
-    --ssh-user "$SSH_USER" \
-    --ssh-stress-n "$SSH_STRESS_N" \
-    --ssh-concurrency "$SSH_CONCURRENCY"
-echo -e "${GREEN}[test] SSH + persistence tests PASSED${NC}"
-
-# ── Summary ─────────────────────────────────────────────────────────
-echo ""
-echo "============================================================"
-echo -e "${GREEN}  ALL TESTS PASSED${NC}"
-echo ""
-echo "  Web terminal: http://localhost:${HOST_TTYD_PORT}/"
-echo "  SSH access:   ssh -p ${HOST_SSH_PORT} ${SSH_USER}@localhost"
-echo "============================================================"

ubuntu-server/git_sync_daemon.py

@@ -1,369 +0,0 @@
-#!/usr/bin/env python3
-"""
-git_sync_daemon.py — Full disk persistence via HuggingFace Dataset
-
-Usage:
-  python3 git_sync_daemon.py init      # Download dataset → restore filesystem
-  python3 git_sync_daemon.py sync-loop # Background sync loop
-  python3 git_sync_daemon.py save      # One-time save + upload
-
-Dataset = disk. The dataset stores the entire filesystem under rootfs/.
-On startup: download dataset → rsync rootfs/ → /
-On sync: rsync / → rootfs/ → upload to dataset
-"""
-
-import os
-import sys
-import time
-import subprocess
-import signal
-import shutil
-import threading
-
-# ── Config ─────────────────────────────────────────────────────────
-PERSIST_PATH = os.environ.get("PERSIST_PATH", "/data")
-HF_TOKEN = os.environ.get("HF_TOKEN", "")
-HF_DATASET_REPO = os.environ.get("HF_DATASET_REPO", "")
-ROOTFS = os.path.join(PERSIST_PATH, "rootfs")
-
-SYNC_INTERVAL = int(os.environ.get("SYNC_INTERVAL", "120"))
-
-# SAVE: only persist these directories (user data + config).
-# System dirs (/bin, /lib, /usr/bin, etc.) come from Docker image;
-# restoring them breaks permissions since HF git doesn't preserve mode bits.
-PERSIST_DIRS = [
-    "/home", "/root", "/etc", "/opt", "/var",
-    "/usr/local",
-]
-
-# Paths to never touch (Docker-managed or virtual)
-SAVE_EXCLUDES = [
-    "/etc/hostname", "/etc/hosts", "/etc/resolv.conf", "/etc/mtab",
-    "/etc/nginx",       # comes from Docker image; don't overwrite with stale config
-    "/etc/ssh/sshd_config",
-    "*.sock", "__pycache__", "*.pyc",
-    ".cache",           # HF API rejects files under .cache/ paths
-]
-
-UPLOAD_IGNORE = [
-    "__pycache__", "*.pyc",
-    ".git", ".git*",
-    "*.sock", "*.lock",
-    ".huggingface",
-    ".cache",
-]
-
-
-LOGFILE = "/var/log/huggingrun.log"
-
-def log(msg):
-    ts = time.strftime("%H:%M:%S", time.gmtime())
-    line = f"[sync {ts}] {msg}"
-    print(line, file=sys.stderr, flush=True)
-    try:
-        with open(LOGFILE, "a") as f:
-            f.write(line + "\n")
-    except Exception:
-        pass
-
-
-def run(cmd, cwd=None):
-    """Run a shell command, return (returncode, stdout). Logs the command."""
-    log(f"  $ {cmd}")
-    t0 = time.time()
-    r = subprocess.run(
-        cmd, shell=True, cwd=cwd,
-        stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
-    )
-    elapsed = time.time() - t0
-    if r.returncode != 0:
-        log(f"  ✗ exit={r.returncode} ({elapsed:.1f}s)")
-        if r.stdout.strip():
-            for line in r.stdout.strip().split('\n')[:10]:
-                log(f"    {line}")
-    else:
-        log(f"  ✓ ({elapsed:.1f}s)")
-    return r.returncode, r.stdout.strip()
-
-
-def disk_usage(path):
-    """Get disk usage of a path in human-readable form."""
-    try:
-        total = 0
-        count = 0
-        for dirpath, dirnames, filenames in os.walk(path):
-            count += len(filenames)
-            for f in filenames:
-                fp = os.path.join(dirpath, f)
-                try:
-                    total += os.path.getsize(fp)
-                except OSError:
-                    pass
-        if total > 1024 * 1024 * 1024:
-            return f"{total / 1024 / 1024 / 1024:.1f}GB, {count} files"
-        return f"{total / 1024 / 1024:.0f}MB, {count} files"
-    except Exception:
-        return "unknown"
-
-
-def download_dataset():
-    """Download the full dataset to PERSIST_PATH using huggingface_hub."""
-    from huggingface_hub import snapshot_download
-
-    log(f"── DOWNLOAD: {HF_DATASET_REPO} → {PERSIST_PATH}")
-    log(f"  Token: {HF_TOKEN[:10]}...{HF_TOKEN[-4:]}" if len(HF_TOKEN) > 14 else "  Token: (short)")
-    t0 = time.time()
-    try:
-        path = snapshot_download(
-            repo_id=HF_DATASET_REPO,
-            repo_type="dataset",
-            local_dir=PERSIST_PATH,
-            token=HF_TOKEN,
-        )
-        elapsed = time.time() - t0
-        log(f"  Download OK → {path} ({elapsed:.1f}s)")
-        # Show what was downloaded
-        if os.path.isdir(PERSIST_PATH):
-            items = os.listdir(PERSIST_PATH)
-            log(f"  /data contents: {items}")
-        if os.path.isdir(ROOTFS):
-            items = os.listdir(ROOTFS)
-            log(f"  /data/rootfs dirs: {len(items)} → {items[:10]}")
-            log(f"  /data/rootfs size: {disk_usage(ROOTFS)}")
-        else:
-            log(f"  /data/rootfs: does not exist")
-    except Exception as e:
-        elapsed = time.time() - t0
-        log(f"  ✗ Download failed ({elapsed:.1f}s): {e}")
-        os.makedirs(PERSIST_PATH, exist_ok=True)
-
-
-def restore_system():
-    """Restore only user directories from /data/rootfs/ → /."""
-    log("── RESTORE: targeted directories only")
-    if not os.path.isdir(ROOTFS):
-        log(f"  ✗ {ROOTFS} does not exist, starting fresh")
-        os.makedirs(ROOTFS, exist_ok=True)
-        return
-
-    excludes = " ".join(f"--exclude='{e}'" for e in SAVE_EXCLUDES)
-    restored = 0
-    # Dirs with executables get F755; others get F644
-    exec_dirs = {"/usr/local", "/opt"}
-    for d in PERSIST_DIRS:
-        src = os.path.join(ROOTFS, d.lstrip("/"))
-        if not os.path.isdir(src):
-            continue
-        os.makedirs(d, exist_ok=True)
-        fmode = "F755" if d in exec_dirs else "F644"
-        cmd = (f"rsync -rlD --no-specials --no-devices "
-               f"--no-perms --chmod=D755,{fmode} "
-               f"{excludes} {src}/ {d}/")
-        t0 = time.time()
-        rc, out = run(cmd)
-        elapsed = time.time() - t0
-        status = "OK" if rc == 0 else f"rc={rc}"
-        log(f"  {d}: {status} ({elapsed:.1f}s)")
-        restored += 1
-
-    if restored == 0:
-        log("  No directories to restore (fresh start)")
-    else:
-        log(f"  Restored {restored} directories")
-
-
-def restore_packages():
-    """Reinstall user-added packages from saved package list."""
-    pkg_list = os.path.join(PERSIST_PATH, "user-packages.list")
-    base_list = "/etc/base-packages.list"
-    if not os.path.exists(pkg_list):
-        log("── PACKAGES: no saved package list, skipping")
-        return
-    if not os.path.exists(base_list):
-        log("── PACKAGES: no base package list, skipping")
-        return
-    log("── PACKAGES: checking for user-installed packages")
-    try:
-        with open(base_list) as f:
-            base = set(f.read().strip().split("\n"))
-        with open(pkg_list) as f:
-            saved = set(f.read().strip().split("\n"))
-        to_install = sorted(saved - base)
-        if not to_install:
-            log("  No additional packages to install")
-            return
-        log(f"  {len(to_install)} packages to reinstall: {to_install[:10]}...")
-        run(f"apt-get update -qq && apt-get install -y --no-install-recommends {' '.join(to_install)}")
-    except Exception as e:
-        log(f"  ✗ Package restore error: {e}")
-
-
-def save_package_list():
-    """Save list of currently installed packages for restore."""
-    pkg_list = os.path.join(PERSIST_PATH, "user-packages.list")
-    try:
-        rc, out = run("dpkg-query -W -f='${Package}\\n'")
-        if rc == 0 and out:
-            with open(pkg_list, "w") as f:
-                f.write(out + "\n")
-    except Exception as e:
-        log(f"  ✗ Package list save error: {e}")
-
-
-def ensure_passwords():
-    """Re-ensure user/root passwords after restore."""
-    log("── PASSWORDS")
-    run("id user >/dev/null 2>&1 || useradd -m -s /bin/bash user")
-    run('usermod -p "$(openssl passwd -6 huggingrun)" user')
-    run('usermod -p "$(openssl passwd -6 huggingrun)" root')
-    run("ldconfig")
-    log("  Passwords set for user + root")
-
-
-def save_and_upload():
-    """Rsync filesystem → rootfs, upload to dataset."""
-    from huggingface_hub import HfApi
-
-    log("══════════════════════════════════════════════")
-    log("── SAVE: targeted directories → /data/rootfs/")
-    os.makedirs(ROOTFS, exist_ok=True)
-    save_package_list()
-
-    excludes = " ".join(f"--exclude='{e}'" for e in SAVE_EXCLUDES)
-    t0_all = time.time()
-    for d in PERSIST_DIRS:
-        if not os.path.isdir(d):
-            continue
-        dst = os.path.join(ROOTFS, d.lstrip("/"))
-        os.makedirs(dst, exist_ok=True)
-        cmd = (f"rsync -rlD --no-specials --no-devices --delete "
-               f"{excludes} {d}/ {dst}/")
-        rc, out = run(cmd)
-    elapsed = time.time() - t0_all
-    log(f"  rsync done ({elapsed:.1f}s)")
-    log(f"  rootfs size: {disk_usage(ROOTFS)}")
-
-    # Clean up dirs that HF API rejects
-    for reject_dir in [".cache"]:
-        for dirpath, dirnames, filenames in os.walk(ROOTFS):
-            for d in list(dirnames):
-                if d == reject_dir:
-                    full = os.path.join(dirpath, d)
-                    log(f"  Removing {full} (rejected by HF API)")
-                    shutil.rmtree(full, ignore_errors=True)
-                    dirnames.remove(d)
-
-    log("── UPLOAD: /data → dataset")
-    api = HfApi(token=HF_TOKEN)
-    ts = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
-    log(f"  repo={HF_DATASET_REPO}, method=upload_folder")
-    log(f"  ignore={UPLOAD_IGNORE}")
-
-    t0 = time.time()
-    try:
-        api.upload_folder(
-            folder_path=PERSIST_PATH,
-            repo_id=HF_DATASET_REPO,
-            repo_type="dataset",
-            path_in_repo="",
-            commit_message=f"sync {ts}",
-            ignore_patterns=UPLOAD_IGNORE,
-        )
-        elapsed = time.time() - t0
-        log(f"  ✓ Upload completed ({elapsed:.1f}s)")
-    except Exception as e:
-        elapsed = time.time() - t0
-        log(f"  ✗ Upload failed ({elapsed:.1f}s): {e}")
-
-    log("══════════════════════════════════════════════")
-
-
-def cmd_init():
-    """Run once at startup: download dataset + restore filesystem."""
-    log("╔══════════════════════════════════════════════╗")
-    log("║          INIT — Full Disk Persistence        ║")
-    log("╚══════════════════════════════════════════════╝")
-    log(f"  HF_TOKEN: {'set (' + HF_TOKEN[:10] + '...)' if HF_TOKEN else 'NOT SET'}")
-    log(f"  HF_DATASET_REPO: {HF_DATASET_REPO or 'NOT SET'}")
-    log(f"  PERSIST_PATH: {PERSIST_PATH}")
-    log(f"  ROOTFS: {ROOTFS}")
-    log(f"  SYNC_INTERVAL: {SYNC_INTERVAL}s")
-    log(f"  PERSIST_DIRS: {PERSIST_DIRS}")
-
-    if not HF_TOKEN or not HF_DATASET_REPO:
-        log("  ✗ No HF_TOKEN or HF_DATASET_REPO — persistence DISABLED")
-        os.makedirs(PERSIST_PATH, exist_ok=True)
-        return
-
-    t0 = time.time()
-    download_dataset()
-    restore_system()
-    restore_packages()
-    ensure_passwords()
-    elapsed = time.time() - t0
-    log(f"  Init complete ({elapsed:.1f}s)")
-
-
-def cmd_sync_loop():
-    """Background daemon: periodic save + upload."""
-    log("┌──────────────────────────────────────────────┐")
-    log("│          SYNC-LOOP daemon started             │")
-    log("└──────────────────────────────────────────────┘")
-    log(f"  HF_TOKEN: {'set' if HF_TOKEN else 'NOT SET'}")
-    log(f"  HF_DATASET_REPO: {HF_DATASET_REPO or 'NOT SET'}")
-    log(f"  SYNC_INTERVAL: {SYNC_INTERVAL}s")
-
-    if not HF_TOKEN or not HF_DATASET_REPO:
-        log("  ✗ No credentials — sync-loop DISABLED, sleeping forever")
-        signal.pause()
-        return
-
-    def on_signal(sig, frame):
-        log(f"  Signal {sig} received, final save ...")
-        try:
-            save_and_upload()
-        except Exception as e:
-            log(f"  Final save error: {e}")
-        sys.exit(0)
-
-    signal.signal(signal.SIGTERM, on_signal)
-    signal.signal(signal.SIGINT, on_signal)
-
-    log(f"  Waiting {60}s before first sync (let services start) ...")
-    time.sleep(60)
-
-    cycle = 0
-    while True:
-        cycle += 1
-        log(f"── Sync cycle #{cycle}")
-        try:
-            save_and_upload()
-        except Exception as e:
-            log(f"  ✗ Sync cycle #{cycle} error: {e}")
-            import traceback
-            traceback.print_exc(file=sys.stderr)
-        log(f"  Sleeping {SYNC_INTERVAL}s until next cycle ...")
-        time.sleep(SYNC_INTERVAL)
-
-
-def cmd_save():
-    """One-time save + upload."""
-    log("── ONE-TIME SAVE")
-    if not HF_TOKEN or not HF_DATASET_REPO:
-        log("  ✗ No credentials, cannot save")
-        return
-    save_and_upload()
-
-
-if __name__ == "__main__":
-    cmd = sys.argv[1] if len(sys.argv) > 1 else "init"
-    log(f"Command: {cmd} (pid={os.getpid()})")
-    if cmd == "init":
-        cmd_init()
-    elif cmd == "sync-loop":
-        cmd_sync_loop()
-    elif cmd == "save":
-        cmd_save()
-    else:
-        print(f"Usage: {sys.argv[0]} [init|sync-loop|save]")
-        sys.exit(1)

ubuntu-server/log_streamer.py

@@ -1,74 +0,0 @@
-#!/usr/bin/env python3
-"""
-SSE log streamer — serves /var/log/huggingrun.log as Server-Sent Events.
-Mimics HF's runtime log API format so you can use the same curl -N pattern.
-
-Usage:
-  curl -N https://tao-shen-huggingrun.hf.space/logs/stream
-"""
-import http.server
-import time
-import os
-import json
-from datetime import datetime, timezone
-
-LOGFILE = "/var/log/huggingrun.log"
-PORT = 7863
-
-
-class SSEHandler(http.server.BaseHTTPRequestHandler):
-    def log_message(self, format, *args):
-        pass  # suppress access logs
-
-    def do_GET(self):
-        if self.path == "/stream":
-            self.send_response(200)
-            self.send_header("Content-Type", "text/event-stream")
-            self.send_header("Cache-Control", "no-cache")
-            self.send_header("Connection", "keep-alive")
-            self.send_header("Access-Control-Allow-Origin", "*")
-            self.end_headers()
-
-            try:
-                # Send existing log content first (history)
-                if os.path.exists(LOGFILE):
-                    with open(LOGFILE, "r") as f:
-                        for line in f:
-                            line = line.rstrip("\n")
-                            if line:
-                                event = json.dumps({
-                                    "data": line + "\n",
-                                    "timestamp": datetime.now(timezone.utc).isoformat()
-                                })
-                                self.wfile.write(f"data: {event}\n\n".encode())
-                                self.wfile.flush()
-
-                # Then tail for new lines
-                with open(LOGFILE, "r") as f:
-                    f.seek(0, 2)  # end of file
-                    while True:
-                        line = f.readline()
-                        if line:
-                            line = line.rstrip("\n")
-                            if line:
-                                event = json.dumps({
-                                    "data": line + "\n",
-                                    "timestamp": datetime.now(timezone.utc).isoformat()
-                                })
-                                self.wfile.write(f"data: {event}\n\n".encode())
-                                self.wfile.flush()
-                        else:
-                            # Send keep-alive comment every 15s
-                            self.wfile.write(b": keep-alive\n\n")
-                            self.wfile.flush()
-                            time.sleep(1)
-            except (BrokenPipeError, ConnectionResetError):
-                pass
-        else:
-            self.send_response(404)
-            self.end_headers()
-
-
-if __name__ == "__main__":
-    server = http.server.HTTPServer(("127.0.0.1", PORT), SSEHandler)
-    server.serve_forever()

ubuntu-server/start-server.sh

@@ -1,114 +0,0 @@
-#!/bin/bash
-# ─────────────────────────────────────────────────────────────────────
-# HuggingRun Ubuntu Server: ttyd + SSH-over-WebSocket + nginx
-# Port 7860 (nginx): web terminal + SSH
-# ─────────────────────────────────────────────────────────────────────
-
-LOGFILE="/var/log/huggingrun.log"
-> "$LOGFILE"  # truncate on start
-
-export SSH_PORT="${SSH_PORT:-2222}"
-export TTYD_PORT="${TTYD_PORT:-7681}"
-
-# Log to stderr (HF captures stderr) + logfile (for /runlog endpoint)
-log() {
-    echo "$*" >&2
-    echo "$*" >> "$LOGFILE"
-}
-
-# ── Boot info ─────────────────────────────────────────────────────
-log "========================================"
-log "[ubuntu] HuggingRun Ubuntu Server"
-log "[ubuntu] $(date -u)"
-log "[ubuntu] Kernel: $(uname -r)"
-log "[ubuntu] Arch: $(uname -m)"
-log "[ubuntu] Hostname: $(hostname)"
-log "[ubuntu] CPU: $(nproc) cores"
-log "[ubuntu] Memory: $(free -h 2>/dev/null | grep Mem: | tr -s ' ' | cut -d' ' -f2 || echo 'unknown')"
-log "[ubuntu] Disk: $(df -h / 2>/dev/null | tail -1 | tr -s ' ' | cut -d' ' -f2,4 | sed 's/ / total, /;s/$/ free/' || echo 'unknown')"
-log "[ubuntu] User: $(whoami) (uid=$(id -u))"
-log "========================================"
-
-# ── Network info ──────────────────────────────────────────────────
-log "[ubuntu] Network interfaces:"
-ip -4 addr show 2>/dev/null | grep -E 'inet |^[0-9]' | while IFS= read -r line; do log "  $line"; done
-
-# ── sshd ──────────────────────────────────────────────────────────
-mkdir -p /run/sshd
-log "[ubuntu] Starting sshd on 127.0.0.1:${SSH_PORT} ..."
-/usr/sbin/sshd -o "Port=$SSH_PORT" \
-    -o "ListenAddress=127.0.0.1" \
-    -o "PermitRootLogin=yes" \
-    -o "PasswordAuthentication=yes" \
-    -o "PermitEmptyPasswords=no" \
-    -o "UsePAM=yes" \
-    -D -e &
-SSHD_PID=$!
-sleep 1
-if kill -0 $SSHD_PID 2>/dev/null; then
-    log "[ubuntu] [  OK  ] sshd started (PID=${SSHD_PID})"
-else
-    log "[ubuntu] [FAILED] sshd failed to start"
-fi
-
-# ── SSE log streamer ──────────────────────────────────────────────
-log "[ubuntu] Starting SSE log streamer on 127.0.0.1:7863 ..."
-python3 /scripts/log_streamer.py &
-STREAMER_PID=$!
-sleep 1
-if kill -0 $STREAMER_PID 2>/dev/null; then
-    log "[ubuntu] [  OK  ] SSE log streamer started (PID=${STREAMER_PID})"
-else
-    log "[ubuntu] [FAILED] SSE log streamer failed to start"
-fi
-
-# ── WebSocket-to-SSH bridge ───────────────────────────────────────
-log "[ubuntu] Starting WS-SSH bridge on 127.0.0.1:7862 ..."
-python3 /scripts/ws-ssh-bridge.py &
-BRIDGE_PID=$!
-sleep 1
-if kill -0 $BRIDGE_PID 2>/dev/null; then
-    log "[ubuntu] [  OK  ] WS-SSH bridge started (PID=${BRIDGE_PID})"
-else
-    log "[ubuntu] [FAILED] WS-SSH bridge failed to start"
-fi
-
-# ── ttyd (web terminal) ──────────────────────────────────────────
-log "[ubuntu] Starting ttyd on 127.0.0.1:${TTYD_PORT} ..."
-ttyd --port "$TTYD_PORT" --writable --base-path / bash --login &
-TTYD_PID=$!
-sleep 1
-if kill -0 $TTYD_PID 2>/dev/null; then
-    log "[ubuntu] [  OK  ] ttyd started (PID=${TTYD_PID})"
-else
-    log "[ubuntu] [FAILED] ttyd failed to start"
-fi
-
-# ── Process summary ───────────────────────────────────────────────
-log "========================================"
-log "[ubuntu] Services:"
-log "[ubuntu]   sshd          PID=${SSHD_PID}     127.0.0.1:${SSH_PORT}"
-log "[ubuntu]   log-streamer  PID=${STREAMER_PID}  127.0.0.1:7863"
-log "[ubuntu]   ws-ssh-bridge PID=${BRIDGE_PID}    127.0.0.1:7862"
-log "[ubuntu]   ttyd          PID=${TTYD_PID}      127.0.0.1:${TTYD_PORT}"
-log "========================================"
-log "[ubuntu] Base packages: $(wc -l < /etc/base-packages.list 2>/dev/null || echo '?')"
-log "[ubuntu] Current packages: $(dpkg-query -W -f='\n' 2>/dev/null | wc -l)"
-
-log "[ubuntu] All processes:"
-ps aux --no-headers 2>/dev/null | while read user pid rest; do log "[ubuntu]   ${user} PID=${pid}"; done
-
-log "[ubuntu] ══ System ready ══"
-log "[ubuntu] View logs:  curl https://<space>.hf.space/runlog"
-log "[ubuntu] Stream SSE: curl -N https://<space>.hf.space/runlog/stream"
-
-# ── Heartbeat ─────────────────────────────────────────────────────
-(while true; do
-    sleep 60
-    log "[ubuntu] heartbeat: $(date -u) | load=$(cat /proc/loadavg 2>/dev/null | cut -d' ' -f1-3) | mem=$(free -h 2>/dev/null | grep Mem: | tr -s ' ' | cut -d' ' -f3,2 | sed 's/ /\//' || echo '?')"
-done) &
-
-# ── Start nginx LAST → opens port 7860 → HF transitions to RUNNING ──
-log "[ubuntu] nginx config: /scripts/nginx.conf"
-log "[ubuntu] Starting nginx on 0.0.0.0:7860 (HF will mark RUNNING) ..."
-exec nginx -c /scripts/nginx.conf -g 'daemon off;'

ubuntu-server/upload_sync.py

@@ -1,61 +0,0 @@
-#!/usr/bin/env python3
-"""Upload /data to HF dataset. Called by start-server.sh save_system()."""
-import os
-import sys
-from datetime import datetime
-
-def main():
-    token = os.environ.get("HF_TOKEN", "")
-    repo = os.environ.get("HF_DATASET_REPO", "")
-    persist_path = os.environ.get("PERSIST_PATH", "/data")
-
-    if not token or not repo:
-        print("[persist] No HF_TOKEN or repo, skip upload", file=sys.stderr)
-        return
-
-    from huggingface_hub import HfApi
-
-    api = HfApi(token=token)
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-    print(f"[persist] Uploading {persist_path} to {repo} ...", file=sys.stderr)
-
-    try:
-        # Use upload_large_folder for reliability with large data
-        api.upload_large_folder(
-            folder_path=persist_path,
-            repo_id=repo,
-            repo_type="dataset",
-            commit_message=f"sync {ts}",
-            ignore_patterns=[
-                "__pycache__", "*.pyc",
-                ".git", ".git*",
-                "*.lock", "*.pid", "*.sock",
-                ".huggingface",
-            ],
-        )
-        print("[persist] Upload completed", file=sys.stderr)
-    except Exception as e:
-        print(f"[persist] upload_large_folder failed: {e}", file=sys.stderr)
-        # Fallback to regular upload_folder
-        try:
-            api.upload_folder(
-                folder_path=persist_path,
-                repo_id=repo,
-                repo_type="dataset",
-                path_in_repo="",
-                commit_message=f"sync {ts}",
-                ignore_patterns=[
-                    "__pycache__", "*.pyc",
-                    ".git", ".git*",
-                    "*.lock", "*.pid", "*.sock",
-                    ".huggingface",
-                ],
-            )
-            print("[persist] Upload completed (fallback)", file=sys.stderr)
-        except Exception as e2:
-            print(f"[persist] Upload failed: {e2}", file=sys.stderr)
-
-
-if __name__ == "__main__":
-    main()

ubuntu-server/ws-ssh-bridge.py → ws_ssh_bridge.py

@@ -73,7 +73,7 @@ async def bridge(websocket):
 
 
 async def main():
-    print(f"[ws-ssh-bridge] Listening on 127.0.0.1:{WS_PORT} → sshd {SSH_HOST}:{SSH_PORT}",
+    print(f"[ws-ssh-bridge] Listening on 127.0.0.1:{WS_PORT} -> sshd {SSH_HOST}:{SSH_PORT}",
           file=sys.stderr)
     async with serve(bridge, "127.0.0.1", WS_PORT,
                      ping_interval=30, ping_timeout=120,