remotivelabs-cli 0.0.24__py3-none-any.whl → 0.0.26__py3-none-any.whl

cli/cloud/rest_helper.py

@@ -5,11 +5,13 @@ import json
 import logging
 import os
 import shutil
+import sys
 from importlib.metadata import version
 from pathlib import Path
-from typing import Dict, List, Union
+from typing import Any, Dict, List, Union
 
 import requests
+from requests.exceptions import JSONDecodeError
 from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn, wrap_file
 
@@ -23,204 +25,260 @@ if "REMOTIVE_CLOUD_HTTP_LOGGING" in os.environ:
     requests_log = logging.getLogger("requests.packages.urllib3")
     requests_log.setLevel(logging.DEBUG)
     requests_log.propagate = True
-global baseurl
-global license_server_base_url
-base_url = "https://cloud.remotivelabs.com"
-license_server_base_url = "https://license.cloud.remotivelabs.com"
-
-if "REMOTIVE_CLOUD_BASE_URL" in os.environ:
-    base_url = os.environ["REMOTIVE_CLOUD_BASE_URL"]
-
-if "cloud-dev" in base_url:
-    license_server_base_url = "https://license.cloud-dev.remotivelabs.com"
-
-# if 'REMOTIVE_CLOUD_AUTH_TOKEN' not in os.environ:
-#    print('export REMOTIVE_CLOUD_AUTH_TOKEN=auth must be set')
-#    exit(0)
-
-# token = os.environ["REMOTIVE_CLOUD_AUTH_TOKEN"]
-# headers = {"Authorization": "Bearer " + token}
-
-headers = {}
-org = ""
-
-token = ""
-
-cli_version = version("remotivelabs-cli")
-
-
-def ensure_auth_token():
-    global token
-
-    # if 'REMOTIVE_CLOUD_ORGANISATION' not in os.environ:
-    #    print('You must first set the organisation id to use: export REMOTIVE_CLOUD_ORGANISATION=organisationUid')
-    #    raise typer.Exit()
-    global org
-    # 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_token()
-    #    os.environ['REMOTIVE_CLOUD_AUTH_TOKEN'] = token
-    global headers
-
-    headers["Authorization"] = "Bearer " + token.strip()
-    headers["User-Agent"] = f"remotivelabs-cli {cli_version}"
-
-
-def handle_get(
-    url,
-    params=None,
-    return_response: bool = False,
-    allow_status_codes=None,
-    progress_label="Fetching...",
-    use_progress_indicator: bool = True,
-    timeout: int = 20,
-):
-    if params is None:
-        params = {}
-    ensure_auth_token()
-    if use_progress_indicator:
-        with use_progress(progress_label):
-            r = requests.get(f"{base_url}{url}", headers=headers, params=params, timeout=timeout)
-    else:
-        r = requests.get(f"{base_url}{url}", headers=headers, params=params, timeout=timeout)
-
-    if return_response:
-        check_api_result(r, allow_status_codes)
-        return r
-    print_api_result(r)
-
-
-def has_access(url, params={}):
-    ensure_auth_token()
-    r = requests.get(f"{base_url}{url}", headers=headers, params=params)
-    if r.status_code == 401:
-        return False
-    return True
-
-
-def check_api_result(response, allow_status_codes: List[int] = None):
-    if response.status_code > 299:
-        if allow_status_codes is not None and response.status_code in allow_status_codes:
-            return
-        err_console.print(f":boom: [bold red]Got status code[/bold red]: {response.status_code}")
-        if response.status_code == 401:
-            err_console.print("Your token has expired, please login again")
-        else:
-            err_console.print(response.text)
-        exit(1)
-
-
-def print_api_result(response):
-    if response.status_code >= 200 and response.status_code < 300:
-        if len(response.content) > 4:
-            print(json.dumps(response.json()))
-        exit(0)
-    else:
-        err_console.print(f":boom: [bold red]Got status code[/bold red]: {response.status_code}")
-        if response.status_code == 401:
-            err_console.print("Your token has expired, please login again")
-        else:
-            err_console.print(response.text)
-        exit(1)
-    # typer.Exit(1) did not work as expected
-
-
-def handle_delete(url, params={}, quiet=False, success_msg="Successfully deleted", progress_label="Deleting..."):
-    ensure_auth_token()
-    with use_progress(progress_label):
-        r = requests.delete(f"{base_url}{url}", headers=headers, params=params)
-    if r.status_code == 200 or r.status_code == 204:
-        if not quiet:
-            print_api_result(r)
-    else:
-        print_api_result(r)
-
-
-def handle_post(url, body=None, params={}, progress_label: str = "Processing...", return_response: bool = False):
-    ensure_auth_token()
-    headers["content-type"] = "application/json"
-
-    with use_progress(progress_label):
-        r = requests.post(f"{base_url}{url}", headers=headers, params=params, data=body)
-
-    if return_response:
-        check_api_result(r)
-        return r
 
