remotivelabs-cli 0.5.0a1__py3-none-any.whl

remotivelabs/cli/settings/__init__.py

@@ -0,0 +1,20 @@
+from remotivelabs.cli.settings.config_file import Account, ConfigFile
+from remotivelabs.cli.settings.config_file import dumps as dumps_config_file
+from remotivelabs.cli.settings.config_file import loads as loads_config_file
+from remotivelabs.cli.settings.core import InvalidSettingsFilePathError, Settings, settings
+from remotivelabs.cli.settings.token_file import TokenFile
+from remotivelabs.cli.settings.token_file import dumps as dumps_token_file
+from remotivelabs.cli.settings.token_file import loads as loads_token_file
+
+__all__ = [
+    "settings",
+    "InvalidSettingsFilePathError",
+    "Settings",
+    "TokenFile",
+    "ConfigFile",
+    "Account",
+    "dumps_config_file",
+    "loads_config_file",
+    "dumps_token_file",
+    "loads_token_file",
+]

remotivelabs/cli/settings/config_file.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+from remotivelabs.cli.settings.token_file import TokenFile
+
+
+class Account(BaseModel):
+    """
+    Account represents an account in the configuration file.
+
+    TODO: Add email field to Account
+    """
+
+    credentials_file: str
+    default_organization: Optional[str] = None
+
+
+class ConfigFile(BaseModel):
+    """
+    ConfigFile represents the configuration file for the CLI.
+
+    TODO: Should all setters return a new instance of the ConfigFile?
+    """
+
+    version: str = "1.0"
+    active: Optional[str] = None
+    accounts: dict[str, Account] = Field(default_factory=dict)
+
+    @model_validator(mode="before")
+    @classmethod
+    def _validate_json_data(cls, json_data: Any) -> Any:
+        """Try to migrate old formats and missing fields as best we can."""
+        if not isinstance(json_data, dict):
+            return json_data
+
+        # If the active account is not in accounts, remove it
+        if "active" in json_data and json_data["active"] not in json_data["accounts"]:
+            del json_data["active"]
+
+        return json_data
+
+    def get_active_account(self) -> Optional[Account]:
+        if not self.active:
+            return None
+        account = self.get_account(self.active)
+        if not account:
+            raise KeyError(f"Activated account {self.active} is not a valid account")
+        return account
+
+    def activate_account(self, email: str) -> None:
+        account = self.get_account(email)
+        if not account:
+            raise KeyError(f"Account {email} does not exists")
+        self.active = email
+
+    def _update_account(self, email: str, **updates: Any) -> None:
+        """TODO: Consider using model_copy and always return a new instance of ConfigFile"""
+        existing_account = self.get_account(email)
+        if existing_account:
+            updated_account = existing_account.model_copy(update=updates)
+        else:
+            updated_account = Account(**updates)
+
+        new_accounts = {**self.accounts, email: updated_account}
+        self.accounts = new_accounts
+
+    def init_account(self, email: str, token_file: TokenFile) -> None:
+        """
+        Create a new account with the given email and token file.
+        """
+        self._update_account(email, credentials_file=token_file.get_token_file_name())
+
+    def set_default_organization_for_account(self, email: str, default_organization: Optional[str] = None) -> None:
+        if not self.get_account(email):
+            raise KeyError(f"Account with email {email} has not been initialized with token")
+        self._update_account(email, default_organization=default_organization)
+
+    def get_account(self, email: str) -> Optional[Account]:
+        return self.accounts.get(email)
+
+    def remove_account(self, email: str) -> None:
+        self.accounts.pop(email, None)
+
+    @classmethod
+    def from_json_str(cls, data: str) -> ConfigFile:
+        return cls.model_validate_json(data)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ConfigFile:
+        return cls.model_validate(data)
+
+    def to_json_str(self) -> str:
+        return self.model_dump_json()
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.model_dump()
+
+
+def loads(data: str) -> ConfigFile:
+    """
+    Creates a ConfigFile from a JSON string.
+    """
+    return ConfigFile.from_json_str(data)
+
+
+def dumps(config: ConfigFile) -> str:
+    """
+    Returns the JSON string representation of the ConfigFile.
+    """
+    return config.to_json_str()

remotivelabs/cli/settings/core.py

