remotivelabs-cli 0.0.34__tar.gz → 0.0.36__tar.gz

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: remotivelabs-cli
-Version: 0.0.34
+Version: 0.0.36
 Summary: CLI for operating RemotiveCloud and RemotiveBroker
 Author: Johan Rask
 Author-email: johan.rask@remotivelabs.com
-Requires-Python: >=3.8
+Requires-Python: >=3.8,<4
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/broker/lib/broker.py

@@ -21,8 +21,8 @@ import typer
 from google.protobuf.json_format import MessageToDict
 from rich.console import Console
 
-from cli import settings
 from cli.errors import ErrorPrinter
+from cli.settings import settings
 
 err_console = Console(stderr=True)
 
@@ -51,7 +51,7 @@ class Broker:
 
         if api_key is None or api_key == "":
             if url.startswith("https"):
-                self.intercept_channel = br.create_channel(url, None, settings.read_secret_token())
+                self.intercept_channel = br.create_channel(url, None, settings.get_active_token())
                 # TODO - Temporary solution to print proper error message, remove ENV once api-key is gone
                 os.environ["ACCESS_TOKEN"] = "true"
             else:

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/cloud/auth/cmd.py

@@ -1,8 +1,11 @@
+import sys
+
 import typer
 
-from cli import settings
 from cli.cloud.auth.login import login as do_login
 from cli.cloud.rest_helper import RestHelper as Rest
+from cli.errors import ErrorPrinter
+from cli.settings import TokenNotFoundError, settings
 
 from .. import auth_tokens
 
@@ -29,18 +32,37 @@ def whoami() -> None:
     """
     Validates authentication and fetches your user information
     """
-    Rest.handle_get("/api/whoami")
+    try:
+        Rest.handle_get("/api/whoami")
+    except TokenNotFoundError as e:
+        ErrorPrinter.print_hint(str(e))
+        sys.exit(1)
 
 
 @app.command()
 def print_access_token() -> None:
     """
-    Print current active access token
+    Print current active token
+    """
+    try:
+        print(settings.get_active_token())
+    except TokenNotFoundError as e:
+        ErrorPrinter.print_hint(str(e))
+        sys.exit(1)
+
+
+def print_access_token_file() -> None:
+    """
+    Print current active token and its metadata
     """
-    print(settings.read_secret_token())
+    try:
+        print(settings.get_active_token_file())
+    except TokenNotFoundError as e:
+        ErrorPrinter.print_hint(str(e))
+        sys.exit(1)
 
 
 @app.command(help="Clear access token")
 def logout() -> None:
-    settings.clear_secret_token()
+    settings.clear_active_token()
     print("Access token removed")

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/cloud/auth/login.py

@@ -1,3 +1,4 @@
+import datetime
 import time
 import webbrowser
 from http.server import BaseHTTPRequestHandler, HTTPServer
@@ -6,8 +7,9 @@ from typing import Any
 
 from typing_extensions import override
 
-from cli import settings
 from cli.cloud.rest_helper import RestHelper as Rest
+from cli.settings import settings
+from cli.settings import token_file as tf
 
 httpd: HTTPServer
 
@@ -35,7 +37,13 @@ class S(BaseHTTPRequestHandler):
         killerthread = Thread(target=httpd.shutdown)
         killerthread.start()
 
-        settings.write_secret_token(path[1:])
+        token = tf.TokenFile(
+            name="CLI_login_token",
+            token=path[1:],
+            created=str(datetime.datetime.now().isoformat()),
+            expires="unknown",
+        )
+        settings.add_and_activate_short_lived_cli_token(tf.dumps(token))
         print("Successfully logged on, you are ready to go with cli")
 
 

remotivelabs_cli-0.0.36/cli/cloud/auth_tokens.py

