uipath 2.1.41__py3-none-any.whl → 2.1.43__py3-none-any.whl

uipath/_cli/_auth/_auth_server.py

@@ -7,7 +7,7 @@ import threading
 import time
 from typing import Optional
 
-from ._oidc_utils import get_auth_config
+from ._oidc_utils import OidcUtils
 
 # Server port
 PORT = 6234
@@ -74,7 +74,7 @@ def make_request_handler_class(state, code_verifier, token_callback, domain):
                     content = f.read()
 
                 # Get the redirect URI from auth config
-                auth_config = get_auth_config()
+                auth_config = OidcUtils.get_auth_config()
                 redirect_uri = auth_config["redirect_uri"]
 
                 content = content.replace("__PY_REPLACE_EXPECTED_STATE__", state)

uipath/_cli/_auth/_auth_service.py

@@ -0,0 +1,151 @@
+import asyncio
+import json
+import os
+import webbrowser
+from socket import AF_INET, SOCK_STREAM, error, socket
+from typing import Optional
+from urllib.parse import urlparse
+
+from uipath._cli._auth._auth_server import HTTPServer
+from uipath._cli._auth._client_credentials import ClientCredentialsService
+from uipath._cli._auth._oidc_utils import OidcUtils
+from uipath._cli._auth._portal_service import PortalService, select_tenant
+from uipath._cli._auth._url_utils import set_force_flag
+from uipath._cli._auth._utils import update_auth_file, update_env_file
+from uipath._cli._utils._console import ConsoleLogger
+
+
+class AuthService:
+    def __init__(
+        self,
+        environment: str,
+        *,
+        force: bool,
+        client_id: Optional[str],
+        client_secret: Optional[str],
+        base_url: Optional[str],
+        scope: Optional[str],
+    ):
+        self._force = force
+        self._console = ConsoleLogger()
+        self._domain = self._get_domain(environment)
+        self._client_id = client_id
+        self._client_secret = client_secret
+        self._base_url = base_url
+        self._scope = scope
+        set_force_flag(self._force)
+
+    def _get_domain(self, environment: str) -> str:
+        # only search env var if not force authentication
+        if not self._force:
+            uipath_url = os.getenv("UIPATH_URL")
+            if uipath_url and environment == "cloud":  # "cloud" is the default
+                parsed_url = urlparse(uipath_url)
+                if parsed_url.scheme and parsed_url.netloc:
+                    environment = f"{parsed_url.scheme}://{parsed_url.netloc}"
+                else:
+                    self._console.error(
+                        f"Malformed UIPATH_URL: '{uipath_url}'. Please ensure it includes both scheme and netloc (e.g., 'https://cloud.uipath.com')."
+                    )
+        return environment
+
+    def authenticate(self) -> None:
+        if self._client_id and self._client_secret:
+            self._authenticate_client_credentials()
+            return
+
+        self._authenticate_authorization_code()
+
+    def _authenticate_client_credentials(self) -> None:
+        if not self._base_url:
+            self._console.error(
+                "--base-url is required when using client credentials authentication."
+            )
+            return
+        self._console.hint("Using client credentials authentication.")
+        credentials_service = ClientCredentialsService(self._base_url)
+        credentials_service.authenticate(
+            self._client_id,  # type: ignore
+            self._client_secret,  # type: ignore
+            self._scope,
+        )
+
+    def _authenticate_authorization_code(self) -> None:
+        with PortalService(self._domain) as portal_service:
+            if not self._force:
+                # use existing env vars
+                if (
+                    os.getenv("UIPATH_URL")
+                    and os.getenv("UIPATH_TENANT_ID")
+                    and os.getenv("UIPATH_ORGANIZATION_ID")
+                ):
+                    try:
+                        portal_service.ensure_valid_token()
+                        return
+                    except Exception:
+                        self._console.error(
+                            "Authentication token is invalid. Please reauthenticate using the '--force' flag.",
+                        )
+            auth_url, code_verifier, state = OidcUtils.get_auth_url(self._domain)
+            webbrowser.open(auth_url, 1)
+            auth_config = OidcUtils.get_auth_config()
+
+            self._console.link(
+                "If a browser window did not open, please open the following URL in your browser:",
+                auth_url,
+            )
+            server = HTTPServer(port=auth_config["port"])
+            token_data = asyncio.run(server.start(state, code_verifier, self._domain))
+
+            if not token_data:
+                self._console.error(
+                    "Authentication failed. Please try again.",
+                )
+
+            portal_service.update_token_data(token_data)
+            update_auth_file(token_data)
+            access_token = token_data["access_token"]
+            update_env_file({"UIPATH_ACCESS_TOKEN": access_token})
+
+            tenants_and_organizations = portal_service.get_tenants_and_organizations()
+            base_url = select_tenant(self._domain, tenants_and_organizations)
+            try:
+                portal_service.post_auth(base_url)
+            except Exception:
+                self._console.error(
+                    "Could not prepare the environment. Please try again.",
+                )
+
+    def set_port(self):
+        def is_port_in_use(target_port: int) -> bool:
+            with socket(AF_INET, SOCK_STREAM) as s:
+                try:
+                    s.bind(("localhost", target_port))
+                    s.close()
+                    return False
+                except error:
+                    return True
+
+        auth_config = OidcUtils.get_auth_config()
+        port = int(auth_config.get("port", 8104))
+        port_option_one = int(auth_config.get("portOptionOne", 8104))  # type: ignore
+        port_option_two = int(auth_config.get("portOptionTwo", 8055))  # type: ignore
+        port_option_three = int(auth_config.get("portOptionThree", 42042))  # type: ignore
+        if is_port_in_use(port):
+            if is_port_in_use(port_option_one):
+                if is_port_in_use(port_option_two):
+                    if is_port_in_use(port_option_three):
+                        self._console.error(
+                            "All configured ports are in use. Please close applications using ports or configure different ports."
+                        )
+                    else:
+                        port = port_option_three
+                else:
+                    port = port_option_two
+            else:
+                port = port_option_one
+        auth_config["port"] = port
+        with open(
+            os.path.join(os.path.dirname(__file__), "..", "auth_config.json"), "w"
+        ) as f:
+            json.dump(auth_config, f)