@@ -0,0 +1,333 @@
+from __future__ import annotations
+
+import os
+import stat
+import sys
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+
+from remotivelabs.cli.settings import config_file as cf
+from remotivelabs.cli.settings import state_file as sf
+from remotivelabs.cli.settings import token_file as tf
+from remotivelabs.cli.settings.config_file import Account, ConfigFile
+from remotivelabs.cli.settings.state_file import StateFile
+from remotivelabs.cli.settings.token_file import TokenFile
+from remotivelabs.cli.utils.console import print_hint
+
+err_console = Console(stderr=True)
+
+CONFIG_DIR_PATH = Path.home() / ".config" / "remotive"
+CLI_CONFIG_FILE_NAME = "config.json"
+CLI_INTERNAL_STATE_FILE_NAME = "app-state.json"
+
+TOKEN_ENV = "REMOTIVE_CLOUD_AUTH_TOKEN"
+# Deprecated in favour of name used in topology-cli
+DEPR_TOKEN_ENV = "REMOTIVE_CLOUD_ACCESS_TOKEN"
+
+
+class InvalidSettingsFilePathError(Exception):
+    """Raised when trying to access an invalid settings file or file path"""
+
+
+class Settings:
+    """
+    Settings handles tokens and other config for the remotive CLI
+
+    TODO: migrate away from singleton instance
+    TODO: How do we handle REMOTIVE_CLOUD_ACCESS_TOKEN in combination with active account? What takes precedence?
+    """
+
+    config_dir: Path
+
+    def __init__(self, config_dir: Path) -> None:
+        self.config_dir = config_dir
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self.config_file_path = self.config_dir / CLI_CONFIG_FILE_NAME
+        if not self.config_file_path.exists():
+            self._write_config_file(ConfigFile())
+        self.state_dir = self.config_dir / "state"
+        self.state_file_path = self.state_dir / CLI_INTERNAL_STATE_FILE_NAME
+        if not self.state_file_path.exists():
+            self._write_state_file(StateFile())
+
+    def _get_cli_config(self) -> ConfigFile:
+        return self._read_config_file()
+
+    def _get_state_file(self) -> StateFile:
+        return self._read_state_file()
+
+    def should_perform_update_check(self) -> bool:
+        """
+        Check if we should perform an update check.
+        """
+        return self._get_state_file().should_perform_update_check()
+
+    def set_default_organisation(self, organisation: str) -> None:
+        """
+        Set the default organization for the active account
+
+        TODO: Raise error, dont sys.exit
+        """
+        config = self._get_cli_config()
+        active_account = config.get_active_account()
+        if not active_account:
+            print_hint("You must have an account activated in order to set default organization")
+            sys.exit(1)
+        active_account.default_organization = organisation
+        self._write_config_file(config)
+
+    def get_active_account(self) -> Account | None:
+        """
+        Get the current active account
+
+        TODO: Add email field to Account
+        """
+        return self._get_cli_config().get_active_account()
+
+    def get_active_token_file(self) -> TokenFile | None:
+        """
+        Get the token file for the current active account
+        """
+        active_account = self.get_active_account()
+        return self._read_token_file(active_account.credentials_file) if active_account else None
+
+    def get_active_token(self) -> str | None:
+        """
+        Get the token secret for the current active account or token specified by env variable
+        """
+
+        token = os.environ[DEPR_TOKEN_ENV] if DEPR_TOKEN_ENV in os.environ else None
+        if not token:
+            token = os.environ[TOKEN_ENV] if TOKEN_ENV in os.environ else None
+        if token:
+            return token
+
+        token_file = self.get_active_token_file()
+        return token_file.token if token_file else None
+
+    def activate_token(self, token_file: TokenFile) -> TokenFile:
+        """
+        Activate a token by name or path
+
+        The token secret will be set as the current active secret.
+
+        Returns the activated token file
+        """
+        config = self._get_cli_config()
+        config.activate_account(token_file.account.email)
+        self._write_config_file(config)
+        return token_file
+
+    def is_active_account(self, email: str) -> bool:
+        """
+        Returns True if the given email is the active account
+        """
+        return self._get_cli_config().active == email
+
+    def clear_active_account(self) -> None:
+        """
+        Clear the current active token
+        """
+        config = self._get_cli_config()
+        config.active = None
+        self._write_config_file(config)
+
+    def get_token_file_by_email(self, email: str) -> Optional[TokenFile]:
+        """
+        Get a token file by email.
+
+        If multiple tokens are found, the first one is returned.
+        """
+        accounts = self._get_cli_config().accounts.get(email)
+        return self._read_token_file(accounts.credentials_file) if accounts else None
+
+    def get_token_file(self, name: str) -> TokenFile | None:
+        """
+        Get a token file by name or path
+        """
+        # 1. Try relative path
+        if (self.config_dir / name).exists():
+            return self._read_token_file(name)
+
+        # 2. Try name
+        return self._get_token_by_name(name)
+
+    def remove_token_file(self, name: str) -> None:
+        """
+        Remove a token file by name or path
+        """
+        token_file = self.get_token_file(name)
+        if not token_file:
+            return
+
+        # If the token is active, clear it first
+        email = token_file.account.email
+        if self.is_active_account(email):
+            self.clear_active_account()
+
+        # Remove the token file
+        path = self.config_dir / self._get_cli_config().accounts[email].credentials_file
+        path.unlink()
+
+        # Remove the account from the config file
+        config = self._get_cli_config()
+        config.remove_account(email)
+        self._write_config_file(config)
+
+    def add_personal_token(self, token: str, activate: bool = False, overwrite_if_exists: bool = False) -> TokenFile:
+        """
+        Add a personal token
+        """
+        token_file = tf.loads(token)
+        if token_file.type != "authorized_user":
+            raise ValueError("Token type MUST be authorized_user")
+
+        token_file = self.add_token_as_account(token_file, overwrite_if_exists)
+
+        if activate:
+            self.activate_token(token_file)
+
+        return token_file
+
+    def add_service_account_token(self, token: str, overwrite_if_exists: bool = False) -> TokenFile:
+        """
+        Add a service account token
+        """
+        token_file = tf.loads(token)
+        if token_file.type != "service_account":
+            raise ValueError("Token type MUST be service_account")
+
+        return self.add_token_as_account(token_file, overwrite_if_exists)
+
+    def add_token_as_account(self, token_file: TokenFile, overwrite_if_exists: bool = False) -> TokenFile:
+        """
+        Add an account to the config file
+        """
+        file_name = token_file.get_token_file_name()
+        path = self.config_dir / file_name
+        if path.exists() and not overwrite_if_exists:
+            raise FileExistsError(f"Token file already exists: {path}")
+
+        self._write_token_file(path, token_file)
+        cli_config = self._get_cli_config()
+        cli_config.init_account(email=token_file.account.email, token_file=token_file)
+        self._write_config_file(cli_config)
+
+        return token_file
+
+    def list_accounts(self) -> dict[str, Account]:
+        """
+        List all accounts
+        """
+        return self._get_cli_config().accounts
+
+    def list_personal_accounts(self) -> dict[str, Account]:
+        """
+        List all personal accounts
+
+        TODO: add account type to Account
+        """
+        accounts = self.list_accounts()
+        return {
+            email: account
+            for email, account in accounts.items()
+            if self._read_token_file(account.credentials_file).type == "authorized_user"
+        }
+
+    def list_service_accounts(self) -> dict[str, Account]:
+        """
+        List all personal accounts
+
+        TODO: add account type to Account
+        """
+        accounts = self.list_accounts()
+        return {
+            email: account
+            for email, account in accounts.items()
+            if self._read_token_file(account.credentials_file).type == "service_account"
+        }
+
+    def list_token_files(self) -> list[TokenFile]:
+        """
+        List all token files
+        """
+        accounts = self._get_cli_config().accounts.values()
+        return [self._read_token_file(account.credentials_file) for account in accounts]
+
+    def list_personal_token_files(self) -> list[TokenFile]:
+        """
+        List all personal token files
+        """
+        return [token_file for token_file in self.list_token_files() if token_file.type == "authorized_user"]
+
+    def list_service_account_token_files(self) -> list[TokenFile]:
+        """
+        List all service account token files
+        """
+        return [token_file for token_file in self.list_token_files() if token_file.type == "service_account"]
+
+    def set_last_update_check_time(self, timestamp: str) -> None:
+        """
+        Sets the timestamp of the last self update check
+        """
+        state = self._read_state_file()
+        state.last_update_check_time = timestamp
+        self._write_state_file(state)
+
+    def _get_token_by_name(self, name: str) -> TokenFile | None:
+        """
+        Token name is only available as a property of TokenFile, so we must iterate over all tokens to find the right one
+        """
+        token_files = self.list_token_files()
+        matches = [token_file for token_file in token_files if token_file.name == name]
+        if len(matches) != 1:
+            return None
+        return matches[0]
+
+    def _read_token_file(self, file_name: str) -> TokenFile:
+        path = self.config_dir / file_name
+        data = self._read_file(path)
+        return tf.loads(data)
+
+    def _write_token_file(self, path: Path, token: TokenFile) -> Path:
+        data = tf.dumps(token)
+        return self._write_file(path, data)
+
+    def _read_config_file(self) -> ConfigFile:
+        data = self._read_file(self.config_file_path)
+        return cf.loads(data)
+
+    def _write_config_file(self, config: ConfigFile) -> Path:
+        data = cf.dumps(config)
+        return self._write_file(self.config_file_path, data)
+
+    def _read_state_file(self) -> StateFile:
+        data = self._read_file(self.state_file_path)
+        return sf.loads(data)
+
+    def _write_state_file(self, state: StateFile) -> Path:
+        data = sf.dumps(state)
+        return self._write_file(self.state_file_path, data)
+
+    def _read_file(self, path: Path) -> str:
+        if not path.exists():
+            raise FileNotFoundError(f"File could not be found: {path}")
+        return path.read_text(encoding="utf-8")
+
+    def _write_file(self, path: Path, data: str) -> Path:
+        if self.config_dir not in path.parents:
+            raise InvalidSettingsFilePathError(f"file {path} not in settings dir {self.config_dir}")
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(data, encoding="utf8")
+        os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
+        return path
+
+
+settings = Settings(CONFIG_DIR_PATH)
+"""
+Global/module-level settings instance. Module-level variables are only loaded once, at import time.
+
+TODO: Migrate away from singleton instance
+"""

