slight addition to pre key verification section

health-check.sh

@@ -1,231 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-CYAN='\033[0;36m'
-NC='\033[0m'
-
-ok()   { echo -e "  ${GREEN}[OK]${NC}    $*"; }
-fail() { echo -e "  ${RED}[FAIL]${NC}  $*"; }
-warn() { echo -e "  ${YELLOW}[WARN]${NC}  $*"; }
-header() { echo -e "\n${CYAN}══════════════════════════════════════════${NC}"; echo -e "${CYAN}  $*${NC}"; echo -e "${CYAN}══════════════════════════════════════════${NC}"; }
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-HUB_USER="${SUDO_USER:-${USER}}"
-if [ "$(id -u)" -eq 0 ] && [ -n "${SUDO_USER:-}" ]; then
-    HUB_HOME=$(getent passwd "$SUDO_USER" | cut -d: -f6)
-else
-    HUB_HOME="$HOME"
-fi
-if [ "$(id -u)" -eq 0 ] && [ "$HUB_HOME" = "/root" ]; then
-    for u in armbian; do
-        CANDIDATE=$(getent passwd "$u" 2>/dev/null | cut -d: -f6)
-        if [ -f "${CANDIDATE}/.config/tinyboard/spokes" ]; then
-            HUB_HOME="$CANDIDATE"
-            break
-        fi
-    done
-fi
-REGISTRY="${HUB_HOME}/.config/tinyboard/spokes"
-COMPOSE="$SCRIPT_DIR/spoke/compose.yaml"
-RCLONE_CONF="${HUB_HOME}/.config/rclone/rclone.conf"
-
-IS_SPOKE=false
-IS_HUB=false
-
-if docker ps --format '{{.Names}}' 2>/dev/null | grep -qi autossh; then
-    IS_SPOKE=true
-fi
-
-if [ -f "$REGISTRY" ]; then
-    IS_HUB=true
-fi
-
-if [ "$IS_SPOKE" = false ] && [ "$IS_HUB" = false ]; then
-    echo -e "${YELLOW}Could not detect hub or spoke configuration. Is tinyboard set up?${NC}"
-    exit 1
-fi
-
-check_disk() {
-    header "Disk Space"
-    while IFS= read -r line; do
-        local pct mount
-        pct=$(echo "$line" | awk '{print $5}' | tr -d '%')
-        mount=$(echo "$line" | awk '{print $6}')
-        if [ "$pct" -ge 90 ]; then
-            fail "Disk usage at ${pct}% on $mount — critically low"
-        elif [ "$pct" -ge 80 ]; then
-            warn "Disk usage at ${pct}% on $mount — getting full"
-        else
-            ok "Disk usage at ${pct}% on $mount"
-        fi
-    done < <(df -h | awk 'NR>1' | grep -v ' /dev' | grep -v ' /sys' | grep -v ' /proc' | grep -v ' /run' | grep -v ' /snap' | grep -v 'overlay2' | grep -v 'docker')
-}
-
-check_common() {
-    header "System"
-
-    local ssh_svc=""
-    if systemctl list-unit-files ssh.service >/dev/null 2>&1; then
-        ssh_svc="ssh"
-    elif systemctl list-unit-files sshd.service >/dev/null 2>&1; then
-        ssh_svc="sshd"
-    fi
-
-    if [ -n "$ssh_svc" ]; then
-        if systemctl is-active "$ssh_svc" >/dev/null 2>&1; then
-            ok "SSH server running ($ssh_svc)"
-        else
-            fail "SSH server not running ($ssh_svc)"
-        fi
-    else
-        warn "Could not detect SSH service"
-    fi
-
-    if [ "$IS_SPOKE" = true ]; then
-        if command -v docker >/dev/null 2>&1; then
-            ok "docker installed"
-        else
-            fail "docker not found"
-        fi
-
-        if docker info >/dev/null 2>&1; then
-            ok "docker daemon running"
-        else
-            fail "docker daemon not running"
-        fi
-
-        local st_container
-        st_container=$(docker ps --format '{{.Names}}' 2>/dev/null | grep -i syncthing | head -1 || true)
-        if [ -n "$st_container" ]; then
-            ok "Syncthing container running ($st_container)"
-            if curl -sf http://127.0.0.1:8384 >/dev/null 2>&1; then
-                ok "Syncthing API reachable"
-            else
-                warn "Syncthing container running but API not reachable on :8384"
-            fi
-        else
-            warn "No Syncthing container running"
-        fi
-    fi
-}
-
-check_spoke() {
-    header "Spoke"
-
-    local autossh_container
-    autossh_container=$(docker ps --format '{{.Names}}' 2>/dev/null | grep -i autossh | head -1 || true)
-    if [ -n "$autossh_container" ]; then
-        ok "autossh container running ($autossh_container)"
-
-        local logs
-        logs=$(docker logs "$autossh_container" 2>&1 | tail -20 || true)
-        if echo "$logs" | grep -q "remote port forwarding failed"; then
-            fail "Tunnel reports port forwarding failed — check hub authorized_keys"
-        else
-            ok "No tunnel errors in recent logs"
-        fi
-    else
-        fail "No autossh container running"
-    fi
-
-    if [ -n "$autossh_container" ]; then
-        local tunnel_port hub_host
-        tunnel_port=$(docker inspect "$autossh_container" 2>/dev/null | python3 -c "
-import sys, json
-data = json.load(sys.stdin)
-cmd = ' '.join(data[0].get('Config', {}).get('Cmd', []))
-import re
-m = re.search(r'-R (\d+):localhost', cmd)
-print(m.group(1) if m else '')
-" 2>/dev/null || true)
-        hub_host=$(docker inspect "$autossh_container" 2>/dev/null | python3 -c "
-import sys, json
-data = json.load(sys.stdin)
-cmd = ' '.join(data[0].get('Config', {}).get('Cmd', []))
-import re
-m = re.search(r'[a-zA-Z0-9._-]+@([a-zA-Z0-9._-]+\.[a-zA-Z0-9._-]+)', cmd)
-print(m.group(1) if m else '')
-" 2>/dev/null || true)
-        if [ -n "$tunnel_port" ] && [ -n "$hub_host" ]; then
-            ok "Tunnel configured: port $tunnel_port → $hub_host"
-        else
-            warn "Could not parse tunnel config from running container"
-        fi
-    fi
-
-    local st_data="/home/armbian/st/data"
-    if [ -d "$st_data" ]; then
-        ok "Syncthing data directory exists ($st_data)"
-    else
-        warn "Syncthing data directory not found ($st_data)"
-    fi
-}
-
-check_hub() {
-    header "Hub"
-
-    local spoke_count
-    spoke_count=$(wc -l < "$REGISTRY" 2>/dev/null || echo 0)
-    ok "$spoke_count spoke(s) in registry"
-
-    while IFS= read -r line; do
-        [ -n "$line" ] || continue
-        local spoke_name tunnel_port key_path mount_point
-        spoke_name=$(echo "$line" | awk '{print $1}')
-        tunnel_port=$(echo "$line" | awk '{print $2}')
-        key_path=$(echo "$line" | awk '{print $3}')
-        mount_point=$(echo "$line" | awk '{print $4}')
-
-        echo ""
-        echo -e "  ${CYAN}Spoke: $spoke_name${NC}"
-
-        if ss -tlnp 2>/dev/null | grep -q ":${tunnel_port}"; then
-            ok "Tunnel port $tunnel_port is listening"
-        else
-            fail "Tunnel port $tunnel_port not listening — is the spoke connected?"
-        fi
-
-        if [ -f "$key_path" ]; then
-            ok "Hub key exists ($key_path)"
-        else
-            fail "Hub key missing ($key_path)"
-        fi
-
-        if mountpoint -q "$mount_point" 2>/dev/null; then
-            ok "Mounted at $mount_point"
-        else
-            fail "Not mounted at $mount_point"
-        fi
-
-        if grep -q "\[${spoke_name}-remote\]" "$RCLONE_CONF" 2>/dev/null; then
-            ok "rclone remote [${spoke_name}-remote] configured"
-        else
-            fail "rclone remote [${spoke_name}-remote] not found in rclone.conf"
-        fi
-
-        if crontab -u "$(basename "$HUB_HOME")" -l 2>/dev/null | grep -q "${spoke_name}-remote:"; then
-            ok "Auto-mount crontab entry present"
-        else
-            warn "No auto-mount crontab entry for $spoke_name"
-        fi
-
-    done < "$REGISTRY"
-
-    echo ""
-}
-
-check_common
-check_disk
-
-if [ "$IS_SPOKE" = true ]; then
-    check_spoke
-fi
-
-if [ "$IS_HUB" = true ]; then
-    check_hub
-fi
-
-echo ""

hub/onboard-spoke.sh

@@ -13,8 +13,15 @@ NC='\033[0m'
 
 info() { echo -e "${GREEN}[+]${NC} $*"; }
 warn() { echo -e "${YELLOW}[!]${NC} $*"; }
-die()    { echo -e "${RED}[ERROR]${NC} $*" >&2; exit 1; }
+die() {
-header() { echo -e "\n${CYAN}══════════════════════════════════════════${NC}"; echo -e "${CYAN}  $*${NC}"; echo -e "${CYAN}══════════════════════════════════════════${NC}"; }
+  echo -e "${RED}[ERROR]${NC} $*" >&2
+  exit 1
+}
+header() {
+  echo -e "\n${CYAN}══════════════════════════════════════════${NC}"
+  echo -e "${CYAN}  $*${NC}"
+  echo -e "${CYAN}══════════════════════════════════════════${NC}"
+}
 
 check_deps() {
   local missing=()
@@ -75,6 +82,7 @@ mkdir -p "$(dirname "$RCLONE_CONF")"
 
 header "Checking Tunnel"
 info "Verifying spoke SSH service is reachable on port $TUNNEL_PORT..."
+# Test TCP connectivity first
 if ! timeout 5 bash -c "cat < /dev/null > /dev/tcp/localhost/$TUNNEL_PORT" 2>/dev/null; then
   die "Cannot connect to port $TUNNEL_PORT on localhost — is the tunnel up?"
 fi
@@ -84,11 +92,11 @@ KEYSCAN=$(ssh-keyscan -p "$TUNNEL_PORT" -H localhost 2>/dev/null)
 while IFS= read -r KEYSCAN_LINE; do
   KEYSCAN_KEY=$(echo "$KEYSCAN_LINE" | awk '{print $2, $3}')
   if ! grep -qF "$KEYSCAN_KEY" "$SSH_DIR/known_hosts" 2>/dev/null; then
-        echo "$KEYSCAN_LINE" >> "$SSH_DIR/known_hosts"
+    echo "$KEYSCAN_LINE" >>"$SSH_DIR/known_hosts"
   fi
-done <<< "$KEYSCAN"
+done <<<"$KEYSCAN"
 
-header "Generating Hub-to-Spoke Access Key"
+header "Generating Hub SSH Key"
 if [ -f "$KEY_PATH" ]; then
   warn "Key $KEY_PATH already exists, skipping generation."
 else
@@ -98,7 +106,7 @@ fi
 chmod 600 "$KEY_PATH"
 info "Permissions set: $KEY_PATH is 600"
 
-header "Installing Hub-to-Spoke Access Key on Spoke"
+header "Installing Hub Access Key on Spoke"
 info "Copying hub public key to spoke's authorized_keys so the hub can SSH in for rclone..."
 info "(You will be prompted for the $SPOKE_USER password on the spoke)"
 if ssh-copy-id -i "$KEY_PATH.pub" -p "$TUNNEL_PORT" "$SPOKE_USER"@localhost; then
@@ -114,7 +122,7 @@ else
   read -rp "Press ENTER once the key has been added to the spoke..."
 fi
 
-header "Testing Hub-to-Spoke Key Auth"
+header "Testing Hub -> Spoke Key Auth"
 retry_or_abort \
   "ssh -i \"$KEY_PATH\" -o BatchMode=yes -o ConnectTimeout=10 -p \"$TUNNEL_PORT\" \"$SPOKE_USER\"@localhost exit" \
   "Key auth failed. Check authorized_keys on the spoke."
@@ -124,13 +132,18 @@ header "Adding rclone Remote"
 if grep -q "\[${SPOKE_NAME}-remote\]" "$RCLONE_CONF" 2>/dev/null; then
   warn "Remote [${SPOKE_NAME}-remote] already exists in $RCLONE_CONF, skipping."
 else
-    [ -s "$RCLONE_CONF" ] && tail -c1 "$RCLONE_CONF" | grep -qv $'\n' && echo "" >> "$RCLONE_CONF"
+  [ -s "$RCLONE_CONF" ] && tail -c1 "$RCLONE_CONF" | grep -qv $'\n' && echo "" >>"$RCLONE_CONF"
-    python3 - "$RCLONE_CONF" "$SPOKE_NAME" "$TUNNEL_PORT" "$KEY_PATH" <<'PYEOF'
+  cat >>"$RCLONE_CONF" <<EOF
-import sys
+
-path, name, port, key = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
+[${SPOKE_NAME}-remote]
-with open(path, 'a') as f:
+type = sftp
-    f.write(f"\n[{name}-remote]\ntype = sftp\nhost = localhost\nport = {port}\nkey_file = {key}\nshell_type = unix\nmd5sum_command = md5sum\nsha1sum_command = sha1sum\n")
+host = localhost
-PYEOF
+port = $TUNNEL_PORT
+key_file = $KEY_PATH
+shell_type = unix
+md5sum_command = md5sum
+sha1sum_command = sha1sum
+EOF
   info "Remote [${SPOKE_NAME}-remote] added to $RCLONE_CONF."
 fi
 
@@ -140,7 +153,7 @@ ADD_UNION="${ADD_UNION:-n}"
 if [[ "${ADD_UNION,,}" == "y" ]]; then
   read -rp "Union remote name [shared-union]: " UNION_NAME
   UNION_NAME="${UNION_NAME:-shared-union}"
-    read -rp "Subfolder path on the spoke being onboarded (e.g. books, leave blank for root): " UNION_PATH
+  read -rp "Subfolder path on this spoke (e.g. books, leave blank for root): " UNION_PATH
   echo ""
   echo "Upstream access mode for this spoke:"
   echo "  0) None       - full read/write (default)"
@@ -155,7 +168,10 @@ if [[ "${ADD_UNION,,}" == "y" ]]; then
   1) UPSTREAM_TAG=":ro" ;;
   2) UPSTREAM_TAG=":nc" ;;
   3) UPSTREAM_TAG=":writeback" ;;