uipath/_cli/_auth/_client_credentials.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, cast
 from urllib.parse import urlparse
 
 import httpx
@@ -14,12 +14,13 @@ console = ConsoleLogger()
 class ClientCredentialsService:
     """Service for client credentials authentication flow."""
 
-    def __init__(self, domain: str):
-        self.domain = domain
+    def __init__(self, base_url: str):
+        self._base_url = base_url
+        self._domain = self._extract_domain_from_base_url(base_url)
 
     def get_token_url(self) -> str:
         """Get the token URL for the specified domain."""
-        match self.domain:
+        match self._domain:
             case "alpha":
                 return "https://alpha.uipath.com/identity_/connect/token"
             case "staging":
@@ -39,7 +40,7 @@ class ClientCredentialsService:
         """
         return hostname == domain or hostname.endswith(f".{domain}")
 
-    def extract_domain_from_base_url(self, base_url: str) -> str:
+    def _extract_domain_from_base_url(self, base_url: str) -> str:
         """Extract domain from base URL.
 
         Args:
@@ -71,7 +72,7 @@ class ClientCredentialsService:
 
     def authenticate(
         self, client_id: str, client_secret: str, scope: Optional[str] = "OR.Execution"
-    ) -> Optional[TokenData]:
+    ) -> None:
         """Authenticate using client credentials flow.
 
         Args:
@@ -97,37 +98,35 @@ class ClientCredentialsService:
                 match response.status_code:
                     case 200:
                         token_data = response.json()
-                        return {
-                            "access_token": token_data["access_token"],
-                            "token_type": token_data.get("token_type", "Bearer"),
-                            "expires_in": token_data.get("expires_in", 3600),
-                            "scope": token_data.get("scope", scope),
-                            # Client credentials flow doesn't provide these, but we need them for compatibility
-                            "refresh_token": "",
-                            "id_token": "",
-                        }
+                        token_data = cast(
+                            TokenData,
+                            {
+                                "access_token": token_data["access_token"],
+                                "token_type": token_data.get("token_type", "Bearer"),
+                                "expires_in": token_data.get("expires_in", 3600),
+                                "scope": token_data.get("scope", scope),
+                                "refresh_token": "",
+                                "id_token": "",
+                            },
+                        )
+                        self._setup_environment(token_data)
                     case 400:
                         console.error(
                             "Invalid client credentials or request parameters."
                         )
-                        return None
                     case 401:
                         console.error("Unauthorized: Invalid client credentials.")
-                        return None
                     case _:
                         console.error(
                             f"Authentication failed: {response.status_code} - {response.text}"
                         )
-                        return None
 
         except httpx.RequestError as e:
             console.error(f"Network error during authentication: {e}")
-            return None
         except Exception as e:
             console.error(f"Unexpected error during authentication: {e}")
-            return None
 
-    def setup_environment(self, token_data: TokenData, base_url: str):
+    def _setup_environment(self, token_data: TokenData):
         """Setup environment variables for client credentials authentication.
 
         Args:
@@ -138,7 +137,7 @@ class ClientCredentialsService:
 
         env_vars = {
             "UIPATH_ACCESS_TOKEN": token_data["access_token"],
-            "UIPATH_URL": base_url,
+            "UIPATH_URL": self._base_url,
             "UIPATH_ORGANIZATION_ID": parsed_access_token.get("prt_id", ""),
             "UIPATH_TENANT_ID": "",
         }

uipath/_cli/_auth/_oidc_utils.py

@@ -24,47 +24,52 @@ def get_state_param() -> str:
     return base64.urlsafe_b64encode(os.urandom(32)).decode("utf-8").rstrip("=")
 
 
-def get_auth_config() -> AuthConfig:
-    auth_config = {}
-    with open(os.path.join(os.path.dirname(__file__), "auth_config.json"), "r") as f:
-        auth_config = json.load(f)
-
-    port = auth_config.get("port", 8104)
-
-    redirect_uri = auth_config["redirect_uri"].replace("__PY_REPLACE_PORT__", str(port))
-
-    return AuthConfig(
-        client_id=auth_config["client_id"],
-        redirect_uri=redirect_uri,
-        scope=auth_config["scope"],
-        port=port,
-    )
-
-
-def get_auth_url(domain: str) -> tuple[str, str, str]:
-    """Get the authorization URL for OAuth2 PKCE flow.
-
-    Args:
-        domain (str): The UiPath domain to authenticate against (e.g. 'alpha', 'cloud')
-
-    Returns:
-        tuple[str, str]: A tuple containing:
-            - The authorization URL with query parameters
-            - The code verifier for PKCE flow
-    """
-    code_verifier, code_challenge = generate_code_verifier_and_challenge()
-    auth_config = get_auth_config()
-    state = get_state_param()
-    query_params = {
-        "client_id": auth_config["client_id"],
-        "redirect_uri": auth_config["redirect_uri"],
-        "response_type": "code",
-        "scope": auth_config["scope"],
-        "state": state,
-        "code_challenge": code_challenge,
-        "code_challenge_method": "S256",
-    }
-
-    query_string = urlencode(query_params)
-    url = build_service_url(domain, f"/identity_/connect/authorize?{query_string}")
-    return url, code_verifier, state
+class OidcUtils:
+    @classmethod
+    def get_auth_config(cls) -> AuthConfig:
+        with open(
+            os.path.join(os.path.dirname(__file__), "auth_config.json"), "r"
+        ) as f:
+            auth_config = json.load(f)
+
+        port = auth_config.get("port", 8104)
+
+        redirect_uri = auth_config["redirect_uri"].replace(
+            "__PY_REPLACE_PORT__", str(port)
+        )
+
+        return AuthConfig(
+            client_id=auth_config["client_id"],
+            redirect_uri=redirect_uri,
+            scope=auth_config["scope"],
+            port=port,
+        )
+
+    @classmethod
+    def get_auth_url(cls, domain: str) -> tuple[str, str, str]:
+        """Get the authorization URL for OAuth2 PKCE flow.
+
+        Args:
+            domain (str): The UiPath domain to authenticate against (e.g. 'alpha', 'cloud')
+
+        Returns:
+            tuple[str, str]: A tuple containing:
+                - The authorization URL with query parameters
+                - The code verifier for PKCE flow
+        """
+        code_verifier, code_challenge = generate_code_verifier_and_challenge()
+        auth_config = cls.get_auth_config()
+        state = get_state_param()
+        query_params = {
+            "client_id": auth_config["client_id"],
+            "redirect_uri": auth_config["redirect_uri"],
+            "response_type": "code",
+            "scope": auth_config["scope"],
+            "state": state,
+            "code_challenge": code_challenge,
+            "code_challenge_method": "S256",
+        }
+
+        query_string = urlencode(query_params)
+        url = build_service_url(domain, f"/identity_/connect/authorize?{query_string}")
+        return url, code_verifier, state