-    print_api_result(r)
 
+class RestHelper:
+    """Static Class with various helper functions for the rest API"""
+
+    __base_url = "https://cloud.remotivelabs.com"
+    __license_server_base_url = "https://license.cloud.remotivelabs.com"
+
+    if "REMOTIVE_CLOUD_BASE_URL" in os.environ:
+        __base_url = os.environ["REMOTIVE_CLOUD_BASE_URL"]
+
+    if "cloud-dev" in __base_url:
+        __license_server_base_url = "https://license.cloud-dev.remotivelabs.com"
+
+    # if 'REMOTIVE_CLOUD_AUTH_TOKEN' not in os.environ:
+    #    print('export REMOTIVE_CLOUD_AUTH_TOKEN=auth must be set')
+    #    exit(0)
+
+    # token = os.environ["REMOTIVE_CLOUD_AUTH_TOKEN"]
+    # headers = {"Authorization": "Bearer " + token}
+
+    __headers: Dict[str, str] = {}
+    __org: str = ""
+
+    __token: str = ""
+
+    @staticmethod
+    def get_cli_version() -> str:
+        return version("remotivelabs-cli")
+
+    @staticmethod
+    def get_base_url() -> str:
+        return RestHelper.__base_url
+
+    @staticmethod
+    def get_license_server_base_url() -> str:
+        return RestHelper.__license_server_base_url
+
+    @staticmethod
+    def get_headers() -> Dict[str, str]:
+        return RestHelper.__headers
+
+    @staticmethod
+    def get_org() -> str:
+        return RestHelper.__org
+
+    @staticmethod
+    def get_token() -> str:
+        return RestHelper.__token
+
+    @staticmethod
+    def ensure_auth_token() -> None:
+        # if 'REMOTIVE_CLOUD_ORGANISATION' not in os.environ:
+        #    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_token()
+        #    os.environ['REMOTIVE_CLOUD_AUTH_TOKEN'] = token
+
+        RestHelper.__headers["Authorization"] = "Bearer " + token.strip()
+        RestHelper.__headers["User-Agent"] = f"remotivelabs-cli {RestHelper.get_cli_version()}"
+
+    @staticmethod
+    def handle_get(
+        url: str,
+        params: Any = None,
+        return_response: bool = False,
+        allow_status_codes: List[int] | None = None,
+        progress_label: str = "Fetching...",
+        use_progress_indicator: bool = True,
+        timeout: int = 20,
+    ) -> requests.Response | None:
+        # pylint: disable=R0913
+        # Returns a Response object if succesfull otherwise None
+        if params is None:
+            params = {}
+        RestHelper.ensure_auth_token()
+        if use_progress_indicator:
+            with RestHelper.use_progress(progress_label):
+                r = requests.get(f"{RestHelper.__base_url}{url}", headers=RestHelper.__headers, params=params, timeout=timeout)
+        else:
+            r = requests.get(f"{RestHelper.__base_url}{url}", headers=RestHelper.__headers, params=params, timeout=timeout)
 