-        *) warn "Invalid choice, defaulting to full read/write."; UPSTREAM_TAG="" ;;
+  *)
+    warn "Invalid choice, defaulting to full read/write."
+    UPSTREAM_TAG=""
+    ;;
   esac
   if [ -n "$UNION_PATH" ]; then
     UPSTREAM="${SPOKE_NAME}-remote:${UNION_PATH}${UPSTREAM_TAG}"
@@ -163,7 +179,8 @@ if [[ "${ADD_UNION,,}" == "y" ]]; then
     UPSTREAM="${SPOKE_NAME}-remote:${UPSTREAM_TAG}"
   fi
   if grep -q "^\[${UNION_NAME}\]" "$RCLONE_CONF" 2>/dev/null; then
-        ALREADY=$(python3 - "$RCLONE_CONF" "$UNION_NAME" "${SPOKE_NAME}-remote:" <<'PYEOF2'
+    ALREADY=$(
+      python3 - "$RCLONE_CONF" "$UNION_NAME" "${SPOKE_NAME}-remote:" <<'PYEOF'
 import sys
 path, section, prefix = sys.argv[1], sys.argv[2], sys.argv[3]
 with open(path) as f:
@@ -178,12 +195,12 @@ for line in lines:
         print("yes")
         sys.exit(0)
 print("no")
-PYEOF2
+PYEOF
-)
+    )
     if [ "$ALREADY" = "yes" ]; then
       warn "Upstream for ${SPOKE_NAME}-remote already in union remote [${UNION_NAME}], skipping."
     else