uipath/_cli/_auth/_portal_service.py

@@ -8,7 +8,7 @@ import httpx
 from ..._utils._ssl_context import get_httpx_client_kwargs
 from .._utils._console import ConsoleLogger
 from ._models import TenantsAndOrganizationInfoResponse, TokenData
-from ._oidc_utils import get_auth_config
+from ._oidc_utils import OidcUtils
 from ._url_utils import build_service_url, get_base_url
 from ._utils import (
     get_auth_data,
@@ -102,7 +102,7 @@ class PortalService:
             raise RuntimeError("HTTP client is not initialized")
 
         url = build_service_url(self.domain, "/identity_/connect/token")
-        client_id = get_auth_config().get("client_id")
+        client_id = OidcUtils.get_auth_config().get("client_id")
 
         data = {
             "grant_type": "refresh_token",
@@ -136,32 +136,33 @@ class PortalService:
         auth_data = get_auth_data()
         claims = get_parsed_token_data(auth_data)
         exp = claims.get("exp")
-
         if exp is not None and float(exp) > time.time():
             if not os.getenv("UIPATH_URL"):
                 tenants_and_organizations = self.get_tenants_and_organizations()
                 select_tenant(
                     self.domain if self.domain else "alpha", tenants_and_organizations
                 )
-            return auth_data.get("access_token")
-
-        refresh_token = auth_data.get("refresh_token")
-        if refresh_token is None:
-            raise Exception("Refresh token not found")
-        token_data = self.post_refresh_token_request(refresh_token)
-        update_auth_file(token_data)
-
-        self.access_token = token_data["access_token"]
-        self.prt_id = claims.get("prt_id")
-
-        updated_env_contents = {
-            "UIPATH_ACCESS_TOKEN": token_data["access_token"],
-        }
-        if not os.getenv("UIPATH_URL"):
-            tenants_and_organizations = self.get_tenants_and_organizations()
-            select_tenant(
-                self.domain if self.domain else "alpha", tenants_and_organizations
-            )
+            updated_env_contents = {
+                "UIPATH_ACCESS_TOKEN": auth_data["access_token"],
+            }
+        else:
+            refresh_token = auth_data.get("refresh_token")
+            if refresh_token is None:
+                raise Exception("Refresh token not found")
+            token_data = self.post_refresh_token_request(refresh_token)
+            update_auth_file(token_data)
+
+            self.access_token = token_data["access_token"]
+            self.prt_id = claims.get("prt_id")
+
+            updated_env_contents = {
+                "UIPATH_ACCESS_TOKEN": token_data["access_token"],
+            }
+            if not os.getenv("UIPATH_URL"):
+                tenants_and_organizations = self.get_tenants_and_organizations()
+                select_tenant(
+                    self.domain if self.domain else "alpha", tenants_and_organizations
+                )
 
         update_env_file(updated_env_contents)
 

uipath/_cli/_auth/_url_utils.py

@@ -1,6 +1,8 @@
 import os
 from urllib.parse import urlparse
 
+ignore_env_var = False
+
 
 def get_base_url(domain: str) -> str:
     """Get the base URL for UiPath services.
@@ -11,11 +13,14 @@ def get_base_url(domain: str) -> str:
     Returns:
         The base URL to use for UiPath services
     """
-    # If UIPATH_URL is set and domain is 'cloud' (default), use the base from UIPATH_URL
-    uipath_url = os.getenv("UIPATH_URL")
-    if uipath_url and domain == "cloud":
-        parsed_url = urlparse(uipath_url)
-        return f"{parsed_url.scheme}://{parsed_url.netloc}"
+    global ignore_env_var
+
+    if not ignore_env_var:
+        # If UIPATH_URL is set and domain is 'cloud' (default), use the base from UIPATH_URL
+        uipath_url = os.getenv("UIPATH_URL")
+        if uipath_url and domain == "cloud":
+            parsed_url = urlparse(uipath_url)
+            return f"{parsed_url.scheme}://{parsed_url.netloc}"
 
     # If domain is already a full URL, use it directly
     if domain.startswith("http"):
@@ -25,6 +30,11 @@ def get_base_url(domain: str) -> str:
     return f"https://{domain if domain else 'cloud'}.uipath.com"
 
 
+def set_force_flag(force: bool):
+    global ignore_env_var
+    ignore_env_var = force
+
+
 def build_service_url(domain: str, path: str) -> str:
     """Build a service URL by combining the base URL with a path.
 

uipath/_cli/_dev/_terminal/__init__.py

@@ -189,6 +189,8 @@ class UiPathDevTerminal(App[Any]):
 
         if not run.conversational:
             asyncio.create_task(self._execute_runtime(run))
+        else:
+            self._focus_chat_input()
 
     async def action_clear_history(self) -> None:
         """Clear run history."""
@@ -285,6 +287,13 @@ class UiPathDevTerminal(App[Any]):
         # Populate the details panel with run data
         details_panel.update_run(run)
 
+    def _focus_chat_input(self):
+        """Focus the chat input box."""
+        details_panel = self.query_one("#details-panel", RunDetailsPanel)
+        details_panel.switch_tab("chat-tab")
+        chat_input = details_panel.query_one("#chat-input", Input)
+        chat_input.focus()
+
     def _add_run_in_history(self, run: ExecutionRun):
         """Add run to history panel."""
         history_panel = self.query_one("#history-panel", RunHistoryPanel)

uipath/_cli/_dev/_terminal/_components/_details.py

@@ -292,7 +292,11 @@ class RunDetailsPanel(Container):
     def _rebuild_spans_tree(self):
         """Rebuild the spans tree from current run's traces."""
         spans_tree = self.query_one("#spans-tree", Tree)
-        spans_tree.clear()
+        if spans_tree is None or spans_tree.root is None:
+            return
+
+        spans_tree.root.remove_children()
+
         # Only clear the node mapping since we're rebuilding the tree structure
         self.span_tree_nodes.clear()
 

uipath/_cli/_evals/_models/_agent_execution_output.py

@@ -0,0 +1,14 @@
+from opentelemetry.sdk.trace import ReadableSpan
+from pydantic import BaseModel, ConfigDict
+
+from uipath._cli._runtime._contracts import UiPathRuntimeResult
+
+
+class UiPathEvalRunExecutionOutput(BaseModel):
+    """Result of a single agent response."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    execution_time: float
+    spans: list[ReadableSpan]
+    result: UiPathRuntimeResult