-def handle_put(url, body=None, params={}, return_response: bool = False):
-    ensure_auth_token()
-    headers["content-type"] = "application/json"
-    r = requests.put(f"{base_url}{url}", headers=headers, params=params, data=body)
+        if return_response:
+            RestHelper.check_api_result(r, allow_status_codes)
+            return r
+        RestHelper.print_api_result(r)
+        return requests.Response()
+
+    @staticmethod
+    def has_access(url: str, params: Any = {}) -> bool:  # pylint: disable=W0102
+        RestHelper.ensure_auth_token()
+        r = requests.get(f"{RestHelper.__base_url}{url}", headers=RestHelper.__headers, params=params, timeout=60)
+        if r.status_code == 401:
+            return False
+        return True
+
+    @staticmethod
+    def check_api_result(response: requests.Response, allow_status_codes: List[int] | None = None) -> None:
+        if response.status_code > 299:
+            if allow_status_codes is not None and response.status_code in allow_status_codes:
+                return
+            err_console.print(f":boom: [bold red]Got status code[/bold red]: {response.status_code}")
+            if response.status_code == 401:
+                err_console.print("Your token has expired, please login again")
+            else:
+                err_console.print(response.text)
+            sys.exit(1)
+
+    @staticmethod
+    def print_api_result(response: requests.Response) -> None:
+        if response.status_code >= 200 and response.status_code < 300:
+            if len(response.content) >= 2:
+                try:
+                    print(json.dumps(response.json()))
+                except JSONDecodeError:
+                    err_console.print(":boom: [bold red]Json parse error[/bold red]: Please try again and report if the error persists")
+            sys.exit(0)
+        else:
+            err_console.print(f":boom: [bold red]Got status code[/bold red]: {response.status_code}")
+            if response.status_code == 401:
+                err_console.print("Your token has expired, please login again")
+            else:
+                err_console.print(response.text)
+            sys.exit(1)
+        # typer.Exit(1) did not work as expected
+
+    @staticmethod
+    def handle_delete(  # pylint: disable=W0102
+        url: str, params: Any = {}, quiet: bool = False, progress_label: str = "Deleting..."
+    ) -> None:
+        RestHelper.ensure_auth_token()
+        with RestHelper.use_progress(progress_label):
+            r = requests.delete(f"{RestHelper.__base_url}{url}", headers=RestHelper.__headers, params=params, timeout=60)
+        if r.status_code in (200, 204):
+            if not quiet:
+                RestHelper.print_api_result(r)
+        else:
+            RestHelper.print_api_result(r)
 
-    if return_response:
-        check_api_result(r)
-        return r
-    print_api_result(r)
+    @staticmethod
+    def handle_post(  # pylint: disable=W0102
+        url: str, body: Any = None, params: Any = {}, progress_label: str = "Processing...", return_response: bool = False
+    ) -> requests.Response | None:
+        # Returns a Response object if succesfull otherwise, None
+        RestHelper.ensure_auth_token()
+        RestHelper.__headers["content-type"] = "application/json"
 
+        with RestHelper.use_progress(progress_label):
+            r = requests.post(f"{RestHelper.__base_url}{url}", headers=RestHelper.__headers, params=params, data=body, timeout=60)
 
-def upload_file(
-    path: Union[str, Path], url: str, upload_headers: dict[str, str] = None, return_response: bool = False, progress_label="Uploading..."
-):
-    ensure_auth_token()
-    if upload_headers is not None:
-        headers.update(upload_headers)
-    with open(path, "rb") as file:
-        with wrap_file(file, os.stat(path).st_size, description=progress_label) as f:
-            r = requests.post(f"{base_url}{url}", files={os.path.basename(path): f}, headers=headers)
         if return_response:
-            check_api_result(r)
+            RestHelper.check_api_result(r)
             return r
-        print_api_result(r)
 