@@ -0,0 +1,32 @@
+import typer
+
+from cli.settings import settings
+
+from .rest_helper import RestHelper as Rest
+
+app = typer.Typer()
+
+
+# TODO: add add interactive flag to set target directory # pylint: disable=fixme
+@app.command(name="create", help="Create and download a new personal access token")
+def create(activate: bool = typer.Option(False, help="Activate the token for use after download")) -> None:  # pylint: disable=W0621
+    response = Rest.handle_post(url="/api/me/keys", return_response=True)
+    pat = settings.add_personal_token(response.text)
+    print(f"Personal access token added: {pat.name}")
+
+    if not activate:
+        print(f"Use 'remotive cloud auth tokens activate {pat.name}' to use this access token from cli")
+    else:
+        settings.activate_token(pat.name)
+        print("Token file activated and ready for use")
+    print("\033[93m This file contains secrets and must be kept safe")
+
+
+@app.command(name="list", help="List personal access tokens")
+def list_tokens() -> None:
+    Rest.handle_get("/api/me/keys")
+
+
+@app.command(name="revoke", help="Revoke personal access token")
+def revoke(name: str = typer.Argument(help="Access token name")) -> None:
+    Rest.handle_delete(f"/api/me/keys/{name}")

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/cloud/configs.py

@@ -59,6 +59,17 @@ def upload(
         )
 
 
