mtr-cli 0.1.0__py3-none-any.whl

mtr/cli.py

@@ -0,0 +1,358 @@
+import os
+import sys
+from datetime import datetime
+
+import click
+
+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
+
+DEFAULT_CONFIG_TEMPLATE = """# MTRemote Configuration
+defaults:
+  # 默认同步引擎
+  # 选项: "rsync" (推荐), "sftp"
+  sync: "rsync"
+
+  exclude:
+    - ".git/"
+    - "__pycache__/"
+    - "*.pyc"
+
+  # 默认下载位置（可选，使用 --get 时生效）
+  # download_dir: "./downloads"
+
+servers:
+  # === 服务器示例 ===
+  dev-node:
+    host: "192.168.1.100"
+    user: "your_username"
+    key_filename: "~/.ssh/id_rsa"
+    remote_dir: "/home/your_username/projects/current_project"
+
+    # 预设命令 (可选)
+    # pre_cmd: "source ~/.bashrc && conda activate myenv"
+
+    # 密码认证 (可选)
+    # password: "secret"
+
+    # 强制同步引擎 (可选)
+    # sync: "sftp"
+
+    # 该服务器的下载位置（可选，覆盖 defaults）
+    # download_dir: "./backups/dev-node"
+  """
+
+
+def _init_config():
+    """Initialize .mtr/config.yaml in current directory."""
+    mtr_dir = os.path.join(os.getcwd(), ".mtr")
+    config_file = os.path.join(mtr_dir, "config.yaml")
+
+    if os.path.exists(config_file):
+        click.secho(f"Configuration already exists at {config_file}", fg="yellow")
+        return
+
+    if not os.path.exists(mtr_dir):
+        os.makedirs(mtr_dir)
+        click.echo(f"Created directory: {mtr_dir}")
+
+    with open(config_file, "w") as f:
+        f.write(DEFAULT_CONFIG_TEMPLATE)
+
+    click.secho(f"Created configuration: {config_file}", fg="green")
+    click.echo("Please edit it to match your environment.")
+
+
+@click.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True))
+@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")
+@click.option("--tty/--no-tty", default=True, help="Force enable/disable TTY")
+@click.option("--init", is_flag=True, help="Initialize a configuration file in current directory")
+@click.option("--enable-log", is_flag=True, help="Enable logging to file")
+@click.option("--log-level", default="INFO", help="Log level (DEBUG/INFO/WARNING/ERROR)")
+@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.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):
+    """MTRemote: Sync and Execute code on remote server."""
+
+    # Get logger instance (will be no-op if not setup)
+    logger = get_logger()
+
+    # Setup logging if enabled
+    if enable_log:
+        if not log_file:
+            # Generate default log file path: ~/.mtr/logs/mtr_YYYYMMDD_HHMMSS.log
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            log_dir = os.path.expanduser("~/.mtr/logs")
+            log_file = os.path.join(log_dir, f"mtr_{timestamp}.log")
+
+        try:
+            level = LogLevel.from_string(log_level)
+            setup_logging(log_file, level)
+        except ValueError:
+            click.secho(f"Warning: Invalid log level '{log_level}', using INFO", fg="yellow")
+            setup_logging(log_file, LogLevel.INFO)
+
+        # Re-get logger after setup to use the real logger instead of no-op
+        logger = get_logger()
+
+    if init:
+        logger = get_logger()
+        _init_config()
+        logger.info("Initialized configuration file", module="mtr.cli")
+        return
+
+    # Handle --get mode
+    cli_dest = local_dest_path
+
+    if not command and not remote_get_path:
+        click.echo(cli.get_help(click.get_current_context()))
+        return
+
+    # Join command parts back into a string
+    remote_cmd = " ".join(command)
+
+    logger.info(f"Starting mtr with command: {remote_cmd}", module="mtr.cli")
+    logger.debug(f"Options: server={server}, sync={sync}, dry_run={dry_run}, tty={tty}", module="mtr.cli")
+
+    # Check for interactive mode (TTY)
+    # Interactive if: TTY is enabled by flag AND stdout is a real terminal
+    is_interactive = tty and sys.stdout.isatty()
+
+    # Import rich if interactive
+    console = None
+    if is_interactive:
+        try:
+            from rich.console import Console
+
+            console = Console()
+        except ImportError:
+            is_interactive = False  # Fallback if rich is missing (should not happen with dependencies)
+
+    # 1. Load Configuration
+    try:
+        loader = ConfigLoader()
+        config = loader.load(server_name=server)
+        logger.info(f"Loaded configuration, target server: {config.target_server}", module="mtr.config")
+    except ConfigError as e:
+        logger.error(f"Configuration error: {e}", module="mtr.config")
+        if console:
+            console.print(f"[bold red]Configuration Error:[/bold red] {e}")
+        else:
+            click.secho(f"Configuration Error: {e}", fg="red", err=True)
+        sys.exit(1)
+
+    server_conf = config.server_config
+    host = server_conf.get("host")
+    port = server_conf.get("port", 22)
+    user = server_conf.get("user")
+    key_filename = server_conf.get("key_filename")
+    password = server_conf.get("password")
+    remote_dir = server_conf.get("remote_dir")
+    pre_cmd = server_conf.get("pre_cmd")
+
+    if not host or not user:
+        logger.error("Missing required config: host or user", module="mtr.cli")
+        click.secho(
+            "Error: 'host' and 'user' are required in server config.",
+            fg="red",
+            err=True,
+        )
+        sys.exit(1)
+
+    auth_method = "key" if key_filename else ("password" if password else "none")
+    logger.info(f"Connecting to {host} as {user} (auth: {auth_method})", module="mtr.ssh")
+
+    if console:
+        console.print(
+            f"🎯 [bold green]Target:[/bold green] {user}@{host}\t 🔖 [bold green]Tag[/bold green]: {config.target_server} "
+        )
+    else:
+        click.secho(f"Target: {user}@{host} [{config.target_server}]", fg="green")
+
+    # 2. Sync Code
+    if sync:
+        local_dir = os.getcwd()
+        # Ensure remote_dir is set
+        if not remote_dir:
+            click.secho("Error: 'remote_dir' is required for sync.", fg="red", err=True)
+            sys.exit(1)
+
+        # Resolve exclude
+        exclude = config.global_defaults.get("exclude", []) + server_conf.get("exclude", [])
+
+        # 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:
+            click.secho(
+                f"Warning: Sync engine '{engine}' not supported yet. Fallback/Skipping.",
+                fg="yellow",
+            )
+            syncer = None
+
+        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:
+                        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)
+
+    # 3. Download from remote (if --get is specified)
+    if remote_get_path:
+        # Resolve local destination path
+        if cli_dest:
+            local_dest = cli_dest
+        else:
+            # Use config: server > defaults > current directory
+            download_base = server_conf.get("download_dir") or config.global_defaults.get("download_dir") or "."
+            remote_basename = os.path.basename(remote_get_path.rstrip("/"))
+            local_dest = os.path.join(download_base, remote_basename)
+
+        # Expand user path
+        local_dest = os.path.expanduser(local_dest)
+
+        # Resolve exclude
+        exclude = config.global_defaults.get("exclude", []) + server_conf.get("exclude", [])
+
+        # 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:
+            click.secho(
+                f"Warning: Sync engine '{engine}' not supported yet.",
+                fg="yellow",
+            )
+            sys.exit(1)
+
+        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)
+                    console.print(f"✅ [green]Downloaded:[/green] {remote_get_path} -> {local_dest}")
+                else:
+                    click.secho(f"Downloading {remote_get_path}...", fg="blue")
+                    syncer.download(remote_get_path, local_dest)
+                    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:
+            logger.error(f"Download failed: {e}", module="mtr.sync")
+            click.secho(f"Download Failed: {e}", fg="red", err=True)
+            sys.exit(1)
+
+        # Download mode doesn't execute commands
+        return
+
+    # 4. Execute Command
+    if not is_interactive:
+        click.secho(f"Executing: {remote_cmd}", fg="blue")
+
+    if dry_run:
+        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)
+
+    except SSHError as e:
+        logger.error(f"SSH error: {e}", module="mtr.ssh")
+        click.secho(f"SSH Error: {e}", fg="red", err=True)
+        sys.exit(1)
+    finally:
+        logger.info("Closing SSH connection", module="mtr.ssh")
+        ssh.close()
+
+
+if __name__ == "__main__":
+    cli()