+        RestHelper.print_api_result(r)
+        return None
+
+    @staticmethod
+    def handle_put(url: str, body: Any = None, params: Any = {}, return_response: bool = False) -> requests.Response | None:  # pylint: disable=W0102
+        # Returns a Response object if succesfull otherwise, None
+        RestHelper.ensure_auth_token()
+        RestHelper.__headers["content-type"] = "application/json"
+        r = requests.put(f"{RestHelper.__base_url}{url}", headers=RestHelper.__headers, params=params, data=body, timeout=60)
 
-def upload_file_with_signed_url(
-    path: Union[str, Path], url: str, upload_headers: dict[str, str], return_response: bool = False, progress_label="Uploading..."
-):
-    with open(path, "rb") as file:
-        with wrap_file(file, os.stat(path).st_size, description=progress_label, transient=True) as f:
-            r = requests.put(url, data=f, headers=upload_headers)
         if return_response:
-            check_api_result(r)
+            RestHelper.check_api_result(r)
             return r
-        print_api_result(r)
-
-
-def use_progress(label: str):
-    p = Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=True)
-    p.add_task(label, total=1)
-    return p
-
-
-def download_file(save_file_name: str, url: str):
-    # Next download the actual file
-    download_resp = requests.get(url=url, stream=True)
-    if download_resp.status_code == 200:
-        content_length = int(download_resp.headers["Content-Length"])
-        with open(save_file_name, "wb") as out_file:
-            with wrap_file(download_resp.raw, content_length, refresh_per_second=100) as stream_with_progress:
-                shutil.copyfileobj(stream_with_progress, out_file)
-    else:
-        check_api_result(download_resp)
-
-
-def request_license(email: str, machine_id: Dict[str, any]) -> str:
-    # Lets keep the email here so we have the same interface for both authenticated
-    # and not authenticated license requests.
-    # email will be validated in the license server to make sure it matches with the user of the
-    # access token so not any email is sent here
-    ensure_auth_token()
-    payload = {"id": email, "machine_id": machine_id}
-    b64_encoded_bytes = base64.encodebytes(json.dumps(payload).encode())
-    license_jsonb64 = {"licensejsonb64": b64_encoded_bytes.decode("utf-8")}
-    headers["content-type"] = "application/json"
-    r = requests.post(url=f"{license_server_base_url}/api/license/request", headers=headers, data=json.dumps(license_jsonb64))
-    check_api_result(r)
-    return r.json()["license_data"]
+        RestHelper.print_api_result(r)
+        return None
+
+    @staticmethod
+    def upload_file(
+        path: Union[str, Path],
+        url: str,
+        upload_headers: Dict[str, str] | None = None,
+        return_response: bool = False,
+        progress_label: str = "Uploading...",
+    ) -> requests.Response | None:
+        # Returns a Response object if succesfull otherwise, None
+        RestHelper.ensure_auth_token()
+        if upload_headers is not None:
+            RestHelper.__headers.update(upload_headers)
+        with open(path, "rb") as file:
+            with wrap_file(file, os.stat(path).st_size, description=progress_label) as f:
+                r = requests.post(
+                    f"{RestHelper.__base_url}{url}", files={os.path.basename(path): f}, headers=RestHelper.__headers, timeout=60
+                )
+            if return_response:
+                RestHelper.check_api_result(r)
+                return r
+            RestHelper.print_api_result(r)
+        return None
+
+    @staticmethod
+    def upload_file_with_signed_url(
+        path: Union[str, Path],
+        url: str,
+        upload_headers: Dict[str, str],
+        return_response: bool = False,
+        progress_label: str = "Uploading...",
+    ) -> requests.Response | None:
+        # Returns a Response object if succesfull otherwise, None
+        with open(path, "rb") as file:
+            with wrap_file(file, os.stat(path).st_size, description=progress_label, transient=False) as f:
+                r = requests.put(url, data=f, headers=upload_headers, timeout=60)
+            if return_response:
+                RestHelper.check_api_result(r)
+                return r
+            RestHelper.print_api_result(r)
+        return None
+
+    @staticmethod
+    def use_progress(label: str) -> Progress:
+        p = Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=True)
+        p.add_task(label, total=1)
+        return p
+
+    @staticmethod
+    def download_file(save_file_name: str, url: str) -> None:
+        # Next download the actual file
+        download_resp = requests.get(url=url, stream=True, timeout=60)
+        if download_resp.status_code == 200:
+            content_length = int(download_resp.headers["Content-Length"])
+            with open(save_file_name, "wb") as out_file:
+                with wrap_file(
+                    download_resp.raw, content_length, refresh_per_second=100, description=f"Downloading to {save_file_name}"
+                ) as stream_with_progress:
+                    shutil.copyfileobj(stream_with_progress, out_file)
+        else:
+            RestHelper.check_api_result(download_resp)
+
+    @staticmethod
+    def request_license(email: str, machine_id: Dict[str, Any]) -> str:
+        # Lets keep the email here so we have the same interface for both authenticated
+        # and not authenticated license requests.
+        # email will be validated in the license server to make sure it matches with the user of the
+        # access token so not any email is sent here
+        RestHelper.ensure_auth_token()
+        payload = {"id": email, "machine_id": machine_id}
+        b64_encoded_bytes = base64.encodebytes(json.dumps(payload).encode())
+        license_jsonb64 = {"licensejsonb64": b64_encoded_bytes.decode("utf-8")}
+        RestHelper.__headers["content-type"] = "application/json"
+        r = requests.post(
+            url=f"{RestHelper.__license_server_base_url}/api/license/request",
+            headers=RestHelper.__headers,
+            data=json.dumps(license_jsonb64),
+            timeout=60,
+        )
+        RestHelper.check_api_result(r)
+        return str(r.json()["license_data"])

