remotivelabs-cli 0.0.41__tar.gz → 0.1.0a1__tar.gz

{remotivelabs_cli-0.0.41 → remotivelabs_cli-0.1.0a1}/PKG-INFO

@@ -1,16 +1,18 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: remotivelabs-cli
-Version: 0.0.41
+Version: 0.1.0a1
 Summary: CLI for operating RemotiveCloud and RemotiveBroker
 Author: Johan Rask
 Author-email: johan.rask@remotivelabs.com
-Requires-Python: >=3.8,<4
+Requires-Python: >=3.9,<4
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: click (<8.2.0)
+Requires-Dist: dacite (>=1.9.2,<2.0.0)
 Requires-Dist: grpc-stubs (>=1.53.0.5)
 Requires-Dist: mypy-protobuf (>=3.0.0)
 Requires-Dist: plotext (>=5.2,<6.0)

remotivelabs_cli-0.1.0a1/cli/api/cloud/tokens.py

@@ -0,0 +1,62 @@
+import dataclasses
+from typing import Any
+
+import requests
+
+from cli.utils.rest_helper import RestHelper as Rest
+
+#
+# Attempt to start cloud-api.
+# Might be better to generate somehow instead.
+# Lets discuss further
+#
+
+
+@dataclasses.dataclass
+class EmptyResponse:
+    is_success: bool
+    status_code: int
+
+
+@dataclasses.dataclass
+class JsonResponse:
+    is_success: bool
+    status_code: int
+    __response: requests.Response
+
+    def json(self) -> Any:
+        return self.__response.json()
+
+    def text(self) -> str:
+        return self.__response.text
+
+
+def __delete_response_from_response(response: requests.Response) -> EmptyResponse:
+    if 200 > response.status_code > 299:
+        ok = False
+    else:
+        ok = True
+    return EmptyResponse(is_success=ok, status_code=response.status_code)
+
+
+def __json_response_from_response(response: requests.Response) -> JsonResponse:
+    if 200 > response.status_code > 299:
+        ok = False
+    else:
+        ok = True
+    return JsonResponse(is_success=ok, status_code=response.status_code, __response=response)
+
+
+def create() -> JsonResponse:
+    response = Rest.handle_post(url="/api/me/keys", return_response=True)
+    return __json_response_from_response(response)
+
+
+def revoke(name: str) -> EmptyResponse:
+    res_revoke = Rest.handle_patch(f"/api/me/keys/{name}/revoke", quiet=True, allow_status_codes=[404, 401])
+    return __delete_response_from_response(res_revoke)
+
+
+def delete(name: str) -> EmptyResponse:
+    res_delete = Rest.handle_delete(f"/api/me/keys/{name}", quiet=True, allow_status_codes=[404, 401])
+    return __delete_response_from_response(res_delete)

{remotivelabs_cli-0.0.41 → remotivelabs_cli-0.1.0a1}/cli/broker/brokers.py

