mtr-cli 0.2.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

mtr/sync.py

@@ -1,4 +1,3 @@
-import fnmatch
 import os
 import shlex
 import shutil
@@ -6,243 +5,23 @@ import subprocess
 from abc import ABC, abstractmethod
 from typing import List, Optional
 
-import paramiko
-
 
 class SyncError(Exception):
     pass
 
 
 class BaseSyncer(ABC):
-    def __init__(self, local_dir: str, remote_dir: str, exclude: List[str]):
+    def __init__(self, local_dir: str, remote_dir: str, exclude: List[str], respect_gitignore: bool = True):
         self.local_dir = local_dir
         self.remote_dir = remote_dir
         self.exclude = exclude
+        self.respect_gitignore = respect_gitignore
 
     @abstractmethod
-    def sync(self):
+    def sync(self, show_progress: bool = False, progress_callback=None):
         pass
 
 
-class SftpSyncer(BaseSyncer):
-    def __init__(
-        self,
-        local_dir: str,
-        remote_dir: str,
-        host: str,
-        user: str,
-        key_filename: Optional[str] = None,
-        password: Optional[str] = None,
-        port: int = 22,
-        exclude: List[str] = None,
-    ):
-        super().__init__(local_dir, remote_dir, exclude or [])
-        self.host = host
-        self.user = user
-        self.key_filename = key_filename
-        self.password = password
-        self.port = port
-        self.transport = None
-        self.sftp = None
-
-    def _should_ignore(self, filename: str) -> bool:
-        for pattern in self.exclude:
-            # Handle directory exclusion (basic)
-            if pattern.endswith("/") and filename.startswith(pattern.rstrip("/")):
-                return True
-            if fnmatch.fnmatch(filename, pattern):
-                return True
-        return False
-
-    def _connect(self):
-        try:
-            self.transport = paramiko.Transport((self.host, self.port))
-            connect_kwargs = {"username": self.user}
-
-            if self.key_filename:
-                key_path = os.path.expanduser(self.key_filename)
-                # Try different key types? For now assuming RSA or standard loading
-                # Or just use connect method of SSHClient? No, Sftp is lower level usually,
-                # but we can use SSHClient to get sftp
-
-                # Simpler approach: Use SSHClientWrapper logic or just Paramiko SSHClient
-                client = paramiko.SSHClient()
-                client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-
-                k_kwargs = {
-                    "hostname": self.host,
-                    "username": self.user,
-                    "port": self.port,
-                    "key_filename": key_path,
-                }
-                if self.password:
-                    k_kwargs["password"] = self.password
-
-                client.connect(**k_kwargs)
-                self.sftp = client.open_sftp()
-                return
-
-            if self.password:
-                connect_kwargs["password"] = self.password
-                self.transport.connect(**connect_kwargs)
-                self.sftp = paramiko.SFTPClient.from_transport(self.transport)
-            else:
-                raise SyncError("No auth method provided (need key or password)")
-
-        except Exception as e:
-            raise SyncError(f"SFTP Connection failed: {e}")
-
-    def _ensure_remote_dir(self, remote_path: str):
-        """Recursively create remote directory."""
-        # This is a bit expensive, optimization: assume parent exists or try/except
-        # Simple implementation:
-        dirs = remote_path.split("/")
-        current = ""
-        for d in dirs:
-            if not d:
-                continue
-            current += f"/{d}"
-            try:
-                self.sftp.stat(current)
-            except FileNotFoundError:
-                try:
-                    self.sftp.mkdir(current)
-                except OSError:
-                    pass  # Already exists maybe
-
-    def sync(self):
-        if not self.sftp:
-            self._connect()
-
-        # Ensure base remote dir exists
-        try:
-            self.sftp.stat(self.remote_dir)
-        except FileNotFoundError:
-            self._ensure_remote_dir(self.remote_dir)
-
-        # Walk local tree
-        for root, dirs, files in os.walk(self.local_dir):
-            # Filtering dirs in place to prevent recursion
-            dirs[:] = [d for d in dirs if not self._should_ignore(d)]
-
-            rel_path = os.path.relpath(root, self.local_dir)
-            if rel_path == ".":
-                remote_root = self.remote_dir
-            else:
-                remote_root = os.path.join(self.remote_dir, rel_path)
-
-                # Check/Create remote dir
-                try:
-                    self.sftp.stat(remote_root)
-                except FileNotFoundError:
-                    self.sftp.mkdir(remote_root)
-
-            for file in files:
-                if self._should_ignore(file):
-                    continue
-
-                local_file = os.path.join(root, file)
-                remote_file = os.path.join(remote_root, file)
-
-                # Check sync necessity (Size & Mtime)
-                should_upload = True
-                try:
-                    remote_stat = self.sftp.stat(remote_file)
-                    local_stat = os.stat(local_file)
-
-                    if remote_stat.st_size == local_stat.st_size and int(remote_stat.st_mtime) >= int(local_stat.st_mtime):
-                        should_upload = False
-                except FileNotFoundError:
-                    pass  # Does not exist, must upload
-
-                if should_upload:
-                    # print(f"Uploading {local_file} -> {remote_file}")
-                    self.sftp.put(local_file, remote_file)
-                    # Preserve permissions
-                    mode = os.stat(local_file).st_mode
-                    self.sftp.chmod(remote_file, mode)
-
-        if self.sftp:
-            self.sftp.close()
-        if self.transport:
-            self.transport.close()
-
-    def download(self, remote_path: str, local_path: str):
-        """Download file or directory from remote to local."""
-        if not self.sftp:
-            self._connect()
-
-        try:
-            # Ensure local directory exists
-            local_dir = os.path.dirname(local_path)
-            if local_dir and not os.path.exists(local_dir):
-                os.makedirs(local_dir, exist_ok=True)
-
-            try:
-                import stat
-
-                remote_stat = self.sftp.stat(remote_path)
-                is_dir = stat.S_ISDIR(remote_stat.st_mode)
-
-                if is_dir:
-                    self._download_dir(remote_path, local_path)
-                else:
-                    self._download_file(remote_path, local_path)
-            except FileNotFoundError:
-                raise SyncError(f"Remote path not found: {remote_path}")
-            except Exception as e:
-                raise SyncError(f"Download failed: {e}")
-        finally:
-            if self.sftp:
-                self.sftp.close()
-            if self.transport:
-                self.transport.close()
-
-    def _should_download_file(self, remote_file: str, local_file: str) -> bool:
-        """Check if file should be downloaded based on size and mtime."""
-        try:
-            remote_stat = self.sftp.stat(remote_file)
-            local_stat = os.stat(local_file)
-
-            # Size different, need download
-            if remote_stat.st_size != local_stat.st_size:
-                return True
-
-            # Remote file is newer than local file
-            return int(remote_stat.st_mtime) > int(local_stat.st_mtime)
-        except FileNotFoundError:
-            return True  # Local file doesn't exist, must download
-
-    def _download_file(self, remote_file: str, local_file: str):
-        """Download a single file with incremental check."""
-        if not self._should_download_file(remote_file, local_file):
-            return  # No need to download
-
-        self.sftp.get(remote_file, local_file)
-        # Preserve permissions
-        remote_stat = self.sftp.stat(remote_file)
-        os.chmod(local_file, remote_stat.st_mode)
-
-    def _download_dir(self, remote_dir: str, local_dir: str):
-        """Recursively download a directory."""
-        if not os.path.exists(local_dir):
-            os.makedirs(local_dir, exist_ok=True)
-
-        for entry in self.sftp.listdir_attr(remote_dir):
-            remote_path = f"{remote_dir}/{entry.filename}"
-            local_path = os.path.join(local_dir, entry.filename)
-
-            if self._should_ignore(entry.filename):
-                continue
-
-            import stat
-
-            if stat.S_ISDIR(entry.st_mode):
-                self._download_dir(remote_path, local_path)
-            else:
-                self._download_file(remote_path, local_path)
-
-
 class RsyncSyncer(BaseSyncer):
     def __init__(
         self,
@@ -254,8 +33,9 @@ class RsyncSyncer(BaseSyncer):
         password: Optional[str] = None,
         port: int = 22,
         exclude: List[str] = None,
+        respect_gitignore: bool = True,
     ):