cli/cloud/resumable_upload.py

@@ -0,0 +1,62 @@
+import os
+import sys
+
+import requests
+from rich.progress import wrap_file
+
+from ..errors import ErrorPrinter
+
+
+def __get_uploaded_bytes(upload_url: str) -> int:
+    headers = {"Content-Range": "bytes */*"}
+    response = requests.put(upload_url, headers=headers, timeout=60)
+    if response.status_code != 308:
+        raise ValueError(f"Failed to retrieve upload status: {response.status_code} {response.text}")
+
+    # Parse the Range header to get the last byte uploaded
+    range_header = response.headers.get("Range")
+    if range_header:
+        last_byte = int(range_header.split("-")[1])
+        return last_byte + 1
+    return 0
+
+
+def upload_signed_url(signed_url: str, source_file_name: str, content_type: str) -> None:
+    """
+    Upload file to file storage with signed url and resumable upload.
+    Resumable upload will only work with the same URL and not if a new signed URL is requested with the
+    same object id.
+    :param signed_url:
+    :param source_file_name:
+    :return:
+    """
+
+    file_size = os.path.getsize(source_file_name)
+    headers = {"x-goog-resumable": "start", "content-type": content_type}
+    response = requests.post(signed_url, headers=headers, timeout=60)
+    if response.status_code not in (200, 201, 308):
+        ErrorPrinter.print_generic_error(f"Failed to upload file: {response.status_code} - {response.text}")
+        sys.exit(1)
+
+    upload_url = response.headers["Location"]
+
+    # Check how many bytes have already been uploaded
+    uploaded_bytes = __get_uploaded_bytes(upload_url)
+
+    # Upload the remaining file in chunks
+    # Not sure what a good chunk size is or if we even should have resumable uploads here, probably not..
+    chunk_size = 256 * 1024 * 10
+    # Upload the file in chunks
+    with open(source_file_name, "rb") as f:
+        with wrap_file(f, os.stat(source_file_name).st_size, description=f"Uploading {source_file_name}...") as file:
+            file.seek(uploaded_bytes)  # Seek to the position of the last uploaded byte
+            for chunk_start in range(uploaded_bytes, file_size, chunk_size):
+                chunk_end = min(chunk_start + chunk_size, file_size) - 1
+                chunk = file.read(chunk_end - chunk_start + 1)
+                headers = {"Content-Range": f"bytes {chunk_start}-{chunk_end}/{file_size}"}
+                response = requests.put(upload_url, headers=headers, data=chunk, timeout=60)
+                if response.status_code not in (200, 201, 308):
+                    ErrorPrinter.print_generic_error(f"Failed to upload file: {response.status_code} - {response.text}")
+                    sys.exit(1)
+
+    print(f"File {source_file_name} uploaded successfully.")

