Merge pull request #686 from UiPath/fix/auth-port-binding

Author: radugheo

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.81"
+version = "2.1.82"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

src/uipath/_cli/_auth/_auth_server.py

@@ -7,8 +7,6 @@
 import time
 from typing import Optional
 
-from ._oidc_utils import OidcUtils
-
 # Server port
 PORT = 6234
 
@@ -22,7 +20,9 @@ def __init__(self, token_data):
         super().__init__("Token received successfully")
 
 
-def make_request_handler_class(state, code_verifier, token_callback, domain):
+def make_request_handler_class(
+    state, code_verifier, token_callback, domain, redirect_uri, client_id
+):
     class SimpleHTTPSRequestHandler(http.server.SimpleHTTPRequestHandler):
         """Simple HTTPS request handler that serves static files."""
 
@@ -73,16 +73,10 @@ def do_GET(self):
                 with open(index_path, "r") as f:
                     content = f.read()
 
-                # Get the redirect URI from auth config
-                auth_config = OidcUtils.get_auth_config()
-                redirect_uri = auth_config["redirect_uri"]
-
                 content = content.replace("__PY_REPLACE_EXPECTED_STATE__", state)
                 content = content.replace("__PY_REPLACE_CODE_VERIFIER__", code_verifier)
                 content = content.replace("__PY_REPLACE_REDIRECT_URI__", redirect_uri)
-                content = content.replace(
-                    "__PY_REPLACE_CLIENT_ID__", auth_config["client_id"]
-                )
+                content = content.replace("__PY_REPLACE_CLIENT_ID__", client_id)
                 content = content.replace("__PY_REPLACE_DOMAIN__", domain)
 
                 self.send_response(200)
@@ -107,14 +101,18 @@ def do_OPTIONS(self):
 
 
 class HTTPServer:
-    def __init__(self, port=6234):
+    def __init__(self, port=6234, redirect_uri=None, client_id=None):
         """Initialize HTTP server with configurable parameters.
 
         Args:
             port (int, optional): Port number to run the server on. Defaults to 6234.
+            redirect_uri (str, optional): OAuth redirect URI. Defaults to None.
+            client_id (str, optional): OAuth client ID. Defaults to None.
         """
         self.current_path = os.path.dirname(os.path.abspath(__file__))
         self.port = port
+        self.redirect_uri = redirect_uri
+        self.client_id = client_id
         self.httpd: Optional[socketserver.TCPServer] = None
         self.token_data = None
         self.should_shutdown = False
@@ -145,7 +143,12 @@ def create_server(self, state, code_verifier, domain):
         # Create server with address reuse
         socketserver.TCPServer.allow_reuse_address = True
         handler = make_request_handler_class(
-            state, code_verifier, self.token_received_callback, domain
+            state,
+            code_verifier,
+            self.token_received_callback,
+            domain,
+            self.redirect_uri,
+            self.client_id,
         )
         self.httpd = socketserver.TCPServer(("", self.port), handler)
         return self.httpd

src/uipath/_cli/_auth/_auth_service.py

@@ -121,11 +121,17 @@ def _can_reuse_existing_token(self, portal_service: PortalService) -> bool:
         return False
 
     def _perform_oauth_flow(self) -> TokenData:
-        auth_url, code_verifier, state = OidcUtils.get_auth_url(self._domain)
+        auth_config = OidcUtils.get_auth_config()
+        auth_url, code_verifier, state = OidcUtils.get_auth_url(
+            self._domain, auth_config
+        )
         self._open_browser(auth_url)
 
-        auth_config = OidcUtils.get_auth_config()
-        server = HTTPServer(port=auth_config["port"])
+        server = HTTPServer(
+            port=auth_config["port"],
+            redirect_uri=auth_config["redirect_uri"],
+            client_id=auth_config["client_id"],
+        )
         token_data = asyncio.run(server.start(state, code_verifier, self._domain))
 
         if not token_data:

src/uipath/_cli/_auth/_oidc_utils.py

@@ -49,12 +49,8 @@ def get_auth_config(cls) -> AuthConfig:
         ) as f:
             auth_config = json.load(f)
 
-        candidates = [
-            int(auth_config.get("port", 8104)),
-            int(auth_config.get("portOptionOne", 8104)),
-            int(auth_config.get("portOptionTwo", 8055)),
-            int(auth_config.get("portOptionThree", 42042)),
-        ]
+        custom_port = os.getenv("UIPATH_AUTH_PORT")
+        candidates = [int(custom_port)] if custom_port else [8104, 8055, 42042]
 
         port = cls._find_free_port(candidates)
         if port is None:
@@ -75,19 +71,19 @@ def get_auth_config(cls) -> AuthConfig:
         )
 
     @classmethod
-    def get_auth_url(cls, domain: str) -> tuple[str, str, str]:
+    def get_auth_url(cls, domain: str, auth_config: AuthConfig) -> 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')
+            auth_config (AuthConfig): The authentication configuration to use
 
         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"],