-        super().__init__(local_dir, remote_dir, exclude or [])
+        super().__init__(local_dir, remote_dir, exclude or [], respect_gitignore)
         self.host = host
         self.user = user
         self.key_filename = key_filename
@@ -269,9 +49,20 @@ class RsyncSyncer(BaseSyncer):
             opts += f" -i {self.key_filename}"
         return opts
 
-    def _build_rsync_base(self) -> List[str]:
+    def _build_rsync_base(self, show_progress: bool = False) -> List[str]:
         """Build rsync base command with common options."""
-        cmd = ["rsync", "-azq"]
+        if show_progress:
+            # In progress mode, use -av --info=NAME to show filenames only
+            cmd = ["rsync", "-av", "--info=NAME"]
+        else:
+            # Silent mode
+            cmd = ["rsync", "-azq"]
+
+        # Add gitignore filter if enabled
+        if self.respect_gitignore:
+            gitignore_path = os.path.join(self.local_dir, ".gitignore")
+            if os.path.exists(gitignore_path):
+                cmd.append("--filter=:- .gitignore")
 
         # Add excludes
         for item in self.exclude:
@@ -294,35 +85,115 @@ class RsyncSyncer(BaseSyncer):
             if not shutil.which("sshpass"):
                 raise SyncError("Rsync with password requires 'sshpass'. Please install it or use SSH Key.")
 