-            python3 - "$RCLONE_CONF" "$UNION_NAME" "$UPSTREAM" <<'PYEOF2'
+      python3 - "$RCLONE_CONF" "$UNION_NAME" "$UPSTREAM" <<'PYEOF'
 import sys
 path, section, upstream = sys.argv[1], sys.argv[2], sys.argv[3]
 with open(path) as f:
@@ -200,12 +217,12 @@ for line in lines:
     out.append(line)
 with open(path, "w") as f:
     f.writelines(out)
-PYEOF2
+PYEOF
       info "Added '$UPSTREAM' to union remote [${UNION_NAME}]."
     fi
   else
-        [ -s "$RCLONE_CONF" ] && tail -c1 "$RCLONE_CONF" | grep -qv $'\n' && echo "" >> "$RCLONE_CONF"
+    [ -s "$RCLONE_CONF" ] && tail -c1 "$RCLONE_CONF" | grep -qv $'\n' && echo "" >>"$RCLONE_CONF"
-        printf '\n[%s]\ntype = union\nupstreams = %s\n' "$UNION_NAME" "$UPSTREAM" >> "$RCLONE_CONF"
+    printf '\n[%s]\ntype = union\nupstreams = %s\n' "$UNION_NAME" "$UPSTREAM" >>"$RCLONE_CONF"
     info "Union remote [${UNION_NAME}] created with upstream '$UPSTREAM'."
   fi
 fi
@@ -223,14 +240,14 @@ MOUNT_POINT="${HOME}/mnt/${SPOKE_NAME}"
 mkdir -p "$MOUNT_POINT"
 if grep -q "^${SPOKE_NAME} " "$REGISTRY" 2>/dev/null; then
   warn "$SPOKE_NAME already in registry, updating."
-    grep -v "^${SPOKE_NAME} " "$REGISTRY" > "${REGISTRY}.tmp" 2>/dev/null || true
+  grep -v "^${SPOKE_NAME} " "$REGISTRY" >"${REGISTRY}.tmp" 2>/dev/null || true
   mv "${REGISTRY}.tmp" "$REGISTRY"
 fi
-echo "${SPOKE_NAME} ${TUNNEL_PORT} ${KEY_PATH} ${MOUNT_POINT}" >> "$REGISTRY"
+echo "${SPOKE_NAME} ${TUNNEL_PORT} ${KEY_PATH} ${MOUNT_POINT}" >>"$REGISTRY"
 info "$SPOKE_NAME registered."
 
 header "Setting Up Auto-Mount"
-MOUNT_CMD="/usr/bin/rclone mount ${SPOKE_NAME}-remote: ${MOUNT_POINT} --config ${HOME}/.config/rclone/rclone.conf --vfs-cache-mode writes --allow-other --allow-non-empty --daemon"
+MOUNT_CMD="rclone mount ${SPOKE_NAME}-remote: ${MOUNT_POINT} --config ${HOME}/.config/rclone/rclone.conf --vfs-cache-mode writes --allow-other --daemon"
 CRON_ENTRY="@reboot ${MOUNT_CMD}"
 EXISTING=$(crontab -l 2>/dev/null || true)
 if echo "$EXISTING" | grep -qF "${SPOKE_NAME}-remote:"; then
@@ -238,9 +255,12 @@ if echo "$EXISTING" | grep -qF "${SPOKE_NAME}-remote:"; then
 else
   CRONTAB_BACKUP="${HOME}/.config/tinyboard/crontab.$(date +%Y%m%d%H%M%S)"
   mkdir -p "$(dirname "$CRONTAB_BACKUP")"
-    echo "$EXISTING" > "$CRONTAB_BACKUP"
+  echo "$EXISTING" >"$CRONTAB_BACKUP"
   info "Crontab backed up to $CRONTAB_BACKUP"
-    { echo "$EXISTING"; echo "$CRON_ENTRY"; } | crontab -
+  {
+    echo "$EXISTING"
+    echo "$CRON_ENTRY"
+  } | crontab -
   info "Auto-mount crontab entry added for ${SPOKE_NAME}."
 fi
 info "Starting mount now..."
@@ -253,3 +273,6 @@ echo -e "  Port:        ${GREEN}$TUNNEL_PORT${NC}"
 echo -e "  Hub key:     ${GREEN}$KEY_PATH${NC}"
 echo -e "  rclone:      ${GREEN}${SPOKE_NAME}-remote${NC}"
 echo ""
+echo -e "${YELLOW}To mount this spoke:${NC}"
+echo "  RCLONE_REMOTE=${SPOKE_NAME}-remote hubspoke-helper.sh hub start"
+echo ""