cli/cloud/sample_recordings.py

@@ -2,7 +2,7 @@ import json
 
 import typer
 
-from . import rest_helper as rest
+from .rest_helper import RestHelper as Rest
 
 app = typer.Typer()
 
@@ -11,14 +11,14 @@ app = typer.Typer()
 def do_import(
     recording_session: str = typer.Argument(..., help="Recording session id"),
     project: str = typer.Option(..., help="Project to import sample recording into", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
-    rest.handle_post(url=f"/api/samples/files/recording/{recording_session}/copy", body=json.dumps({"projectUid": project}))
+) -> None:
+    Rest.handle_post(url=f"/api/samples/files/recording/{recording_session}/copy", body=json.dumps({"projectUid": project}))
 
 
 @app.command("list")
-def list():
+def list() -> None:  # pylint: disable=W0622
     """
     List available sample recordings
     """
 
-    rest.handle_get("/api/samples/files/recording")
+    Rest.handle_get("/api/samples/files/recording")

cli/cloud/service_account_tokens.py

@@ -4,12 +4,12 @@ from pathlib import Path
 
 import typer
 
-from . import rest_helper as rest
+from .rest_helper import RestHelper as Rest
 
 app = typer.Typer()
 
-config_dir_name = str(Path.home()) + "/.config/.remotive/"
-token_file_name = str(Path.home()) + "/.config/.remotive/cloud.secret.token2"
+CONFIG_DIR_NAME = str(Path.home()) + "/.config/.remotive/"
+TOKEN_FILE_NAME = str(Path.home()) + "/.config/.remotive/cloud.secret.token2"
 
 
 @app.command(name="create", help="Create new access token")
@@ -17,13 +17,16 @@ 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"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
-    response = rest.handle_post(
+) -> None:
+    response = Rest.handle_post(
         url=f"/api/project/{project}/admin/accounts/{service_account}/keys",
         return_response=True,
         body=json.dumps({"daysUntilExpiry": expire_in_days}),
     )
 
+    if response is None:
+        return
+
     if response.status_code == 200:
         name = response.json()["name"]
         write_token(f"service-account-{service_account}-{name}-token.json", response.text)
@@ -36,16 +39,16 @@ def create(
 def list_keys(
     service_account: str = typer.Option(..., help="Service account name"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
-    rest.handle_get(f"/api/project/{project}/admin/accounts/{service_account}/keys")
+) -> None:
+    Rest.handle_get(f"/api/project/{project}/admin/accounts/{service_account}/keys")
 
 
 @app.command(name="list-files")
-def list_files():
+def list_files() -> None:
     """
     List personal access token files in remotivelabs config directory
     """
-    personal_files = filter(lambda f: f.startswith("service-account"), os.listdir(config_dir_name))
+    personal_files = filter(lambda f: f.startswith("service-account"), os.listdir(CONFIG_DIR_NAME))
     for file in personal_files:
         print(file)
 
@@ -55,13 +58,12 @@ def revoke(
     name: str = typer.Argument(..., help="Access token name"),
     service_account: str = typer.Option(..., help="Service account name"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
-    rest.handle_delete(f"/api/project/{project}/admin/accounts/{service_account}/keys/{name}")
+) -> None:
+    Rest.handle_delete(f"/api/project/{project}/admin/accounts/{service_account}/keys/{name}")
 
 
-def write_token(file, token):
+def write_token(file: str, token: str) -> None:
     path = str(Path.home()) + f"/.config/.remotive/{file}"
-    f = open(path, "w")
-    f.write(token)
-    f.close()
-    print(f"Secret token written to {path}")
+    with open(path, "w", encoding="utf8") as f:
+        f.write(token)
+        print(f"Secret token written to {path}")