-    def _build_rsync_command(self) -> List[str]:
+    def _check_rsync_version(self) -> tuple:
+        """Check local rsync version and return (major, minor, patch) tuple.
+
+        Returns:
+            Tuple of (major, minor, patch) version numbers
+        Raises:
+            SyncError: If rsync is not installed or version cannot be parsed
+        """
+        try:
+            result = subprocess.run(["rsync", "--version"], capture_output=True, text=True, timeout=5)
+            if result.returncode != 0:
+                raise SyncError("Failed to check rsync version. Is rsync installed?")
+
+            # Parse version from first line, e.g., "rsync  version 3.2.5  protocol version 31"
+            first_line = result.stdout.split("\n")[0]
+            import re
+
+            match = re.search(r"version\s+(\d+)\.(\d+)\.(\d+)", first_line)
+            if not match:
+                # Try alternative format: "rsync version 2.6.9 compatible"
+                match = re.search(r"version\s+(\d+)\.(\d+)\.(\d+)", first_line)
+                if not match:
+                    raise SyncError(f"Cannot parse rsync version from: {first_line}")
+
+            major, minor, patch = int(match.group(1)), int(match.group(2)), int(match.group(3))
+            return (major, minor, patch)
+        except FileNotFoundError:
+            raise SyncError("rsync not found. Please install rsync.")
+        except subprocess.TimeoutExpired:
+            raise SyncError("Timeout while checking rsync version.")
+        except Exception as e:
+            raise SyncError(f"Failed to check rsync version: {e}")
+
+    def _is_rsync_version_supported(self, min_version: tuple = (3, 1, 0)) -> bool:
+        """Check if local rsync version meets minimum requirement.
+
+        Args:
+            min_version: Minimum required version as (major, minor, patch) tuple
+        Returns:
+            True if version is supported, False otherwise
+        """
+        try:
+            current_version = self._check_rsync_version()
+            return current_version >= min_version
+        except SyncError:
+            return False
+
+    def _build_rsync_command(self, show_progress: bool = False) -> List[str]:
         """Build rsync command for uploading (local -> remote)."""
         # Ensure local dir ends with / to sync contents, not the dir itself
         src = self.local_dir if self.local_dir.endswith("/") else f"{self.local_dir}/"
         dest = f"{self.user}@{self.host}:{shlex.quote(self.remote_dir)}"
 
-        cmd = self._build_rsync_base()
+        cmd = self._build_rsync_base(show_progress=show_progress)
         cmd.extend([src, dest])
 
         return self._wrap_with_sshpass(cmd)
 
-    def _build_rsync_download_command(self, remote_path: str, local_path: str) -> List[str]:
+    def _build_rsync_download_command(self, remote_path: str, local_path: str, show_progress: bool = False) -> List[str]:
         """Build rsync command for downloading (remote -> local)."""
         src = f"{self.user}@{self.host}:{shlex.quote(remote_path)}"
 
-        cmd = self._build_rsync_base()
+        cmd = self._build_rsync_base(show_progress=show_progress)
         cmd.extend([src, local_path])
 
         return self._wrap_with_sshpass(cmd)
 
-    def sync(self):
+    def sync(self, show_progress: bool = False, progress_callback=None):
         self._check_sshpass()
