fastsmtp-cli 0.6.0__py3-none-any.whl

fastsmtp_cli/config.py

@@ -0,0 +1,218 @@
+"""CLI configuration management with profiles."""
+
+import contextlib
+import os
+
+# tomllib is stdlib from 3.11 and this package requires >=3.12, so no fallback.
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+from pydantic import BaseModel, Field
+
+DEFAULT_CONFIG_DIR = Path.home() / ".fastsmtp"
+DEFAULT_CONFIG_FILE = DEFAULT_CONFIG_DIR / "config.toml"
+
+# The config file holds API keys in clear, so its mode is set explicitly rather
+# than left to the umask: the common 022 would leave it world-readable. This is
+# what every comparable tool does - ~/.aws/credentials, ~/.docker/config.json,
+# ~/.netrc - and ssh refuses outright to use a key file others can read.
+CONFIG_FILE_MODE = 0o600
+CONFIG_DIR_MODE = 0o700
+
+
+class Profile(BaseModel):
+    """A server profile configuration."""
+
+    url: str = Field(default="http://localhost:8000", description="Server URL")
+    api_key: str | None = Field(default=None, description="API key for authentication")
+    timeout: float = Field(default=30.0, description="Request timeout in seconds")
+    verify_ssl: bool = Field(default=True, description="Verify SSL certificates")
+
+
+class CLIConfig(BaseModel):
+    """CLI configuration with multiple profiles."""
+
+    default_profile: str = Field(default="default", description="Default profile name")
+    profiles: dict[str, Profile] = Field(
+        default_factory=lambda: {"default": Profile()},
+        description="Server profiles",
+    )
+
+
+def get_config_path() -> Path:
+    """Get the configuration file path."""
+    # Check environment variable first
+    env_path = os.environ.get("FSMTP_CONFIG")
+    if env_path:
+        return Path(env_path)
+    return DEFAULT_CONFIG_FILE
+
+
+def load_config() -> CLIConfig:
+    """Load configuration from file."""
+    config_path = get_config_path()
+
+    if not config_path.exists():
+        return CLIConfig()
+
+    try:
+        with open(config_path, "rb") as f:
+            data = tomllib.load(f)
+        return CLIConfig.model_validate(data)
+    except Exception:
+        # If config is corrupted, return default
+        return CLIConfig()
+
+
+def save_config(config: CLIConfig) -> None:
+    """Save configuration to file, readable only by its owner.
+
+    The mode is applied before the content, not chmod-ed after it, so an API key
+    never sits on disk in a file others can read. A file an older version left
+    permissive is repaired here, since someone whose key already leaked that way
+    should not have to notice and fix it by hand.
+
+    Only a directory this function *creates* gets ``CONFIG_DIR_MODE``. An existing
+    one is left alone deliberately: ``FSMTP_CONFIG`` can point anywhere, and
+    tightening, say, ``/etc`` because a config lives under it would be worse than
+    the problem being solved.
+    """
+    config_path = get_config_path()
+
+    config_path.parent.mkdir(parents=True, exist_ok=True, mode=CONFIG_DIR_MODE)
+
+    fd = os.open(config_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, CONFIG_FILE_MODE)
+    try:
+        # O_CREAT applies the mode only to a file it creates, so an existing one
+        # keeps whatever it had. Truncation has already dropped the old content;
+        # this lands before the new key does.
+        os.fchmod(fd, CONFIG_FILE_MODE)
+        handle = os.fdopen(fd, "wb")
+    except BaseException:
+        os.close(fd)
+        raise
+
+    # Exclude None values from the dump (TOML can't serialize None)
+    with handle as f:
+        tomli_w.dump(config.model_dump(exclude_none=True), f)
+
+
+def get_profile(profile_name: str | None = None) -> Profile:
+    """Get a profile by name, with environment variable overrides.
+
+    Priority (highest to lowest):
+    1. Environment variables (FSMTP_URL, FSMTP_API_KEY, etc.)
+    2. Named profile from config file
+    3. Default profile from config file
+    4. Built-in defaults
+    """
+    config = load_config()
+
+    # Determine which profile to use
+    name = profile_name or os.environ.get("FSMTP_PROFILE") or config.default_profile
+
+    # Get base profile
+    profile = config.profiles[name] if name in config.profiles else Profile()
+
+    # Apply environment variable overrides
+    url = os.environ.get("FSMTP_URL")
+    if url:
+        profile = profile.model_copy(update={"url": url})
+
+    api_key = os.environ.get("FSMTP_API_KEY")
+    if api_key:
+        profile = profile.model_copy(update={"api_key": api_key})
+
+    timeout = os.environ.get("FSMTP_TIMEOUT")
+    if timeout:
+        with contextlib.suppress(ValueError):
+            profile = profile.model_copy(update={"timeout": float(timeout)})
+
+    verify_ssl = os.environ.get("FSMTP_VERIFY_SSL")
+    if verify_ssl is not None:
+        profile = profile.model_copy(
+            update={"verify_ssl": verify_ssl.lower() not in ("0", "false", "no")}
+        )
+
+    return profile
+
+
+def set_profile(
+    name: str,
+    url: str | None = None,
+    api_key: str | None = None,
+    timeout: float | None = None,
+    verify_ssl: bool | None = None,
+) -> None:
+    """Create or update a profile."""
+    config = load_config()
+
+    # Get existing profile or create new one
+    profile_data: dict[str, Any] = (
+        config.profiles[name].model_dump() if name in config.profiles else {}
+    )
+
+    # Update with provided values
+    if url is not None:
+        profile_data["url"] = url
+    if api_key is not None:
+        profile_data["api_key"] = api_key
+    if timeout is not None:
+        profile_data["timeout"] = timeout
+    if verify_ssl is not None:
+        profile_data["verify_ssl"] = verify_ssl
+
+    config.profiles[name] = Profile.model_validate(profile_data)
+    save_config(config)
+
+
+def delete_profile(name: str) -> bool:
+    """Delete a profile. Returns True if deleted, False if not found."""
+    config = load_config()
+
+    if name not in config.profiles:
+        return False
+
+    if name == config.default_profile and len(config.profiles) > 1:
+        # Can't delete the default profile if there are others
+        # Set a different default first
+        for other_name in config.profiles:
+            if other_name != name:
+                config.default_profile = other_name
+                break
+
+    del config.profiles[name]
+
+    # Ensure at least one profile exists
+    if not config.profiles:
+        config.profiles["default"] = Profile()
+        config.default_profile = "default"
+
+    save_config(config)
+    return True
+
+
+def set_default_profile(name: str) -> bool:
+    """Set the default profile. Returns True if set, False if profile not found."""
+    config = load_config()
+
+    if name not in config.profiles:
+        return False
+
+    config.default_profile = name
+    save_config(config)
+    return True
+
+
+def list_profiles() -> dict[str, Profile]:
+    """List all profiles."""
+    config = load_config()
+    return config.profiles
+
+
+def get_default_profile_name() -> str:
+    """Get the name of the default profile."""
+    config = load_config()
+    return config.default_profile

