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

mtr/__init__.py

@@ -0,0 +1,3 @@
+"""MTRemote - A CLI tool for seamless local development and remote execution."""
+
+__version__ = "2.0.0"

mtr/cli.py

@@ -4,20 +4,20 @@ from datetime import datetime
 
 import click
 
+from mtr import __version__
 from mtr.config import ConfigError, ConfigLoader
 from mtr.logger import LogLevel, get_logger, setup_logging
-from mtr.ssh import SSHClientWrapper, SSHError
-from mtr.sync import RsyncSyncer, SftpSyncer, SyncError
+from mtr.ssh import SSHError, run_ssh_command
+from mtr.sync import RsyncSyncer, SyncError
+from mtr.updater import UpdateChecker
 
 DEFAULT_CONFIG_TEMPLATE = """# MTRemote Configuration
 defaults:
-  # 默认同步引擎
-  # 选项: "rsync" (推荐), "sftp"
+  # 默认同步引擎 (仅支持 rsync)
   sync: "rsync"
 
-  # 是否尊重 .gitignore 文件（仅 rsync 模式支持）
+  # 是否尊重 .gitignore 文件
   # 设置为 true 时，rsync 会自动读取项目根目录的 .gitignore 并排除匹配的文件
-  # SFTP 模式不支持此选项，如启用会报错
   respect_gitignore: true
 
   exclude:
@@ -39,12 +39,9 @@ servers:
     # 预设命令 (可选)
     # pre_cmd: "source ~/.bashrc && conda activate myenv"
 
-    # 密码认证 (可选)
+    # 密码认证 (可选，需要安装 sshpass)
     # password: "secret"
 
-    # 强制同步引擎 (可选)
-    # sync: "sftp"
-
     # 该服务器的下载位置（可选，覆盖 defaults）
     # download_dir: "./backups/dev-node"
   """
@@ -71,6 +68,7 @@ def _init_config():
 
 
 @click.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True))
+@click.version_option(version=__version__, prog_name="mtr-cli", help="Show version and exit.")
 @click.option("-s", "--server", help="Target server alias")
 @click.option("--sync/--no-sync", default=True, help="Enable/Disable code sync")
 @click.option("--dry-run", is_flag=True, help="Print commands without executing")
@@ -81,10 +79,36 @@ def _init_config():
 @click.option("--log-file", help="Path to log file (default: ./.mtr/logs/mtr_YYYYMMDD_HHMMSS.log)")
 @click.option("--get", "remote_get_path", help="Remote path to download from")
 @click.option("--to", "local_dest_path", help="Local destination path for download (optional)")
+@click.option("--no-check-update", is_flag=True, help="Disable update check")
 @click.argument("command", nargs=-1, type=click.UNPROCESSED)
-def cli(server, sync, dry_run, tty, init, enable_log, log_level, log_file, remote_get_path, local_dest_path, command):
+def cli(
+    server,
+    sync,
+    dry_run,
+    tty,
+    init,
+    enable_log,
+    log_level,
+    log_file,
+    remote_get_path,
+    local_dest_path,
+    no_check_update,
+    command,
+):
     """MTRemote: Sync and Execute code on remote server."""
 
+    # Check for updates (async, non-blocking)
+    update_message = None
+    if not no_check_update and not init:
+        checker = UpdateChecker()
+        # Try to get cached update message first (from previous check)
+        update_message = checker.get_cached_update_message()
+        # Trigger background check for next time
+        try:
+            checker.check()
+        except Exception:
+            pass  # Silently fail update check
+
     # Get logger instance (will be no-op if not setup)
     logger = get_logger()
 