mtr/config.py

@@ -0,0 +1,87 @@
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+import yaml
+
+
+class ConfigError(Exception):
+    """Base exception for configuration errors."""
+
+    pass
+
+
+@dataclass
+class Config:
+    """Holds the resolved configuration for a specific execution context."""
+
+    target_server: str
+    server_config: Dict[str, Any]
+    global_defaults: Dict[str, Any]
+
+
+class ConfigLoader:
+    def __init__(self, config_path: Optional[str] = None):
+        self.config_path = config_path or self._resolve_default_config_path()
+
+    def _resolve_default_config_path(self) -> str:
+        # Priority: ./.mtr/config.yaml -> ~/.config/mtr/config.yaml
+        local_config = os.path.join(os.getcwd(), ".mtr", "config.yaml")
+        if os.path.exists(local_config):
+            return local_config
+
+        user_config = os.path.expanduser("~/.config/mtr/config.yaml")
+        if os.path.exists(user_config):
+            return user_config
+
+        # Fallback to local if neither exists (will fail later on read if needed, or we can handle it)
+        return local_config
+
+    def load(self, server_name: Optional[str] = None) -> Config:
+        if not os.path.exists(self.config_path):
+            raise ConfigError(f"Configuration file not found at: {self.config_path}")
+
+        try:
+            with open(self.config_path, "r") as f:
+                raw_config = yaml.safe_load(f) or {}
+        except yaml.YAMLError as e:
+            raise ConfigError(f"Failed to parse config file: {e}")
+
+        servers = raw_config.get("servers", {})
+        if not servers:
+            raise ConfigError("No servers defined in configuration.")
+
+        # Determine target server
+        target_server = server_name
+        if not target_server:
+            # Check for 'default' field (supports both 'default' and 'defaults' key potential confusion,
+            # let's stick to 'default' for server alias as per spec)
+            target_server = raw_config.get("default")
+
+        if not target_server:
+            # Implicit default: first server
+            # In Python 3.7+, dicts preserve insertion order
+            target_server = next(iter(servers))
+
+        if target_server not in servers:
+            raise ConfigError(f"Server '{target_server}' not found in configuration.")
+
+        server_config = servers[target_server]
+
+        # Merge global defaults into server config if needed
+        # (This is a simplified merge, real one might need deep merge)
+        global_defaults = raw_config.get("defaults", {})
+
+        # Apply defaults to server config if keys are missing
+        # For now, let's just return them separately or we can merge them.
+        # The prompt implies we might want to use defaults.
+        # Let's simple merge: defaults < server_config
+
+        merged_config = global_defaults.copy()
+        merged_config.update(server_config)
+
+        return Config(
+            target_server=target_server,
+            server_config=merged_config,
+            global_defaults=global_defaults,
+        )

