mtr-cli 0.2.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,17 +4,22 @@ 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 文件
+  # 设置为 true 时，rsync 会自动读取项目根目录的 .gitignore 并排除匹配的文件
+  respect_gitignore: true
+
   exclude:
     - ".git/"
     - "__pycache__/"
@@ -34,12 +39,9 @@ servers:
     # 预设命令 (可选)
     # pre_cmd: "source ~/.bashrc && conda activate myenv"
 
-    # 密码认证 (可选)
+    # 密码认证 (可选，需要安装 sshpass)
     # password: "secret"
 
-    # 强制同步引擎 (可选)
-    # sync: "sftp"
-
     # 该服务器的下载位置（可选，覆盖 defaults）
     # download_dir: "./backups/dev-node"
   """
@@ -66,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")
@@ -76,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()
 
@@ -186,55 +215,67 @@ def cli(server, sync, dry_run, tty, init, enable_log, log_level, log_file, remot
         # Resolve exclude
         exclude = config.global_defaults.get("exclude", []) + server_conf.get("exclude", [])
 
+        # Get respect_gitignore setting
+        respect_gitignore = config.get_respect_gitignore()
+
         # 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,
-            )
-        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,
-            )
-        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")
+                        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:
-                    if is_interactive and console:
-                        with console.status("[bold blue]Syncing code...", spinner="dots"):
-                            syncer.sync()
-                    else:
-                        click.secho("Syncing code...", fg="blue")
-                        syncer.sync()
-                    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)
+                    # 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:
@@ -260,50 +301,61 @@ def cli(server, sync, dry_run, tty, init, enable_log, log_level, log_file, remot
         # Resolve exclude
         exclude = config.global_defaults.get("exclude", []) + server_conf.get("exclude", [])
 
+        # Get respect_gitignore setting
+        respect_gitignore = config.get_respect_gitignore()
+
         # 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,
-            )
-        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,
-            )
-        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}")
                 logger.info(f"[DryRun] Would download {remote_get_path} -> {local_dest}", module="mtr.sync")
             else:
                 if is_interactive and console:
-                    with console.status(f"[bold blue]Downloading {remote_get_path}...", spinner="dots"):
-                        syncer.download(remote_get_path, local_dest)
+                    # TTY mode: single line real-time update using Rich Live
+                    from rich.live import Live
+                    from rich.text import Text
+
+                    with Live(Text("Starting download...", style="blue"), refresh_per_second=10) as live:
+
+                        def show_download_progress(filename):
+                            live.update(Text(f"Downloading: {filename}", style="blue"))
+
+                        syncer.download(
+                            remote_get_path, local_dest, show_progress=True, progress_callback=show_download_progress
+                        )
+                        live.update(Text("Download completed!", style="green"))
                     console.print(f"✅ [green]Downloaded:[/green] {remote_get_path} -> {local_dest}")
                 else:
+                    # no_tty mode: print each file on new line
+                    def show_download_progress(filename):
+                        click.echo(f"Downloading: {filename}")
+
                     click.secho(f"Downloading {remote_get_path}...", fg="blue")
-                    syncer.download(remote_get_path, local_dest)
+                    syncer.download(remote_get_path, local_dest, show_progress=True, progress_callback=show_download_progress)
                     click.secho(f"Download completed: {local_dest}", fg="green")
                 logger.info(f"Download completed: {remote_get_path} -> {local_dest}", module="mtr.sync")
         except SyncError as e:
@@ -322,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/config.py

@@ -19,6 +19,20 @@ class Config:
     server_config: Dict[str, Any]
     global_defaults: Dict[str, Any]
 
+    def get_respect_gitignore(self) -> bool:
+        """Get respect_gitignore setting, default True.
+
+        Priority: server config > global defaults > True (default)
+        """
+        # Check server config first
+        if "respect_gitignore" in self.server_config:
+            return self.server_config["respect_gitignore"]
+        # Then check global defaults
+        if "respect_gitignore" in self.global_defaults:
+            return self.global_defaults["respect_gitignore"]
+        # Default to True
+        return True
+
 
 class ConfigLoader:
     def __init__(self, config_path: Optional[str] = None):

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}")