-        cmd = self._build_rsync_command()
+
+        # Check rsync version if progress mode is requested
+        if show_progress and progress_callback:
+            if not self._is_rsync_version_supported():
+                version = self._check_rsync_version()
+                raise SyncError(
+                    f"rsync version {version[0]}.{version[1]}.{version[2]} is too old. "
+                    f"Progress display requires rsync >= 3.1.0. "
+                    f"Please upgrade rsync or use --no-tty mode."
+                )
+
+        cmd = self._build_rsync_command(show_progress=show_progress)
+
         try:
-            subprocess.run(cmd, check=True)
+            if show_progress and progress_callback:
+                # Run with real-time output parsing for progress display
+                process = subprocess.Popen(
+                    cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1, universal_newlines=True
+                )
+
+                # Parse rsync output line by line
+                for line in process.stdout:
+                    line = line.strip()
+                    # Skip empty lines and summary lines
+                    if line and not line.startswith("sent") and not line.startswith("total"):
+                        # Extract filename from rsync output
+                        # Rsync --info=NAME outputs filenames directly
+                        if not line.startswith("receiving") and not line.startswith("building"):
+                            progress_callback(line)
+
+                process.wait()
+                if process.returncode != 0:
+                    raise SyncError(f"Rsync failed with exit code {process.returncode}")
+            else:
+                # Silent mode - use subprocess.run
+                subprocess.run(cmd, check=True)
         except subprocess.CalledProcessError as e:
             raise SyncError(f"Rsync failed with exit code {e.returncode}")
 
-    def download(self, remote_path: str, local_path: str):
+    def download(self, remote_path: str, local_path: str, show_progress: bool = False, progress_callback=None):
         """Download file or directory from remote to local."""
         self._check_sshpass()
 
@@ -331,8 +202,29 @@ class RsyncSyncer(BaseSyncer):
         if local_dir and not os.path.exists(local_dir):
             os.makedirs(local_dir, exist_ok=True)
 
-        cmd = self._build_rsync_download_command(remote_path, local_path)
+        cmd = self._build_rsync_download_command(remote_path, local_path, show_progress=show_progress)
         try:
-            subprocess.run(cmd, check=True)
+            if show_progress and progress_callback:
+                # Run with real-time output parsing for progress display
+                process = subprocess.Popen(
+                    cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1, universal_newlines=True
+                )
+
+                # Parse rsync output line by line
+                for line in process.stdout:
+                    line = line.strip()
+                    # Skip empty lines and summary lines
+                    if line and not line.startswith("sent") and not line.startswith("total"):
+                        # Extract filename from rsync output
+                        # Rsync --info=NAME outputs filenames directly
+                        if not line.startswith("receiving") and not line.startswith("building"):
+                            progress_callback(line)
+
+                process.wait()
+                if process.returncode != 0:
+                    raise SyncError(f"Rsync download failed with exit code {process.returncode}")
+            else:
+                # Silent mode - use subprocess.run
+                subprocess.run(cmd, check=True)
         except subprocess.CalledProcessError as e:
             raise SyncError(f"Rsync download failed with exit code {e.returncode}")

mtr/updater.py