hub/setup-hub.sh

@@ -63,7 +63,7 @@ if command -v apt-get >/dev/null 2>&1; then
     PKG_MANAGER="apt"
     PKG_INSTALL="apt-get install -y -q"
     OPENSSH_PKG="openssh-server"
-    FUSE_PKG="fuse3"
+    FUSE_PKG="fuse"
     info "Detected: apt (Debian/Ubuntu)"
     apt-get update -q
 elif command -v dnf >/dev/null 2>&1; then
@@ -136,7 +136,7 @@ header "SSH Server Configuration"
 SSHD_CONF="/etc/ssh/sshd_config"
 [ -f "$SSHD_CONF" ] || die "sshd_config not found at $SSHD_CONF"
 
-for DIRECTIVE in "GatewayPorts no" "AllowTcpForwarding yes" "ClientAliveInterval 60" "ClientAliveCountMax 3"; do
+for DIRECTIVE in "GatewayPorts no" "AllowTcpForwarding local" "ClientAliveInterval 60" "ClientAliveCountMax 3"; do
     KEY="${DIRECTIVE%% *}"
     if grep -q "^$KEY" "$SSHD_CONF"; then
         sed -i "s|^$KEY.*|$DIRECTIVE|" "$SSHD_CONF"
@@ -161,8 +161,8 @@ else
 fi
 
 header "Password Authentication"
-read -rp "Disable password auth for $HUB_USER and use keys only? [y/N]: " DISABLE_PASS
+read -rp "Disable password auth for $HUB_USER and use keys only? [Y/n]: " DISABLE_PASS
-DISABLE_PASS="${DISABLE_PASS:-n}"
+DISABLE_PASS="${DISABLE_PASS:-y}"
 if [[ "${DISABLE_PASS,,}" == "y" ]]; then
     if [ ! -s "$SSH_DIR/authorized_keys" ]; then
         warn "No keys found in $SSH_DIR/authorized_keys — skipping password auth disable to avoid lockout."
@@ -251,7 +251,7 @@ info "Mount point created at $MOUNT_POINT."
 
 header "Hub Setup Complete"
 echo -e "  Hub user:      ${GREEN}$HUB_USER${NC}"
-echo -e "  SSH config:    ${GREEN}GatewayPorts no, AllowTcpForwarding yes, ClientAliveInterval 60${NC}"
+echo -e "  SSH config:    ${GREEN}GatewayPorts no, AllowTcpForwarding local, ClientAliveInterval 60${NC}"
 echo -e "  FUSE:          ${GREEN}user_allow_other enabled${NC}"
 echo -e "  rclone config: ${GREEN}$RCLONE_CONF${NC}"
 echo -e "  Mount point:   ${GREEN}$MOUNT_POINT${NC}"

hub/setup-opds.sh