mtr/logger.py

@@ -0,0 +1,133 @@
+import os
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+
+class LogLevel(Enum):
+    """Log level enumeration."""
+
+    DEBUG = 10
+    INFO = 20
+    WARNING = 30
+    ERROR = 40
+
+    @classmethod
+    def from_string(cls, level_str: str) -> "LogLevel":
+        """Convert string to LogLevel (case-insensitive)."""
+        level_map = {
+            "DEBUG": cls.DEBUG,
+            "INFO": cls.INFO,
+            "WARNING": cls.WARNING,
+            "ERROR": cls.ERROR,
+        }
+        level_upper = level_str.upper()
+        if level_upper not in level_map:
+            raise ValueError(f"Invalid log level: {level_str}")
+        return level_map[level_upper]
+
+
+class _NoOpLogger:
+    """No-op logger that silently discards all log messages.
+
+    This is returned by get_logger() when logging is not initialized.
+    It provides the same interface as Logger but does nothing.
+    """
+
+    def debug(self, message: str, module: str = "") -> None:
+        """No-op debug log."""
+        pass
+
+    def info(self, message: str, module: str = "") -> None:
+        """No-op info log."""
+        pass
+
+    def warning(self, message: str, module: str = "") -> None:
+        """No-op warning log."""
+        pass
+
+    def error(self, message: str, module: str = "") -> None:
+        """No-op error log."""
+        pass
+
+
+class Logger:
+    """Simple file-based logger."""
+
+    def __init__(self, log_file: str, level: LogLevel = LogLevel.INFO):
+        """Initialize logger.
+
+        Args:
+            log_file: Path to log file
+            level: Minimum log level to record
+        """
+        self.log_file = log_file
+        self.level = level
+
+    def _write(self, level: LogLevel, message: str, module: str = ""):
+        """Write log message to file if level is sufficient."""
+        if level.value < self.level.value:
+            return
+
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        module_str = f"[{module}]" if module else ""
+        log_line = f"[{timestamp}] [{level.name}] {module_str} {message}\n"
+
+        with open(self.log_file, "a", encoding="utf-8") as f:
+            f.write(log_line)
+
+    def debug(self, message: str, module: str = ""):
+        """Log debug message."""
+        self._write(LogLevel.DEBUG, message, module)
+
+    def info(self, message: str, module: str = ""):
+        """Log info message."""
+        self._write(LogLevel.INFO, message, module)
+
+    def warning(self, message: str, module: str = ""):
+        """Log warning message."""
+        self._write(LogLevel.WARNING, message, module)
+
+    def error(self, message: str, module: str = ""):
+        """Log error message."""
+        self._write(LogLevel.ERROR, message, module)
+
+
+# Global logger instance
+_logger: Optional[Logger] = None
+# No-op logger singleton
+_no_op_logger = _NoOpLogger()
+
+
+def setup_logging(log_file: str, level: LogLevel = LogLevel.INFO) -> Logger:
+    """Setup logging with file output.
+
+    Args:
+        log_file: Path to log file
+        level: Minimum log level
+
+    Returns:
+        Configured logger instance
+    """
+    global _logger
+
+    # Create log directory if not exists
+    log_dir = os.path.dirname(log_file)
+    if log_dir and not os.path.exists(log_dir):
+        os.makedirs(log_dir, exist_ok=True)
+
+    _logger = Logger(log_file, level)
+    return _logger
+
+
+def get_logger():
+    """Get the global logger instance.
+
+    Returns:
+        Logger instance if logging is initialized, otherwise a no-op logger.
+        The returned object always has debug(), info(), warning(), error() methods.
+    """
+    global _logger
+    if _logger is None:
+        return _no_op_logger
+    return _logger