remotivelabs/cli/settings/migration/migrate_all_token_files.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from remotivelabs.cli.settings.core import Settings
+from remotivelabs.cli.settings.migration.migrate_token_file import InvalidTokenError, UnsupportedTokenVersionError, migrate_legacy_token
+from remotivelabs.cli.settings.migration.migration_tools import list_token_files
+from remotivelabs.cli.settings.token_file import TokenFile, dumps
+
+ACTIVE_TOKEN_FILE_NAME = "cloud.secret.token"
+
+
+def migrate_legacy_tokens(tokens: list[TokenFile]) -> tuple[list[TokenFile], set[str]]:
+    """
+    Determine which tokens can be updated and which should be removed.
+
+    Returns:
+        tuple of (updated_tokens, invalid_tokens)
+    """
+    updated_tokens: list[TokenFile] = []
+    invalid_tokens: set[str] = set()
+
+    for token in tokens:
+        try:
+            migrated_token = migrate_legacy_token(token)
+            if migrated_token.version != token.version:
+                updated_tokens.append(migrated_token)
+        except (InvalidTokenError, UnsupportedTokenVersionError):
+            # Token not valid or unsupported version, mark for removal
+            invalid_tokens.add(token.name)
+
+    return updated_tokens, invalid_tokens
+
+
+def _write_updated_tokens(settings: Settings, updated_tokens: list[TokenFile]) -> None:
+    for updated_token in updated_tokens:
+        settings.remove_token_file(name=updated_token.name)
+        if updated_token.type == "authorized_user":
+            settings.add_personal_token(dumps(updated_token), overwrite_if_exists=True)
+        elif updated_token.type == "service_account":
+            settings.add_service_account_token(dumps(updated_token))
+        else:
+            raise ValueError(f"Unsupported token type: {updated_token.type}")
+
+
+def _remove_invalid_tokens(settings: Settings, invalid_tokens: set[str]) -> None:
+    for token_name in invalid_tokens:
+        settings.remove_token_file(name=token_name)
+
+
+def _remove_old_secret_file(settings: Settings) -> bool:
+    old_activated_secret_file = settings.config_dir / ACTIVE_TOKEN_FILE_NAME
+    old_secret_exists = old_activated_secret_file.exists()
+    if old_secret_exists:
+        old_activated_secret_file.unlink(missing_ok=True)
+    return old_secret_exists
+
+
+def migrate_any_legacy_tokens(settings: Settings) -> bool:
+    """
+    Migrate any legacy tokens to the latest TokenFile format.
+
+    If the legacy secret file exists (cloud.secret.token), it will be removed.
+
+    Returns True if any tokens were migrated, False otherwise.
+    """
+    tokens = list_token_files(settings.config_dir)
+
+    # Get tokens to update/remove
+    updated_tokens, invalid_tokens = migrate_legacy_tokens(tokens)
+
+    # Perform file operations
+    _write_updated_tokens(settings, updated_tokens)
+    _remove_invalid_tokens(settings, invalid_tokens)
+
+    # Remove old secret file if exists
+    old_secret_removed = _remove_old_secret_file(settings)
+    if old_secret_removed:
+        return True  # We migrated at least one token
+
+    # only return True if we migrated at least one token
+    return len(updated_tokens) + len(invalid_tokens) > 0