+@app.command()
+def describe(
+    signal_db_file: str = typer.Argument("", help="Signal database file"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    """
+    Shows all metadata related to this signal database
+    """
+    Rest.handle_get(f"/api/project/{project}/files/config/{signal_db_file}")
+
+
 @app.command()
 def download(
     signal_db_file: str = typer.Argument("", help="Signal database file"),

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/cloud/recordings.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import glob
 import json
 import os
@@ -16,7 +14,9 @@ import grpc
 import requests
 import typer
 from rich.progress import Progress, SpinnerColumn, TaskID, TextColumn, track
+from typing_extensions import Annotated
 
+from cli.cloud.uri import URI
 from cli.errors import ErrorPrinter
 
 from ..broker.lib.broker import Broker
@@ -33,6 +33,10 @@ def uid(p: Any) -> Any:
     return p["uid"]
 
 
+# ruff: noqa: FA100
+# ruff: noqa: C901
+
+
 # to be used in options
 # autocompletion=project_names)
 def project_names() -> Any:
@@ -83,25 +87,19 @@ def describe(
 
 @app.command(name="import")
 def import_as_recording(
+    uri: Annotated[URI, typer.Argument(help="Remote storage path", parser=URI, show_default=False)],
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-    path: str = typer.Argument(default=..., help="Remote storage path to file to delete"),
 ) -> None:
     """
     Imports a file from Storage as a recording.
+
     NOTE that Storage is not yet available to all customers
     """
-
-    if path.startswith("rcs://"):
-        final_path = __check_rcs_path(path)
-    else:
-        ErrorPrinter.print_hint("Path must start with rcs://")
-        sys.exit(1)
-
     Rest.handle_post(
         url=f"/api/project/{project}/files/recording",
         return_response=True,
-        progress_label=f"Importing {final_path}...",
-        body=json.dumps({"path": final_path}),
+        progress_label=f"Importing {uri.path}...",
+        body=json.dumps({"path": uri.path}),
     )
 
     ErrorPrinter.print_hint(
@@ -109,15 +107,6 @@ def import_as_recording(
     )
 
 
-# Copied from filestorage
-def __check_rcs_path(path: str) -> str:
-    rcs_path = path.replace("rcs://", "/")
-    if rcs_path.startswith("/."):
-        ErrorPrinter.print_hint("Invalid path")
-        sys.exit(1)
-    return rcs_path
-
-
 def do_start(name: str, project: str, api_key: str, return_response: bool = False) -> requests.Response:
     body = {"size": "S"}
     if not api_key:
@@ -252,7 +241,7 @@ def upload(  # noqa: C901
         help="Path to recording file to upload",
     ),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-    recording_session: str = typer.Option(default=None, help="Optional existing recording to upload file to"),
+    recording_session: Optional[str] = typer.Option(default=None, help="Optional existing recording to upload file to"),
 ) -> None:
     # pylint: disable=R0912,R0914,R0915
     """
@@ -540,7 +529,9 @@ def stop(
 
 
 # pylint: disable-next=C0301
-def _do_change_playback_mode(mode: str, recording_session: str, broker_name: str, project: str, seconds: int | None = None) -> None:  # noqa: C901
+def _do_change_playback_mode(
+    mode: str, recording_session: str, broker_name: Optional[str], project: str, seconds: Optional[int] = None
+) -> None:  # noqa: C901
     # pylint: disable=R0912,R0914,R0915
     response = Rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
     if response is None:

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/cloud/rest_helper.py

@@ -15,7 +15,8 @@ from requests.exceptions import JSONDecodeError
 from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn, wrap_file
 
-from cli import settings
+from cli.errors import ErrorPrinter
+from cli.settings import TokenNotFoundError, settings
 
 err_console = Console(stderr=True)
 
@@ -81,14 +82,12 @@ class RestHelper:
         #    print('You must first set the organisation id to use: export REMOTIVE_CLOUD_ORGANISATION=organisationUid')
         #    raise typer.Exit()
         # org = os.environ["REMOTIVE_CLOUD_ORGANISATION"]
-
-        #    if not exists(str(Path.home()) + "/.config/.remotive/cloud.secret.token"):
-        #        print("Access token not found, please login first")
-        #        raise typer.Exit()
-
-        #    f = open(str(Path.home()) + "/.config/.remotive/cloud.secret.token", "r")
-        token = settings.read_secret_token()
-        #    os.environ['REMOTIVE_CLOUD_AUTH_TOKEN'] = token
+        # os.environ['REMOTIVE_CLOUD_AUTH_TOKEN'] = token
+        try:
+            token = settings.get_active_token()
+        except TokenNotFoundError:
+            ErrorPrinter.print_hint("you are not logged in, please login using [green]remotive cloud auth login[/green]")
+            sys.exit(1)
 
         RestHelper.__headers["Authorization"] = "Bearer " + token.strip()
         RestHelper.__headers["User-Agent"] = f"remotivelabs-cli {RestHelper.get_cli_version()}"

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/cloud/service_account_tokens.py

@@ -1,16 +1,16 @@
 import json
-from pathlib import Path
 
 import typer
 
-from cli import settings
+from cli.settings import settings
 
 from .rest_helper import RestHelper as Rest
 
 app = typer.Typer()
 
 
-@app.command(name="create", help="Create new access token")
+# TODO: add add interactive flag to set target directory # pylint: disable=fixme
+@app.command(name="create", help="Create and download a new service account access token")
 def create(
     expire_in_days: int = typer.Option(default=365, help="Number of this token is valid"),
     service_account: str = typer.Option(..., help="Service account name"),
@@ -22,35 +22,19 @@ def create(
         body=json.dumps({"daysUntilExpiry": expire_in_days}),
     )
 
-    if response is None:
-        return
+    sat = settings.add_service_account_token(service_account, response.text)
+    print(f"Service account access token added: {sat.name}")
+    print("\033[93m This file contains secrets and must be kept safe")
 
-    if response.status_code == 200:
-        name = response.json()["name"]
-        write_sa_token(service_account, name, response.text)
-    else:
-        print(f"Got status code: {response.status_code}")
-        print(response.text)
 
-
-@app.command(name="list", help="List service-account access tokens")
-def list_keys(
+@app.command(name="list", help="List service account access tokens")
+def list_tokens(
     service_account: str = typer.Option(..., help="Service account name"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
 ) -> None:
     Rest.handle_get(f"/api/project/{project}/admin/accounts/{service_account}/keys")
 
 
-@app.command(name="list-files")
-def list_files() -> None:
-    """
-    List personal access token files in remotivelabs config directory
-    """
-    sa_files = settings.list_service_account_token_files()
-    for file in sa_files:
-        print(file)
-
-
 @app.command(name="revoke", help="Revoke service account access token")
 def revoke(
     name: str = typer.Argument(..., help="Access token name"),
@@ -58,10 +42,3 @@ def revoke(
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
 ) -> None:
     Rest.handle_delete(f"/api/project/{project}/admin/accounts/{service_account}/keys/{name}")
-
-
-# TODO: Move to settings # pylint: disable=W0511
-def write_sa_token(service_account: str, name: str, token: str) -> Path:
-    file = f"service-account-{service_account}-{name}-token.json"
-    path = settings.CONFIG_DIR_PATH / file
-    return settings._write_settings_file(path, token)  # pylint: disable=W0212

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/cloud/storage/__init__.py

@@ -1,5 +1,5 @@
 from cli.cloud.storage.cmd import app
-from cli.cloud.storage.uri import URI
 from cli.cloud.storage.uri_or_path import UriOrPath
+from cli.cloud.uri import URI
 
 __all__ = ["URI", "UriOrPath", "app"]

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/cloud/storage/cmd.py

@@ -5,9 +5,9 @@ from typing_extensions import Annotated
 
 from cli.cloud.rest_helper import RestHelper as Rest
 from cli.cloud.storage.copy import copy
-from cli.cloud.storage.uri import URI, InvalidURIError, JoinURIError
 from cli.cloud.storage.uri_or_path import UriOrPath
 from cli.cloud.storage.uri_or_path import uri as uri_parser
+from cli.cloud.uri import URI, InvalidURIError, JoinURIError
 from cli.errors import ErrorPrinter
 
 HELP = """

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/cloud/storage/copy.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 from cli.cloud.rest_helper import RestHelper as Rest
 from cli.cloud.resumable_upload import upload_signed_url
-from cli.cloud.storage.uri import URI
+from cli.cloud.uri import URI
 
 _RCS_STORAGE_PATH = "/api/project/{project}/files/storage{path}"
 
@@ -29,7 +29,7 @@ def copy(project: str, source: URI | Path, dest: URI | Path, overwrite: bool = F
 
 def _upload(source: Path, dest: URI, project: str, overwrite: bool = False) -> None:
     if not source.exists():
-        raise FileNotFoundError(source)
+        raise FileNotFoundError(f"Source file does not exist: {source}")
 
     files_to_upload = _list_files_for_upload(source, dest)
 

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/cloud/storage/uri_or_path.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from pathlib import Path
 
-from cli.cloud.storage.uri import URI, InvalidURIError
+from cli.cloud.uri import URI, InvalidURIError
 
 
 def uri(path: str) -> UriOrPath:

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/connect/protopie/protopie.py

@@ -16,9 +16,9 @@ from rich import print as pretty_print
 from rich.console import Console
 from socketio.exceptions import ConnectionError as SocketIoConnectionError  # type: ignore
 
-from cli import settings
 from cli.broker.lib.broker import SubscribableSignal
 from cli.errors import ErrorPrinter
+from cli.settings import settings
 
 global PP_CONNECT_APP_NAME
 PP_CONNECT_APP_NAME = "RemotiveBridge"
@@ -167,7 +167,7 @@ def do_connect(
     if broker_url.startswith("https"):
         if api_key is None:
             print("No --api-key, reading token from file")
-            x_api_key = settings.read_secret_token()
+            x_api_key = settings.get_active_token_secret()
         else:
             x_api_key = api_key
     elif api_key is not None:

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/cli/remotive.py

@@ -9,6 +9,7 @@ from typer.main import get_group
 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.cmd import app as settings_app
 from .tools.tools import app as tools_app
 
 if os.getenv("GRPC_VERBOSITY") is None:
@@ -63,5 +64,6 @@ app.add_typer(
     name="cloud",
     help="Manage resources in RemotiveCloud",
 )
+app.add_typer(settings_app, name="config", help="Manage access tokens")
 app.add_typer(connect_app, name="connect", help="Integrations with other systems")
 app.add_typer(tools_app, name="tools")

remotivelabs_cli-0.0.36/cli/settings/__init__.py

@@ -0,0 +1,5 @@
+from cli.settings.cmd import app
+from cli.settings.core import InvalidSettingsFilePathError, Settings, TokenNotFoundError, settings
+from cli.settings.token_file import TokenFile
+
+__all__ = ["app", "settings", "TokenFile", "TokenNotFoundError", "InvalidSettingsFilePathError", "Settings"]

remotivelabs_cli-0.0.36/cli/settings/cmd.py

@@ -0,0 +1,71 @@
+import typer
+
+from cli.errors import ErrorPrinter
+from cli.settings.core import TokenNotFoundError, settings
+
+app = typer.Typer()
+
+
+@app.command()
+def describe(file: str = typer.Argument(help="Token name or file path")) -> None:
+    """
+    Show contents of specified access token file
+    """
+    try:
+        print(settings.get_token_file(file))
+    except TokenNotFoundError:
+        ErrorPrinter.print_generic_error(f"Token file {file} not found")
+
+
+@app.command()
+def activate(file: str = typer.Argument(..., help="Token name or file path")) -> None:
+    """
+    Activate a access token file to be used for authentication.
+
+    This will be used as the current access token in all subsequent requests. This would
+    be the same as login with a browser.
+    """
+    try:
+        settings.activate_token(file)
+    except FileNotFoundError as e:
+        print(f"File could not be found: {e}")
+
+
+@app.command(name="list-personal-tokens")
+def list_pats() -> None:
+    """
+    List personal access token files in remotivelabs config directory
+    """
+    pats = settings.list_personal_tokens()
+    for pat in pats:
+        print(pat.name)
+
+
+@app.command(name="list-personal-tokens-files")
+def list_pats_files() -> None:
+    """
+    List personal access token files in remotivelabs config directory
+    """
+    personal_files = settings.list_personal_token_files()
+    for file in personal_files:
+        print(file)
+
+
+@app.command(name="list-service-account-tokens")
+def list_sats() -> None:
+    """
+    List service account access token files in remotivelabs config directory
+    """
+    sats = settings.list_service_account_tokens()
+    for sat in sats:
+        print(sat.name)
+
+
+@app.command(name="list-service-account-tokens-files")
+def list_sats_files() -> None:
+    """
+    List service account access token files in remotivelabs config directory
+    """
+    service_account_files = settings.list_service_account_token_files()
+    for file in service_account_files:
+        print(file)

remotivelabs_cli-0.0.36/cli/settings/core.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+import datetime
+import shutil
+import sys
+from json import JSONDecodeError
+from pathlib import Path
+from typing import Tuple
+
+from rich.console import Console
+
+from cli.settings import token_file as tf
+from cli.settings.token_file import TokenFile
+
+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"
+
+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]
+
+
+class InvalidSettingsFilePathError(Exception):
+    """Raised when trying to access an invalid settings file or file path"""
+
+
+class TokenNotFoundError(Exception):
+    """Raised when a token cannot be found in settings"""
+
+
+class Settings:
+    """
+    Settings for the remotive CLI
+    """
+
+    config_dir: Path
+
+    def __init__(self, config_dir: Path, deprecated_config_dirs: list[Path] | None = None) -> None:
+        self.config_dir = config_dir
+        self._active_secret_token_path = self.config_dir / ACTIVE_TOKEN_FILE_NAME
+
+        # no migration of deprecated config dirs if the new config dir already exists
+        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 get_active_token(self) -> str:
+        """
+        Get the current active token secret
+        """
+        token_file = self.get_active_token_file()
+        return token_file.token
+
+    def get_active_token_file(self) -> TokenFile:
+        """
+        Get the current active token file
+        """
+        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, name: str) -> 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)
+        self._write_token_file(self._active_secret_token_path, token_file)
+
+    def clear_active_token(self) -> None:
+        """
+        Clear the current active token
+        """
+        self._active_secret_token_path.unlink(missing_ok=True)
+
+    def get_token_file(self, name: str) -> TokenFile:
+        """
+        Get a token file by name or path
+        """
+        if Path(name).exists():
+            return self._read_token_file(Path(name))
+
+        return self._get_token_by_name(name)[0]
+
+    def remove_token_file(self, name: str) -> None:
+        """
+        Remove a token file by name or path
+
+        TODO: what about manually downloaded tokens?
+        """
+        if Path(name).exists():
+            if self.config_dir not in Path(name).parents:
+                raise InvalidSettingsFilePathError(f"cannot remove a token file not located in settings dir {self.config_dir}")
+            return Path(name).unlink()
+
+        # TODO: what about the active token? # pylint: disable=fixme
+
+        path = self._get_token_by_name(name)[1]
+        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:
+        """
+        Add a personal token
+        """
+        token_file = tf.loads(token)
+
+        file = f"{PERSONAL_TOKEN_FILE_PREFIX}{token_file.name}.json"
+        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)
+
+        if activate:
+            self.activate_token(token_file.name)
+
+        return token_file
+
+    def list_personal_tokens(self) -> list[TokenFile]:
+        """
+        List all personal tokens
+        """
+        return [f[0] for f in self._list_personal_tokens()]
+
+    def list_personal_token_files(self) -> list[Path]:
+        """
+        List paths to all personal token files
+        """
+        return [f[1] for f in self._list_personal_tokens()]
+
+    def add_service_account_token(self, service_account: str, token: str) -> TokenFile:
+        """
+        Add a service account token to the config directory
+        """
+        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
+        """
+        return [f[0] for f in self._list_service_account_tokens()]
+
+    def list_service_account_token_files(self) -> list[Path]:
+        """
+        List paths to all service account token files
+        """
+        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)
+
+    def _list_service_account_tokens(self) -> list[TokenFileMetadata]:
+        return self._list_token_files(prefix=SERVICE_ACCOUNT_TOKEN_FILE_PREFIX)
+
+    def _get_token_by_name(self, name: str) -> TokenFileMetadata:
+        token_files = self._list_token_files()
+        matches = [token_file for token_file in token_files if token_file[0].name == name]
+        if len(matches) != 1:
+            raise TokenNotFoundError(f"Ambiguous token file name {name}, found {len(matches)} files")
+        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 the special active token file
+        def is_path_prefixed_and_not_active_secret(path: Path) -> bool:
+            has_correct_prefix = path.is_file() and path.name.startswith(prefix)
+            is_active_secret = path == self._active_secret_token_path
+            return has_correct_prefix and not is_active_secret
+
+        paths = [path for path in self.config_dir.iterdir() if is_path_prefixed_and_not_active_secret(path)]
+
+        return [(self._read_token_file(token_file), token_file) for token_file in paths]
+
+    def _read_token_file(self, path: Path) -> TokenFile:
+        data = self._read_file(path)
+        return tf.loads(data)
+
+    def _read_file(self, path: Path) -> str:
+        if not path.exists():
+            raise TokenNotFoundError(f"File could not be found: {path}")
+        return path.read_text(encoding="utf-8")
+
+    def _write_token_file(self, path: Path, token: TokenFile) -> Path:
+        data = tf.dumps(token)
+        return self._write_file(path, data)
+
+    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")
+        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():
+            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(
+                    name="MigratedActiveToken",
+                    token=value,
+                    created=str(datetime.datetime.now().isoformat()),
+                    expires="unknown",
+                )
+            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()
+"""
+Global/module-level settings instance. Module-level variables are only loaded once, at import time.
+
+TODO: Migrate away from singleton instance
+"""

remotivelabs_cli-0.0.36/cli/settings/token_file.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import dataclasses
+import json
+from dataclasses import dataclass
+
+
+def loads(data: str) -> TokenFile:
+    d = json.loads(data)
+    return TokenFile(name=d["name"], token=d["token"], created=d["created"], expires=d["expires"])
+
+
+def dumps(token: TokenFile) -> str:
+    return json.dumps(dataclasses.asdict(token), default=str)
+
+
+@dataclass
+class TokenFile:
+    name: str
+    token: str
+    created: str
+    expires: str

{remotivelabs_cli-0.0.34 → remotivelabs_cli-0.0.36}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "remotivelabs-cli"
-version = "0.0.34"
+version = "0.0.36"
 description = "CLI for operating RemotiveCloud and RemotiveBroker"
 authors = ["Johan Rask <johan.rask@remotivelabs.com>"]
 readme = "README.md"
@@ -11,7 +11,7 @@ packages = [{ include = "cli" }]
 remotive = "cli.remotive:app"
 
 [tool.poetry.dependencies]
-python = ">=3.8"
+python = ">=3.8,<4"
 trogon = ">=0.5.0"
 typer = "0.12.5"
 remotivelabs-broker = "~=0.1.17"

remotivelabs_cli-0.0.34/cli/cloud/auth_tokens.py

@@ -1,143 +0,0 @@
-import json
-import sys
-from json.decoder import JSONDecodeError
-from pathlib import Path
-
-import typer
-
-from cli import settings
-
-from .rest_helper import RestHelper as Rest
-
-app = typer.Typer()
-
-
-@app.command(name="create", help="Create and download a new personal access token")
-def get_personal_access_token(activate: bool = typer.Option(False, help="Activate the token for use after download")) -> None:  # pylint: disable=W0621
-    Rest.ensure_auth_token()
-    response = Rest.handle_post(url="/api/me/keys", return_response=True)
-
-    if response is None:
-        return
-
-    if response.status_code == 200:
-        name = response.json()["name"]
-        pat_path = write_personal_token(name, response.text)
-        print(f"Personal access token written to {pat_path}")
-        if not activate:
-            print(f"Use 'remotive cloud auth tokens activate {pat_path.name}' to use this access token from cli")
-        else:
-            do_activate(str(pat_path))
-            print("Token file activated and ready for use")
-        print("\033[93m This file contains secrets and must be kept safe")
-    else:
-        print(f"Got status code: {response.status_code}")
-        print(response.text)
-
-
-@app.command(name="list", help="List personal access tokens")
-def list_personal_access_tokens() -> None:
-    Rest.ensure_auth_token()
-    Rest.handle_get("/api/me/keys")
-
-
-@app.command(name="revoke")
-def revoke(name_or_file: str = typer.Argument(help="Name or file path of the access token to revoke")) -> None:
-    """
-    Revoke an access token by token name or path to a file containing that token
-
-    Name is found in the json file
-    ```
-    {
-        "expires": "2034-07-31",
-        "token": "xxx",
-        "created": "2024-07-31T09:18:50.406+02:00",
-        "name": "token_name"
-    }
-    ```
-    """
-    name = name_or_file
-    if "." in name_or_file:
-        json_str = read_file(name_or_file)
-        try:
-            name = json.loads(json_str)["name"]
-        except JSONDecodeError:
-            sys.stderr.write("Failed to parse json, make sure its a correct access token file\n")
-            sys.exit(1)
-        except KeyError:
-            sys.stderr.write("Json does not contain a name property, make sure its a correct access token file\n")
-            sys.exit(1)
-    Rest.ensure_auth_token()
-    Rest.handle_delete(f"/api/me/keys/{name}")
-
-
-@app.command()
-def describe(file: str = typer.Argument(help="File name")) -> None:
-    """
-    Show contents of specified access token file
-    """
-    print(read_file(file))
-
-
-@app.command()
-def activate(file: str = typer.Argument(..., help="File name")) -> None:
-    """
-    Activate a access token file to be used for authentication.
-
-    --file
-
-    This will be used as the current access token in all subsequent requests. This would
-    be the same as login with a browser.
-    """
-    do_activate(file)
-
-
-# TODO: Move parts of this to settings # pylint: disable=W0511
-def do_activate(file: str) -> None:
-    # Best effort to read file
-    if Path(file).exists():
-        token_file = json.loads(read_file_with_path(Path(file)))
-        settings.write_secret_token(token_file["token"])
-    elif (settings.CONFIG_DIR_PATH / file).exists():
-        token_file = json.loads(read_file(file))
-        settings.write_secret_token(token_file["token"])
-    else:
-        sys.stderr.write("File could not be found \n")
-
-
-@app.command(name="list-files")
-def list_files() -> None:
-    """
-    List personal access token files in remotivelabs config directory
-    """
-    personal_files = settings.list_personal_token_files()
-    for file in personal_files:
-        print(file)
-
-
-# TODO: Move to settings # pylint: disable=W0511
-def read_file(file: str) -> str:
-    """
-    Reads a file using file path or if that does not exist check in config directory
-    """
-    path = Path(file)
-    if not path.exists():
-        path = settings.CONFIG_DIR_PATH / file
-        if not path.exists():
-            sys.stderr.write(f"Failed to find file using {file} or {path}\n")
-            sys.exit(1)
-
-    return read_file_with_path(path)
-
-
-# TODO: Move to settings # pylint: disable=W0511
-def read_file_with_path(path: Path) -> str:
-    with open(path, "r", encoding="utf8") as f:
-        return f.read()
-
-
-# TODO: Move to settings # pylint: disable=W0511
-def write_personal_token(name: str, token: str) -> Path:
-    file = f"personal-token-{name}.json"
-    path = settings.CONFIG_DIR_PATH / file
-    return settings._write_settings_file(path, token)  # pylint: disable=W0212

remotivelabs_cli-0.0.34/cli/settings.py

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-from rich.console import Console
-
-err_console = Console(stderr=True)
-
-# pylint: disable-next=W0511
-# TODO: We probably want this to be both configurable, and testable. The best solution would probably be to refactor this module into a
-# proper class, and configure it similar to logging.
-CONFIG_DIR_PATH = Path.home() / ".config" / ".remotive/"
-TOKEN_SECRET_FILE_PATH = CONFIG_DIR_PATH / "cloud.secret.token"
-
-
-class InvalidSettingsFileError(Exception):
-    """Raised when trying to access an invalid settings file or file path"""
-
-
-def read_secret_token() -> str:
-    if not TOKEN_SECRET_FILE_PATH.exists():
-        err_console.print(":boom: [bold red]Access failed[/bold red] - No access token found")
-        err_console.print("Login with [italic]remotive cloud auth login[/italic]")
-        err_console.print(
-            "If you have downloaded a personal access token, you can activate "
-            "it with [italic]remotive cloud auth tokens activate [FILE_NAME][/italic]"
-        )
-        sys.exit(1)
-
-    return _read_file(TOKEN_SECRET_FILE_PATH)
-
-
-def list_personal_token_files() -> list[Path]:
-    return [f for f in CONFIG_DIR_PATH.iterdir() if f.is_file() and f.name.startswith("personal-")]
-
-
-def list_service_account_token_files() -> list[Path]:
-    return [f for f in CONFIG_DIR_PATH.iterdir() if f.is_file() and f.name.startswith("service-account-")]
-
-
-def write_secret_token(secret: str) -> Path:
-    return _write_settings_file(TOKEN_SECRET_FILE_PATH, secret)
-
-
-def clear_secret_token() -> None:
-    TOKEN_SECRET_FILE_PATH.unlink()
-
-
-def _read_file(path: Path) -> str:
-    with open(path, "r", encoding="utf-8") as f:
-        return f.read()
-
-
-def _write_settings_file(path: Path, data: str) -> Path:
-    if CONFIG_DIR_PATH not in path.parents:
-        raise InvalidSettingsFileError(f"file {path} not in settings dir {CONFIG_DIR_PATH}")
-
-    path.parent.mkdir(parents=True, exist_ok=True)
-
-    with open(path, "w", encoding="utf8") as f:
-        f.write(data)
-
-    return path