test

Dockerfile

@@ -0,0 +1,58 @@
+# Node 20 slim base suitable for VPS
+FROM node:20-slim
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# System deps for node-pty (node-gyp toolchain) and useful terminal tools
+RUN apt-get update && \
+    apt-get -o Acquire::Retries=3 -o Acquire::http::Timeout=30 install -y --no-install-recommends \
+      bash git python3 python3-pip python3-venv python-is-python3 build-essential \
+      tmux ncurses-term rclone rsync nano ssh curl && \
+    rm -rf /var/lib/apt/lists/* && \
+    pip install --no-cache-dir --break-system-packages PyInstaller
+
+# Python QoL defaults
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# Convenience symlinks for common typos
+RUN ln -sf /usr/bin/python3 /usr/local/bin/pyhon && \
+    ln -sf /usr/bin/python3 /usr/local/bin/ptyhon
+
+# install Claude Code CLI
+RUN npm install -g @anthropic-ai/claude-code
+
+WORKDIR /app
+
+# Preinstall Python packages used in terminal
+COPY requirements.txt ./
+RUN pip install --no-cache-dir --break-system-packages --timeout=60 -r requirements.txt || true
+
+# Node deps
+COPY package.json ./
+RUN npm install --production
+
+# App source
+COPY server.js ./
+COPY scripts ./scripts
+COPY public ./public
+
+# Make backup scripts available on PATH
+COPY scripts/download_claude_backup.sh /usr/local/bin/download_claude_backup.sh
+COPY scripts/upload_claude_backup.sh /usr/local/bin/upload_claude_backup.sh
+COPY scripts/terminal-anywhere-setup.sh /usr/local/bin/terminal-anywhere-setup.sh
+COPY scripts/setup.sh /usr/local/bin/setup.sh
+COPY scripts/ssh-setup.sh /usr/local/bin/ssh-setup
+RUN chmod +x /usr/local/bin/ssh-setup
+RUN chmod +x /usr/local/bin/download_claude_backup.sh
+RUN chmod +x /usr/local/bin/upload_claude_backup.sh
+RUN chmod +x /usr/local/bin/terminal-anywhere-setup.sh
+RUN chmod +x /usr/local/bin/setup.sh
+
+ENV PORT=7860 \
+    NODE_ENV=production
+EXPOSE 7860
+
+CMD ["sh", "-c", "/usr/local/bin/setup.sh"]
+

README.md

@@ -1,10 +1,55 @@
----
-title: Test Terminal
-emoji: 👀
-colorFrom: red
-colorTo: indigo
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**Overview**
+- Purpose: Secure, browser-based terminal you can deploy on a VPS using Docker. Uses `xterm.js` in the browser with a `node-pty` backend.
+- Security: Requires a shared secret token (`TERMINAL_TOKEN`) to open a terminal session.
+
+**Quick Start**
+- Build and run with Docker Compose:
+  - `cp .env.example .env` and fill in `TERMINAL_TOKEN` (and optional vars).
+  - `docker compose up -d --build`
+  - Open `http://<your-vps-ip>:<HOST_PORT>` and click Connect (enter token).
+
+**Environment**
+- `TERMINAL_TOKEN`: Shared secret required by the UI to connect.
+- `HOST_PORT`: Host port to expose (default 7860).
+- `JOB_WEBHOOK_TOKEN`: Optional. If set, secures `POST /tasks/heartbeat`.
+- `SLACK_BOT_TOKEN`, `SLACK_CHANNEL_ID`: Optional. Send heartbeats to Slack.
+- `PCLOUD_USERNAME`, `PCLOUD_PASSWORD`: Optional. Backup `~/.claude` to pCloud.
+- `HEARTBEAT_LOG_PATH`: Optional. Where heartbeat requests are logged.
+- `INSTALL_CLAUDE_CLI`: Optional `true|false`. Install Claude CLI during build.
+
+**Ports**
+- App listens on container port `7860`. Host port is controlled by `HOST_PORT` in `.env`.
+
+**Persistent Data**
+- Named volume `claude_data` is mounted at `/root/.claude` to persist Claude CLI tokens/config across restarts.
+
+**Docker**
+- Build image: `docker build -t claude-vps-web-terminal .`
+- Run container: `docker run -d --name claude-vps-web-terminal -p 7860:7860 -e TERMINAL_TOKEN=yourtoken -v claude_data:/root/.claude claude-vps-web-terminal`
+
+**Reverse Proxy (optional)**
+- Put behind nginx/traefik/caddy and forward WebSocket `Upgrade` headers.
+- Example nginx snippet:
+  - `location / { proxy_pass http://127.0.0.1:7860; proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection "upgrade"; proxy_set_header Host $host; }`
+
+**API Endpoints**
+- `GET /health`: Returns `ok`.
+- `POST /tasks/heartbeat`: Sends a message to Slack. If `JOB_WEBHOOK_TOKEN` is set, include header `Authorization: Bearer <token>` or `?token=` query.
+
+**Security Notes**
+- Always set a strong `TERMINAL_TOKEN`. Anyone with the token can open a shell in the container.
+- Use a firewall and/or reverse proxy to restrict access by IP if needed.
+- For TLS, terminate at your reverse proxy (nginx/traefik/caddy/Cloudflare) and forward to the container.
+
+**Files**
+- `server.js`: Express server and WebSocket bridge to `node-pty`.
+- `public/*`: Minimal terminal UI using `xterm.js`.
+- `scripts/upload_claude_to_pcloud.py`: Optional pCloud backup of `~/.claude` to `/claude-vps/.claude` and `~/.claude.json` to `/claude-vps`.
+- `scripts/download_claude_from_pcloud.py`: Restore backup from `/claude-vps/.claude` to `~/.claude` and `/claude-vps/.claude.json` to `~/.claude.json`. Supports `--overwrite` to replace existing local files.
+- `Dockerfile`: Node 20 base with Python + build tools for `node-pty` and terminal QoL tools (tmux, rclone, rsync).
+- `docker-compose.yml`: One-service stack with env vars and volume for persistence.
+
+**Local Dev**
+- `npm install`
+- `npm start` then visit `http://localhost:7860`.
+- Set `TERMINAL_TOKEN=yourtoken npm start` to require a token locally.

docker-compose.yml

@@ -0,0 +1,32 @@
+version: "3.9"
+services:
+  web-terminal:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      args:
+        # set to "true" to include the Claude CLI inside the image
+        INSTALL_CLAUDE_CLI: ${INSTALL_CLAUDE_CLI-false}
+    image: claude-vps-web-terminal:latest
+    container_name: claude-vps-web-terminal
+    restart: unless-stopped
+    ports:
+      - "${HOST_PORT-7860}:7860"
+    environment:
+      # required to gate access to the terminal UI
+      - TERMINAL_TOKEN=${TERMINAL_TOKEN}
+      # optional: provide SSH keys via env (used by entrypoint to create /root/.ssh)
+      - SSH_PUBLIC_KEY=${SSH_PUBLIC_KEY}
+      - SSH_PRIVATE_KEY=${SSH_PRIVATE_KEY}
+      - SSH_OPTS=${SSH_OPTS}
+      # optional: rsync remote for backup restore
+      - REMOTE_HOST=${REMOTE_HOST}
+      - REMOTE_PATH=${REMOTE_PATH}
+    volumes:
+      # persist Claude CLI auth/config across restarts
+      - claude_data:/root/.claude
+      # optional: persist tmp logs if desired
+      # - ./data/tmp:/tmp
+
+volumes:
+  claude_data: {}

package.json

@@ -0,0 +1,15 @@
+{
+  "name": "vps-web-terminal",
+  "version": "1.0.0",
+  "description": "Secure browser terminal for VPS using xterm.js + node-pty",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js"
+  },
+  "dependencies": {
+    "express": "^4.19.2",
+    "node-pty": "^1.0.0",
+    "ws": "^8.18.0"
+  }
+}
+

public/index.html

@@ -0,0 +1,101 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>VPS Web Terminal</title>
+  <link rel="stylesheet" href="https://unpkg.com/xterm/css/xterm.css" />
+  <link rel="stylesheet" href="/style.css" />
+  <meta http-equiv="Content-Security-Policy" content="default-src 'self'; style-src 'self' https://unpkg.com 'unsafe-inline'; script-src 'self' https://unpkg.com 'unsafe-inline'; connect-src 'self' ws: wss:; img-src 'self' data:;">
+  <meta http-equiv="Referrer-Policy" content="no-referrer" />
+</head>
+<body>
+  <div class="bar">
+    <div class="left">
+      <strong>Web Terminal</strong>
+    </div>
+    <div class="right">
+      <label>Token: <input id="token" type="password" placeholder="required if set" /></label>
+      <button id="connect">Connect</button>
+      <button id="clear">Clear</button>
+    </div>
+  </div>
+  <div id="terminal"></div>
+
+  <script src="https://unpkg.com/xterm/lib/xterm.js"></script>
+  <script src="https://unpkg.com/xterm-addon-fit/lib/xterm-addon-fit.js"></script>
+  <script>
+    const term = new window.Terminal({
+      fontFamily: 'Menlo, Monaco, Consolas, monospace',
+      fontSize: 14,
+      convertEol: true,
+      cursorBlink: true,
+      scrollback: 5000,
+      theme: { background: '#111111' }
+    });
+    const fitAddon = new window.FitAddon.FitAddon();
+    term.loadAddon(fitAddon);
+
+    const el = document.getElementById('terminal');
+    term.open(el);
+    fitAddon.fit();
+
+    let ws;
+
+    function connect() {
+      if (ws && ws.readyState === WebSocket.OPEN) return;
+      const token = document.getElementById('token').value.trim();
+      const proto = (location.protocol === 'https:') ? 'wss' : 'ws';
+      const url = `${proto}://${location.host}/ws${token ? `?token=${encodeURIComponent(token)}` : ''}`;
+      ws = new WebSocket(url);
+
+      ws.onopen = () => {
+        term.focus();
+        sendResize();
+      };
+
+      ws.onmessage = (ev) => {
+        try {
+          const msg = JSON.parse(ev.data);
+          if (msg.type === 'output' && typeof msg.data === 'string') {
+            term.write(msg.data);
+          }
+        } catch (_) {}
+      };
+
+      ws.onclose = (ev) => {
+        term.write(`\r\n\x1b[31m[disconnected: ${ev.code}]\x1b[0m\r\n`);
+      };
+
+      ws.onerror = () => {
+        term.write('\r\n\x1b[31m[ws error]\x1b[0m\r\n');
+      };
+    }
+
+    function sendResize() {
+      if (!ws || ws.readyState !== WebSocket.OPEN) return;
+      const cols = term.cols;
+      const rows = term.rows;
+      ws.send(JSON.stringify({ type: 'resize', cols, rows }));
+    }
+
+    // forward user keystrokes to pty
+    term.onData(data => {
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'input', data }));
+      }
+    });
+
+    window.addEventListener('resize', () => {
+      fitAddon.fit();
+      sendResize();
+    });
+
+    document.getElementById('connect').addEventListener('click', connect);
+    document.getElementById('clear').addEventListener('click', () => term.clear());
+
+    // initial hint
+    term.write('\x1b[32m[ready]\x1b[0m type to begin — click Connect first.\r\n');
+  </script>
+</body>
+</html>

public/style.css

@@ -0,0 +1,52 @@
+html, body {
+  height: 100%;
+  margin: 0;
+}
+
+body {
+  background: #111;
+  color: #eee;
+  font-family: -apple-system, BlinkMacSystemFont, Segoe UI, Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+}
+
+.bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 8px 12px;
+  background: #1b1b1b;
+  border-bottom: 1px solid #2a2a2a;
+}
+
+.right label {
+  margin-right: 8px;
+}
+
+#terminal {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 44px;
+  bottom: 0;
+}
+
+input[type="password"] {
+  background: #222;
+  color: #eee;
+  border: 1px solid #333;
+  padding: 4px 6px;
+}
+
+button {
+  background: #333;
+  color: #eee;
+  border: 1px solid #444;
+  padding: 4px 8px;
+  margin-left: 6px;
+  cursor: pointer;
+}
+
+button:hover {
+  background: #3a3a3a;
+}
+

requirements.txt

@@ -0,0 +1,10 @@
+mcp
+pcloud
+ptyprocess
+websockets
+gradio
+plotly
+rich
+textual
+asyncio
+psutil

run.sh

@@ -0,0 +1,2 @@
+docker compose up -d --build
+docker compose logs -f

scripts/download_claude_backup.sh

@@ -0,0 +1,343 @@
+#!/bin/bash
+
+# Claude Configuration Restore Script
+# Downloads ~/.claude.json and ~/.claude/ folder from rsync.net storage
+# Usage: ./download_claude_backup.sh [OPTIONS]
+
+set -euo pipefail
+
+# Allow environment overrides while keeping sane defaults
+REMOTE_HOST="${REMOTE_HOST:-zh5486@zh5486.rsync.net}"
+REMOTE_PATH="${REMOTE_PATH:-vps/claude_code/host_1}"
+# SSH options: accept new host keys automatically to avoid interactive prompt
+# You can override via SSH_OPTS env (e.g., to pin known_hosts instead)
+SSH_OPTS="${SSH_OPTS:--o StrictHostKeyChecking=accept-new}"
+LOG_DIR="$HOME/.claude_backup_logs"
+LOG_FILE="$LOG_DIR/download_$(date +%Y%m%d_%H%M%S).log"
+
+# Default values
+DEFAULT_DEST="$HOME"
+DEST_DIR="$DEFAULT_DEST"
+MODE="override"
+DRY_RUN=false
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Function to log messages
+log() {
+    local level=$1
+    shift
+    local message="$*"
+    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+    
+    # Create log directory if it doesn't exist
+    mkdir -p "$LOG_DIR"
+    
+    # Write to log file
+    echo "[$timestamp] [$level] $message" >> "$LOG_FILE"
+    
+    # Print to console with colors
+    case $level in
+        "ERROR") echo -e "${RED}[ERROR]${NC} $message" ;;
+        "SUCCESS") echo -e "${GREEN}[SUCCESS]${NC} $message" ;;
+        "WARNING") echo -e "${YELLOW}[WARNING]${NC} $message" ;;
+        "INFO") echo -e "${BLUE}[INFO]${NC} $message" ;;
+        *) echo "[$level] $message" ;;
+    esac
+}
+
+# Function to show usage
+show_help() {
+    cat << EOF
+Claude Configuration Restore Script
+
+Usage: $0 [OPTIONS]
+
+OPTIONS:
+    --override          Overwrite existing files (default)
+    --skip             Skip existing files, only download new/missing files
+    --dest PATH        Destination directory (default: $DEFAULT_DEST)
+    --dry-run          Show what would be downloaded without actually doing it
+    --help             Show this help message
+
+MODES:
+    --override: Downloads all files and overwrites existing ones
+                Creates backup of existing files before overwriting
+    
+    --skip:     Only downloads files that don't exist locally
+                Preserves all existing local files
+
+EXAMPLES:
+    $0                                    # Download to ~/ with override mode
+    $0 --skip                            # Download missing files only
+    $0 --dest /tmp/claude_restore        # Download to custom location
+    $0 --skip --dest /backup/claude      # Download missing files to custom location
+    $0 --dry-run                         # Preview what would be downloaded
+
+This script restores:
+    - .claude.json
+    - .claude/ folder
+
+From: $REMOTE_HOST:$REMOTE_PATH/
+
+Requirements:
+    - SSH key authentication must be set up for $REMOTE_HOST
+    - rsync must be installed
+
+Logs are saved to: $LOG_DIR/
+EOF
+}
+
+# Parse command line arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --override)
+            MODE="override"
+            shift
+            ;;
+        --skip)
+            MODE="skip"
+            shift
+            ;;
+        --dest)
+            if [[ -z "${2:-}" ]]; then
+                log "ERROR" "--dest requires a path argument"
+                exit 1
+            fi
+            DEST_DIR="$2"
+            shift 2
+            ;;
+        --dry-run)
+            DRY_RUN=true
+            shift
+            ;;
+        --help|-h)
+            show_help
+            exit 0
+            ;;
+        *)
+            log "ERROR" "Unknown option: $1"
+            show_help
+            exit 1
+            ;;
+    esac
+done
+
+# Validate and create destination directory
+setup_destination() {
+    # Expand tilde if present
+    DEST_DIR="${DEST_DIR/#\~/$HOME}"
+    
+    log "INFO" "Destination directory: $DEST_DIR"
+    log "INFO" "Mode: $MODE"
+    
+    if $DRY_RUN; then
+        log "INFO" "[DRY RUN] Would use destination: $DEST_DIR"
+        return
+    fi
+    
+    if [[ ! -d "$DEST_DIR" ]]; then
+        log "INFO" "Creating destination directory: $DEST_DIR"
+        if ! mkdir -p "$DEST_DIR"; then
+            log "ERROR" "Failed to create destination directory: $DEST_DIR"
+            exit 1
+        fi
+    fi
+    
+    if [[ ! -w "$DEST_DIR" ]]; then
+        log "ERROR" "Destination directory is not writable: $DEST_DIR"
+        exit 1
+    fi
+    
+    log "SUCCESS" "Destination directory ready: $DEST_DIR"
+}
+
+# Test SSH connection and check remote files
+test_remote_connection() {
+    log "INFO" "Testing SSH connection to $REMOTE_HOST..."
+    
+    if ! ssh $SSH_OPTS -o ConnectTimeout=10 -o BatchMode=yes "$REMOTE_HOST" "echo 'SSH connection successful'" >/dev/null 2>&1; then
+        log "ERROR" "Failed to connect to $REMOTE_HOST"
+        log "ERROR" "Please ensure:"
+        log "ERROR" "  1. SSH key authentication is set up"
+        log "ERROR" "  2. The host is reachable"
+        log "ERROR" "  3. Your SSH key is loaded (ssh-add -l)"
+        exit 1
+    fi
+    
+    log "SUCCESS" "SSH connection successful"
+    
+    # Check if remote backup directory exists
+    log "INFO" "Checking remote backup directory..."
+    if ! ssh $SSH_OPTS "$REMOTE_HOST" "test -d '$REMOTE_PATH'"; then
+        log "ERROR" "Remote backup directory does not exist: $REMOTE_PATH"
+        log "ERROR" "Please run the upload script first to create a backup"
+        exit 1
+    fi
+    
+    log "SUCCESS" "Remote backup directory found: $REMOTE_PATH"
+}
+
+# Create backup of existing files before override
+backup_existing_files() {
+    if [[ "$MODE" != "override" ]]; then
+        return
+    fi
+    
+    local backup_dir="$DEST_DIR/.claude_backup_$(date +%Y%m%d_%H%M%S)"
+    local files_to_backup=()
+    
+    # Check what exists locally
+    if [[ -f "$DEST_DIR/.claude.json" ]]; then
+        files_to_backup+=(".claude.json")
+    fi
+    
+    if [[ -d "$DEST_DIR/.claude" ]]; then
+        files_to_backup+=(".claude/")
+    fi
+    
+    if [[ ${#files_to_backup[@]} -eq 0 ]]; then
+        log "INFO" "No existing files to backup"
+        return
+    fi
+    
+    if $DRY_RUN; then
+        log "INFO" "[DRY RUN] Would backup existing files to: $backup_dir"
+        for file in "${files_to_backup[@]}"; do
+            log "INFO" "[DRY RUN] Would backup: $DEST_DIR/$file"
+        done
+        return
+    fi
+    
+    log "INFO" "Creating backup of existing files..."
+    mkdir -p "$backup_dir"
+    
+    for file in "${files_to_backup[@]}"; do
+        log "INFO" "Backing up existing: $file"
+        if cp -r "$DEST_DIR/$file" "$backup_dir/"; then
+            log "SUCCESS" "Backed up: $file to $backup_dir/"
+        else
+            log "WARNING" "Failed to backup: $file"
+        fi
+    done
+}
+
+# Download files using rsync
+download_files() {
+    local rsync_opts="-avz --progress"
+    
+    case $MODE in
+        "override")
+            # Default rsync behavior - overwrites existing files
+            ;;
+        "skip")
+            # Skip existing files
+            rsync_opts="$rsync_opts --ignore-existing"
+            ;;
+    esac
+    
+    if $DRY_RUN; then
+        rsync_opts="$rsync_opts --dry-run"
+        log "INFO" "[DRY RUN] Showing what would be downloaded..."
+    else
+        log "INFO" "Starting download from $REMOTE_HOST:$REMOTE_PATH"
+        log "INFO" "Using mode: $MODE"
+    fi
+    
+    # Download .claude.json if it exists remotely
+    log "INFO" "Checking for .claude.json on remote server..."
+    if ssh $SSH_OPTS "$REMOTE_HOST" "test -f '$REMOTE_PATH/.claude.json'"; then
+        log "INFO" "Downloading .claude.json..."
+        if rsync -e "ssh $SSH_OPTS" $rsync_opts "$REMOTE_HOST:$REMOTE_PATH/.claude.json" "$DEST_DIR/"; then
+            if ! $DRY_RUN; then
+                log "SUCCESS" ".claude.json downloaded successfully"
+            fi
+        else
+            log "ERROR" "Failed to download .claude.json"
+            exit 1
+        fi
+    else
+        log "WARNING" ".claude.json not found on remote server"
+    fi
+    
+    # Download .claude folder if it exists remotely
+    log "INFO" "Checking for .claude/ folder on remote server..."
+    if ssh $SSH_OPTS "$REMOTE_HOST" "test -d '$REMOTE_PATH/claude'"; then
+        log "INFO" "Downloading .claude/ folder..."
+        
+        # Create local .claude directory if it doesn't exist
+        if ! $DRY_RUN && [[ ! -d "$DEST_DIR/.claude" ]]; then
+            mkdir -p "$DEST_DIR/.claude"
+        fi
+        
+        if rsync -e "ssh $SSH_OPTS" $rsync_opts "$REMOTE_HOST:$REMOTE_PATH/claude/" "$DEST_DIR/.claude/"; then
+            if ! $DRY_RUN; then
+                log "SUCCESS" ".claude/ folder downloaded successfully"
+            fi
+        else
+            log "ERROR" "Failed to download .claude/ folder"
+            exit 1
+        fi
+    else
+        log "WARNING" ".claude/ folder not found on remote server"
+    fi
+}
+
+# Show summary of what was downloaded/would be downloaded
+show_summary() {
+    log "INFO" "Download summary:"
+    log "INFO" "  Source: $REMOTE_HOST:$REMOTE_PATH"
+    log "INFO" "  Destination: $DEST_DIR"
+    log "INFO" "  Mode: $MODE"
+    
+    if $DRY_RUN; then
+        log "INFO" "  Status: DRY RUN - no files were actually transferred"
+    else
+        log "INFO" "  Status: Completed successfully"
+        
+        # Show what was actually downloaded
+        if [[ -f "$DEST_DIR/.claude.json" ]]; then
+            log "INFO" "  Downloaded: .claude.json"
+        fi
+        
+        if [[ -d "$DEST_DIR/.claude" ]]; then
+            log "INFO" "  Downloaded: .claude/ folder"
+        fi
+    fi
+}
+
+# Main execution
+main() {
+    log "INFO" "Starting Claude configuration restore..."
+    log "INFO" "Log file: $LOG_FILE"
+    
+    if $DRY_RUN; then
+        log "INFO" "Running in DRY RUN mode - no files will be transferred"
+    fi
+    
+    setup_destination
+    test_remote_connection
+    backup_existing_files
+    download_files
+    show_summary
+    
+    if $DRY_RUN; then
+        log "INFO" "[DRY RUN] Restore simulation completed"
+    else
+        log "SUCCESS" "Restore completed successfully!"
+    fi
+}
+
+# Check if rsync is available
+if ! command -v rsync &> /dev/null; then
+    log "ERROR" "rsync is not installed. Please install rsync first."
+    exit 1
+fi
+
+# Run main function
+main "$@"

scripts/setup.sh

@@ -0,0 +1,4 @@
+echo "test"
+/usr/local/bin/ssh-setup 2>&1
+/usr/local/bin/terminal-anywhere-setup.sh 2>&1
+node server

scripts/ssh-setup.sh

@@ -0,0 +1,58 @@
+#!/usr/bin/env sh
+set -eu
+
+
+if [ -f /.env ]; then
+   export $(grep -v '^#' /.env | xargs)
+fi
+# Write SSH keys from env vars into /root/.ssh with correct permissions.
+# Handles both real newlines and literal \n sequences in SSH_PRIVATE_KEY.
+
+HOME_DIR="${HOME:-/root}"
+SSH_DIR="$HOME_DIR/.ssh"
+
+mkdir -p "$SSH_DIR"
+chmod 700 "$SSH_DIR"
+
+echo "created folder $SSH_DIR"
+
+# Public key (optional)
+if [ -n "${SSH_PUBLIC_KEY:-}" ]; then
+  printf "%s\n" "$SSH_PUBLIC_KEY" > "$SSH_DIR/id_rsa.pub"
+  echo "Created id_rsa.pub"
+  chmod 644 "$SSH_DIR/id_rsa.pub"
+fi
+
+# Private key (optional)
+if [ -n "${SSH_PRIVATE_KEY:-}" ]; then
+  # If the key contains literal \n sequences, convert them to newlines.
+  if printf "%s" "$SSH_PRIVATE_KEY" | grep -q '\\n'; then
+    printf "%s" "$SSH_PRIVATE_KEY" | sed 's/\\n/\n/g' > "$SSH_DIR/id_rsa"
+    echo "created id_rsa"
+  else
+    printf "%s" "$SSH_PRIVATE_KEY" > "$SSH_DIR/id_rsa"
+  fi
+  chmod 600 "$SSH_DIR/id_rsa"
+fi
+
+# Prime known_hosts to avoid host key prompts for common git hosts
+if command -v ssh-keyscan >/dev/null 2>&1; then
+  for host in github.com gitlab.com; do
+    ssh-keyscan -H "$host" 2>/dev/null >> "$SSH_DIR/known_hosts" || true
+  done
+  # Optionally pre-seed remote backup host if provided via REMOTE_HOST (user@host)
+  if [ -n "${REMOTE_HOST:-}" ]; then
+    remote_host_domain="$(printf "%s" "$REMOTE_HOST" | awk -F'@' '{print $NF}')"
+    if [ -n "$remote_host_domain" ]; then
+      ssh-keyscan -H "$remote_host_domain" 2>/dev/null >> "$SSH_DIR/known_hosts" || true
+    fi
+  fi
+  chmod 644 "$SSH_DIR/known_hosts" || true
+fi
+
+
+#rm /app/scripts/*.sh
+#rm ~/.ssh/id_rsa
+#rm ~/.ssh/id_rsa.pub
+
+exec "$@"

scripts/terminal-anywhere-setup.sh

@@ -0,0 +1,7 @@
+echo "setup terminal-anywhere"
+echo "clone repo"
+cd ~/
+rm -f -r terminal-anywhere-source
+/usr/bin/git clone git@github.com:scantrancher/terminal-anywhere-source.git
+cd ~/terminal-anywhere-source/
+/usr/bin/bash run.sh

scripts/upload_claude_backup.sh

@@ -0,0 +1,209 @@
+#!/bin/bash
+
+# Claude Configuration Backup Script
+# Backs up ~/.claude.json and ~/.claude/ folder to rsync.net storage
+# Usage: ./upload_claude_backup.sh [--dry-run]
+
+set -euo pipefail
+
+REMOTE_HOST="zh5486@zh5486.rsync.net"
+REMOTE_PATH="vps/claude_code/host_1"
+LOG_DIR="$HOME/.claude_backup_logs"
+LOG_FILE="$LOG_DIR/upload_$(date +%Y%m%d_%H%M%S).log"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Function to log messages
+log() {
+    local level=$1
+    shift
+    local message="$*"
+    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+    
+    # Create log directory if it doesn't exist
+    mkdir -p "$LOG_DIR"
+    
+    # Write to log file
+    echo "[$timestamp] [$level] $message" >> "$LOG_FILE"
+    
+    # Print to console with colors
+    case $level in
+        "ERROR") echo -e "${RED}[ERROR]${NC} $message" ;;
+        "SUCCESS") echo -e "${GREEN}[SUCCESS]${NC} $message" ;;
+        "WARNING") echo -e "${YELLOW}[WARNING]${NC} $message" ;;
+        "INFO") echo -e "${BLUE}[INFO]${NC} $message" ;;
+        *) echo "[$level] $message" ;;
+    esac
+}
+
+# Function to show usage
+show_help() {
+    cat << EOF
+Claude Configuration Backup Script
+
+Usage: $0 [OPTIONS]
+
+OPTIONS:
+    --dry-run    Show what would be backed up without actually doing it
+    --help       Show this help message
+
+This script backs up:
+    - ~/.claude.json
+    - ~/.claude/ folder
+
+To: $REMOTE_HOST:$REMOTE_PATH/
+
+Requirements:
+    - SSH key authentication must be set up for $REMOTE_HOST
+    - rsync must be installed
+
+Logs are saved to: $LOG_DIR/
+EOF
+}
+
+# Parse command line arguments
+DRY_RUN=false
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --dry-run)
+            DRY_RUN=true
+            shift
+            ;;
+        --help|-h)
+            show_help
+            exit 0
+            ;;
+        *)
+            log "ERROR" "Unknown option: $1"
+            show_help
+            exit 1
+            ;;
+    esac
+done
+
+# Check if required files/folders exist
+check_source_files() {
+    local missing_files=()
+    
+    if [[ ! -f "$HOME/.claude.json" ]]; then
+        missing_files+=("~/.claude.json")
+    fi
+    
+    if [[ ! -d "$HOME/.claude" ]]; then
+        missing_files+=("~/.claude/")
+    fi
+    
+    if [[ ${#missing_files[@]} -gt 0 ]]; then
+        log "WARNING" "Some Claude configuration files are missing:"
+        for file in "${missing_files[@]}"; do
+            log "WARNING" "  - $file"
+        done
+        log "WARNING" "Backup will proceed with available files only."
+    fi
+}
+
+# Test SSH connection
+test_ssh_connection() {
+    log "INFO" "Testing SSH connection to $REMOTE_HOST..."
+    
+    if ! ssh -o ConnectTimeout=10 -o BatchMode=yes "$REMOTE_HOST" "echo 'SSH connection successful'" >/dev/null 2>&1; then
+        log "ERROR" "Failed to connect to $REMOTE_HOST"
+        log "ERROR" "Please ensure:"
+        log "ERROR" "  1. SSH key authentication is set up"
+        log "ERROR" "  2. The host is reachable"
+        log "ERROR" "  3. Your SSH key is loaded (ssh-add -l)"
+        exit 1
+    fi
+    
+    log "SUCCESS" "SSH connection successful"
+}
+
+# Create remote directory if it doesn't exist
+create_remote_directory() {
+    log "INFO" "Creating remote directory structure..."
+    
+    if $DRY_RUN; then
+        log "INFO" "[DRY RUN] Would create directory: $REMOTE_HOST:$REMOTE_PATH"
+        return
+    fi
+    
+    if ssh "$REMOTE_HOST" "mkdir -p '$REMOTE_PATH'"; then
+        log "SUCCESS" "Remote directory ready: $REMOTE_PATH"
+    else
+        log "ERROR" "Failed to create remote directory: $REMOTE_PATH"
+        exit 1
+    fi
+}
+
+# Backup files using rsync
+backup_files() {
+    local rsync_opts="-avz --progress --delete"
+    
+    if $DRY_RUN; then
+        rsync_opts="$rsync_opts --dry-run"
+        log "INFO" "[DRY RUN] Showing what would be backed up..."
+    else
+        log "INFO" "Starting backup to $REMOTE_HOST:$REMOTE_PATH"
+    fi
+    
+    # Backup .claude.json if it exists
+    if [[ -f "$HOME/.claude.json" ]]; then
+        log "INFO" "Backing up ~/.claude.json..."
+        if rsync $rsync_opts "$HOME/.claude.json" "$REMOTE_HOST:$REMOTE_PATH/"; then
+            if ! $DRY_RUN; then
+                log "SUCCESS" "~/.claude.json backed up successfully"
+            fi
+        else
+            log "ERROR" "Failed to backup ~/.claude.json"
+            exit 1
+        fi
+    fi
+    
+    # Backup .claude folder if it exists
+    if [[ -d "$HOME/.claude" ]]; then
+        log "INFO" "Backing up ~/.claude/ folder..."
+        if rsync $rsync_opts "$HOME/.claude/" "$REMOTE_HOST:$REMOTE_PATH/claude/"; then
+            if ! $DRY_RUN; then
+                log "SUCCESS" "~/.claude/ folder backed up successfully"
+            fi
+        else
+            log "ERROR" "Failed to backup ~/.claude/ folder"
+            exit 1
+        fi
+    fi
+}
+
+# Main execution
+main() {
+    log "INFO" "Starting Claude configuration backup..."
+    log "INFO" "Log file: $LOG_FILE"
+    
+    if $DRY_RUN; then
+        log "INFO" "Running in DRY RUN mode - no files will be transferred"
+    fi
+    
+    check_source_files
+    test_ssh_connection
+    create_remote_directory
+    backup_files
+    
+    if $DRY_RUN; then
+        log "INFO" "[DRY RUN] Backup simulation completed"
+    else
+        log "SUCCESS" "Backup completed successfully!"
+        log "INFO" "Remote location: $REMOTE_HOST:$REMOTE_PATH"
+    fi
+}
+
+# Check if rsync is available
+if ! command -v rsync &> /dev/null; then
+    log "ERROR" "rsync is not installed. Please install rsync first."
+    exit 1
+fi
+
+# Run main function

server.js

@@ -0,0 +1,137 @@
+const http = require('http');
+const express = require('express');
+const path = require('path');
+const fs = require('fs');
+const { WebSocketServer } = require('ws');
+const { spawn } = require('child_process');
+const pty = require('node-pty');
+
+const app = express();
+const server = http.createServer(app);
+
+const PORT = process.env.PORT || 7860;
+const TERMINAL_TOKEN = process.env.TERMINAL_TOKEN || ""; // set in env for security
+const JOB_WEBHOOK_TOKEN = process.env.JOB_WEBHOOK_TOKEN || ""; // bearer token for webhook auth
+const SLACK_BOT_TOKEN = process.env.SLACK_BOT_TOKEN || ""; // xoxb- token from Slack app
+const SLACK_CHANNEL_ID = process.env.SLACK_CHANNEL_ID || ""; // channel ID to post heartbeat
+const HEARTBEAT_LOG_PATH = process.env.HEARTBEAT_LOG_PATH || '/tmp/heartbeat.log';
+
+// If behind a reverse proxy (nginx/traefik), trust X-Forwarded-* for req.ip
+app.set('trust proxy', true);
+
+// Serve static client
+app.use(express.static(path.join(__dirname, 'public')));
+// JSON parser for webhook
+app.use(express.json());
+
+// Basic liveness endpoint
+app.get('/health', (_req, res) => res.status(200).send('ok'));
+
+// Minimal webhook to send a heartbeat message to Slack
+app.post('/tasks/heartbeat', async (req, res) => {
+  try {
+    const authHeader = req.headers['authorization'] || '';
+    const bearer = authHeader.startsWith('Bearer ')
+      ? authHeader.slice('Bearer '.length)
+      : (req.query.token || '');
+    // Enforce only when JOB_WEBHOOK_TOKEN is set
+    if (JOB_WEBHOOK_TOKEN && bearer !== JOB_WEBHOOK_TOKEN) {
+      return res.sendStatus(401);
+    }
+    if (!SLACK_BOT_TOKEN || !SLACK_CHANNEL_ID) {
+      return res.status(500).json({ error: 'Slack not configured' });
+    }
+
+    const now = new Date().toISOString();
+    const host = req.headers.host || 'unknown-host';
+    const text = `Heartbeat: VPS web terminal alive at ${now} (host: ${host})`;
+
+    const resp = await fetch('https://slack.com/api/chat.postMessage', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${SLACK_BOT_TOKEN}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({ channel: SLACK_CHANNEL_ID, text })
+    });
+    const data = await resp.json().catch(() => ({}));
+    const ip = req.ip;
+    const ua = req.headers['user-agent'] || '';
+    const logLine = `${now}\tip=${ip}\tua=${JSON.stringify(ua)}\tstatus=${data && data.ok ? 'ok' : 'error'}\n`;
+    try {
+      const dir = path.dirname(HEARTBEAT_LOG_PATH);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.appendFileSync(HEARTBEAT_LOG_PATH, logLine, 'utf8');
+    } catch (_) { /* ignore log failures */ }
+
+    // Kick off pCloud backup: ~/.claude -> /claude-vps/.claude and ~/.claude.json -> /claude-vps (non-blocking)
+    try {
+      const child = spawn('python', ['scripts/upload_claude_to_pcloud.py'], {
+        cwd: __dirname,
+        stdio: 'inherit',
+        env: process.env,
+        detached: false
+      });
+      // no await; run in background
+    } catch (_) { /* ignore spawn errors */ }
+
+    if (!data.ok) {
+      return res.status(502).json({ error: 'Slack API error', details: data });
+    }
+    return res.status(202).json({ ok: true, ts: data.ts, channel: data.channel });
+  } catch (err) {
+    return res.status(500).json({ error: 'server_error' });
+  }
+});
+
+// WebSocket for terminal
+const wss = new WebSocketServer({ server, path: '/ws' });
+
+wss.on('connection', (ws, req) => {
+  try {
+    // Simple shared-secret check via query string: /ws?token=...
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const token = url.searchParams.get('token') || '';
+    if (TERMINAL_TOKEN && token !== TERMINAL_TOKEN) {
+      ws.close(1008, 'Invalid token'); // Policy Violation
+      return;
+    }
+
+    const shell = process.env.SHELL || '/bin/bash';
+
+    const ptyProcess = pty.spawn(shell, ['-l'], {
+      name: 'xterm-256color',
+      cols: 80,
+      rows: 24,
+      cwd: process.env.HOME || process.cwd(),
+      env: process.env
+    });
+
+    ptyProcess.onData(data => {
+      if (ws.readyState === ws.OPEN) {
+        ws.send(JSON.stringify({ type: 'output', data }));
+      }
+    });
+
+    ws.on('message', (msg) => {
+      try {
+        const { type, data, cols, rows } = JSON.parse(msg.toString());
+        if (type === 'input' && typeof data === 'string') {
+          ptyProcess.write(data);
+        } else if (type === 'resize' && Number.isInteger(cols) && Number.isInteger(rows)) {
+          ptyProcess.resize(cols, rows);
+        }
+      } catch (_) {/* ignore malformed */}
+    });
+
+    ws.on('close', () => {
+      try { ptyProcess.kill(); } catch (_) {}
+    });
+  } catch (err) {
+    try { ws.close(1011, 'Server error'); } catch (_) {}
+  }
+});
+
+server.listen(PORT, '0.0.0.0', () => {
+  console.log(`Web terminal listening on :${PORT}`);
+});