@@ -1,363 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-CYAN='\033[0;36m'
-NC='\033[0m'
-
-info()   { echo -e "${GREEN}[+]${NC} $*"; }
-warn()   { echo -e "${YELLOW}[!]${NC} $*"; }
-die()    { echo -e "${RED}[ERROR]${NC} $*" >&2; exit 1; }
-header() { echo -e "\n${CYAN}══════════════════════════════════════════${NC}"; echo -e "${CYAN}  $*${NC}"; echo -e "${CYAN}══════════════════════════════════════════${NC}"; }
-
-[ "$(id -u)" -eq 0 ] || die "Run as root"
-
-if ! command -v docker >/dev/null 2>&1; then
-    warn "Docker is not installed."
-    read -rp "Install Docker now? [Y/n]: " INSTALL_DOCKER
-    INSTALL_DOCKER="${INSTALL_DOCKER:-y}"
-    if [[ "${INSTALL_DOCKER,,}" == "y" ]]; then
-        header "Installing Docker"
-        if command -v apt-get >/dev/null 2>&1; then
-            apt-get update -q
-            apt-get install -y -q docker.io docker-cli docker-compose
-        else
-            curl -fsSL https://get.docker.com | bash
-        fi
-        command -v docker >/dev/null 2>&1 || die "Docker installation failed."
-        info "Docker installed."
-    else
-        die "Docker is required. Aborting."
-    fi
-fi
-
-header "TinyBoard OPDS Setup"
-echo ""
-
-EXISTING_SERVER=""
-if docker ps -a --format '{{.Names}}' 2>/dev/null | grep -qE '^(dir2opds|stump)$'; then
-    EXISTING_SERVER=$(docker ps -a --format '{{.Names}}' 2>/dev/null | grep -E '^(dir2opds|stump)$' | head -1)
-fi
-
-if [ -n "$EXISTING_SERVER" ]; then
-    echo "An existing OPDS server was found: ${EXISTING_SERVER}"
-    echo ""
-    echo "  1) Reconfigure — update books path, domain, SSL, or auth"
-    echo "  2) Fresh install — remove existing and start over"
-    echo "  q) Quit"
-    echo ""
-    read -rp "Choose [1/2/q]: " RECONF_CHOICE
-    case "$RECONF_CHOICE" in
-        1) info "Reconfiguring existing setup..." ;;
-        2) 
-            docker rm -f dir2opds stump caddy-opds 2>/dev/null || true
-            info "Existing containers removed."
-            ;;
-        q|Q) exit 0 ;;
-        *) die "Invalid choice." ;;
-    esac
-    echo ""
-fi
-
-echo "Choose an OPDS server:"
-echo "  1) dir2opds — lightweight, no database, serves files directly from a folder"
-echo "  2) Stump    — full-featured book/comic server with web UI and OPDS support"
-echo ""
-read -rp "Choose [1/2]: " OPDS_CHOICE
-
-case "$OPDS_CHOICE" in
-1)
-    OPDS_SERVER="dir2opds"
-    OPDS_IMAGE="ghcr.io/dubyte/dir2opds:latest"
-    OPDS_INTERNAL_PORT="8080"
-    ;;
-2)
-    OPDS_SERVER="stump"
-    OPDS_IMAGE="aaronleopold/stump"
-    OPDS_INTERNAL_PORT="10801"
-    ;;
-*)
-    die "Invalid choice."
-    ;;
-esac
-
-info "Selected: $OPDS_SERVER"
-echo ""
-
-read -rp "OPDS domain (e.g. opds.yourdomain.com): " OPDS_DOMAIN
-[ -n "$OPDS_DOMAIN" ] || die "Domain cannot be empty"
-
-read -rp "Hub user [armbian]: " HUB_USER
-HUB_USER="${HUB_USER:-armbian}"
-HUB_HOME="/home/$HUB_USER"
-
-MOUNT_BASE="${HUB_HOME}/mnt"
-AVAILABLE_MOUNTS=()
-if [ -d "$MOUNT_BASE" ]; then
-    while IFS= read -r mountdir; do
-        AVAILABLE_MOUNTS+=("$mountdir")
-    done < <(find "$MOUNT_BASE" -mindepth 1 -maxdepth 1 -type d | sort)
-fi
-
-if [ ${#AVAILABLE_MOUNTS[@]} -gt 0 ]; then
-    echo "Available spoke mounts:"
-    for i in "${!AVAILABLE_MOUNTS[@]}"; do
-        echo "  $i) ${AVAILABLE_MOUNTS[$i]}"
-    done
-    echo "  m) Enter path manually"
-    echo ""
-    read -rp "Choose a mount [0]: " MOUNT_CHOICE
-    MOUNT_CHOICE="${MOUNT_CHOICE:-0}"
-    if [[ "$MOUNT_CHOICE" == "m" ]]; then
-        read -rp "Path to books directory: " BOOKS_PATH
-    elif [[ "$MOUNT_CHOICE" =~ ^[0-9]+$ ]] && [ "$MOUNT_CHOICE" -lt "${#AVAILABLE_MOUNTS[@]}" ]; then
-        BASE="${AVAILABLE_MOUNTS[$MOUNT_CHOICE]}"
-        read -rp "Subdirectory within ${BASE} (leave blank for root): " SUBDIR
-        if [ -n "$SUBDIR" ]; then
-            BOOKS_PATH="${BASE}/${SUBDIR}"
-        else
-            BOOKS_PATH="$BASE"
-        fi
-    else
-        die "Invalid choice."
-    fi
-else
-    warn "No spoke mounts found in ${MOUNT_BASE}."
-    read -rp "Path to books directory: " BOOKS_PATH
-fi
-
-[ -n "$BOOKS_PATH" ] || die "Books path cannot be empty."
-[ -d "$BOOKS_PATH" ] || die "Books directory not found: $BOOKS_PATH"
-
-echo ""
-echo "SSL certificate management:"
-echo "  1) Automatic — Caddy obtains and renews certs from Let's Encrypt (recommended)"
-echo "  2) Manual    — provide paths to existing certificate files"
-echo ""
-read -rp "Choose [1/2]: " SSL_CHOICE
-
-AUTO_HTTPS=true
-CERT_PATH=""
-KEY_PATH=""
-
-case "$SSL_CHOICE" in
-1)
-    AUTO_HTTPS=true
-    info "Automatic HTTPS selected — DNS must point ${OPDS_DOMAIN} to this server."
-    ;;
-2)
-    AUTO_HTTPS=false
-    read -rp "Path to fullchain.pem: " CERT_PATH
-    [ -f "$CERT_PATH" ] || die "Certificate file not found: $CERT_PATH"
-    read -rp "Path to privkey.pem: " KEY_PATH
-    [ -f "$KEY_PATH" ] || die "Key file not found: $KEY_PATH"
-    ;;
-*)
-    die "Invalid choice."
-    ;;
-esac
-
-echo ""
-read -rp "Protect with a password? [y/N]: " USE_AUTH
-USE_AUTH="${USE_AUTH:-n}"
-OPDS_USER=""
-OPDS_PASS=""
-HASHED_PASS=""
-if [[ "${USE_AUTH,,}" == "y" ]]; then
-    read -rp "Username [opds]: " OPDS_USER
-    OPDS_USER="${OPDS_USER:-opds}"
-    read -rsp "Password: " OPDS_PASS
-    echo ""
-    [ -n "$OPDS_PASS" ] || die "Password cannot be empty"
-fi
-
-OPDS_DIR="${HUB_HOME}/opds"
-mkdir -p "$OPDS_DIR"
-chown "$HUB_USER":"$HUB_USER" "$OPDS_DIR"
-
-header "Creating Docker Network"
-docker network create opds-net 2>/dev/null || info "Network opds-net already exists."
-
-header "Starting $OPDS_SERVER"
-docker rm -f "$OPDS_SERVER" 2>/dev/null || true
-
-case "$OPDS_SERVER" in
-dir2opds)
-    docker run -d \
-        --name dir2opds \
-        --restart unless-stopped \
-        --network opds-net \
-        --mount "type=bind,source=${BOOKS_PATH},target=/books,readonly,bind-propagation=shared" \
-        "$OPDS_IMAGE" \
-        /dir2opds -dir /books -hide-dot-files -calibre
-    ;;
-stump)
-    mkdir -p "${OPDS_DIR}/stump-config"
-    chown -R "$HUB_USER":"$HUB_USER" "${OPDS_DIR}"
-    docker run -d \
-        --name stump \
-        --restart unless-stopped \
-        --network opds-net \
-        -v "${BOOKS_PATH}:/books:ro" \
-        -v "${OPDS_DIR}/stump-config:/config" \
-        -e PUID=1000 \
-        -e PGID=1000 \
-        "$OPDS_IMAGE"
-    ;;
-esac
-
-info "$OPDS_SERVER started on internal network opds-net."
-
-header "Writing Caddyfile"
-CADDY_DIR="${OPDS_DIR}/caddy"
-mkdir -p "${CADDY_DIR}/data" "${CADDY_DIR}/config"
-
-if [ "$AUTO_HTTPS" = false ]; then
-    TLS_BLOCK="    tls ${CERT_PATH} ${KEY_PATH}"
-else
-    TLS_BLOCK=""
-fi
-
-if [[ "${USE_AUTH,,}" == "y" ]]; then
-    docker run --rm caddy:alpine caddy hash-password --plaintext "$OPDS_PASS" > /tmp/opds_hash.txt 2>/dev/null
-    HASHED_PASS=$(cat /tmp/opds_hash.txt)
-    rm -f /tmp/opds_hash.txt
-    AUTH_BLOCK="    basicauth {
-        ${OPDS_USER} ${HASHED_PASS}
-    }"
-else
-    AUTH_BLOCK=""
-fi
-
-if [ "$AUTO_HTTPS" = false ]; then
-    cat > "${CADDY_DIR}/Caddyfile" << EOF
-{
-    auto_https off
-}
-
-:80 {
-    redir https://{host}{uri} permanent
-}
-
-${OPDS_DOMAIN} {
-    encode gzip
-${TLS_BLOCK}
-${AUTH_BLOCK}
-    reverse_proxy http://${OPDS_SERVER}:${OPDS_INTERNAL_PORT} {
-        header_up Host {host}
-        header_up X-Real-IP {remote}
-    }
-}
-EOF
-else
-    cat > "${CADDY_DIR}/Caddyfile" << EOF
-${OPDS_DOMAIN} {
-    encode gzip
-${AUTH_BLOCK}
-    reverse_proxy http://${OPDS_SERVER}:${OPDS_INTERNAL_PORT} {
-        header_up Host {host}
-        header_up X-Real-IP {remote}
-    }
-}
-EOF
-fi
-
-info "Caddyfile written to ${CADDY_DIR}/Caddyfile"
-
-header "Firewall Check"
-warn "Caddy requires ports 80 and 443 to be open on this server."
-warn "If using a cloud firewall (e.g. Linode), ensure inbound TCP rules allow:"
-warn "  Port 80  — required for Let's Encrypt HTTP challenge and HTTP→HTTPS redirect"
-warn "  Port 443 — required for HTTPS"
-echo ""
-read -rp "Press ENTER to continue once ports are open..."
-
-header "Starting Caddy"
-docker rm -f caddy-opds 2>/dev/null || true
-
-if [ "$AUTO_HTTPS" = true ]; then
-    docker run -d \
-        --name caddy-opds \
-        --restart unless-stopped \
-        --network opds-net \
-        -p 80:80 \
-        -p 443:443 \
-        -v "${CADDY_DIR}/Caddyfile:/etc/caddy/Caddyfile:ro" \
-        -v "${CADDY_DIR}/data:/data" \
-        -v "${CADDY_DIR}/config:/config" \
-        caddy:alpine
-else
-    CERT_DIR=$(dirname "$CERT_PATH")
-    docker run -d \
-        --name caddy-opds \
-        --restart unless-stopped \
-        --network opds-net \
-        -p 80:80 \
-        -p 443:443 \
-        -v "${CADDY_DIR}/Caddyfile:/etc/caddy/Caddyfile:ro" \
-        -v "${CADDY_DIR}/data:/data" \
-        -v "${CADDY_DIR}/config:/config" \
-        -v "${CERT_DIR}:/certs:ro" \
-        caddy:alpine
-fi
-
-sleep 3
-docker logs caddy-opds --tail 5 2>/dev/null || true
-
-header "Setting Up Mount Watchdog"
-
-WATCHDOG_SCRIPT="/usr/local/bin/opds-watchdog.sh"
-cat > "$WATCHDOG_SCRIPT" << EOF
-#!/usr/bin/env bash
-SERVER_NAME="${OPDS_SERVER}"
-MAX_WAIT=300
-ELAPSED=0
-while [ \$ELAPSED -lt \$MAX_WAIT ]; do
-    COUNT=\$(docker exec "\$SERVER_NAME" ls /books 2>/dev/null | wc -l)
-    if [ "\$COUNT" -gt 0 ]; then
-        exit 0
-    fi
-    docker restart "\$SERVER_NAME" 2>/dev/null || true
-    sleep 15
-    ELAPSED=\$((ELAPSED + 15))
-done
-EOF
-chmod +x "$WATCHDOG_SCRIPT"
-
-MOUNT_SCRIPT="/home/${HUB_USER}/mount-$(basename ${MOUNT_POINT:-grace}).sh"
-cat > "$MOUNT_SCRIPT" << EOF
-#!/usr/bin/env bash
-sleep 90
-/usr/bin/rclone mount ${OPDS_SERVER}-remote: ${MOUNT_POINT:-/home/${HUB_USER}/mnt/grace} --config /home/${HUB_USER}/.config/rclone/rclone.conf --vfs-cache-mode writes --allow-other --allow-non-empty --daemon
-EOF
-chmod +x "$MOUNT_SCRIPT"
-chown "$HUB_USER":"$HUB_USER" "$MOUNT_SCRIPT"
-
-CRON_LINE="@reboot $WATCHDOG_SCRIPT"
-EXISTING_ROOT_CRON=$(crontab -l 2>/dev/null || true)
-if ! echo "$EXISTING_ROOT_CRON" | grep -qF "opds-watchdog"; then
-    { echo "$EXISTING_ROOT_CRON"; echo "$CRON_LINE"; } | crontab -
-    info "Watchdog crontab entry added — restarts $OPDS_SERVER until books are visible."
-else
-    crontab -l 2>/dev/null | grep -v "opds-watchdog" | { cat; echo "$CRON_LINE"; } | crontab -
-    info "Watchdog crontab entry updated."
-fi
-
-header "OPDS Setup Complete"
-echo ""
-echo -e "  OPDS URL:     ${GREEN}https://${OPDS_DOMAIN}${NC}"
-if [[ "${USE_AUTH,,}" == "y" ]]; then
-    echo -e "  Username:     ${GREEN}${OPDS_USER}${NC}"
-    echo -e "  Password:     ${GREEN}(as entered)${NC}"
-else
-    echo -e "  Auth:         ${YELLOW}None — publicly accessible${NC}"
-fi
-if [ "$AUTO_HTTPS" = true ]; then
-    echo -e "  SSL:          ${GREEN}Automatic (Let's Encrypt)${NC}"
-    warn "DNS must point ${OPDS_DOMAIN} to this server's IP for HTTPS to work."
-else
-    echo -e "  SSL:          ${GREEN}Manual certificates${NC}"
-fi
-echo ""

