feat(cli): serve uipath server over uipath-ipc only when --ipc-pipe is given alone [ROBO-6057]

Author: eduard-dumitru

packages/uipath/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.14.31"
+version = "2.14.32"
 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.11"

packages/uipath/src/uipath/_cli/cli_server.py

@@ -297,8 +297,8 @@ async def start_tcp_server(host: str, port: int) -> None:
 
 
 # The uipath-ipc transport (contract, DTOs, service, ``start_ipc_server``) lives
-# in ``cli_server_ipc`` and is served alongside HTTP when ``--ipc-pipe`` is given.
-# Older servers served HTTP only; the .NET Handler copes.
+# in ``cli_server_ipc``. ``--ipc-pipe`` alone serves it alone; with any HTTP option it
+# is served alongside HTTP. Older servers served HTTP only; the .NET Handler copes.
 
 
 # --------------------------------------------------------------------------- #
@@ -324,8 +324,9 @@ async def start_tcp_server(host: str, port: int) -> None:
     "--ipc-pipe",
     type=str,
     default=None,
-    help="Named pipe for the uipath-ipc channel. IPC is served only when this is "
-    "given; omit it for HTTP-only.",
+    help="Named pipe for the uipath-ipc channel. Given alone, only uipath-ipc is "
+    "served: no HTTP listener and no ready ACK. Given with any HTTP option, HTTP is "
+    "served as well.",
 )
 @click.option(
     "--port",
@@ -346,7 +347,7 @@ def server(
     port: int | None,
     tcp: bool,
 ) -> None:
-    """Serve run/debug/eval over HTTP, plus uipath-ipc when --ipc-pipe is given."""
+    """Serve run/debug/eval over HTTP, uipath-ipc (--ipc-pipe alone), or both."""
     preload_modules()
     _run_server(client_socket, server_socket, ipc_pipe, port, tcp)
 
@@ -357,15 +358,18 @@ async def _serve(
     ipc_pipe: str | None,
     port: int,
     use_tcp: bool,
+    serve_http: bool = True,
 ) -> None:
-    """Run the HTTP channel, plus the uipath-ipc channel when a pipe name is given."""
+    """Run the HTTP channel unless told not to, plus uipath-ipc when a pipe is named."""
     _state.init()
 
     tasks: list[Any] = []
-    if use_tcp:
-        tasks.append(start_tcp_server("127.0.0.1", port))
-    else:
-        tasks.append(start_unix_server(ack_socket_path, server_socket))
+    if serve_http:
+        tasks.append(
+            start_tcp_server("127.0.0.1", port)
+            if use_tcp
+            else start_unix_server(ack_socket_path, server_socket)
+        )
 
     # IPC is opt-in and independent of the HTTP socket: it is served only when an
     # explicit pipe name is given, which both sides agree on out of band (the .NET
@@ -384,12 +388,21 @@ def _run_server(
     tcp: bool,
 ) -> None:
     """Drive ``_serve`` on the right event loop for the platform."""
+    # Any HTTP option means the caller expects the HTTP channel (and, on Unix, its ACK).
+    serve_http = not ipc_pipe or any(
+        (client_socket is not None, server_socket is not None, port is not None, tcp)
+    )
     use_tcp = IS_WINDOWS or tcp
     ack_socket_path = (
         client_socket or os.environ.get(SOCKET_ENV_VAR) or DEFAULT_SOCKET_PATH
     )
     coro = _serve(
-        ack_socket_path, server_socket, ipc_pipe, port or DEFAULT_PORT, use_tcp
+        ack_socket_path,
+        server_socket,
+        ipc_pipe,
+        port or DEFAULT_PORT,
+        use_tcp,
+        serve_http,
     )
     try:
         if sys.platform == "win32":

packages/uipath/tests/cli/test_server_transport.py

@@ -1,10 +1,10 @@
-"""`uipath server` serves BOTH transports concurrently — never either/or.
+"""`uipath server` serves HTTP, plus uipath-ipc when a pipe is named.
 
-The HTTP channel (aiohttp over a Unix socket, or TCP on Windows / ``--tcp``) is
-ALWAYS started. The uipath-ipc named-pipe channel is opt-in and independent of the
-HTTP socket: it is started alongside HTTP only when ``--ipc-pipe`` names a pipe,
-served verbatim on that name (both sides agree on it out of band). The HTTP channel
-is never torn down.
+The uipath-ipc named-pipe channel is opt-in: it is started when ``--ipc-pipe`` names
+a pipe, served verbatim on that name (both sides agree on it out of band). The HTTP
+channel (aiohttp over a Unix socket, or TCP on Windows / ``--tcp``) is started
+unless ``--ipc-pipe`` is given without any HTTP option (``--client-socket``,
+``--server-socket``, ``--port``, ``--tcp``).
 
 These tests stub the three channel runners (so ``_serve``'s ``asyncio.gather``
 returns at once instead of serving forever) and assert which channels ``_serve``
@@ -15,6 +15,7 @@
 import asyncio
 from typing import Any
 
+import pytest
 from click.testing import CliRunner
 
 import uipath._cli._telemetry as _telemetry
@@ -97,6 +98,14 @@ def test_serve_rides_ipc_alongside_tcp(monkeypatch):
     assert calls["ipc"] == "agent.pipe"  # IPC rides next to TCP too, not only UDS
 
 
+def test_serve_without_http_runs_ipc_only(monkeypatch):
+    calls = _stub_channels(monkeypatch)
+    asyncio.run(
+        cli_server._serve("/tmp/ack.sock", None, "agent.pipe", 8765, True, False)
+    )
+    assert calls == {"ipc": "agent.pipe"}
+
+
 def test_serve_skips_ipc_without_ipc_pipe(monkeypatch):
     """No ``--ipc-pipe`` ⇒ HTTP only, regardless of the HTTP socket."""
     calls = _stub_channels(monkeypatch)
@@ -118,13 +127,16 @@ def _capture_serve(monkeypatch) -> dict[str, Any]:
     Linux) without actually serving anything."""
     seen: dict[str, Any] = {}
 
-    async def _rec_serve(ack_socket_path, server_socket, ipc_pipe, port, use_tcp):
+    async def _rec_serve(
+        ack_socket_path, server_socket, ipc_pipe, port, use_tcp, serve_http=True
+    ):
         seen.update(
             ack=ack_socket_path,
             server_socket=server_socket,
             ipc_pipe=ipc_pipe,
             port=port,
             use_tcp=use_tcp,
+            serve_http=serve_http,
         )
 
     monkeypatch.setattr(cli_server, "_serve", _rec_serve)
@@ -157,6 +169,39 @@ def test_run_server_falls_back_to_default_ack(monkeypatch):
     assert seen["ack"] == cli_server.DEFAULT_SOCKET_PATH
 
 
+def test_run_server_bare_ipc_pipe_serves_ipc_only(monkeypatch):
+    seen = _capture_serve(monkeypatch)
+    cli_server._run_server(None, None, "agent.pipe", None, False)
+    assert seen["serve_http"] is False
+    assert seen["ipc_pipe"] == "agent.pipe"
+
+
+@pytest.mark.parametrize(
+    "client_socket, server_socket, port, tcp",
+    [
+        ("/tmp/ack.sock", None, None, False),
+        (None, "/tmp/s.sock", None, False),
+        (None, None, 9000, False),
+        (None, None, None, True),
+        ("/tmp/ack.sock", "/tmp/s.sock", None, False),
+    ],
+)
+def test_run_server_any_http_option_keeps_http(
+    monkeypatch, client_socket, server_socket, port, tcp
+):
+    seen = _capture_serve(monkeypatch)
+    cli_server._run_server(client_socket, server_socket, "agent.pipe", port, tcp)
+    assert seen["serve_http"] is True
+    assert seen["ipc_pipe"] == "agent.pipe"
+
+
+@pytest.mark.parametrize("ipc_pipe", [None, ""])
+def test_run_server_without_ipc_pipe_serves_http(monkeypatch, ipc_pipe):
+    seen = _capture_serve(monkeypatch)
+    cli_server._run_server(None, None, ipc_pipe, None, False)
+    assert seen["serve_http"] is True
+
+
 def test_run_server_tcp_flag_forces_tcp(monkeypatch):
     seen = _capture_serve(monkeypatch)
     cli_server._run_server("/tmp/a.sock", "/tmp/s.sock", None, None, True)