@@ -26,7 +26,6 @@ def main(
     if url is not None:
         os.environ["REMOTIVE_BROKER_URL"] = url
     # Do other global stuff, handle other global options here
-    return
 
 
 @app.command(help="Discover brokers on this network")

{remotivelabs_cli-0.0.41 → remotivelabs_cli-0.1.0a1}/cli/broker/export.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-import os
 import signal as os_signal
+import sys
 from typing import Any, List
 
 import grpc
@@ -57,7 +57,7 @@ def influxdb(
     def exit_on_ctrlc(_sig: Any, _frame: Any) -> None:
         if output is not None:
             f.close()
-        os._exit(0)
+        sys.exit(0)
 
     def per_frame_influx_line_protocol(x: Any) -> None:
         signals = list(x)
@@ -67,7 +67,7 @@ def influxdb(
         frame = signals[0]["name"].rsplit(".", 1)[0]
         # frame_name = signals[0]["name"].split(".")[1]
         namespace = signals[0]["namespace"]
-        signals_str = ",".join(list(map(lambda s: f'{sig}={s["value"]}', signals)))
+        signals_str = ",".join(list(map(lambda s: f"{sig}={s['value']}", signals)))
         influx_lp = f"{frame},namespace={namespace} {signals_str} {round(signals[0]['timestamp_us'] * 1000)}"
         if output is not None:
             f.write(f"{influx_lp}\n")
@@ -112,7 +112,7 @@ def influxdb(
             arr = sig.split(":")
             if len(arr) != 2:
                 ErrorPrinter.print_hint(f"--signal must have format namespace:signal ({sig})")
-                exit(1)
+                sys.exit(1)
 
             return SubscribableSignal(namespace=arr[0], name=arr[1])
 

{remotivelabs_cli-0.0.41 → remotivelabs_cli-0.1.0a1}/cli/broker/lib/broker.py

@@ -6,6 +6,7 @@ import os
 import posixpath
 import queue
 import signal as os_signal
+import sys
 import tempfile
 import time
 import zipfile
@@ -59,9 +60,7 @@ class Broker:
                 os.environ["ACCESS_TOKEN"] = "false"
                 self.intercept_channel = br.create_channel(url, None, None)
         else:
-            err_console.print(
-                "Option --api-key will is deprecated and will be removed. " "Use access access tokens by logging in with cli."
-            )
+            err_console.print("Option --api-key will is deprecated and will be removed. Use access access tokens by logging in with cli.")
             os.environ["ACCESS_TOKEN"] = "false"
             self.intercept_channel = br.create_channel(url, api_key, None)
 
@@ -303,11 +302,10 @@ class Broker:
 
             for r in response:
                 if r["data"]:
-                    print(f'Successfully received traffic on {r["namespace"]}')
+                    print(f"Successfully received traffic on {r['namespace']}")
                     keep_running = False
-                else:
-                    if not wait_for_traffic or (not keep_running and not keep_running_during_recording):
-                        print(f'Namespace {r["namespace"]} did not receive any traffic')
+                elif not wait_for_traffic or (not keep_running and not keep_running_during_recording):
+                    print(f"Namespace {r['namespace']} did not receive any traffic")
 
     def upload(self, file: str, dest: str) -> None:
         try:
@@ -456,10 +454,8 @@ class Broker:
             if ns not in existing_ns:
                 ns_not_matching.append(ns)
         if len(ns_not_matching) > 0:
-            ErrorPrinter.print_hint(
-                f"Namespace(s) {ns_not_matching} does not exist on broker. " f"Namespaces found on broker: {existing_ns}"
-            )
-            exit(1)
+            ErrorPrinter.print_hint(f"Namespace(s) {ns_not_matching} does not exist on broker. Namespaces found on broker: {existing_ns}")
+            sys.exit(1)
 
         available_signals = list(filter(verify_namespace, existing_signals))  # type: ignore
         signals_to_subscribe_to = list(filter(find_subscribed_signal, available_signals))  # type: ignore
@@ -468,8 +464,8 @@ class Broker:
         signals_subscribed_to_but_does_not_exist = set(subscribed_signals) - set(map(lambda s: s["signal"], signals_to_subscribe_to))
 
         if len(signals_subscribed_to_but_does_not_exist) > 0:
-            ErrorPrinter.print_hint(f"One or more signals you subscribed to does not exist " f"{signals_subscribed_to_but_does_not_exist}")
-            exit(1)
+            ErrorPrinter.print_hint(f"One or more signals you subscribed to does not exist {signals_subscribed_to_but_does_not_exist}")
+            sys.exit(1)
 
         return list(map(lambda s: SubscribableSignal(s["signal"], s["namespace"]), signals_to_subscribe_to))
 

{remotivelabs_cli-0.0.41 → remotivelabs_cli-0.1.0a1}/cli/broker/license_flows.py

@@ -11,7 +11,7 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from cli.broker.lib.broker import Broker, LicenseInfo
-from cli.cloud.rest_helper import RestHelper as Rest
+from cli.utils.rest_helper import RestHelper as Rest
 
 console = Console(stderr=True)
 

{remotivelabs_cli-0.0.41 → remotivelabs_cli-0.1.0a1}/cli/broker/scripting.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import sys
 from string import Template
 from typing import List
 
@@ -35,7 +36,7 @@ def new_script(
         arr = sig.split(":")
         if len(arr) != 2:
             ErrorPrinter.print_hint(f"--input-signal must have format namespace:signal ({sig})")
-            exit(1)
+            sys.exit(1)
         return arr[0], arr[1]
 
     signals_to_subscribe_to = list(map(to_subscribable_signal, input_signal))

{remotivelabs_cli-0.0.41 → remotivelabs_cli-0.1.0a1}/cli/broker/signals.py

@@ -4,6 +4,7 @@ import json
 import numbers
 import os
 import signal as os_signal
+import sys
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, Iterable, List, TypedDict, Union
@@ -60,11 +61,11 @@ def read_scripted_code_file(file_path: Path) -> bytes:
             return file.read()
     except FileNotFoundError:
         print("File not found. Please check your file path.")
-        exit(1)
+        sys.exit(1)
 
 
 @app.command()
-def subscribe(  # noqa: C901
+def subscribe(  # noqa: C901, PLR0913, PLR0915
     url: str = typer.Option(DEFAULT_GRPC_URL, help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
     api_key: str = typer.Option(None, help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
     signal: List[str] = typer.Option([], help="Signal names to subscribe to, mandatory when not using script"),
@@ -79,7 +80,7 @@ def subscribe(  # noqa: C901
         help="Supply a path to Lua script that to use for signal transformation",
     ),
     on_change_only: bool = typer.Option(default=False, help="Only get signal if value is changed"),
-    x_plot: bool = typer.Option(default=False, help="Experimental: Plot the signal in terminal. Note graphs are not " "aligned by time"),
+    x_plot: bool = typer.Option(default=False, help="Experimental: Plot the signal in terminal. Note graphs are not aligned by time"),
     x_plot_size: int = typer.Option(default=100, help="Experimental: how many points show for each plot"),
     # samples: int = typer.Option(default=0, he)
 ) -> None:
@@ -100,12 +101,12 @@ def subscribe(  # noqa: C901
     if script is None:
         if len(signal) == 0:
             ErrorPrinter.print_generic_error("You must use --signal or use --script when subscribing")
-            exit(1)
+            sys.exit(1)
 
     if script is not None:
         if len(signal) > 0:
             ErrorPrinter.print_generic_error("You must must not specify --signal when using --script")
-            exit(1)
+            sys.exit(1)
 
     plt.title("Signals")
 
@@ -113,8 +114,6 @@ def subscribe(  # noqa: C901
         os._exit(0)
 
     def on_frame_plot(x: Iterable[Any]) -> None:
-        global signal_values
-
         plt.clt()  # to clear the terminal
         plt.cld()  # to clear the data only
         frames = list(x)
@@ -146,9 +145,9 @@ def subscribe(  # noqa: C901
                 signal_values[f"ts_{name}"] = signal_values[f"ts_{name}"][len(signal_values[f"ts_{name}"]) - x_plot_size :]
 
         cnt = 1
-        for key in signal_values:
+        for key, value in signal_values.items():
             if not key.startswith("ts_"):
-                plt.subplot(cnt, 1).plot(signal_values[f"ts_{key}"], signal_values[key], label=key, color=cnt)
+                plt.subplot(cnt, 1).plot(signal_values[f"ts_{key}"], value, label=key, color=cnt)
                 cnt = cnt + 1
         plt.sleep(0.001)  # to add
         plt.show()
@@ -174,7 +173,7 @@ def subscribe(  # noqa: C901
                 arr = sig.split(":")
                 if len(arr) != 2:
                     ErrorPrinter.print_hint(f"--signal must have format namespace:signal ({sig})")
-                    exit(1)
+                    sys.exit(1)
                 return SubscribableSignal(namespace=arr[0], name=arr[1])
 
             signals_to_subscribe_to = list(map(to_subscribable_signal, signal))

{remotivelabs_cli-0.0.41 → remotivelabs_cli-0.1.0a1}/cli/cloud/auth/cmd.py

@@ -1,35 +1,50 @@
+from __future__ import annotations
+
 import sys
 
+import typer
+
 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 cli.typer import typer_utils
+from cli.utils.rest_helper import RestHelper as Rest
 
 from .. import auth_tokens
+from ..organisations import do_select_default_org
 
 HELP = """
 Manage how you authenticate with our cloud platform
 """
 app = typer_utils.create_typer(help=HELP)
-app.add_typer(auth_tokens.app, name="tokens", help="Manage users personal access tokens")
+# app.add_typer(auth_tokens.app, name="credentials", help="Manage account credentials")
 
 
 @app.command(name="login")
-def login() -> None:
+def login(browser: bool = typer.Option(default=True, help="Does not automatically open browser, instead shows a link")) -> None:
     """
     Login to the cli using browser
 
+    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()
+    do_login(headless=not browser)
+    if settings.get_cli_config().get_active_default_organisation() is None:
+        set_default_organisation = typer.confirm(
+            "You have not set a default organisation\nWould you like to choose one now?", abort=False, default=True
+        )
+        if set_default_organisation:
+            do_select_default_org(get=False)
 
 
 @app.command()
 def whoami() -> None:
     """
-    Validates authentication and fetches your user information
+    Validates authentication and fetches your account information
     """
     try:
         Rest.handle_get("/api/whoami")
@@ -61,7 +76,11 @@ def print_access_token_file() -> None:
         sys.exit(1)
 
 
-@app.command(help="Clear access token")
+# @app.command(help="Clears active credentials")
 def logout() -> None:
     settings.clear_active_token()
     print("Access token removed")
+
+
+app.command("activate")(auth_tokens.select_personal_token)
+app.command("list")(auth_tokens.list_pats_files)

remotivelabs_cli-0.1.0a1/cli/cloud/auth/login.py

@@ -0,0 +1,317 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+import secrets
+import sys
+import time
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from threading import Thread
+from typing import Any, Optional, Tuple
+from urllib.parse import parse_qs, urlparse
+
+import typer
+from rich.console import Console
+from typing_extensions import override
+
+from cli.cloud.auth_tokens import list_and_select_personal_token
+from cli.errors import ErrorPrinter
+from cli.settings import TokenNotFoundError, settings
+from cli.utils.rest_helper import RestHelper as Rest
+
+httpd: HTTPServer
+
+console = Console()
+
+
+def generate_pkce_pair() -> Tuple[str, str]:
+    """
+    PKCE is used for all cli login flows, both headless and browser.
+    """
+    code_verifier_ = secrets.token_urlsafe(64)  # High-entropy string
+    code_challenge_ = base64.urlsafe_b64encode(hashlib.sha256(code_verifier_.encode("ascii")).digest()).rstrip(b"=").decode("ascii")
+    return code_verifier_, code_challenge_
+
+
+code_verifier, code_challenge = generate_pkce_pair()
+state = secrets.token_urlsafe(16)
+
+short_lived_token = None
+
+
+class S(BaseHTTPRequestHandler):
+    def _set_response(self) -> None:
+        self.send_response(200)
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+
+    @override
+    def log_message(self, format: Any, *args: Any) -> None:
+        return
+
+    # Please do not change this into lowercase!
+    @override
+    def do_GET(self) -> None:  # type: ignore # noqa: PLR0912
+        self._set_response()
+
+        parsed_url = urlparse(self.path)
+
+        # Get query parameters as a dict
+        query_params = parse_qs(parsed_url.query)
+
+        # Example: Get the value of the "error" parameter if it exists
+        error_value = query_params.get("error", [None])[0]
+        path = self.path
+        auth_code = path[1:]  # Remotive /
+        time.sleep(1)
+        httpd.server_close()
+
+        killerthread = Thread(target=httpd.shutdown)
+        killerthread.start()
+        if error_value is None:
+            res = Rest.handle_get(
+                f"/api/open/token?code={auth_code}&code_verifier={code_verifier}",
+                return_response=True,
+                skip_access_token=True,
+                allow_status_codes=[401, 400],
+            )
+            if res.status_code != 200:
+                ErrorPrinter.print_generic_error(
+                    "Failed to fetch token. Please try again, if the problem persists please reach out to support@remotivelabs.com"
+                )
+                self.wfile.write(
+                    "Failed to fetch token. Please try again, if the problem persists please reach out to support@remotivelabs.com".encode(
+                        "utf-8"
+                    )
+                )
+                sys.exit(1)
+            self.wfile.write("Successfully setup CLI, return to your terminal to continue".encode("utf-8"))
+            access_token = res.json()["access_token"]
+            # token = tf.TokenFile(
+            #    name="CLI_login_token",
+            #    token=access_token,
+            #    created=str(datetime.datetime.now().isoformat()),
+            #    expires="unknown",
+            # )
+
+            global short_lived_token  # noqa: PLW0603
+            short_lived_token = access_token
+
+            # settings.add_and_activate_short_lived_cli_token(tf.dumps(token))
+            # print("Successfully logged on, you are ready to go with cli")
+        else:
+            if error_value == "no_consent":
+                self.wfile.write(
+                    """
+                Authorization was cancelled.<br/>
+                To use RemotiveCLI, you need to grant access to your RemotiveCloud account.
+                <br/><br/>
+                Run `remotive cloud auth login` to try again.
+                """.encode("utf-8")
+                )
+                ErrorPrinter.print_generic_error("You did not grant access to RemotiveCloud, login aborted")
+            else:
+                self.wfile.write(f"Unknown error {error_value}, please contact support@remotivelabs.com".encode("utf-8"))
+                ErrorPrinter.print_generic_error(f"Unexpected error {error_value}, please contact support@remotivelabs.com")
+            sys.exit(1)
+
+
+def prepare_local_webserver(server_class: type = HTTPServer, handler_class: type = S, port: Optional[int] = None) -> None:
+    if port is None:
+        env_val = os.getenv("REMOTIVE_LOGIN_CALLBACK_PORT" or "")
+        if env_val and env_val.isdigit():
+            port = int(env_val)
+        else:
+            port = 0
+
+    server_address = ("", port)
+    global httpd  # noqa: PLW0603
+    httpd = server_class(server_address, handler_class)
+
+
+def create_personal_token() -> None:
+    response = Rest.handle_post(
+        url="/api/me/keys",
+        return_response=True,
+        body=json.dumps({"alias": "roine"}),
+        access_token=short_lived_token,
+    )
+    token = response.json()
+    email = token["account"]["email"]
+    existing_file = settings.get_token_file_by_email(email=email)
+    if existing_file is not None:
+        # ErrorPrinter.print_hint(f"Revoking and deleting existing credentials [remove_me]{existing_file.name}")
+        res = Rest.handle_patch(
+            f"/api/me/keys/{existing_file.name}/revoke",
+            quiet=True,
+            access_token=short_lived_token,
+            allow_status_codes=[400, 404],
+        )
+        if res is not None and res.status_code == 200:
+            Rest.handle_delete(
+                f"/api/me/keys/{existing_file.name}",
+                quiet=True,
+                access_token=short_lived_token,
+            )
+        settings.remove_token_file(existing_file.name)
+
+    settings.add_personal_token(response.text, activate=True)
+
+    print("Successfully logged on")
+
+
+def login(headless: bool = False) -> bool:  # noqa: C901, PLR0912, PLR0915
+    """
+    Initiate login
+    """
+
+    #
+    # Check login.md flowchart for better understanding
+    #
+    # 1. Check for active token valid and working credentials
+    #
+    try:
+        activate_token = settings.get_active_token_file()
+
+        if not activate_token.is_expired():
+            if Rest.has_access("/api/whoami"):
+                console.print(f"You are already signed in with valid credentials that expires in {activate_token.expires_in_days()} days")
+                files = settings.list_personal_token_files()
+                if len(files) > 0:
+                    print("")
+                    console.print("You have available credentials on disk, [bold]choose one or press q to login again[/bold]")
+                    token_selected = list_and_select_personal_token(skip_prompt=False)
+                    if token_selected:
+                        return True
+                # list_and_select_personal_token(skip_prompt=True)
+                # print("")
+                # typer.confirm("Are you sure you want to login again?", abort=True)
+                # If we are here, user still wants to login
+            else:
+                settings.clear_active_token()
+                raise TokenNotFoundError()
+        else:
+            # TODO - Cleanup token since expired
+            pass
+
+    except TokenNotFoundError:
+        #
+        # 2. If no token was found, let user choose an existing if exists
+        #
+        files = settings.list_personal_token_files()
+        if len(files) > 0:
+            print("")
+            token_selected = list_and_select_personal_token(
+                skip_prompt=False,
+                info_message="You have available credentials on disk, choose one or press q to login again",
+            )
+            if token_selected:
+                return True
+
+    prepare_local_webserver()
+
+    def force_use_webserver_callback() -> bool:
+        env_val = os.getenv("REMOTIVE_LOGIN_FORCE_CALLBACK" or "no")
+        if env_val and env_val == "yes":
+            return True
+        return False
+
+    def login_with_callback_but_copy_url() -> None:
+        """
+        This will print a url the will trigger a callback later so the webserver must be up and running.
+        """
+        print("Copy the following link in a browser to login to cloud, and complete the sign-in prompts:")
+        print("")
+
+        url = (
+            f"{Rest.get_base_frontend_url()}/login"
+            f"?state={state}"
+            f"&cli_version={Rest.get_cli_version()}"
+            f"&response_type=code"
+            f"&code_challenge={code_challenge}"
+            f"&redirect_uri=http://localhost:{httpd.server_address[1]}"
+        )
+        console.print(url, style="bold")
+        httpd.serve_forever()
+
+    def login_headless() -> None:
+        """
+        Full headless, opens a browser and expects a auth code to be entered and exchanged for the token
+        """
+        print("Copy the following link in a browser to login to cloud, and complete the sign-in prompts:")
+        print("")
+
+        url = (
+            f"{Rest.get_base_frontend_url()}/login"
+            f"?state={state}"
+            f"&cli_version={Rest.get_cli_version()}"
+            f"&response_type=code"
+            f"&code_challenge={code_challenge}"
+        )
+        console.print(url, style="bold")
+
+        code = typer.prompt(
+            "Once finished, enter the verification code provided in your browser",
+            hide_input=False,
+        )
+        res = Rest.handle_get(
+            f"/api/open/token?code={code}&code_verifier={code_verifier}",
+            return_response=True,
+            skip_access_token=True,
+            allow_status_codes=[401],
+        )
+        if res.status_code == 401:
+            ErrorPrinter.print_generic_error(
+                "Failed to fetch token. Please try again, if the problem persists please reach out to support@remotivelabs.com"
+            )
+            sys.exit(1)
+        access_token = res.json()["access_token"]
+        # res = Rest.handle_get("/api/whoami", return_response=True, access_token=access_token)
+        global short_lived_token  # noqa: PLW0603
+        short_lived_token = access_token
+        create_personal_token()
+        # current_user = res.json()
+        # token = tf.TokenFile(
+        #    type="authorized_user",
+        #    name="CLI_login_token",
+        #    token=access_token,
+        #    created=str(datetime.datetime.now().isoformat()),
+        #    expires="unknown",
+        #    account=TokenFileUser(email=current_user["email"], uid=current_user["uid"], project=None),
+        # )
+        # settings.add_and_activate_short_lived_cli_token(tf.dumps(token))
+        # console.print("Successfully logged on, you are ready to go with cli", style="green bold")
+
+    if headless and not force_use_webserver_callback():
+        login_headless()
+    elif headless and force_use_webserver_callback():
+        login_with_callback_but_copy_url()
+    else:
+        could_open = webbrowser.open_new_tab(
+            f"{Rest.get_base_frontend_url()}/login"
+            f"?state={state}"
+            f"&cli_version={Rest.get_cli_version()}"
+            f"&response_type=code"
+            f"&code_challenge={code_challenge}"
+            f"&redirect_uri=http://localhost:{httpd.server_address[1]}"
+        )
+
+        if not could_open:
+            print(
+                "Could not open a browser on this machine, this is likely because you are in an environment where no browser is avaialble"
+            )
+            print("")
+            if force_use_webserver_callback():
+                login_with_callback_but_copy_url()
+            else:
+                login_headless()
+        else:
+            httpd.serve_forever()
+
+        # Once we received our callback or code we are logged in and ready to go
+        create_personal_token()
+
+    return True