spoke/compose.yaml

@@ -11,22 +11,25 @@ services:
       -o "ServerAliveInterval=60"
       -o "ServerAliveCountMax=3"
       -R 11111:localhost:22
-      -i /home/armbian/.ssh/hubkey
+      -i /home/armbian/.ssh/oilykey2026
-      armbian@hub.example.com
+      armbian@oily.dad
     volumes:
-      - /home/armbian/.ssh/hubkey:/home/armbian/.ssh/hubkey:ro
+      - /home/armbian/.ssh/oilykey2026:/home/armbian/.ssh/oilykey2026:ro
       - /home/armbian/.ssh/known_hosts:/home/armbian/.ssh/known_hosts:ro
   syncthing:
     image: syncthing/syncthing
     container_name: spoke-syncthing
     hostname: spoke-syncthing
     restart: unless-stopped
-    user: "1000:1000"
     environment:
-      - HOME=/var/syncthing
+      - PUID=1000
+      - PGID=1000
     ports:
-      - "8384:8384"
+      - "127.0.0.1:8384:8384"
       - "22000:22000"
     volumes:
-      - /home/armbian/st/config:/var/syncthing/config
+      - syncthing-config:/var/syncthing/config
       - /home/armbian/st/data:/var/syncthing/data
+
+volumes:
+  syncthing-config:

spoke/setup-network.sh

@@ -32,8 +32,6 @@ header "TinyBoard Network Setup"
 echo ""
 echo "  0) Change hostname"
 echo "  1) Configure static IP"
-echo "  2) Prefer IPv4 over IPv6"
-echo "  3) Prefer IPv6 over IPv4"
 echo "  q) Quit"
 echo ""
 read -rp "Choose: " NET_OPT
@@ -55,22 +53,6 @@ case "$NET_OPT" in
     ;;
 1)
     ;;
-2)
-    header "Prefer IPv4 over IPv6"
-    if grep -q "precedence ::ffff:0:0/96" /etc/gai.conf 2>/dev/null; then
-        warn "IPv4 preference already set."
-    else
-        echo "precedence ::ffff:0:0/96  100" >> /etc/gai.conf
-        info "IPv4 preference set. Outgoing connections will prefer IPv4."
-    fi
-    exit 0
-    ;;
-3)
-    header "Prefer IPv6 over IPv4"
-    sed -i '/precedence ::ffff:0:0\/96/d' /etc/gai.conf 2>/dev/null || true
-    info "IPv4 preference removed. System will use default IPv6-first behavior."
-    exit 0
-    ;;
 q|Q)
     exit 0
     ;;