remotivelabs/cli/settings/migration/migrate_config_file.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any, Optional
+
+from remotivelabs.cli.settings.config_file import ConfigFile, loads
+from remotivelabs.cli.settings.core import Settings
+from remotivelabs.cli.settings.migration.migration_tools import get_token_file
+
+
+def migrate_account_data(config: dict[str, Any], settings: Settings) -> Optional[dict[str, Any]]:
+    """
+    Migrates Account property credentials_name to credentials_file
+    """
+    accounts = config.get("accounts", {})
+    to_delete = []
+    found_old = False
+    for account_email, account_info in list(accounts.items()):
+        cred_name = account_info.pop("credentials_name", None)
+        if not cred_name:
+            continue
+
+        # found legacy account, try to migrate it, or drop it...
+        found_old = True
+
+        token_file = get_token_file(cred_name, settings.config_dir)
+        if not token_file:
+            sys.stderr.write(f"Dropping account {account_email!r}: credentials file for {cred_name} not found")
+            to_delete.append(account_email)
+            continue
+
+        cred_file = token_file.get_token_file_name()
+        if not cred_file:
+            sys.stderr.write(f"Dropping account {account_email!r}: credentials file for {cred_name} not found")
+            to_delete.append(account_email)
+            continue
+
+        account_info["credentials_file"] = cred_file
+
+    # actually remove them (also remove active if it was the one being removed)
+    for account_email in to_delete:
+        del accounts[account_email]
+        if config.get("active", None) == account_email:
+            config["active"] = None
+
+    return config if found_old else None
+
+
+def migrate_config_file(path: Path, settings: Settings) -> ConfigFile:
+    """
+    Migrates data in config file to new format
+    """
+    data = path.read_text()
+    loaded_data: dict[str, Any] = json.loads(data)
+    migrated_data = migrate_account_data(loaded_data, settings)
+    if not migrated_data:
+        return loads(data)
+
+    sys.stderr.write("Migrating old configuration format")
+    migrated_config: ConfigFile = ConfigFile.from_dict(migrated_data)
+    settings._write_config_file(migrated_config)
+    return migrated_config