@@ -0,0 +1,130 @@
+"""Update checker for mtr-cli."""
+
+import json
+import os
+import urllib.request
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Optional
+
+from packaging import version
+
+from mtr import __version__
+
+PYPI_API_URL = "https://pypi.org/pypi/mtr-cli/json"
+CACHE_DIR = Path.home() / ".cache" / "mtr"
+CACHE_FILE = CACHE_DIR / "update_cache.json"
+CHECK_INTERVAL_HOURS = 24
+
+
+class UpdateChecker:
+    """Check for updates from PyPI."""
+
+    def __init__(self, current_version: str = __version__):
+        self.current_version = version.parse(current_version)
+        self.cache_file = CACHE_FILE
+
+    def _ensure_cache_dir(self) -> None:
+        """Ensure cache directory exists."""
+        self.cache_file.parent.mkdir(parents=True, exist_ok=True)
+
+    def _load_cache(self) -> dict:
+        """Load cache from file."""
+        if not self.cache_file.exists():
+            return {}
+        try:
+            with open(self.cache_file, "r") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+
+    def _save_cache(self, data: dict) -> None:
+        """Save cache to file."""
+        self._ensure_cache_dir()
+        try:
+            with open(self.cache_file, "w") as f:
+                json.dump(data, f)
+        except IOError:
+            pass  # Silently fail if we can't write cache
+
+    def should_check(self) -> bool:
+        """Check if we should perform an update check."""
+        # Check if disabled via environment variable
+        if os.environ.get("MTR_DISABLE_UPDATE_CHECK", "").lower() in ("1", "true", "yes"):
+            return False
+
+        cache = self._load_cache()
+        last_check = cache.get("last_check_time")
+
+        if not last_check:
+            return True
+
+        try:
+            last_check_time = datetime.fromisoformat(last_check)
+            next_check_time = last_check_time + timedelta(hours=CHECK_INTERVAL_HOURS)
+            return datetime.now() >= next_check_time
+        except ValueError:
+            return True
+
+    def get_latest_version(self) -> Optional[str]:
+        """Fetch latest version from PyPI."""
+        try:
+            with urllib.request.urlopen(PYPI_API_URL, timeout=5) as response:
+                data = json.loads(response.read().decode("utf-8"))
+                return data["info"]["version"]
+        except Exception:
+            return None
+
+    def check(self) -> Optional[str]:
+        """Perform update check and return update message if available.
+
+        Returns:
+            Update message string if a new version is available, None otherwise.
+        """
+        if not self.should_check():
+            return None
+
+        latest_version_str = self.get_latest_version()
+
+        # Save check result regardless of success (to avoid hammering PyPI on failures)
+        cache_data = {
+            "last_check_time": datetime.now().isoformat(),
+            "current_version": str(self.current_version),
+        }
+
+        if latest_version_str:
+            cache_data["latest_version"] = latest_version_str
+            self._save_cache(cache_data)
+
+            latest = version.parse(latest_version_str)
+            if latest > self.current_version:
+                return self._format_update_message(latest_version_str)
+        else:
+            self._save_cache(cache_data)
+
+        return None
+
+    def _format_update_message(self, latest_version: str) -> str:
+        """Format update message."""
+        return (
+            f"\n"
+            f"⚠️  Update available: {self.current_version} → {latest_version}\n"
+            f"   Run: uv tool upgrade mtr-cli\n"
+            f"   Or:  pip install -U mtr-cli\n"
+        )
+
+    def get_cached_update_message(self) -> Optional[str]:
+        """Get update message from cache without making network request.
+
+        Returns:
+            Update message string if a new version was previously detected, None otherwise.
+        """
+        cache = self._load_cache()
+        latest_version_str = cache.get("latest_version")
+
+        if latest_version_str:
+            latest = version.parse(latest_version_str)
+            if latest > self.current_version:
+                return self._format_update_message(latest_version_str)
+
+        return None