@@ -177,19 +159,10 @@ PYEOF
 fi
 
 header "Writing Netplan Config"
-NETPLAN_BACKUP_DIR="/root/.config/tinyboard/netplan-backups"
-mkdir -p "$NETPLAN_BACKUP_DIR"
 BACKUP_FILE=""
-
-for OTHER_FILE in /etc/netplan/*.yaml; do
-    [ "$OTHER_FILE" = "$NETPLAN_FILE" ] && continue
-    BACKUP_OTHER="$NETPLAN_BACKUP_DIR/$(basename "${OTHER_FILE}").$(date +%Y%m%d%H%M%S)"
-    cp "$OTHER_FILE" "$BACKUP_OTHER"
-    rm "$OTHER_FILE"
-    warn "Removed conflicting netplan file: $OTHER_FILE (backed up to $BACKUP_OTHER)"
-done
-
 if [ -f "$NETPLAN_FILE" ]; then
+    NETPLAN_BACKUP_DIR="/root/.config/tinyboard/netplan-backups"
+    mkdir -p "$NETPLAN_BACKUP_DIR"
     BACKUP_FILE="$NETPLAN_BACKUP_DIR/$(basename "${NETPLAN_FILE}").$(date +%Y%m%d%H%M%S)"
     cp "$NETPLAN_FILE" "$BACKUP_FILE"
     info "Netplan config backed up to $BACKUP_FILE"

spoke/setup-spoke.sh

@@ -174,7 +174,7 @@ SSHD_CONF="/etc/ssh/sshd_config"
 header "Hostname Setup"
 CURRENT_HOSTNAME=$(hostname)
 echo -e "Current hostname: ${YELLOW}$CURRENT_HOSTNAME${NC}"
-read -rp "Enter a hostname for this spoke [${CURRENT_HOSTNAME}]: " SPOKE_NAME
+read -rp "Enter a hostname for this spoke (e.g. rocky, gouda, camembert): " SPOKE_NAME
 SPOKE_NAME="${SPOKE_NAME:-$CURRENT_HOSTNAME}"
 [[ "$SPOKE_NAME" =~ ^[a-zA-Z0-9._-]+$ ]] || die "Spoke name '$SPOKE_NAME' contains invalid characters. Use only letters, numbers, dots, underscores, hyphens."
 hostnamectl set-hostname "$SPOKE_NAME"
@@ -215,10 +215,6 @@ case "$KEY_CHOICE" in
     cat "$KEY_PATH.pub"
     echo -e "${YELLOW}══════════════════════════════════════════${NC}"
     echo ""
-    echo -e "${YELLOW}  On the hub, run as ${HUB_USER}:${NC}"
-    echo ""
-    echo "  echo "$(cat "$KEY_PATH.pub")" >> /home/${HUB_USER}/.ssh/authorized_keys"
-    echo ""
     read -rp "Press ENTER once the key has been added to ${HUB_HOST}..."
     ;;
 2)
@@ -319,12 +315,6 @@ if [ -n "$HUB_KEYSCAN" ]; then
         if ! grep -qF "$KEYSCAN_KEY" "$SSH_DIR/known_hosts" 2>/dev/null; then
             echo "$KEYSCAN_LINE" >> "$SSH_DIR/known_hosts"
         fi
-        mkdir -p /root/.ssh
-        touch /root/.ssh/known_hosts
-        chmod 600 /root/.ssh/known_hosts
-        if ! grep -qF "$KEYSCAN_KEY" /root/.ssh/known_hosts 2>/dev/null; then
-            echo "$KEYSCAN_LINE" >> /root/.ssh/known_hosts
-        fi
     done <<< "$HUB_KEYSCAN"
 fi
 check_permissions "$SSH_DIR/known_hosts" "known_hosts"
@@ -359,9 +349,8 @@ header "Configuring compose.yaml"
 info "Setting port to $TUNNEL_PORT and key to $KEY_NAME..."
 
 SYNCTHING_MOUNT="$ARMBIAN_HOME/st/data"
-SYNCTHING_CONFIG="$ARMBIAN_HOME/st/config"
+mkdir -p "$SYNCTHING_MOUNT"
-mkdir -p "$SYNCTHING_MOUNT" "$SYNCTHING_CONFIG"
+chown "$SPOKE_USER":"$SPOKE_USER" "$SYNCTHING_MOUNT"
-chown "$SPOKE_USER":"$SPOKE_USER" "$SYNCTHING_MOUNT" "$SYNCTHING_CONFIG"
 
 SPOKE_UID=$(id -u "$SPOKE_USER")
 SPOKE_GID=$(id -g "$SPOKE_USER")
@@ -372,8 +361,8 @@ sed -i "/known_hosts/!s|/home/[^/]*/\.ssh/[^:]*:/home/[^/]*/\.ssh/[^:]*:ro|${SSH
 sed -i "s|/home/[^/]*/\.ssh/known_hosts|${SSH_DIR}/known_hosts|g" "$COMPOSE"
 sed -i "s| [a-zA-Z0-9._-]*@[a-zA-Z0-9._-]*\.[a-zA-Z0-9._-]*[[:space:]]*\$| ${HUB_USER}@${HUB_HOST}|" "$COMPOSE"
 sed -i "s|/home/[^/]*/st/data:|${SYNCTHING_MOUNT}:|g" "$COMPOSE"
-sed -i "s|/home/[^/]*/st/config:|${SYNCTHING_CONFIG}:|g" "$COMPOSE"
+sed -i "s|PUID=[0-9]*|PUID=${SPOKE_UID}|g" "$COMPOSE"
-sed -i "s|user: \"[0-9]*:[0-9]*\"|user: \"${SPOKE_UID}:${SPOKE_GID}\"|" "$COMPOSE"
+sed -i "s|PGID=[0-9]*|PGID=${SPOKE_GID}|g" "$COMPOSE"
 sed -i "s|container_name: spoke-autossh|container_name: ${SPOKE_NAME}-autossh|g" "$COMPOSE"
 sed -i "s|container_name: spoke-syncthing|container_name: ${SPOKE_NAME}-syncthing|g" "$COMPOSE"
 sed -i "s|hostname: spoke-syncthing|hostname: ${SPOKE_NAME}-syncthing|g" "$COMPOSE"

syncthing.sh

@@ -19,7 +19,7 @@ ST_CONTAINER=""
 get_apikey() {
     ST_CONTAINER=$(docker ps --format '{{.Names}}' | grep -i syncthing | head -1 || true)
     [ -n "$ST_CONTAINER" ] || die "No running Syncthing container found."
-    APIKEY=$(docker exec "$ST_CONTAINER" cat /var/syncthing/config/config.xml 2>/dev/null | grep -o '<apikey>[^<]*</apikey>' | sed 's/<[^>]*>//g' || true)
+    APIKEY=$(docker exec "$ST_CONTAINER" python3 -c "import xml.etree.ElementTree as ET; print(ET.parse('/var/syncthing/config/config.xml').find('.//apikey').text)" 2>/dev/null || true)
     [ -n "$APIKEY" ] || die "Could not read Syncthing API key from container '$ST_CONTAINER'."
 }
 
@@ -84,145 +84,6 @@ for device_id, info in devices.items():
     fi
 }
 