@@ -197,71 +221,61 @@ def cli(server, sync, dry_run, tty, init, enable_log, log_level, log_file, remot
         # Determine engine
         engine = server_conf.get("sync", config.global_defaults.get("sync", "rsync"))
 
-        if engine == "rsync":
-            syncer = RsyncSyncer(
-                local_dir=local_dir,
-                remote_dir=remote_dir,
-                host=host,
-                user=user,
-                key_filename=key_filename,
-                password=password,
-                port=port,
-                exclude=exclude,
-                respect_gitignore=respect_gitignore,
-            )
-        elif engine == "sftp":
-            syncer = SftpSyncer(
-                local_dir=local_dir,
-                remote_dir=remote_dir,
-                host=host,
-                user=user,
-                key_filename=key_filename,
-                password=password,
-                port=port,
-                exclude=exclude,
-                respect_gitignore=respect_gitignore,
-            )
-        else:
+        # Check if SFTP is configured
+        if engine == "sftp":
+            logger.error("SFTP mode is no longer supported. Please use rsync.", module="mtr.cli")
             click.secho(
-                f"Warning: Sync engine '{engine}' not supported yet. Fallback/Skipping.",
-                fg="yellow",
+                "Error: SFTP mode has been removed. Please update your config to use 'sync: rsync'.",
+                fg="red",
+                err=True,
             )
-            syncer = None
+            sys.exit(1)
+
+        syncer = RsyncSyncer(
+            local_dir=local_dir,
+            remote_dir=remote_dir,
+            host=host,
+            user=user,
+            key_filename=key_filename,
+            password=password,
+            port=port,
+            exclude=exclude,
+            respect_gitignore=respect_gitignore,
+        )
+
+        try:
+            if dry_run:
+                click.echo(f"[DryRun] Would sync {local_dir} -> {remote_dir}")
+                logger.info(f"[DryRun] Would sync {local_dir} -> {remote_dir}", module="mtr.sync")
+            else:
+                if is_interactive and console:
+                    # TTY mode: single line real-time update using Rich Live
+                    from rich.live import Live
+                    from rich.text import Text
+
+                    with Live(Text("Starting sync...", style="blue"), refresh_per_second=10) as live:
 
-        if syncer:
-            try:
-                if dry_run:
-                    click.echo(f"[DryRun] Would sync {local_dir} -> {remote_dir}")
-                    logger.info(f"[DryRun] Would sync {local_dir} -> {remote_dir}", module="mtr.sync")
-                else:
-                    if is_interactive and console:
-                        # TTY mode: single line real-time update using Rich Live
-                        from rich.live import Live
-                        from rich.text import Text
-
-                        with Live(Text("Starting sync...", style="blue"), refresh_per_second=10) as live:
-
-                            def show_sync_progress(filename):
-                                # Get relative path for cleaner display
-                                rel_path = os.path.relpath(filename, local_dir)
-                                live.update(Text(f"Syncing: {rel_path}", style="blue"))
-
-                            syncer.sync(show_progress=True, progress_callback=show_sync_progress)
-                            live.update(Text("Sync completed!", style="green"))
-                    else:
-                        # no_tty mode: print each file on new line
                         def show_sync_progress(filename):
+                            # Get relative path for cleaner display
                             rel_path = os.path.relpath(filename, local_dir)
-                            click.echo(f"Syncing: {rel_path}")
+                            live.update(Text(f"Syncing: {rel_path}", style="blue"))
 
-                        click.secho("Syncing code...", fg="blue")
                         syncer.sync(show_progress=True, progress_callback=show_sync_progress)
-                        click.secho("Sync completed!", fg="green")
-                    logger.info(f"Sync completed: {local_dir} -> {remote_dir}", module="mtr.sync")
-            except SyncError as e:
-                logger.error(f"Sync failed: {e}", module="mtr.sync")
-                click.secho(f"Sync Failed: {e}", fg="red", err=True)
-                sys.exit(1)
+                        live.update(Text("Sync completed!", style="green"))
+                else:
+                    # no_tty mode: print each file on new line
+                    def show_sync_progress(filename):
+                        rel_path = os.path.relpath(filename, local_dir)
+                        click.echo(f"Syncing: {rel_path}")
+
+                    click.secho("Syncing code...", fg="blue")
+                    syncer.sync(show_progress=True, progress_callback=show_sync_progress)
+                    click.secho("Sync completed!", fg="green")
+                logger.info(f"Sync completed: {local_dir} -> {remote_dir}", module="mtr.sync")
+        except SyncError as e:
+            logger.error(f"Sync failed: {e}", module="mtr.sync")
+            click.secho(f"Sync Failed: {e}", fg="red", err=True)
+            sys.exit(1)
 
     # 3. Download from remote (if --get is specified)
     if remote_get_path:
@@ -293,37 +307,28 @@ def cli(server, sync, dry_run, tty, init, enable_log, log_level, log_file, remot
         # Determine engine
         engine = server_conf.get("sync", config.global_defaults.get("sync", "rsync"))
 
-        if engine == "rsync":
-            syncer = RsyncSyncer(
-                local_dir=".",  # Not used for download
-                remote_dir=".",  # Not used for download
-                host=host,
-                user=user,
-                key_filename=key_filename,
-                password=password,
-                port=port,
-                exclude=exclude,
-                respect_gitignore=respect_gitignore,
-            )
-        elif engine == "sftp":
-            syncer = SftpSyncer(
-                local_dir=".",  # Not used for download
-                remote_dir=".",  # Not used for download
-                host=host,
-                user=user,
-                key_filename=key_filename,
-                password=password,
-                port=port,
-                exclude=exclude,
-                respect_gitignore=respect_gitignore,
-            )
-        else:
+        # Check if SFTP is configured
+        if engine == "sftp":
+            logger.error("SFTP mode is no longer supported. Please use rsync.", module="mtr.cli")
             click.secho(
-                f"Warning: Sync engine '{engine}' not supported yet.",
-                fg="yellow",
+                "Error: SFTP mode has been removed. Please update your config to use 'sync: rsync'.",
+                fg="red",
+                err=True,
             )
             sys.exit(1)
 
+        syncer = RsyncSyncer(
+            local_dir=".",  # Not used for download
+            remote_dir=".",  # Not used for download
+            host=host,
+            user=user,
+            key_filename=key_filename,
+            password=password,
+            port=port,
+            exclude=exclude,
+            respect_gitignore=respect_gitignore,
+        )
+
         try:
             if dry_run:
                 click.echo(f"[DryRun] Would download {remote_get_path} -> {local_dest}")
@@ -369,43 +374,34 @@ def cli(server, sync, dry_run, tty, init, enable_log, log_level, log_file, remot
         click.echo(f"[DryRun] Would run on {host}: {remote_cmd} (workdir={remote_dir})")
         return
 
-    ssh = SSHClientWrapper(host, user, port=port, key_filename=key_filename, password=password)
     try:
-        ssh.connect()
-        logger.info(f"SSH connection established to {host}", module="mtr.ssh")
-
-        if is_interactive:
-            # Run interactive shell (full TTY support)
-            logger.info(f"Executing interactive command: {remote_cmd}", module="mtr.cli")
-            exit_code = ssh.run_interactive_shell(remote_cmd, workdir=remote_dir, pre_cmd=pre_cmd)
-            logger.info(f"Command completed with exit code: {exit_code}", module="mtr.cli")
-            sys.exit(exit_code)
-        else:
-            # Run stream mode (for scripts/pipes)
-            # pty=False ensures clean output for parsing (separates stdout/stderr if we implemented that,
-            # but currently streams merged or just stdout. Let's keep pty=False to avoid control chars)
-            logger.info(f"Executing command: {remote_cmd}", module="mtr.cli")
-            stream = ssh.exec_command_stream(remote_cmd, workdir=remote_dir, pre_cmd=pre_cmd, pty=False)
-
-            # Consume generator and print
-            exit_code = 0
-            try:
-                while True:
-                    line = next(stream)
-                    click.echo(line, nl=False)
-            except StopIteration as e:
-                exit_code = e.value
-
-            logger.info(f"Command completed with exit code: {exit_code}", module="mtr.cli")
-            sys.exit(exit_code)
+        # Execute command via SSH
+        logger.info(f"Executing command: {remote_cmd}", module="mtr.cli")
+        exit_code = run_ssh_command(
+            host=host,
+            user=user,
+            command=remote_cmd,
+            port=port,
+            key_filename=key_filename,
+            password=password,
+            workdir=remote_dir,
+            pre_cmd=pre_cmd,
+            tty=is_interactive,
+        )
+        logger.info(f"Command completed with exit code: {exit_code}", module="mtr.cli")
+
+        # Show update message if available
+        if update_message:
+            click.echo(update_message, err=True)
+        sys.exit(exit_code)
 
     except SSHError as e:
         logger.error(f"SSH error: {e}", module="mtr.ssh")
         click.secho(f"SSH Error: {e}", fg="red", err=True)
+        # Show update message if available even on error
+        if update_message:
+            click.echo(update_message, err=True)
         sys.exit(1)
-    finally:
-        logger.info("Closing SSH connection", module="mtr.ssh")
-        ssh.close()
 
 
 if __name__ == "__main__":

mtr/ssh.py

@@ -1,19 +1,17 @@
+"""SSH utilities for MTRemote."""
+
 import os
 import shutil
 import subprocess
-from typing import Generator, Optional
-
-import paramiko
+from typing import Optional
 
 from mtr.logger import get_logger
 
 
 class SSHError(Exception):
-    pass
+    """SSH-related errors."""
 
-
-# Constants for batch mode
-BUFFER_SIZE = 32768  # 32KB for better performance
+    pass
 
 
 def _check_ssh_availability():
@@ -38,162 +36,97 @@ def _check_sshpass_availability():
         )
 
 
-class SSHClientWrapper:
-    def __init__(
-        self,
-        host: str,
-        user: str,
-        port: int = 22,
-        key_filename: Optional[str] = None,
-        password: Optional[str] = None,
-    ):
-        self.host = host
-        self.user = user
-        self.port = port
-        self.key_filename = key_filename
-        self.password = password
-        self.client: Optional[paramiko.SSHClient] = None
-
-    def connect(self):
-        logger = get_logger()
-        logger.info(f"Connecting to {self.host}:{self.port} as {self.user}", module="mtr.ssh")
-        self.client = paramiko.SSHClient()
-        self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-
-        connect_kwargs = {
-            "hostname": self.host,
-            "username": self.user,
-            "port": self.port,
-            "timeout": 10,
-        }
-
-        if self.key_filename:
-            expanded_key = os.path.expanduser(self.key_filename)
-            connect_kwargs["key_filename"] = expanded_key
-            logger.info("Using key-based authentication", module="mtr.ssh")
-        elif self.password:
-            connect_kwargs["password"] = self.password
-            logger.info("Using password authentication", module="mtr.ssh")
-        else:
-            logger.info("No authentication method specified, using default", module="mtr.ssh")
-
-        try:
-            self.client.connect(**connect_kwargs)
-            logger.info(f"SSH connection established to {self.host}", module="mtr.ssh")
-        except paramiko.SSHException as e:
-            logger.error(f"Failed to connect to {self.host}: {e}", module="mtr.ssh")
-            raise SSHError(f"Failed to connect to {self.host}: {e}")
-
-    def _build_command(self, command: str, workdir: Optional[str] = None, pre_cmd: Optional[str] = None) -> str:
-        parts = []
-        if workdir:
-            parts.append(f"cd {workdir}")
-        if pre_cmd:
-            parts.append(pre_cmd)
-        parts.append(command)
-        return " && ".join(parts)
-
-    def exec_command_stream(
-        self,
-        command: str,
-        workdir: Optional[str] = None,
-        pre_cmd: Optional[str] = None,
-        pty: bool = True,
-    ) -> Generator[str, None, int]:
-        """
-        Executes command and yields output lines.
-        Returns the exit code.
-        Suitable for batch mode or when interactivity is not required.
-        """
-        logger = get_logger()
-        logger.info(f"Executing command (stream mode): {command}", module="mtr.ssh")
-        logger.debug(f"Workdir: {workdir}, Pre-cmd: {pre_cmd}, PTY: {pty}", module="mtr.ssh")
-
-        if not self.client:
-            raise SSHError("Client not connected")
-
-        full_command = self._build_command(command, workdir, pre_cmd)
-        logger.debug(f"Full command: {full_command}", module="mtr.ssh")
-
-        try:
-            stdin, stdout, stderr = self.client.exec_command(full_command, get_pty=pty)
-            stdin.close()
-
-            logger.debug("Command executed, starting output stream", module="mtr.ssh")
-
-            line_count = 0
-            for line in stdout:
-                line_count += 1
-                if line_count % 100 == 0:
-                    logger.debug(f"Streamed {line_count} lines so far", module="mtr.ssh")
-                yield line
-
-            logger.debug(f"Output stream ended, total lines: {line_count}", module="mtr.ssh")
-
-            exit_code = stdout.channel.recv_exit_status()
-            logger.info(f"Command exited with code: {exit_code}", module="mtr.ssh")
-            return exit_code
-
-        except paramiko.SSHException as e:
-            logger.error(f"Command execution failed: {e}", module="mtr.ssh")
-            raise SSHError(f"Command execution failed: {e}")
-
-    def run_interactive_shell(self, command: str, workdir: Optional[str] = None, pre_cmd: Optional[str] = None) -> int:
-        """
-        Runs an interactive shell using system ssh -t command.
-        This provides full TTY support with proper signal handling.
-        Returns exit code.
-        """
-        logger = get_logger()
-        logger.info(f"Starting interactive shell via ssh -t: {command}", module="mtr.ssh")
-        logger.debug(f"Workdir: {workdir}, Pre-cmd: {pre_cmd}", module="mtr.ssh")
-
-        # Check SSH availability
-        _check_ssh_availability()
-
-        # Check sshpass availability if password is used
-        if self.password:
-            _check_sshpass_availability()
-
-        full_command = self._build_command(command, workdir, pre_cmd)
-
-        # Build ssh command
-        ssh_cmd = ["ssh", "-t"]
-
-        # Port
-        if self.port != 22:
-            ssh_cmd.extend(["-p", str(self.port)])
-
-        # Key authentication
-        if self.key_filename:
-            ssh_cmd.extend(["-i", os.path.expanduser(self.key_filename)])
-
-        # Target host and command
-        target = f"{self.user}@{self.host}"
-        ssh_cmd.extend([target, full_command])
-
-        # Wrap with sshpass if password is provided
-        if self.password:
-            ssh_cmd = ["sshpass", "-p", self.password] + ssh_cmd
-
-        logger.debug(f"Executing: {' '.join(ssh_cmd)}", module="mtr.ssh")
-
-        # Run command with direct stdin/stdout/stderr forwarding
-        try:
-            result = subprocess.run(ssh_cmd)
-            logger.info(f"Interactive shell exited with code: {result.returncode}", module="mtr.ssh")
-            return result.returncode
-        except FileNotFoundError as e:
-            # This shouldn't happen if _check_ssh_availability passed, but just in case
-            logger.error(f"Command not found: {e}", module="mtr.ssh")
-            raise SSHError(f"SSH command execution failed: {e}")
-        except Exception as e:
-            logger.error(f"Interactive shell failed: {e}", module="mtr.ssh")
-            raise SSHError(f"Interactive shell failed: {e}")
-
-    def close(self):
-        if self.client:
-            logger = get_logger()
-            logger.debug("Closing SSH connection", module="mtr.ssh")
-            self.client.close()
-            logger.debug("SSH connection closed", module="mtr.ssh")
+def _build_command(command: str, workdir: Optional[str] = None, pre_cmd: Optional[str] = None) -> str:
+    """Build the full command string with workdir and pre_cmd."""
+    parts = []
+    if workdir:
+        parts.append(f"cd {workdir}")
+    if pre_cmd:
+        parts.append(pre_cmd)
+    parts.append(command)
+    return " && ".join(parts)
+
+
+def run_ssh_command(
+    host: str,
+    user: str,
+    command: str,
+    port: int = 22,
+    key_filename: Optional[str] = None,
+    password: Optional[str] = None,
+    workdir: Optional[str] = None,
+    pre_cmd: Optional[str] = None,
+    tty: bool = True,
+) -> int:
+    """
+    Run a command on remote host via system SSH.
+
+    Args:
+        host: Remote host address
+        user: SSH username
+        command: Command to execute
+        port: SSH port (default: 22)
+        key_filename: Path to SSH private key
+        password: SSH password (requires sshpass)
+        workdir: Working directory on remote host
+        pre_cmd: Command to run before main command
+        tty: If True, use ssh -t for TTY allocation
+
+    Returns:
+        Exit code from the remote command
+
+    Raises:
+        SSHError: If SSH command fails or is not available
+    """
+    logger = get_logger()
+    mode_str = "interactive" if tty else "batch"
+    logger.info(f"Executing {mode_str} command via SSH: {command}", module="mtr.ssh")
+    logger.debug(f"Host: {host}, User: {user}, Port: {port}, TTY: {tty}", module="mtr.ssh")
+
+    # Check SSH availability
+    _check_ssh_availability()
+
+    # Check sshpass availability if password is used
+    if password and not key_filename:
+        _check_sshpass_availability()
+
+    # Build the full command
+    full_command = _build_command(command, workdir, pre_cmd)
+    logger.debug(f"Full command: {full_command}", module="mtr.ssh")
+
+    # Build SSH command
+    ssh_cmd = ["ssh"]
+
+    # Add -t flag for TTY mode
+    if tty:
+        ssh_cmd.append("-t")
+
+    # Port
+    if port != 22:
+        ssh_cmd.extend(["-p", str(port)])
+
+    # Key authentication
+    if key_filename:
+        ssh_cmd.extend(["-i", os.path.expanduser(key_filename)])
+
+    # Target host and command
+    target = f"{user}@{host}"
+    ssh_cmd.extend([target, full_command])
+
+    # Wrap with sshpass if password is provided
+    if password and not key_filename:
+        ssh_cmd = ["sshpass", "-p", password] + ssh_cmd
+
+    logger.debug(f"Executing: {' '.join(ssh_cmd)}", module="mtr.ssh")
+
+    # Run command
+    try:
+        result = subprocess.run(ssh_cmd)
+        logger.info(f"Command exited with code: {result.returncode}", module="mtr.ssh")
+        return result.returncode
+    except FileNotFoundError as e:
+        logger.error(f"Command not found: {e}", module="mtr.ssh")
+        raise SSHError(f"SSH command execution failed: {e}")
+    except Exception as e:
+        logger.error(f"SSH command failed: {e}", module="mtr.ssh")
+        raise SSHError(f"SSH command failed: {e}")

mtr/sync.py

@@ -1,4 +1,3 @@
-import fnmatch
 import os
 import shlex
 import shutil
@@ -6,8 +5,6 @@ import subprocess
 from abc import ABC, abstractmethod
 from typing import List, Optional
 
-import paramiko
-
 
 class SyncError(Exception):
     pass
@@ -25,243 +22,6 @@ class BaseSyncer(ABC):
         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,
-        respect_gitignore: bool = True,
-    ):
-        super().__init__(local_dir, remote_dir, exclude or [], respect_gitignore)
-        self.host = host
-        self.user = user
-        self.key_filename = key_filename
-        self.password = password
-        self.port = port
-        self.transport = None
-        self.sftp = None
-
-        # SFTP mode does not support respect_gitignore
-        if respect_gitignore:
-            raise SyncError(
-                "respect_gitignore is not supported in SFTP mode. "
-                "Please set respect_gitignore to false in your config or use rsync mode."
-            )
-
-    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, show_progress: bool = False, progress_callback=None):
-        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:
-                    # Call progress callback if provided
-                    if show_progress and progress_callback:
-                        progress_callback(local_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, show_progress: bool = False, progress_callback=None):
-        """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, show_progress=show_progress, progress_callback=progress_callback
-                    )
-                else:
-                    self._download_file(
-                        remote_path, local_path, show_progress=show_progress, progress_callback=progress_callback
-                    )
-            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, show_progress: bool = False, progress_callback=None):
-        """Download a single file with incremental check."""
-        if not self._should_download_file(remote_file, local_file):
-            return  # No need to download
-
-        # Call progress callback if provided
-        if show_progress and progress_callback:
-            progress_callback(remote_file)
-
-        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, show_progress: bool = False, progress_callback=None):
-        """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, show_progress=show_progress, progress_callback=progress_callback)
-            else:
-                self._download_file(remote_path, local_path, show_progress=show_progress, progress_callback=progress_callback)
-
-
 class RsyncSyncer(BaseSyncer):
     def __init__(
         self,

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.3.0.dist-info → mtr_cli-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mtr-cli
-Version: 0.3.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`。
@@ -93,7 +92,7 @@ mtr --init
 
 ```yaml
 defaults:
-  sync: "rsync"  # 或 "sftp"
+  sync: "rsync"
   exclude: [".git/", "__pycache__/"]
   download_dir: "./downloads"  # 默认下载位置（可选）
 
@@ -125,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
@@ -169,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`:
@@ -198,7 +200,7 @@ sudo apt-get install sshpass
 sudo yum install sshpass
 ```
 
-### 4. 从远端下载文件 (--get)
+### 3. 从远端下载文件 (--get)
 使用 `--get` 参数可以从远端服务器下载文件或文件夹到本地：
 
 ```bash
@@ -241,7 +243,7 @@ servers:
 3. 默认配置中的 `download_dir`
 4. 当前工作目录
 
-### 5. 调试日志 (--enable-log)
+### 4. 调试日志 (--enable-log)
 当遇到问题需要排查时，可以启用文件日志：
 
 ```bash

mtr_cli-2.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+mtr/__init__.py,sha256=8cyDYQIUDSlgJOLnC8PLiPDXLQa-H8yH9pp8WAgZ_-0,104
+mtr/cli.py,sha256=KxrWYOe360nhvFz05Ffk5kP6Qn72B5TU-uehnaimLAQ,15480
+mtr/config.py,sha256=HA_pZ3rTFPYa6JhgFnEQlf4ukdFovx8obv58UILloWQ,3568
+mtr/logger.py,sha256=9DPKTTzYsNMF7vXnvJ0bJditNYgzhZWHwLKUErtwCBY,3669
+mtr/ssh.py,sha256=z2MZf5sI2TIve62aUOOGHnYMC_zU6p8SXwyoLiCF1Sg,3962
+mtr/sync.py,sha256=UFpqW_QIdmYVfWtflQsADkvoizFhfdG_owJCAvYIwmE,9529
+mtr/updater.py,sha256=2R6d2ohsTDXY1Oor0NZy4wRfF-Iy6Un9g_2hkqbUlmA,4263
+mtr_cli-2.0.0.dist-info/METADATA,sha256=jz604P5fjikJAo69oIFYB7yRGtcKtmwoz-EZ0Kg_PHw,9860
+mtr_cli-2.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mtr_cli-2.0.0.dist-info/entry_points.txt,sha256=8BRK0VoSAWGzovrOdzWqpwwNj-dmjVY1iQcz5MQseV4,36
+mtr_cli-2.0.0.dist-info/licenses/LICENSE,sha256=PkuO1VHNDkFylFSOtMADb93mjExarK6DBTjtCB3kBeU,1067
+mtr_cli-2.0.0.dist-info/RECORD,,

mtr_cli-0.3.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-mtr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mtr/cli.py,sha256=LXoXCdajKQe_oVXlf9FPGgHt7N3P0zQxE-mh9xPwnII,16363
-mtr/config.py,sha256=HA_pZ3rTFPYa6JhgFnEQlf4ukdFovx8obv58UILloWQ,3568
-mtr/logger.py,sha256=9DPKTTzYsNMF7vXnvJ0bJditNYgzhZWHwLKUErtwCBY,3669
-mtr/ssh.py,sha256=fCEXxfEK6ao8YrCU9FBJ_e5zrK93AKz6bgjXWkORQkk,7170
-mtr/sync.py,sha256=xrljWPt8keigyiri7oc1RNvxJxBNBHjJjhgGtXP0F_g,18668
-mtr_cli-0.3.0.dist-info/METADATA,sha256=XFZfTrcxMzhCbvzwY6LQrJWq_r2lnboCqL8SbDSuYnQ,9806
-mtr_cli-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mtr_cli-0.3.0.dist-info/entry_points.txt,sha256=8BRK0VoSAWGzovrOdzWqpwwNj-dmjVY1iQcz5MQseV4,36
-mtr_cli-0.3.0.dist-info/licenses/LICENSE,sha256=PkuO1VHNDkFylFSOtMADb93mjExarK6DBTjtCB3kBeU,1067
-mtr_cli-0.3.0.dist-info/RECORD,,