{mtr_cli-0.2.0.dist-info → mtr_cli-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mtr-cli
-Version: 0.2.0
+Version: 2.0.0
 Summary: A CLI tool for seamless local development and remote execution on GPU servers.
 Project-URL: Homepage, https://github.com/lecoan/mtremote
 Project-URL: Repository, https://github.com/lecoan/mtremote
@@ -20,7 +20,7 @@ Classifier: Topic :: Software Development :: Build Tools
 Classifier: Topic :: System :: Systems Administration
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0.0
-Requires-Dist: paramiko>=2.11.0
+Requires-Dist: packaging>=21.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=12.0.0
 Description-Content-Type: text/markdown
@@ -33,8 +33,7 @@ MTRemote 是一个专为 AI Infra 和 Python/C++ 混合开发设计的命令行
 
 *   **多服务器管理**：通过配置文件管理多个 GPU 节点，支持默认服务器 (Implicit/Explicit)。
 *   **智能同步引擎**：
-    *   **Rsync (推荐)**：调用系统 `rsync`，支持增量同步，速度极快。支持 `sshpass` 自动处理密码认证。
-    *   **SFTP (兼容)**：纯 Python 实现，适用于无 `rsync` 的环境，配置简单。
+    *   **Rsync**：调用系统 `rsync`，支持增量同步，速度极快。支持 `sshpass` 自动处理密码认证。
 *   **双向同步**：支持从远端下载文件/文件夹到本地（`--get` 参数）。
 *   **双模式交互 (Dual-Mode Interaction)**：
     *   **交互模式 (Interactive)**：自动检测 TTY，支持 PTY 分配、Raw Mode、Rich UI 动画。完美支持 `vim`, `ipython`, `pdb`, `htop`。
@@ -57,11 +56,21 @@ pip install mtr-cli
 
 MTRemote 需要以下系统命令：
 
-| 命令 | 用途 | 安装方式 |
-|------|------|----------|
-| `ssh` | 交互式 Shell (TTY) | macOS/Linux 自带，或 `brew install openssh` |
-| `rsync` | 快速文件同步 (推荐) | macOS/Linux 自带 |
-| `sshpass` | 密码认证 (可选) | `brew install hudochenkov/sshpass/sshpass` (macOS) / `apt install sshpass` (Ubuntu) |
+| 命令 | 用途 | 安装方式 | 版本要求 |
+|------|------|----------|----------|
+| `ssh` | 交互式 Shell (TTY) | macOS/Linux 自带，或 `brew install openssh` | - |
+| `rsync` | 快速文件同步 (推荐) | macOS/Linux 自带 | **≥ 3.1.0** (TTY 进度显示需要) |
+| `sshpass` | 密码认证 (可选) | `brew install hudochenkov/sshpass/sshpass` (macOS) / `apt install sshpass` (Ubuntu) | - |
+
+**注意**：macOS 自带的 rsync 版本较旧（2.6.9），不支持 TTY 模式下的进度显示。建议通过 Homebrew 安装新版：
+
+```bash
+# macOS 用户建议升级 rsync
+brew install rsync
+
+# 验证版本
+rsync --version  # 应显示 3.1.0 或更高版本
+```
 
 **注意**：交互式 Shell 功能（如 `mtr bash`, `mtr ipython`）**必须**安装 `ssh`。密码认证**必须**安装 `sshpass`。
 
@@ -83,7 +92,7 @@ mtr --init
 
 ```yaml
 defaults:
-  sync: "rsync"  # 或 "sftp"
+  sync: "rsync"
   exclude: [".git/", "__pycache__/"]
   download_dir: "./downloads"  # 默认下载位置（可选）
 
@@ -115,6 +124,21 @@ mtr ipython
 mtr -s prod-node python train.py
 ```
 
+### ⚠️ 参数传递注意事项
+
+当执行的命令包含以 `-` 开头的参数时（如 `python -c`, `gcc -O2`），建议使用 `--` 作为分隔符，避免被误认为是 `mtr` 的选项：
+
+```bash
+# ❌ 错误：-s 会被当作 --server 的短选项
+mtr python3 -s
+
+# ✅ 正确：使用 -- 分隔符
+mtr -- python3 -s
+
+# ✅ 指定服务器时也使用 --
+mtr --server prod-node -- python3 -c "print('hello')"
+```
+
 ## 📖 命令行选项
 
 ```bash
@@ -159,21 +183,9 @@ mtr --enable-log --log-file ./debug.log python train.py
 mtr --no-tty python train.py > log.txt
 ```
 
-### 2. 使用 SFTP 模式
-如果本地或远程无法使用 rsync，可以在配置中指定 `sync: sftp`：
-
-```yaml
-servers:
-  win-server:
-    host: "10.0.0.9"
-    sync: "sftp"
-    password: "secret_password"
-```
-
-### 3. 密码认证
+### 2. 密码认证
 支持 SSH 密码认证，但推荐使用 SSH Key。
 *   **交互式 Shell**: 使用 `sshpass` 包装 `ssh -t` 命令。
-*   **SFTP**: 原生支持密码。
 *   **Rsync**: 需要本地安装 `sshpass` 工具才能使用密码认证。
 
 **密码认证依赖**: 使用密码认证时，必须安装 `sshpass`:
@@ -188,7 +200,7 @@ sudo apt-get install sshpass
 sudo yum install sshpass
 ```
 
-### 4. 从远端下载文件 (--get)
+### 3. 从远端下载文件 (--get)
 使用 `--get` 参数可以从远端服务器下载文件或文件夹到本地：
 
 ```bash
@@ -231,7 +243,7 @@ servers:
 3. 默认配置中的 `download_dir`
 4. 当前工作目录
 
-### 5. 调试日志 (--enable-log)
+### 4. 调试日志 (--enable-log)
 当遇到问题需要排查时，可以启用文件日志：
 
 ```bash