-show_ignored_folders() {
-    local config
-    config=$(st_get /rest/config)
-    local ignored
-    ignored=$(echo "$config" | python3 -c '
-import sys,json
-d=json.load(sys.stdin)
-folders = d.get("ignoredFolders", [])
-for f in folders:
-    print(f.get("id","?") + " — " + f.get("label","(no label)"))
-' 2>/dev/null || true)
-    if [ -z "$ignored" ]; then
-        info "No ignored folders."
-        return
-    fi
-    echo ""
-    warn "Ignored folders (click Ignore in WUI causes this):"
-    echo "$ignored" | sed 's/^/  /'
-    echo ""
-    read -rp "Un-ignore a folder? [y/N]: " UNIGNORE
-    UNIGNORE="${UNIGNORE:-n}"
-    if [[ "${UNIGNORE,,}" != "y" ]]; then return; fi
-
-    local folder_ids
-    folder_ids=$(echo "$config" | python3 -c '
-import sys,json
-d=json.load(sys.stdin)
-for f in d.get("ignoredFolders",[]):
-    print(f.get("id",""))
-' 2>/dev/null || true)
-
-    echo "Ignored folder IDs:"
-    local i=1
-    while IFS= read -r fid; do
-        echo "  $i) $fid"
-        i=$((i+1))
-    done <<< "$folder_ids"
-    read -rp "Choose folder number to un-ignore: " CHOICE
-    local TARGET_ID
-    TARGET_ID=$(echo "$folder_ids" | sed -n "${CHOICE}p")
-    [ -n "$TARGET_ID" ] || { warn "Invalid choice."; return; }
-
-    local new_config
-    new_config=$(echo "$config" | python3 -c "
-import sys,json
-d=json.load(sys.stdin)
-d['ignoredFolders'] = [f for f in d.get('ignoredFolders',[]) if f.get('id') != sys.argv[1]]
-print(json.dumps(d))
-" "$TARGET_ID")
-    st_put /rest/config "$new_config"
-    info "Folder $TARGET_ID removed from ignored list. It should now appear as pending."
-}
-
-show_pending_folders() {
-    header "Pending Folders"
-    local pending
-    pending=$(st_get /rest/cluster/pending/folders)
-    local count
-    count=$(echo "$pending" | python3 -c 'import sys,json; d=json.load(sys.stdin); print(len(d))')
-    if [ "$count" -eq 0 ]; then
-        warn "No pending folders."
-        echo ""
-        read -rp "Check ignored folders? [y/N]: " CHECK_IGNORED
-        if [[ "${CHECK_IGNORED,,}" == "y" ]]; then
-            show_ignored_folders
-        fi
-        return
-    fi
-    echo "$pending" | python3 -c '
-import sys,json
-d=json.load(sys.stdin)
-for fid,info in d.items():
-    label = info.get("label", "") or info.get("offeredBy", {})
-    label = list(info.get("offeredBy",{}).values())[0].get("receiveEncrypted","") if info.get("offeredBy") else ""
-    offered_by = list(info.get("offeredBy",{}).keys())
-    folder_label = ""
-    for dev_info in info.get("offeredBy",{}).values():
-        if dev_info.get("folderLabel"):
-            folder_label = dev_info["folderLabel"]
-            break
-    if folder_label:
-        print(f"  Folder Name: {folder_label}")
-    print(f"  Folder ID: {fid}")
-    print(f"  Offered by: {offered_by}")
-    print("")
-'
-    read -rp "Accept a pending folder? [y/N/R (retry/check ignored)]: " ACCEPT
-    ACCEPT="${ACCEPT:-n}"
-    if [[ "${ACCEPT,,}" == "r" ]]; then
-        show_ignored_folders
-        return
-    fi
-    if [[ "${ACCEPT,,}" != "y" ]]; then return; fi
-
-    local folder_ids folder_labels
-    folder_ids=$(echo "$pending" | python3 -c 'import sys,json; [print(k) for k in json.load(sys.stdin)]')
-    folder_labels=$(echo "$pending" | python3 -c '
-import sys,json
-d=json.load(sys.stdin)
-for fid,info in d.items():
-    label=""
-    for dev_info in info.get("offeredBy",{}).values():
-        if dev_info.get("folderLabel"):
-            label=dev_info["folderLabel"]
-            break
-    print(label if label else fid)
-')
-    local FOLDER_ID
-    if [ "$(echo "$folder_ids" | wc -l)" -eq 1 ]; then
-        FOLDER_ID="$folder_ids"
-    else
-        echo "Available pending folders:"
-        local i=1
-        while IFS= read -r fid && IFS= read -r flabel <&3; do
-            echo "  $i) $flabel ($fid)"
-            i=$((i+1))
-        done <<< "$folder_ids" 3<<< "$folder_labels"
-        read -rp "Choose folder number: " FOLDER_NUM
-        FOLDER_ID=$(echo "$folder_ids" | sed -n "${FOLDER_NUM}p")
-    fi
-    [ -n "$FOLDER_ID" ] || { warn "No folder selected."; return; }
-
-    echo ""
-    info "Available directories in /var/syncthing/data/:"
-    ls /var/syncthing/data/ 2>/dev/null | sed 's/^/  /' || true
-    echo ""
-    read -rp "Folder path on this device: " FOLDER_PATH
-    [ -n "$FOLDER_PATH" ] || { warn "Path cannot be empty."; return; }
-
-    read -rp "Folder label [$FOLDER_ID]: " FOLDER_LABEL
-    FOLDER_LABEL="${FOLDER_LABEL:-$FOLDER_ID}"
-
-    st_post /rest/config/folders "$(python3 -c "
-import json
-print(json.dumps({'id': '$FOLDER_ID', 'label': '$FOLDER_LABEL', 'path': '$FOLDER_PATH'}))
-")"
-    info "Folder '$FOLDER_LABEL' added at $FOLDER_PATH."
-}
-
 add_device_by_pending() {
     local pending="$1"
     local ids
@@ -575,7 +436,7 @@ get_apikey
 while true; do
     header "Syncthing Manager"
     echo "  0) Show This Device's ID"
-    echo "  1) Pending Devices & Folders"
+    echo "  1) Pending Devices"
     echo "  2) List Devices"
     echo "  3) Add Device"
     echo "  4) Remove Device"
@@ -590,7 +451,7 @@ while true; do
     echo ""
     case "$OPT" in
         0) show_own_device_id ;;
-        1) show_pending_devices; show_pending_folders ;;
+        1) show_pending_devices ;;
         2) list_devices ;;
         3) add_device ;;
         4) remove_device ;;