remotivelabs-cli 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

cli/cloud/auth/cmd.py

@@ -27,9 +27,6 @@ def login(browser: bool = typer.Option(default=True, help="Does not automaticall
     If not able to open a browser it will show fallback to headless login and show a link that
     users can copy into any browser when this is unsupported where running the cli - such as in docker,
     virtual machine or ssh sessions.
-
-    This will be used as the current access token in all subsequent requests. This would
-    be the same as activating a personal access key or service-account access key.
     """
     do_login(headless=not browser)
 
@@ -61,9 +58,9 @@ def print_access_token(
     else:
         config = settings.get_cli_config()
         if account in config.accounts:
-            token_name = config.accounts[account].credentials_name
+            token_file_name = config.accounts[account].credentials_file
             try:
-                print(settings.get_token_file(token_name).token)
+                print(settings.get_token_file(token_file_name).token)
             except TokenNotFoundError:
                 ErrorPrinter.print_generic_error(f"Token file for {account} could not be found", exit_code=1)
         else:

cli/cloud/auth/login.py

@@ -18,7 +18,8 @@ from typing_extensions import override
 
 from cli.cloud.auth_tokens import do_activate, prompt_to_set_org
 from cli.errors import ErrorPrinter
-from cli.settings import TokenFile, TokenNotFoundError, settings
+from cli.settings import TokenNotFoundError, settings
+from cli.settings.token_file import TokenFile
 from cli.utils.rest_helper import RestHelper as Rest
 
 httpd: HTTPServer

cli/cloud/auth_tokens.py

@@ -9,7 +9,9 @@ from rich.table import Table
 from cli.api.cloud import tokens
 from cli.cloud.organisations import do_select_default_org
 from cli.errors import ErrorPrinter
-from cli.settings import TokenFile, TokenNotFoundError, settings
+from cli.settings import TokenNotFoundError, settings
+from cli.settings.config_file import Account
+from cli.settings.token_file import TokenFile
 from cli.typer import typer_utils
 from cli.utils.rest_helper import RestHelper as Rest
 
@@ -27,10 +29,6 @@ def _prompt_choice(  # noqa: C901, PLR0912
     info_message: Optional[str] = None,
 ) -> Optional[TokenFile]:
     accounts = settings.get_cli_config().accounts
-    try:
-        active_account = settings.get_cli_config().get_active()
-    except TokenNotFoundError:
-        active_account = None
 
     table = Table("#", "Active", "Type", "Token", "Account", "Created", "Expires")
 
@@ -39,8 +37,13 @@ def _prompt_choice(  # noqa: C901, PLR0912
 
     for token in choices:
         account = accounts.get(token.account.email)
-        if account and account.credentials_name and account.credentials_name in (token.name or ""):
-            included_tokens.append(token)
+        if account and account.credentials_file:
+            try:
+                token_file = settings.get_token_file(account.credentials_file)
+                if token_file.name in (token.name or ""):
+                    included_tokens.append(token)
+            except TokenNotFoundError:
+                excluded_tokens.append(token)
         else:
             excluded_tokens.append(token)
 
@@ -49,10 +52,27 @@ def _prompt_choice(  # noqa: C901, PLR0912
 
     included_tokens.sort(key=lambda token: token.created, reverse=True)
 
+    def get_active_account_or_none() -> Optional[Account]:
+        try:
+            return settings.get_cli_config().get_active()
+        except TokenNotFoundError:
+            return None
+
+    def get_active_token_or_none() -> Optional[TokenFile]:
+        try:
+            active_account = get_active_account_or_none()
+            if active_account is not None:
+                return settings.get_token_file(active_account.credentials_file)
+        except TokenNotFoundError:
+            pass
+        return None
+
+    active_token = get_active_token_or_none()
     active_token_index = None
     for idx, choice in enumerate(included_tokens, start=1):
-        is_active = active_account is not None and active_account.credentials_name == choice.name
+        is_active = active_token is not None and active_token.name == choice.name
         active_token_index = idx if is_active else active_token_index
+
         table.add_row(
             f"[yellow]{idx}",
             ":white_check_mark:" if is_active else "",
@@ -62,7 +82,6 @@ def _prompt_choice(  # noqa: C901, PLR0912
             str(choice.created),
             str(choice.expires),
         )
-    # console.print("It seems like you have access tokens from previous login, you can select one of these instead of logging in")
     console.print(table)
 
     if skip_prompt:
@@ -165,9 +184,7 @@ def select_personal_token(
     do_activate(token_name)
 
 
-def do_activate(
-    token_name: Optional[str],
-) -> Optional[TokenFile]:
+def do_activate(token_name: Optional[str]) -> Optional[TokenFile]:
     if token_name is not None:
         try:
             token_file = settings.get_token_file(token_name)
@@ -208,8 +225,6 @@ def list_and_select_personal_token(
         sa_tokens = settings.list_service_account_tokens()
         personal_tokens.extend(sa_tokens)
 
-    # merged = _merge_local_tokens_with_cloud(personal_tokens)
-
     selected_token = _prompt_choice(personal_tokens, skip_prompt=skip_prompt, info_message=info_message)
     if selected_token is not None:
         settings.activate_token(selected_token)

cli/cloud/organisations.py

@@ -76,7 +76,7 @@ def do_select_default_org(organisation_uid: Optional[str] = None, get: bool = Fa
     """
     if get:
         default_organisation = settings.get_cli_config().get_active_default_organisation()
-        if default_organisation is not None:
+        if default_organisation:
             console.print(default_organisation)
         else:
             console.print("No default organization set")
@@ -84,8 +84,8 @@ def do_select_default_org(organisation_uid: Optional[str] = None, get: bool = Fa
         settings.set_default_organisation(organisation_uid)
     else:
         account = settings.get_cli_config().get_active()
-        if account is not None:
-            token = settings.get_token_file(account.credentials_name)
+        if account:
+            token = settings.get_token_file(account.credentials_file)
             if token.type != "authorized_user":
                 ErrorPrinter.print_hint(
                     "You must supply the organization name as argument when using a service-account since the "

cli/cloud/recordings.py

@@ -137,14 +137,13 @@ def mount(  # noqa: C901
         r = Rest.handle_get(url=f"/api/project/{project}/brokers/personal", return_response=True, allow_status_codes=[404])
 
         if r.status_code == 200:
-            broker = r.json()["shortName"]
-
+            broker_info = r.json()
+            broker = broker_info["shortName"]
         elif r.status_code == 404:
             r = do_start("personal", project, "", return_response=True)
             if r.status_code != 200:
                 print(r.text)
                 sys.exit(0)
-            broker = r.json()["shortName"]
         else:
             sys.stderr.write(f"Got http status code {r.status_code}")
             raise typer.Exit(0)
@@ -154,7 +153,6 @@ def mount(  # noqa: C901
         if r.status_code == 404:
             if ensure_broker_started:
                 r = do_start(broker, project, "", return_response=True)
-
                 if r.status_code != 200:
                     print(r.text)
                     sys.exit(1)
@@ -164,6 +162,9 @@ def mount(  # noqa: C901
         elif r.status_code != 200:
             sys.stderr.write(f"Got http status code {r.status_code}")
             raise typer.Exit(1)
+
+    broker_info = r.json()
+    broker = broker_info["shortName"]
     broker_config_query = ""
     if transformation_name != "default":
         broker_config_query = f"?brokerConfigName={transformation_name}"
@@ -174,7 +175,8 @@ def mount(  # noqa: C901
         return_response=True,
         progress_label="Preparing recording on broker...",
     )
-    print("Successfully mounted recording on broker")
+    err_console.print("Successfully mounted recording on broker")
+    print(json.dumps(broker_info))
 
 
 @app.command(help="Downloads the specified recording file to disk")

cli/errors.py

@@ -41,4 +41,4 @@ class ErrorPrinter:
 
     @staticmethod
     def print_generic_message(message: str) -> None:
-        err_console.print(f"[bold]{message}[/bold]:")
+        err_console.print(f"[bold]{message}[/bold]")

cli/remotive.py

@@ -6,20 +6,29 @@ from importlib.metadata import version
 import typer
 from rich import print as rich_print
 from rich.console import Console
-from trogon import Trogon  # type: ignore
+from trogon import Trogon
 from typer.main import get_group
 
-from cli.settings.migrate_all_token_files import migrate_any_legacy_tokens
-
-from .broker.brokers import app as broker_app
-from .cloud.cloud_cli import app as cloud_app
-from .connect.connect import app as connect_app
-from .settings import settings
-from .tools.tools import app as tools_app
-from .typer import typer_utils
+from cli.broker.brokers import app as broker_app
+from cli.cloud.cloud_cli import app as cloud_app
+from cli.connect.connect import app as connect_app
+from cli.settings import settings
+from cli.settings.core import Settings
+from cli.settings.migration.migrate_all_token_files import migrate_any_legacy_tokens
+from cli.settings.migration.migrate_config_file import migrate_config_file
+from cli.settings.migration.migrate_legacy_dirs import migrate_legacy_settings_dirs
+from cli.tools.tools import app as tools_app
+from cli.topology.cmd import app as topology_app
+from cli.typer import typer_utils
 
 err_console = Console(stderr=True)
 
+
+def is_featue_flag_enabled(env_var: str) -> bool:
+    """Check if an environment variable indicates a feature is enabled."""
+    return os.getenv(env_var, "").lower() in ("true", "1", "yes", "on")
+
+
 if os.getenv("GRPC_VERBOSITY") is None:
     os.environ["GRPC_VERBOSITY"] = "NONE"
 
@@ -32,8 +41,6 @@ For documentation - https://docs.remotivelabs.com
 """,
 )
 
-# settings.set_default_config_as_env()
-
 
 def version_callback(value: bool) -> None:
     if value:
@@ -48,14 +55,26 @@ def test_callback(value: int) -> None:
         raise typer.Exit()
 
 
-def _migrate_old_tokens() -> None:
-    tokens = settings.list_personal_tokens()
-    tokens.extend(settings.list_service_account_tokens())
-    if migrate_any_legacy_tokens(tokens):
+def run_migrations(settings: Settings) -> None:
+    """
+    Run all migration scripts.
+
+    Each migration script is responsible for a particular migration, and order matters.
+    """
+    # 1. Migrate legacy settings dirs
+    migrate_legacy_settings_dirs(settings.config_dir)
+
+    # 2. Migrate any legacy tokens
+    has_migrated_tokens = migrate_any_legacy_tokens(settings)
+
+    # 3. Migrate legacy config file format
+    migrate_config_file(settings.config_file_path, settings)
+
+    if has_migrated_tokens:
         err_console.print("Migrated old credentials and configuration files, you may need to login again or activate correct credentials")
 
 
-def _set_default_org_as_env() -> None:
+def set_default_org_as_env(settings: Settings) -> None:
     """
     If not already set, take the default organisation from file and set as env
     This has to be done early before it is read
@@ -68,10 +87,16 @@ def _set_default_org_as_env() -> None:
 
 @app.callback()
 def main(
-    _the_version: bool = typer.Option(None, "--version", callback=version_callback, is_eager=False, help="Print current version"),
+    _the_version: bool = typer.Option(
+        None,
+        "--version",
+        callback=version_callback,
+        is_eager=False,
+        help="Print current version",
+    ),
 ) -> None:
-    _set_default_org_as_env()
-    _migrate_old_tokens()
+    run_migrations(settings)
+    set_default_org_as_env(settings)
     # Do other global stuff, handle other global options here
 
 
@@ -92,3 +117,14 @@ app.add_typer(
 )
 app.add_typer(connect_app, name="connect", help="Integrations with other systems")
 app.add_typer(tools_app, name="tools")
+
+if is_featue_flag_enabled("REMOTIVE_TOPOLOGY_ENABLED"):
+    app.add_typer(
+        topology_app,
+        name="topology",
+        help="""
+    RemotiveTopology actions
+
+    Read more at https://docs.remotivelabs.com/docs/remotive-topology
+    """,
+    )

cli/settings/__init__.py

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

cli/settings/config_file.py

@@ -3,21 +3,16 @@ from __future__ import annotations
 import dataclasses
 import json
 from dataclasses import dataclass
-from json import JSONDecodeError
-from typing import Dict, Optional
+from typing import Any, Optional
 
 from dacite import from_dict
 
+from cli.settings.token_file import TokenFile
+
 
 def loads(data: str) -> ConfigFile:
-    try:
-        d = json.loads(data)
-        return from_dict(ConfigFile, d)
-    except JSONDecodeError as e:
-        # ErrorPrinter.print_generic_error("Invalid json format, config.json")
-        raise JSONDecodeError(
-            f"File config.json is not valid json, please edit or remove file to have it re-created ({e.msg})", pos=e.pos, doc=e.doc
-        )
+    d = json.loads(data)
+    return from_dict(ConfigFile, d)
 
 
 def dumps(config: ConfigFile) -> str:
@@ -26,7 +21,7 @@ def dumps(config: ConfigFile) -> str:
 
 @dataclass
 class Account:
-    credentials_name: str
+    credentials_file: str
     default_organization: Optional[str] = None
     # Add project as well
 
@@ -35,53 +30,51 @@ class Account:
 class ConfigFile:
     version: str = "1.0"
     active: Optional[str] = None
-    accounts: Dict[str, Account] = dataclasses.field(default_factory=dict)
+    accounts: dict[str, Account] = dataclasses.field(default_factory=dict)
 
     def get_active_default_organisation(self) -> Optional[str]:
         active_account = self.get_active()
-        return active_account.default_organization if active_account is not None else None
+        return active_account.default_organization if active_account else None
 
     def get_active(self) -> Optional[Account]:
-        if self.active is not None:
-            account = self.accounts.get(self.active)
-            if account is not None:
-                return 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 None
+        return account
 
     def activate(self, email: str) -> None:
-        account = self.accounts.get(email)
-
-        if account is not None:
-            self.active = email
-        else:
+        account = self.get_account(email)
+        if not account:
             raise KeyError(f"Account {email} does not exists")
+        self.active = email
 
     def get_account(self, email: str) -> Optional[Account]:
-        if self.accounts:
-            return self.accounts[email]
-        return None
+        if not self.accounts:
+            return None
+        return self.accounts.get(email, None)
 
     def remove_account(self, email: str) -> None:
         if self.accounts:
             self.accounts.pop(email, None)
 
-    def init_account(self, email: str, token_name: str) -> None:
+    def init_account(self, email: str, token_file: TokenFile) -> None:
         if self.accounts is None:
             self.accounts = {}
 
-        account = self.accounts.get(email)
+        account = self.get_account(email)
         if not account:
-            account = Account(credentials_name=token_name)
+            account = Account(credentials_file=token_file.get_token_file_name())
         else:
-            account.credentials_name = token_name
+            account.credentials_file = token_file.get_token_file_name()
         self.accounts[email] = account
 
     def set_account_field(self, email: str, default_organization: Optional[str] = None) -> ConfigFile:
         if self.accounts is None:
             self.accounts = {}
 
-        account = self.accounts.get(email)
+        account = self.get_account(email)
         if not account:
             raise KeyError(f"Account with email {email} has not been initialized with token")
 
@@ -90,3 +83,11 @@ class ConfigFile:
             account.default_organization = default_organization
 
         return self
+
+    @staticmethod
+    def from_json_str(data: str) -> ConfigFile:
+        return loads(data)
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> ConfigFile:
+        return from_dict(ConfigFile, data)

cli/settings/core.py

@@ -1,19 +1,16 @@
 from __future__ import annotations
 
 import os
-import re
-import shutil
 import stat
 import sys
-from dataclasses import dataclass
 from json import JSONDecodeError
 from pathlib import Path
-from typing import Optional, Tuple, Union
+from typing import Optional, Tuple
 
 from rich.console import Console
 
 from cli.errors import ErrorPrinter
-from cli.settings import config_file
+from cli.settings import config_file, token_file
 from cli.settings import token_file as tf
 from cli.settings.config_file import ConfigFile
 from cli.settings.token_file import TokenFile
@@ -22,13 +19,7 @@ err_console = Console(stderr=True)
 
 
 CONFIG_DIR_PATH = Path.home() / ".config" / "remotive"
-INCORRECT_CONFIG_DIR_PATH = Path.home() / ".config" / ".remotive"
-DEPRECATED_CONFIG_DIR_PATH = Path.home() / ".remotive"
-
 CLI_CONFIG_FILE_NAME = "config.json"
-ACTIVE_TOKEN_FILE_NAME = "cloud.secret.token"
-PERSONAL_TOKEN_FILE_PREFIX = "personal-token-"
-SERVICE_ACCOUNT_TOKEN_FILE_PREFIX = "service-account-token-"
 
 
 TokenFileMetadata = Tuple[TokenFile, Path]
@@ -38,67 +29,26 @@ class InvalidSettingsFilePathError(Exception):
     """Raised when trying to access an invalid settings file or file path"""
 
 
-class NotFoundError(Exception):
-    """Raised when a token cannot be found in settings"""
-
-
 class TokenNotFoundError(Exception):
     """Raised when a token cannot be found in settings"""
 
 
-@dataclass()
-class CliConfigFile:
-    default_organisation: Union[str, None]
-
-
 class Settings:
     """
-    Settings for the remotive CLI
+    Settings handles tokens and other config for the remotive CLI
     """
 
     config_dir: Path
 
-    def __init__(self, config_dir: Path, deprecated_config_dirs: list[Path] | None = None) -> None:
+    def __init__(self, config_dir: Path) -> None:
         self.config_dir = config_dir
-        self._active_secret_token_path = self.config_dir / ACTIVE_TOKEN_FILE_NAME
-        self._cli_config = self.config_dir / CLI_CONFIG_FILE_NAME
-
-        if self.config_dir.exists():
-            return
-
-        # create the config dir and try to migrate legacy config dirs if they exist
         self.config_dir.mkdir(parents=True, exist_ok=True)
-        if deprecated_config_dirs:
-            for deprecated_config_dir in deprecated_config_dirs:
-                self._migrate_legacy_config_dir(deprecated_config_dir)
-
-    # def _write_properties(self, filepath: Path, props: CliConfigFile) -> None:
-    #    with open(filepath, "w", encoding="utf-8") as file:
-    #        # keys = sorted(props.keys()) if sort_keys else props.keys()
-    #        # for key in keys:
-    #        file.write(f"default_organisation={props.default_organisation}\n")
-
-    def _read_properties(self, filepath: Path) -> CliConfigFile:
-        props = {}
-        with open(filepath, "r", encoding="utf-8") as file:
-            for line_num, line in enumerate(file, start=1):
-                line_stripped = line.strip()
-                if not line_stripped or line_stripped.startswith("#"):
-                    continue
-                if "=" not in line_stripped:
-                    raise ValueError(f"Invalid line format at line {line_num}: {line}")
-                key, value = line_stripped.split("=", 1)
-                key, value = key.strip(), value.strip()
-                if key in props:
-                    raise ValueError(f"Duplicate key '{key}' found at line {line_num}")
-                props[key] = value
-        if "default_organisation" in props:
-            return CliConfigFile(default_organisation=props["default_organisation"])
-        return CliConfigFile(default_organisation=None)
+        self.config_file_path = self.config_dir / CLI_CONFIG_FILE_NAME
+        if not self.config_file_path.exists():
+            self._write_config_file(ConfigFile())
 
     def set_default_organisation(self, organisation: str) -> None:
         cli_config = self.get_cli_config()
-
         try:
             token = settings.get_active_token_file()
             cli_config.set_account_field(token.account.email, organisation)
@@ -112,7 +62,6 @@ class Settings:
             return self._read_config_file()
         except TokenNotFoundError:
             return ConfigFile()
-            # self._write_properties(CONFIG_DIR_PATH / CLI_CONFIG_FILE_NAME, [])
 
     def get_active_token(self) -> str:
         """
@@ -125,29 +74,22 @@ class Settings:
         """
         Get the current active token file
         """
-
         active_account = self.get_cli_config().get_active()
         if active_account is not None:
-            token_name = active_account.credentials_name
-            return self.get_token_file(token_name)
+            token_file_name = active_account.credentials_file
+            return self._read_token_file(self.config_dir / token_file_name)
+
         raise TokenNotFoundError
-        # if not self._active_secret_token_path.exists():
-        #    raise TokenNotFoundError("no active token file found")
-        # return self._read_token_file(self._active_secret_token_path)
 
-    def activate_token(self, token: TokenFile) -> None:
+    def activate_token(self, token_file: TokenFile) -> None:
         """
         Activate a token by name or path
 
         The token secret will be set as the current active secret.
         """
-        # token_file = self.get_token_file(name)
         cli_config = self.get_cli_config()
-        cli_config.activate(token.account.email)
-        # if token_file.account.email not in cli_config.accounts:
-        #    cli_config.set_account_field(token_file.account.email)
+        cli_config.activate(token_file.account.email)
         self._write_config_file(cli_config)
-        # self._write_token_file(self._active_secret_token_path, token_file)
 
     def clear_active_token(self) -> None:
         """
@@ -157,9 +99,12 @@ class Settings:
         config.active = None
         self._write_config_file(config)
 
-    # self._active_secret_token_path.unlink(missing_ok=True)
-
     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.
+        """
         tokens = [t for t in self.list_personal_tokens() if t.account is not None and t.account.email == email]
         if len(tokens) > 0:
             return tokens[0]
@@ -172,11 +117,15 @@ class Settings:
         """
         Get a token file by name or path
         """
+        # 1. Try relative path
+        if (self.config_dir / name).exists():
+            return self._read_token_file(self.config_dir / name)
+
+        # 2. Try absolute path
         if Path(name).exists():
             return self._read_token_file(Path(name))
-        if Path(CONFIG_DIR_PATH / name).exists():
-            return self._read_token_file(Path(CONFIG_DIR_PATH / name))
 
+        # 3. Try name
         return self._get_token_by_name(name)[0]
 
     def remove_token_file(self, name: str) -> None:
@@ -192,48 +141,30 @@ class Settings:
 
         # TODO: what about the active token?
         path = self._get_token_by_name(name)[1]
-        # print("Deleting", path)
         return path.unlink()
 
-    # def add_and_activate_short_lived_cli_token(self, token: str) -> TokenFile:
-    #    """
-    #    Activates a short lived token
-    #    """
-    #    token_file = tf.loads(token)
-    #    self._write_token_file(self._active_secret_token_path, token_file)
-    #    return token_file
-
-    def add_personal_token(
-        self,
-        token: str,
-        activate: bool = False,
-        overwrite_if_exists: bool = False,
-    ) -> TokenFile:
+    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)
-
-        def email_to_safe_filename(email: str) -> str:
-            # Replace any invalid character with an underscore
-            return re.sub(r'[<>:"/\\|?*]', "_", email)
+        file = tf.loads(token)
+        if file.type != "authorized_user":
+            raise ValueError("Token type MUST be authorized_user")
 
-        # From now, user will never be None when adding a token so in this case token_file.user is never None
-        email = email_to_safe_filename(token_file.account.email) if token_file.account is not None else "unknown"
-        file = f"{PERSONAL_TOKEN_FILE_PREFIX}{token_file.name}-{email}.json"
-        path = self.config_dir / file
+        file_name = 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)
+        self._write_token_file(path, file)
         cli_config = self.get_cli_config()
-        cli_config.init_account(email=token_file.account.email, token_name=token_file.name)
+        cli_config.init_account(email=file.account.email, token_file=file)
         self._write_config_file(cli_config)
 
         if activate:
-            self.activate_token(token_file)
+            self.activate_token(file)
 
-        return token_file
+        return file
 
     def list_personal_tokens(self) -> list[TokenFile]:
         """
@@ -247,39 +178,26 @@ class Settings:
         """
         return [f[1] for f in self._list_personal_tokens()]
 
-    def add_service_account_token(self, token: str) -> TokenFile:
+    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")
 
-        def email_to_safe_filename(email: str) -> str:
-            # Replace any invalid character with an underscore
-            return re.sub(r'[<>:"/\\|?*]', "_", email)
-
-            # From now, user will never be None when adding a token so in this case token_file.user is never None
-
-        email = email_to_safe_filename(token_file.account.email) if token_file.account is not None else "unknown"
-        file = f"{SERVICE_ACCOUNT_TOKEN_FILE_PREFIX}{token_file.name}-{email}.json"
+        file = token_file.get_token_file_name()
         path = self.config_dir / file
+        if path.exists() and not overwrite_if_exists:
+            raise FileExistsError(f"Token file already exists: {path}")
 
         self._write_token_file(path, token_file)
-        print(f"Service account token stored at {path}")
         cli_config = self.get_cli_config()
-        cli_config.init_account(email=token_file.account.email, token_name=token_file.name)
+        cli_config.init_account(email=token_file.account.email, token_file=token_file)
         self._write_config_file(cli_config)
 
-        # if activate:
-        #    self.activate_token(token_file.account.email)
-
         return token_file
 
-        # token_file = tf.loads(token)
-        # file = f"{SERVICE_ACCOUNT_TOKEN_FILE_PREFIX}{service_account}-{token_file.name}.json"
-        # path = self.config_dir / file
-        # if path.exists():
-        #    raise FileExistsError(f"Token file already exists: {path}")
-
-        # self._write_token_file(path, token_file)
-        # return token_file
-
     def list_service_account_tokens(self) -> list[TokenFile]:
         """
         List all service account tokens
@@ -293,10 +211,10 @@ class Settings:
         return [f[1] for f in self._list_service_account_tokens()]
 
     def _list_personal_tokens(self) -> list[TokenFileMetadata]:
-        return self._list_token_files(prefix=PERSONAL_TOKEN_FILE_PREFIX)
+        return self._list_token_files(prefix=token_file.PERSONAL_TOKEN_FILE_PREFIX)
 
     def _list_service_account_tokens(self) -> list[TokenFileMetadata]:
-        return self._list_token_files(prefix=SERVICE_ACCOUNT_TOKEN_FILE_PREFIX)
+        return self._list_token_files(prefix=token_file.SERVICE_ACCOUNT_TOKEN_FILE_PREFIX)
 
     def _get_token_by_name(self, name: str) -> TokenFileMetadata:
         token_files = self._list_token_files()
@@ -306,7 +224,11 @@ class Settings:
         return matches[0]
 
     def _list_token_files(self, prefix: str = "") -> list[TokenFileMetadata]:
-        """list all tokens with the correct prefix in the config dir, but omit files that are not token files"""
+        """
+        list all tokens with the correct prefix in the config dir, but omit files that are not token files
+
+        TODO: improve is_valid_json and is_valid_token_file using token_file parsing instead
+        """
 
         def is_valid_json(path: Path) -> bool:
             try:
@@ -318,14 +240,17 @@ class Settings:
                 return False
 
         def is_valid_token_file(path: Path) -> bool:
-            is_token_file = path.name.startswith(SERVICE_ACCOUNT_TOKEN_FILE_PREFIX) or path.name.startswith(PERSONAL_TOKEN_FILE_PREFIX)
+            is_token_file = path.name.startswith(tf.SERVICE_ACCOUNT_TOKEN_FILE_PREFIX) or path.name.startswith(
+                tf.PERSONAL_TOKEN_FILE_PREFIX
+            )
             has_correct_prefix = path.is_file() and path.name.startswith(prefix)
-            is_active_secret = path == self._active_secret_token_path
-            is_cli_config = path == self._cli_config
-            return is_token_file and is_valid_json(path) and has_correct_prefix and not is_active_secret and not is_cli_config
+            is_cli_config = path == self.config_file_path
+            is_present_in_cli_config_accounts = any(
+                path.name == account.credentials_file for account in self.get_cli_config().accounts.values()
+            )
+            return is_token_file and is_valid_json(path) and has_correct_prefix and not is_cli_config and is_present_in_cli_config_accounts
 
         paths = [path for path in self.config_dir.iterdir() if is_valid_token_file(path)]
-
         return [(self._read_token_file(token_file), token_file) for token_file in paths]
 
     def _read_token_file(self, path: Path) -> TokenFile:
@@ -347,9 +272,16 @@ class Settings:
         os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
         return path
 
+    # Temporary function while considering how to solve this
+    def write_config_file(self, config: ConfigFile) -> Path:
+        return self._write_config_file(config)
+
     def _write_config_file(self, config: ConfigFile) -> Path:
+        """
+        TODO: add read cache to avoid parsing the config every time we read it
+        """
         data = config_file.dumps(config)
-        path = self._write_file(self._cli_config, data)
+        path = self._write_file(self.config_file_path, data)
         os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
         return path
 
@@ -360,43 +292,8 @@ class Settings:
         path.write_text(data, encoding="utf8")
         return path
 
-    def _migrate_legacy_config_dir(self, path: Path) -> None:
-        if not path.exists():
-            return
-
-        sys.stderr.write(f"migrating deprecated config directory {path} to {self.config_dir}\n")
-        shutil.copytree(str(path), str(self.config_dir), dirs_exist_ok=True)
-        secret = path / ACTIVE_TOKEN_FILE_NAME
-        if secret.exists():
-            sys.stderr.write(f"Removing old activated token {secret}")
-            secret.unlink(missing_ok=True)
-            # value = secret.read_text(encoding="utf-8").strip()
-            # The existing token file might either be a token file, or simply a string. We handle both cases...
-            # try:
-            #    token = tf.loads(value)
-            # except JSONDecodeError:
-            #    token = tf.TokenFile(
-            #        version="1.0",
-            #        type="service-account" if value.startswith("sa") else "authorized_user",
-            #        name="MigratedActiveToken",
-            #        token=value,
-            #        created=str(datetime.datetime.now().isoformat()),
-            #        expires="unknown",
-            #        account=TokenFileAccount(email="unknown@remotivecloud.com"),
-            #    )
-            # self.add_and_activate_short_lived_cli_token(tf.dumps(token))
-        shutil.rmtree(str(path))
-
-
-def create_settings() -> Settings:
-    """Create remotive CLI config directory and return its settings instance"""
-    return Settings(
-        CONFIG_DIR_PATH,
-        deprecated_config_dirs=[DEPRECATED_CONFIG_DIR_PATH, INCORRECT_CONFIG_DIR_PATH],
-    )
-
-
-settings = create_settings()
+
+settings = Settings(CONFIG_DIR_PATH)
 """
 Global/module-level settings instance. Module-level variables are only loaded once, at import time.
 

cli/settings/{migrate_all_token_files.py → migration/migrate_all_token_files.py}

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
-from cli.settings import settings
-from cli.settings.core import ACTIVE_TOKEN_FILE_NAME
-from cli.settings.migrate_token_file import InvalidTokenError, UnsupportedTokenVersionError, migrate_legacy_token
+from cli.settings.core import Settings
+from cli.settings.migration.migrate_token_file import InvalidTokenError, UnsupportedTokenVersionError, migrate_legacy_token
+from cli.settings.migration.migration_tools import list_token_files
 from 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]]:
+
+def migrate_legacy_tokens(tokens: list[TokenFile]) -> tuple[list[TokenFile], set[str]]:
     """
     Determine which tokens can be updated and which should be removed.
 
@@ -28,7 +30,7 @@ def _migrate_legacy_tokens(tokens: list[TokenFile]) -> tuple[list[TokenFile], se
     return updated_tokens, invalid_tokens
 
 
-def _write_updated_tokens(updated_tokens: list[TokenFile]) -> None:
+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":
@@ -39,12 +41,12 @@ def _write_updated_tokens(updated_tokens: list[TokenFile]) -> None:
             raise ValueError(f"Unsupported token type: {updated_token.type}")
 
 
-def _remove_invalid_tokens(invalid_tokens: set[str]) -> None:
+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() -> bool:
+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:
@@ -52,21 +54,25 @@ def _remove_old_secret_file() -> bool:
     return old_secret_exists
 
 
-def migrate_any_legacy_tokens(tokens: list[TokenFile]) -> bool:
+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)
+    updated_tokens, invalid_tokens = migrate_legacy_tokens(tokens)
 
     # Perform file operations
-    _write_updated_tokens(updated_tokens)
-    _remove_invalid_tokens(invalid_tokens)
+    _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()
+    old_secret_removed = _remove_old_secret_file(settings)
     if old_secret_removed:
         return True  # We migrated at least one token
 

cli/settings/migration/migrate_config_file.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any, Optional
+
+from dacite import from_dict
+
+from cli.settings.config_file import ConfigFile, loads
+from cli.settings.core import Settings, TokenNotFoundError
+from 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_old = True
+        try:
+            cred_file = get_token_file(cred_name, settings.config_dir).get_token_file_name()
+        except TokenNotFoundError:
+            # schedule this account for removal
+            to_delete.append(account_email)
+            sys.stderr.write(f"Dropping account {account_email!r}: token file for {cred_name} not found")
+            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 = from_dict(data_class=ConfigFile, data=migrated_data)
+    settings.write_config_file(migrated_config)
+    return migrated_config

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)

cli/settings/migration/migration_tools.py

@@ -0,0 +1,36 @@
+from itertools import chain
+from pathlib import Path
+
+from cli.settings.core import TokenNotFoundError
+from cli.settings.token_file import TokenFile
+
+
+def list_token_files(config_dir: Path) -> list[TokenFile]:
+    """
+    List all token files in the config directory
+
+    Note! Dont use settings, as that will couple settings to the old config and token formats we want to migrate away from.
+    """
+    token_files = []
+    patterns = ["personal-token-*.json", "service-account-token-*.json"]
+    files = list(chain.from_iterable(config_dir.glob(pattern) for pattern in patterns))
+    for file in files:
+        try:
+            token_file = TokenFile.from_json_str(file.read_text())
+            token_files.append(token_file)
+        except Exception:
+            print(f"warning: invalid token file {file}. Consider removing it.")
+    return token_files
+
+
+def get_token_file(cred_name: str, config_dir: Path) -> TokenFile:
+    """
+    Get the token file for a given credentials name.
+
+    Note! Dont use settings, as that will couple settings to the old config and token formats we want to migrate away from.
+    """
+    token_files = list_token_files(config_dir)
+    matches = [token_file for token_file in token_files if token_file.name == cred_name]
+    if len(matches) != 1:
+        raise TokenNotFoundError(f"Token file for {cred_name} not found")
+    return matches[0]

cli/settings/token_file.py

@@ -2,11 +2,14 @@ from __future__ import annotations
 
 import dataclasses
 import json
+import re
 from dataclasses import dataclass
 from datetime import date, datetime
 from typing import Any, Literal
 
 DEFAULT_EMAIL = "unknown@remotivecloud.com"
+PERSONAL_TOKEN_FILE_PREFIX = "personal-token-"
+SERVICE_ACCOUNT_TOKEN_FILE_PREFIX = "service-account-token-"
 
 TokenType = Literal["authorized_user", "service_account"]
 
@@ -72,6 +75,17 @@ class TokenFile:
     expires: date
     account: TokenFileAccount
 
+    def get_token_file_name(self) -> str:
+        def email_to_safe_filename(email: str) -> str:
+            # Replace any invalid character with an underscore
+            return re.sub(r'[<>:"/\\|?*]', "_", email)
+
+        # From now, user will never be None when adding a token so in this case token_file.user is never None
+        email = email_to_safe_filename(self.account.email) if self.account is not None else "unknown"
+        if self.type == "authorized_user":
+            return f"{PERSONAL_TOKEN_FILE_PREFIX}{self.name}-{email}.json"
+        return f"{SERVICE_ACCOUNT_TOKEN_FILE_PREFIX}{self.name}-{email}.json"
+
     def is_expired(self) -> bool:
         return datetime.today().date() > self.expires
 

cli/topology/cmd.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import dataclasses
+import datetime
+from typing import Any
+
+import typer
+from rich.console import Console
+
+from cli.errors import ErrorPrinter
+from cli.settings import TokenNotFoundError, settings
+from cli.typer import typer_utils
+from cli.utils.rest_helper import RestHelper
+
+HELP = """
+RemotiveTopology commands
+"""
+console = Console()
+app = typer_utils.create_typer(help=HELP)
+
+
+@dataclasses.dataclass
+class Subscription:
+    type: str
+    display_name: str
+    feature: str
+    start_date: str  # TODO: add datetime
+    end_date: str  # TODO: add datetime
+
+
+def _print_current_subscription(subscription_info: dict[str, Any]) -> None:
+    subscription_type = subscription_info.get("subscriptionType")
+    end_date_str = subscription_info.get("endDate")
+    now = datetime.datetime.now()
+
+    def parse_date(date_str: str | None) -> datetime.datetime | None:
+        return datetime.datetime.fromisoformat(date_str) if date_str else None
+
+    expires = parse_date(end_date_str)
+
+    if subscription_type == "trial":
+        if expires and expires < now:
+            console.print(f"Your Topology trial expired {end_date_str}, please contact support@remotivelabs.com")
+        else:
+            console.print(f"You already have an active topology trial, it expires {end_date_str}")
+
+    elif subscription_type == "paid":
+        if expires and expires < now:
+            console.print(f"Topology subscription has ended, expired {end_date_str}")
+        else:
+            console.print(f"You already have an active topology subscription, it expires {end_date_str or 'Never'}")
+
+    else:
+        ErrorPrinter.print_generic_error("Unexpected exception, please contact support@remotivelabs.com")
+        raise typer.Exit(1)
+
+
+@app.command("start-trial")
+def start_trial(
+    organization: str = typer.Option(None, help="Organization to start trial for", envvar="REMOTIVE_CLOUD_ORGANIZATION"),
+) -> None:
+    """
+    Allows you ta start a 30 day trial subscription for running RemotiveTopology, you can read more at https://docs.remotivelabs.com/docs/remotive-topology.
+
+    """
+    RestHelper.use_progress("Checking access tokens...", transient=True)
+    try:
+        _ = settings.get_active_token_file()
+    except TokenNotFoundError:
+        if len(settings.list_personal_token_files()) == 0:
+            console.print(
+                "You must first sign in to RemotiveCloud, please use [bold]remotive cloud auth login[/bold] to sign-in"
+                "This requires a RemotiveCloud account, if you do not have an account you can sign-up at https://cloud.remotivelabs.com"
+            )
+        else:
+            console.print(
+                "You have not active account, please run [bold]remotive cloud auth activate[/bold] to choose an account"
+                "or [bold]remotive cloud auth login[/bold] to sign-in"
+            )
+        return
+
+    has_access = RestHelper.has_access("/api/whoami")
+    if not has_access:
+        ErrorPrinter.print_generic_message("Your current active credentials are not valid")
+        raise typer.Exit(1)
+
+    if organization is None and settings.get_cli_config().get_active_default_organisation() is None:
+        ErrorPrinter.print_hint("You have not specified any organization and no default organization is set")
+        raise typer.Exit(1)
+
+    sub = RestHelper.handle_get(f"/api/bu/{organization}/features/topology", return_response=True, allow_status_codes=[404, 403])
+    if sub.status_code == 404:
+        created = RestHelper.handle_post(f"/api/bu/{organization}/features/topology", return_response=True)
+        console.print(f"Topology trial started, it expires {created.json()['endDate']}")
+    elif sub.status_code == 403:
+        ErrorPrinter.print_generic_error(f"You are not allowed to start-trial topology in organization {organization}")
+        raise typer.Exit(1)
+    else:
+        subscription_info = sub.json()
+        _print_current_subscription(subscription_info)
+    return

{remotivelabs_cli-0.1.1.dist-info → remotivelabs_cli-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: remotivelabs-cli
-Version: 0.1.1
+Version: 0.2.0
 Summary: CLI for operating RemotiveCloud and RemotiveBroker
 Author: Johan Rask
 Author-email: johan.rask@remotivelabs.com

{remotivelabs_cli-0.1.1.dist-info → remotivelabs_cli-0.2.0.dist-info}/RECORD

@@ -14,15 +14,15 @@ cli/broker/scripting.py,sha256=LFLdaBNxe2sfpcxhDmRlAbEorjL3SJZNK-zEdLQ9ySU,3854
 cli/broker/signals.py,sha256=MFj_bOLIxHY1v3XPkKk6n8U3JLaY8nrXHahRQaVse6s,8207
 cli/cloud/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cli/cloud/auth/__init__.py,sha256=MtQ01-n8CgZb9Y_SvxwZUgj44Yo0dFAU3_XwhQiUYtw,54
-cli/cloud/auth/cmd.py,sha256=aOvbrzNb7moClgmde25T0coBs8Ge696xUB_w6qfvN8I,2920
-cli/cloud/auth/login.py,sha256=sAlUeBVypK4ibBR9gdU0DMUmwvxqOjvFNTLUHPseyCE,11476
-cli/cloud/auth_tokens.py,sha256=XHXrCwgK_akrCbFxcxtDr7GDM9cd-T_s40PrRovY4Lk,12344
+cli/cloud/auth/cmd.py,sha256=gLmfjIN9Vrytk9BwGH1cq4WeeryOfwTTnQ4yuZrbRcs,2757
+cli/cloud/auth/login.py,sha256=dX6M5ysE0n9Zg3gVT7hJbChxTsmuba-Z-1Or6DCFYis,11511
+cli/cloud/auth_tokens.py,sha256=K_HSBto2XfbD-Hxhb0SAFhxSDZdSXo961UcvdVWNkZI,12831
 cli/cloud/brokers.py,sha256=QTA9bmaK06LKEccF6IBgWBonC4VFrKwFQBsACX_IzYw,3896
 cli/cloud/cloud_cli.py,sha256=q-oiaLcKC-BRamXfIFGn-BskRmJ3utA7-tI39lSs3Cs,1309
 cli/cloud/configs.py,sha256=uv46nUoGXOr99smQHahv_ageDv6bGYfUnlRlxcS5D9A,5125
-cli/cloud/organisations.py,sha256=QBD2RnCbpZ9XQrTIcvD74o321JHNnKxDleKlYmSZEuI,4116
+cli/cloud/organisations.py,sha256=iEmGMEzOIvuWomoJZ0WBa3Rmrkrup5UH7wjPMoElSn4,4092
 cli/cloud/projects.py,sha256=ecn5Y8UKhgYnHSJQACUk1GNZt9EF8ug4B-6MCr8rZqM,1487
-cli/cloud/recordings.py,sha256=B0XOj8LIm3hBqBzVKPLPvPUCXCKZBTEISssrijK481w,24855
+cli/cloud/recordings.py,sha256=In2fKX668CPsEVBAy7zkU92lEnmu3UcnqiVrqsvLNDQ,24961
 cli/cloud/recordings_playback.py,sha256=XZoVyujufMQFN2v_Nwsf8tOqn61yLEpAf2z_u5uhXik,11532
 cli/cloud/resumable_upload.py,sha256=8lEIdncJZoTZzNsQVHH3gm_GunxEmN5JbmWX7awy3p4,3713
 cli/cloud/sample_recordings.py,sha256=RmuT-a2iMwGj3LXVcPkV5l66uFcf7nyWyJciUjnYkk4,721
@@ -36,24 +36,29 @@ cli/cloud/uri.py,sha256=QZCus--KJQlVwGCOzZqiglvj8VvSRKxfVvN33Pilgyg,3616
 cli/connect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cli/connect/connect.py,sha256=SH2DNTTVLu2dNpk6xIah1-KJZAqrK_7Skt8RKp8Mjh8,4231
 cli/connect/protopie/protopie.py,sha256=ElmrGaV0ivb85wo0gLzCAXZhmSmIDASaCVlF1iQblLI,6532
-cli/errors.py,sha256=_P-qpayY06qgLA7wvoDFsyMaTfo_zjNY--fgHPAuhrs,1658
-cli/remotive.py,sha256=PsxR3Hhp3zhj-A06sqvtSkmXwv9moWHT_ify8Vg5xQA,2756
-cli/settings/__init__.py,sha256=5ZRq04PHp3WU_5e7mGwWUoFYUPWfnnS16yF45wUv7mY,248
-cli/settings/config_file.py,sha256=6WHlJT74aQvqc5elcW1FDafcG0NttYvPawmArN5H2MQ,2869
-cli/settings/core.py,sha256=vRS_3JZDKRMGMa65C3LT178BCUcZ2RAlp2knn158CA4,15669
-cli/settings/migrate_all_token_files.py,sha256=7kvHbpP4BtILJ8kPtb_bFnTnBYX9isZ4rwB5lfnEkbA,2722
-cli/settings/migrate_token_file.py,sha256=Fp7Z_lNqSdoWY05TYwFW2QH8q9QhmB2TYSok6hV1Mic,1530
-cli/settings/token_file.py,sha256=KISVaSVV2pzfduCtJYUtCLtJa3htrpP4_qTODp5IhW8,2210
+cli/errors.py,sha256=djODw6sdMJXzOsuAUOP3N13nfmm1sIP3Pe6tllGdozM,1657
+cli/remotive.py,sha256=FkXJCq0mw_bak75u6aukleIld-jjgn4hjuBQ28Lcz1U,3831
+cli/settings/__init__.py,sha256=t1qkaGrJ4xx8WMHlmBTbQ1VdJL4YOcz8VFfRkGa2_jQ,711
+cli/settings/config_file.py,sha256=6sdHUtZSUIgubwpfwEEn7GarTK1M_iQhtRJZzFDdP5o,2784
+cli/settings/core.py,sha256=FqME9ghV6bBNDrZnQCm3jxz-7T8M04dSFumYK1-QOhs,10911
+cli/settings/migration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/settings/migration/migrate_all_token_files.py,sha256=xoVvAqn_tGskEW148uf3xZx1mpJKUnERMTcBo0nkCnI,3010
+cli/settings/migration/migrate_config_file.py,sha256=hw4EpRwJz1zUNxfCOk0PvMuZjAlaGy4m_rDbMsHZO_w,2047
+cli/settings/migration/migrate_legacy_dirs.py,sha256=N0t2io3bT_ub8BcVPw1CeQ4eeexRUiu3jXq3DL018OE,1819
+cli/settings/migration/migrate_token_file.py,sha256=Fp7Z_lNqSdoWY05TYwFW2QH8q9QhmB2TYSok6hV1Mic,1530
+cli/settings/migration/migration_tools.py,sha256=P72tuw6-aS_Kd0qn-0ZecplsYxMTu0LTXM5sMSNTVEM,1378
+cli/settings/token_file.py,sha256=llfP1GohXtLVIDy3UyNB8FneGRuCesnce9uasv-7XKM,2953
 cli/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cli/tools/can/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cli/tools/can/can.py,sha256=TtP5w8vb0QG4ObNhkWIDpRMdNelirFffoc_lFZy8ePM,2260
 cli/tools/tools.py,sha256=jhLfrFDqkmWV3eBAzNwBf6WgDGrz7sOhgVCia36Twn8,232
+cli/topology/cmd.py,sha256=SQ5wi7KDoh4iR2Ed7gyfGLNj6UE0K6UkksmBMSD2XAk,3981
 cli/typer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cli/typer/typer_utils.py,sha256=8SkvG9aKkfK9fTRsLD9pOBtWn9XSwtOXWg2RAk9FhOI,708
 cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cli/utils/rest_helper.py,sha256=b_FJY6MxnFSqo11qaHxkBFHfVlKf7Zj28Uxv9Oj7XY4,14141
-remotivelabs_cli-0.1.1.dist-info/LICENSE,sha256=qDPP_yfuv1fF-u7EfexN-cN3M8aFgGVndGhGLovLKz0,608
-remotivelabs_cli-0.1.1.dist-info/METADATA,sha256=S0EkVqlAXfJQT2chMamWtl5mMgkIhX80eX4LNEgblN8,1428
-remotivelabs_cli-0.1.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-remotivelabs_cli-0.1.1.dist-info/entry_points.txt,sha256=lvDhPgagLqW_KTnLPCwKSqfYlEp-1uYVosRiPjsVj10,45
-remotivelabs_cli-0.1.1.dist-info/RECORD,,
+remotivelabs_cli-0.2.0.dist-info/LICENSE,sha256=qDPP_yfuv1fF-u7EfexN-cN3M8aFgGVndGhGLovLKz0,608
+remotivelabs_cli-0.2.0.dist-info/METADATA,sha256=nyRzH6JasTH4wYLC7itZSo9yIYqvcmNUf3kajMN9aQ8,1428
+remotivelabs_cli-0.2.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+remotivelabs_cli-0.2.0.dist-info/entry_points.txt,sha256=lvDhPgagLqW_KTnLPCwKSqfYlEp-1uYVosRiPjsVj10,45
+remotivelabs_cli-0.2.0.dist-info/RECORD,,