remotivelabs/cli/settings/migration/migrate_legacy_dirs.py

@@ -0,0 +1,50 @@
+"""
+Migrate all files from legacy config directories to the new config directory. Any migration of the content is handled by specific migration
+scripts later in the migration process.
+"""
+
+import shutil
+import sys
+from pathlib import Path
+
+INCORRECT_CONFIG_DIR_PATH = Path.home() / ".config" / ".remotive"
+DEPRECATED_CONFIG_DIR_PATH = Path.home() / ".remotive"
+DEPRECATED_CONFIG_DIRS = [DEPRECATED_CONFIG_DIR_PATH, INCORRECT_CONFIG_DIR_PATH]
+
+
+def _copy_dir_fail_on_conflict(src: Path, dst: Path) -> None:
+    if not dst.is_dir():
+        dst.mkdir(parents=True, exist_ok=True)
+
+    for item in src.iterdir():
+        src_file = src / item.name
+        dst_file = dst / item.name
+
+        if src_file.is_file():
+            if dst_file.exists():
+                raise FileExistsError(f"File '{dst_file}' already exists.")
+            shutil.copy2(src_file, dst_file)  # preserve metadata
+
+
+def migrate_legacy_settings_dir(path: Path, target_dir: Path) -> None:
+    if not path.exists():
+        return
+
+    sys.stderr.write(f"found legacy config directory {path}, trying to migrate to {target_dir}\n")
+    try:
+        _copy_dir_fail_on_conflict(path, target_dir)
+        shutil.rmtree(str(path))
+    except FileExistsError as e:
+        sys.stderr.write(
+            f"file {e.filename} already exists in {target_dir}, so files in {path} cannot be migrated without risk of data loss. \
+            Please remove or move the files to {target_dir} manually and make sure to remove {path}.\n"
+        )
+        raise e
+
+
+def migrate_legacy_settings_dirs(target_dir: Path) -> None:
+    """
+    Migrate any valid configuration from legacy config directories to the new config directory.
+    """
+    for deprecated_config_dir in DEPRECATED_CONFIG_DIRS:
+        migrate_legacy_settings_dir(deprecated_config_dir, target_dir)