fastsmtp_cli/main.py

@@ -0,0 +1,59 @@
+"""FastSMTP CLI - Remote CLI client for FastSMTP server."""
+
+from typing import Annotated
+
+import typer
+
+from fastsmtp_cli import __version__
+from fastsmtp_cli.commands import auth, config, domains, operations, recipients, rules, users
+from fastsmtp_cli.output import console
+
+app = typer.Typer(
+    name="fsmtp",
+    help="FastSMTP CLI - Remote CLI client for FastSMTP server",
+    no_args_is_help=True,
+)
+
+# Global options
+ProfileOption = Annotated[
+    str | None,
+    typer.Option("--profile", "-p", help="Profile to use", envvar="FSMTP_PROFILE"),
+]
+
+
+def version_callback(value: bool) -> None:
+    """Print version and exit."""
+    if value:
+        console.print(f"FastSMTP CLI version {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            "-V",
+            callback=version_callback,
+            is_eager=True,
+            help="Show version and exit",
+        ),
+    ] = False,
+) -> None:
+    """FastSMTP CLI - Remote CLI client for FastSMTP server."""
+    pass
+
+
+# Register command groups
+app.add_typer(config.app, name="config", help="Manage CLI configuration and profiles")
+app.add_typer(auth.app, name="auth", help="Authentication and API key management")
+app.add_typer(users.app, name="users", help="User management (superuser only)")
+app.add_typer(domains.app, name="domain", help="Domain management")
+app.add_typer(recipients.app, name="recipient", help="Recipient management")
+app.add_typer(rules.app, name="rules", help="RuleSet and rule management")
+app.add_typer(operations.app, name="ops", help="Operations (health, logs, test)")
+
+
+if __name__ == "__main__":
+    app()