zrb 1.8.2__py3-none-any.whl → 1.8.3__py3-none-any.whl

zrb/__main__.py

@@ -60,8 +60,9 @@ def serve_cli():
         # run the CLI
         cli.run(sys.argv[1:])
     except KeyboardInterrupt:
+        # The exception is handled by the task runner
         print(stylize_warning("\nStopped"), file=sys.stderr)
-        sys.exit(1)
+        pass
     except RuntimeError as e:
         if f"{e}".lower() != "event loop is closed":
             raise e

zrb/builtin/setup/asdf/asdf.py

@@ -22,6 +22,7 @@ install_asdf_prerequisites = CmdTask(
     name="install-asdf-prerequisites",
     input=[package_manager_input, use_sudo_input],
     cmd=get_install_prerequisites_cmd,
+    is_interactive=True,
 )
 
 

zrb/builtin/setup/tmux/tmux.py

@@ -13,6 +13,7 @@ install_tmux = CmdTask(
     name="install-tmux",
     input=[package_manager_input, use_sudo_input],
     cmd=get_install_tmux_cmd,
+    is_interactive=True,
 )
 
 

zrb/builtin/setup/ubuntu.py

@@ -1,10 +1,18 @@
 from zrb.builtin.group import setup_group
 from zrb.task.cmd_task import CmdTask
 
-update_ubuntu = CmdTask(name="update-ubuntu", cmd="sudo apt update", render_cmd=False)
+update_ubuntu = CmdTask(
+    name="update-ubuntu",
+    cmd="sudo apt update",
+    render_cmd=False,
+    is_interactive=True,
+)
 
 upgrade_todo = CmdTask(
-    name="upgrade-ubuntu", cmd="sudo apt upgrade -y", render_cmd=False
+    name="upgrade-ubuntu",
+    cmd="sudo apt upgrade -y",
+    render_cmd=False,
+    is_interactive=True,
 )
 update_ubuntu >> upgrade_todo
 
@@ -22,6 +30,7 @@ setup_ubuntu = setup_group.add_task(
             "cmake make tree tmux zsh neovim xdotool xsel",
         ],
         render_cmd=False,
+        is_interactive=True,
     ),
     alias="ubuntu",
 )

zrb/builtin/setup/zsh/zsh.py

@@ -13,6 +13,7 @@ install_zsh = CmdTask(
     name="install-zsh",
     input=[package_manager_input, use_sudo_input],
     cmd=get_install_zsh_cmd,
+    is_interactive=True,
 )
 
 install_omz = CmdTask(

zrb/session/session.py

@@ -51,9 +51,9 @@ class Session(AnySession):
         self._shared_ctx = shared_ctx
         self._shared_ctx.set_session(self)
         self._parent = parent
-        self._action_coros: dict[AnyTask, Coroutine] = {}
-        self._monitoring_coros: dict[AnyTask, Coroutine] = {}
-        self._coros: list[Coroutine] = []
+        self._action_coros: dict[AnyTask, asyncio.Task] = {}
+        self._monitoring_coros: dict[AnyTask, asyncio.Task] = {}
+        self._coros: list[asyncio.Task] = []
         self._colors = [
             GREEN,
             YELLOW,
@@ -100,6 +100,12 @@ class Session(AnySession):
         self._is_terminated = True
         for task_status in self._task_status.values():
             task_status.mark_as_terminated()
+        for task in self._action_coros.values():
+            task.cancel()
+        for task in self._monitoring_coros.values():
+            task.cancel()
+        for task in self._coros:
+            task.cancel()
 
     @property
     def is_terminated(self) -> bool:
@@ -180,16 +186,17 @@ class Session(AnySession):
 
     def defer_monitoring(self, task: AnyTask, coro: Coroutine):
         self._register_single_task(task)
-        self._monitoring_coros[task] = coro
+        self._monitoring_coros[task] = asyncio.create_task(coro)
 
     def defer_action(self, task: AnyTask, coro: Coroutine):
         self._register_single_task(task)
-        self._action_coros[task] = coro
+        self._action_coros[task] = asyncio.create_task(coro)
 
     def defer_coro(self, coro: Coroutine):
-        self._coros.append(coro)
+        task = asyncio.create_task(coro)
+        self._coros.append(task)
         self._coros = [
-            existing_coro for existing_coro in self._coros if not existing_coro.done()
+            existing_task for existing_task in self._coros if not existing_task.done()
         ]
 
     async def wait_deferred(self):

zrb/task/base/execution.py

@@ -175,8 +175,7 @@ async def execute_action_with_retry(task: "BaseTask", session: AnySession) -> An
             ctx.log_warning("Task cancelled or interrupted")
             session.get_task_status(task).mark_as_failed()  # Mark as failed on cancel
             # Do not trigger fallbacks/successors on cancellation
-            return  # Or re-raise? Depends on desired cancellation behavior
-
+            raise
         except BaseException as e:
             ctx.log_error(f"Attempt {attempt + 1}/{max_attempt} failed: {e}")
             session.get_task_status(

zrb/task/base/lifecycle.py

@@ -38,26 +38,30 @@ async def run_and_cleanup(
             ctx = task.get_ctx(session)  # Get context for logging
             ctx.log_info("Terminating session after run completion/error.")
             session.terminate()
-
         # Clean up other potentially running asyncio tasks (excluding the main one)
         # Be cautious with blanket cancellation if other background tasks are expected
-        pending = [
-            t for t in asyncio.all_tasks() if t is not main_task_coro and not t.done()
-        ]
-        if pending:
-            ctx = task.get_ctx(session)  # Get context for logging
-            ctx.log_debug(f"Cleaning up {len(pending)} pending asyncio tasks...")
-            for t in pending:
-                t.cancel()
-            try:
-                # Give cancelled tasks a moment to process cancellation
-                await asyncio.wait(pending, timeout=1.0)
-            except asyncio.CancelledError:
-                # Expected if tasks handle cancellation promptly
-                pass
-            except Exception as cleanup_exc:
-                # Log errors during cleanup if necessary
-                ctx.log_warning(f"Error during task cleanup: {cleanup_exc}")
+        try:
+            pending = [
+                t
+                for t in asyncio.all_tasks()
+                if t is not main_task_coro and not t.done()
+            ]
+            if pending:
+                ctx = task.get_ctx(session)  # Get context for logging
+                ctx.log_debug(f"Cleaning up {len(pending)} pending asyncio tasks...")
+                for t in pending:
+                    t.cancel()
+                try:
+                    # Give cancelled tasks a moment to process cancellation
+                    await asyncio.wait(pending, timeout=1.0)
+                except asyncio.CancelledError:
+                    # Expected if tasks handle cancellation promptly
+                    pass
+                except Exception as cleanup_exc:
+                    # Log errors during cleanup if necessary
+                    ctx.log_warning(f"Error during task cleanup: {cleanup_exc}")
+        except RuntimeError as cleanup_exc:
+            ctx.log_warning(f"Error during task cleanup: {cleanup_exc}")
 
 
 async def run_task_async(

zrb/task/cmd_task.py

@@ -48,6 +48,7 @@ class CmdTask(BaseTask):
         warn_unrecommended_command: bool | None = None,
         max_output_line: int = 1000,
         max_error_line: int = 1000,
+        is_interactive: bool = False,
         execute_condition: BoolAttr = True,
         retries: int = 2,
         retry_period: float = 0,
@@ -104,6 +105,7 @@ class CmdTask(BaseTask):
         self._max_error_line = max_error_line
         self._should_plain_print = plain_print
         self._should_warn_unrecommended_command = warn_unrecommended_command
+        self._is_interactive = is_interactive
 
     async def _exec_action(self, ctx: AnyContext) -> CmdResult:
         """Turn _cmd attribute into subprocess.Popen and execute it as task's action.
@@ -140,6 +142,7 @@ class CmdTask(BaseTask):
             register_pid_method=lambda pid: ctx.xcom.get(xcom_pid_key).push(pid),
             max_output_line=self._max_output_line,
             max_error_line=self._max_error_line,
+            is_interactive=self._is_interactive,
         )
         # Check for errors
         if return_code > 0:

zrb/util/cmd/command.py

@@ -1,8 +1,11 @@
 import asyncio
 import os
 import re
+import signal
 import sys
+from collections import deque
 from collections.abc import Callable
+from typing import TextIO
 
 import psutil
 
@@ -59,67 +62,112 @@ async def run_command(
     register_pid_method: Callable[[int], None] | None = None,
     max_output_line: int = 1000,
     max_error_line: int = 1000,
+    is_interactive: bool = False,
 ) -> tuple[CmdResult, int]:
-    async def __read_stream(
-        stream, print_method: Callable[..., None], max_lines: int
-    ) -> str:
-        lines = []
-        if hasattr(stream, "_limit"):
-            # The limit is set to 10 MB
-            stream._limit = 1024 * 1024 * 10
-        while True:
-            line = None
-            try:
-                line = await stream.readline()
-            except asyncio.exceptions.CancelledError:
-                pass
-            except asyncio.exceptions.LimitOverrunError as e:
-                # Recover by reading a limited chunk instead
-                await stream.read(e.consumed)
-                line = "<output line too long>"
-            except BaseException as e:
-                line = f"Error while reading stream {type(e)} {e}"
-                pass
-            if not line:
-                break
-            try:
-                line = line.decode("utf-8").rstrip()
-            except Exception:
-                pass
-            lines.append(line)
-            if len(lines) > max_lines:
-                lines.pop(0)  # Keep only the last max_lines
-            print_method(line)
-        return "\n".join(lines)
-
+    """
+    Executes a command using the robust `readline` strategy with a memory
+    limit, and correctly handles terminal control characters in the output.
+    Please note that `interactive` execution is generally not recommended and thus
+    disabled by default.
+    When using `interactive execution, the command will not be started in new session
+    and will share the same stdin as the main process, which might trigger race condition.
+    You can use interactive execution for a limited usecase when the command
+    require user input.
+    """
     actual_print_method = print_method if print_method is not None else print
-    cmd_process = None
     if cwd is None:
         cwd = os.getcwd()
-    if env_map is None:
-        env_map = os.environ
+    # While environment variables alone weren't the fix, they are still
+    # good practice for encouraging simpler output from tools.
+    child_env = (env_map or os.environ).copy()
+    child_env["TERM"] = "xterm-256color"  # A capable but standard terminal
+    child_env["NO_COLOR"] = "0"  # Explicitly allow color
     cmd_process = await asyncio.create_subprocess_exec(
         *cmd,
         cwd=cwd,
-        stdin=sys.stdin if sys.stdin.isatty() else None,
+        env=child_env,
+        start_new_session=not is_interactive,
+        stdin=__get_cmd_stdin(is_interactive),
         stdout=asyncio.subprocess.PIPE,
         stderr=asyncio.subprocess.PIPE,
-        env=env_map,
-        bufsize=0,
+        limit=10 * 10 * 1024,  # Buffer memory limit
     )
     if register_pid_method is not None:
         register_pid_method(cmd_process.pid)
+    # Use the new, simple, and correct stream reader.
     stdout_task = asyncio.create_task(
         __read_stream(cmd_process.stdout, actual_print_method, max_output_line)
     )
     stderr_task = asyncio.create_task(
         __read_stream(cmd_process.stderr, actual_print_method, max_error_line)
     )
-    # Wait for process to complete and gather stdout/stderr
-    return_code = await cmd_process.wait()
-    stdout = await stdout_task
-    stderr = await stderr_task
-    return CmdResult(stdout, stderr), return_code
+    try:
+        return_code = await cmd_process.wait()
+        stdout, stderr = await asyncio.gather(stdout_task, stderr_task)
+        return CmdResult(stdout, stderr), return_code
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        try:
+            os.killpg(cmd_process.pid, signal.SIGINT)
+            await asyncio.wait_for(cmd_process.wait(), timeout=2.0)
+        except asyncio.TimeoutError:
+            # If it doesn't terminate, kill it forcefully
+            actual_print_method(
+                f"Process {cmd_process.pid} did not terminate gracefully, killing."
+            )
+            kill_pid(cmd_process.pid, print_method=actual_print_method)
+        except Exception:
+            pass
+        # Final cleanup
+        stdout_task.cancel()
+        stderr_task.cancel()
+        await asyncio.gather(stdout_task, stderr_task, return_exceptions=True)
+        raise
+
+
+def __get_cmd_stdin(is_interactive: bool) -> int | TextIO:
+    if is_interactive and sys.stdin.isatty():
+        return sys.stdin
+    return asyncio.subprocess.DEVNULL
+
+
+async def __read_stream(
+    stream: asyncio.StreamReader,
+    print_method: Callable[..., None],
+    max_lines: int,
+) -> str:
+    """
+    Reads from the stream using the robust `readline()` and correctly
+    interprets carriage returns (`\r`) as distinct print events.
+    """
+    captured_lines = deque(maxlen=max_lines if max_lines > 0 else 0)
+    while True:
+        try:
+            line_bytes = await stream.readline()
+            if not line_bytes:
+                break
+        except ValueError:
+            # Safety valve for the memory limit.
+            error_msg = "[ERROR] A single line of output was too long to process."
+            print_method(error_msg)
+            if max_lines > 0:
+                captured_lines.append(error_msg)
+            break
+        except (KeyboardInterrupt, asyncio.CancelledError):
+            raise
+        except Exception:
+            break
+        decoded_line = line_bytes.decode("utf-8", errors="replace")
+        parts = decoded_line.replace("\r", "\n").splitlines()
+        for part in parts:
+            clean_part = part.rstrip()
+            if clean_part:
+                try:
+                    print_method(clean_part, end="\r\n")
+                except Exception:
+                    print_method(clean_part)
+                if max_lines > 0:
+                    captured_lines.append(clean_part)
+    return "\r\n".join(captured_lines)
 
 
 def kill_pid(pid: int, print_method: Callable[..., None] | None = None):
@@ -132,10 +180,13 @@ def kill_pid(pid: int, print_method: Callable[..., None] | None = None):
             Defaults to the built-in print function.
     """
     actual_print_method = print_method if print_method is not None else print
-    parent = psutil.Process(pid)
-    children = parent.children(recursive=True)
-    for child in children:
-        actual_print_method(f"Killing child process {child.pid}")
-        child.terminate()
-    actual_print_method(f"Killing process {pid}")
-    parent.terminate()
+    try:
+        parent = psutil.Process(pid)
+        children = parent.children(recursive=True)
+        for child in children:
+            actual_print_method(f"Killing child process {child.pid}")
+            child.kill()
+        actual_print_method(f"Killing process {pid}")
+        parent.kill()
+    except psutil.NoSuchProcess:
+        actual_print_method(f"Process with pid: {pid} already terminated")

{zrb-1.8.2.dist-info → zrb-1.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.8.2
+Version: 1.8.3
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -194,31 +194,35 @@ Then open your browser and visit `http://localhost:21213`
 ![Zrb Web UI](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/zrb-web-ui.png)
 
 
-# 🐋 As Container
+# 🐋 Running Zrb as a Container
 
-Zrb has two version of container:
-- The normal version
-- The dind (Docker in Docker) version
+Zrb can be run in a containerized environment, offering two distinct versions to suit different needs:
 
-The dind version has builtin docker command, and is suitable to access host's docker CLI command.
+- **Standard Version**: Ideal for general use cases where Docker CLI access is not required.
+- **Dind (Docker in Docker) Version**: Includes built-in Docker commands, perfect for scenarios where you need to access the host's Docker CLI.
 
-To run the normal version, you can execute:
+### Standard Version
+
+The standard version of the Zrb container is suitable for most automation tasks. To run this version, execute the following command:
 
 ```bash
-# docker run -v <host-path>:<container-path> -it stalchmst/zrb:<version> <command>
+# Replace <host-path> and <container-path> with your desired paths
 docker run -v ${HOME}:/zrb-home -it --rm stalchmst/zrb:1.8.1 zrb
 ```
 
-While to run the dind version, you can execute:
+### Dind Version
+
+The Dind version is tailored for advanced use cases where Docker commands need to be executed within the container. This version allows the container to interact with the host's Docker daemon. To run the Dind version, use the command below:
 
 ```bash
-# docker run -v <host-path>:<container-path> -it stalchmst/zrb:<version>-dind <command>
+# Replace <host-path> and <container-path> with your desired paths
 docker run \
     -v ${HOME}:/zrb-home \
     -v /var/run/docker.sock:/var/run/docker.sock \
     -it --rm stalchmst/zrb:1.8.1-dind docker ps
 ```
 
+> **Note:** The Dind (Docker in Docker) version of the container is larger in size compared to the standard version due to the inclusion of Docker CLI tools. Consider this when choosing the appropriate version for your needs.
 
 # 🎥 Demo & Documentation
 

{zrb-1.8.2.dist-info → zrb-1.8.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 zrb/__init__.py,sha256=e0fZglzFsjO-jz0HhHaBV5Vm0e3MZJBtXcrgDOPESB0,3103
-zrb/__main__.py,sha256=Kr_AkgmwBEycQcPVkZmrNh4hp2g62G-7ZXeOhJg0Qis,2603
+zrb/__main__.py,sha256=aeIpBjlLef8bfdp0CYumnn5jVkHDPS5bwAxfuCJVUNI,2650
 zrb/attr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/attr/type.py,sha256=4TV5gPYMMrKh5V-yB6iRYKCbsXAH_AvGXMsjxKLHcUs,568
 zrb/builtin/__init__.py,sha256=N-h-BoXWv0jYOldixXwgk6ekiWtrGZsGv57iqonsYdc,2657
@@ -192,15 +192,15 @@ zrb/builtin/project/create/project-template/zrb_init.py,sha256=kY0x5MrkIVl3l1GtN
 zrb/builtin/project/create/project_task.py,sha256=az-yd2FRDmGZ_7qxslmW11ryTeI3yttRmXtlFnZhF00,1132
 zrb/builtin/python.py,sha256=e-yyVWovwlxCBLyXGsd9Ek3IAL_X-Q_hpNNOPoRjOgk,349
 zrb/builtin/random.py,sha256=p9kCvosSiSJyuGQrlrXuIQT8TRDGxXhfiUbsm3GFPd0,1793
-zrb/builtin/setup/asdf/asdf.py,sha256=n_dWoyYa7vZ9tBCy8hgxmSWZ-XHltC1R70mIVZQhnXY,2419
+zrb/builtin/setup/asdf/asdf.py,sha256=_k60yiRiKbRPh_eJVI4Nx_ZmmClOlOb9G0b0KhSGo1M,2444
 zrb/builtin/setup/asdf/asdf_helper.py,sha256=6jARtyIAE1H82HKVQ84D25RrMAsAip_gD28X9ZlaTCk,1205
 zrb/builtin/setup/common_input.py,sha256=zIVVsZsNlSoV2Fw8kyt7g5B8XAU8cWBsT865NPoddwo,848
 zrb/builtin/setup/latex/ubuntu.py,sha256=er9wJAT4CpmghIaiIPFb3FvgqAn1aqU5UgX7GHL3FjA,577
-zrb/builtin/setup/tmux/tmux.py,sha256=YaiZKQODsBDip2ya5pA02c2-lfLDU8VKGbeHwFWI43s,1403
+zrb/builtin/setup/tmux/tmux.py,sha256=cV-azDzLtNYtwxucmYqpPqoeSVz3lxP2GOc1-I1yhKs,1428
 zrb/builtin/setup/tmux/tmux_config.sh,sha256=wQCb4Q-mNkxIPOcvpN84X9RUWkGY16u3Vd-pOhVidgg,416
 zrb/builtin/setup/tmux/tmux_helper.py,sha256=M03l0wfL25TzGGp6lnVfX40ayT_x7N2lz-nz2chO7PU,396
-zrb/builtin/setup/ubuntu.py,sha256=oOSN7Eq7arEpY2i0vWHPR2owio6dqqOvceteYrgmbYw,1019
-zrb/builtin/setup/zsh/zsh.py,sha256=b9_UDSJpOT246RiL5BNr6N1jqNHzoUQircZ_u6dkU5g,1820
+zrb/builtin/setup/ubuntu.py,sha256=N4F55xzWKy0Hm115Qr19BADO29thDN7HB5myUaHZDBQ,1122
+zrb/builtin/setup/zsh/zsh.py,sha256=wy7WSYIie6GprCqH4J2ygcTjWdOeRnxmOZcz8fRykcg,1845
 zrb/builtin/setup/zsh/zsh_config.sh,sha256=SRkcXvVT3tdfS1UDT0-dSj2PKXPLohhyakY6tUEQPjc,4764
 zrb/builtin/setup/zsh/zsh_helper.py,sha256=1zF1FH0oEPVAVhMA20tsdk1H0RPMCkLusYX8twsTbGI,393
 zrb/builtin/shell/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -315,7 +315,7 @@ zrb/runner/web_util/token.py,sha256=6Yqp6mQJJMAOsSkAN-6dvtdiQbAv5xtll9jOmNYzbUY,
 zrb/runner/web_util/user.py,sha256=vE61pDjHoaHw9K0YAv1Gu2zWX2WkM2aWG-8776_aAiM,2061
 zrb/session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/session/any_session.py,sha256=x57mS15E-AfUjdVxwOWEzCBjW32zjer7WoeBw0guoDc,5266
-zrb/session/session.py,sha256=aDaLV1tuE7PhcC17LMk6c7KiSs7yX7QXI9O-Z4MMZO8,9967
+zrb/session/session.py,sha256=wkWwueMotpbXaMew1JKil4QMR3UbcBbx4IAZWKSFYjY,10272
 zrb/session_state_log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/session_state_log/session_state_log.py,sha256=VVghDMU72PbrvnzQ7MJuc-KTJ5P5fX0FYuCh3Rlwd9M,709
 zrb/session_state_logger/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -326,13 +326,13 @@ zrb/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/task/any_task.py,sha256=zklUjkLRQ62TEvfnOUUYfXChj8Zk4igee3w8V3_rN08,5846
 zrb/task/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/task/base/context.py,sha256=73k3fKwup0AJwTTLpay0f_-axJextaxgbTem4w4Bmas,3670
-zrb/task/base/execution.py,sha256=lB6cfivk-EM6sZSaPjYs_ufb7jb-A2jLJNhBupwBFgI,11101
-zrb/task/base/lifecycle.py,sha256=YIugyqRmEKMnc9MTCDEZr9jVhie3Kwt7LTMtAVAN9Ks,7278
+zrb/task/base/execution.py,sha256=scDLfNYBe8Bc8Ct1LCIKmFtjpPxm7FjqZ2bJXIQAzv8,11042
+zrb/task/base/lifecycle.py,sha256=4tGeN9yE5sQt1lHYq-1_vOFSGk1z8JneNCbVUWFVm-Q,7507
 zrb/task/base/monitoring.py,sha256=UAOEcPiYNtZR4FFxzWCosuOEFE_P3c4GT5vAhQmohqI,5663
 zrb/task/base/operators.py,sha256=uAMFqpZJsPnCrojgOl1FUDXTS15mtOa_IqiAXltyYRU,1576
 zrb/task/base_task.py,sha256=Y5JNzU6Y1E8RKGdj16HTlhny0v8N2I98GCA4D8h6Kmw,10962
 zrb/task/base_trigger.py,sha256=WSGcmBcGAZw8EzUXfmCjqJQkz8GEmi1RzogpF6A1V4s,6902
-zrb/task/cmd_task.py,sha256=3JFkWZEhyrQAwbQJs2pgICBmkohUR9T-hjXw82JyNtA,10720
+zrb/task/cmd_task.py,sha256=irGi0txTcsvGhxjfem4_radR4csNXhgtfcxruSF1LFI,10853
 zrb/task/http_check.py,sha256=Gf5rOB2Se2EdizuN9rp65HpGmfZkGc-clIAlHmPVehs,2565
 zrb/task/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/task/llm/agent.py,sha256=6wGSsw03GdY_fj12CsJh7wxB6BnE13N8RYXaWfbiUsk,5451
@@ -361,7 +361,7 @@ zrb/util/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/util/cli/style.py,sha256=D_548KG1gXEirQGdkAVTc81vBdCeInXtnG1gV1yabBA,6655
 zrb/util/cli/subcommand.py,sha256=umTZIlrL-9g-qc_eRRgdaQgK-whvXK1roFfvnbuY7NQ,1753
 zrb/util/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/util/cmd/command.py,sha256=CsS6KKATOAmM9F482Ox5kVV8hRgFcueqvB5obEcJENs,5211
+zrb/util/cmd/command.py,sha256=WpEMWVL9hBsxptvDHmRR93_cJ2zP05BJ2h9-tP93M1Y,7473
 zrb/util/cmd/remote.py,sha256=NGQq2_IrUMDoZz3qmcgtnNYVGjMHaBKQpZxImf0yfXA,1296
 zrb/util/codemod/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/util/codemod/modification_mode.py,sha256=z_4U2gjskEHkFm6UtBe_Wbm-erufYaXgPbdCQ6CZMlw,128
@@ -388,7 +388,7 @@ zrb/util/string/name.py,sha256=SXEfxJ1-tDOzHqmSV8kvepRVyMqs2XdV_vyoh_9XUu0,1584
 zrb/util/todo.py,sha256=VGISej2KQZERpornK-8X7bysp4JydMrMUTnG8B0-liI,20708
 zrb/xcom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/xcom/xcom.py,sha256=o79rxR9wphnShrcIushA0Qt71d_p3ZTxjNf7x9hJB78,1571
-zrb-1.8.2.dist-info/METADATA,sha256=NRlAG2IfE1oZDH9CDlAn9hAaQ8Arn5ytoXyZ6pdDZBA,9086
-zrb-1.8.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-zrb-1.8.2.dist-info/entry_points.txt,sha256=-Pg3ElWPfnaSM-XvXqCxEAa-wfVI6BEgcs386s8C8v8,46
-zrb-1.8.2.dist-info/RECORD,,
+zrb-1.8.3.dist-info/METADATA,sha256=VMBmGEImGJOvME1Jr6IrdYEWexUsmYcmgh8kmhE-kT4,9760
+zrb-1.8.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+zrb-1.8.3.dist-info/entry_points.txt,sha256=-Pg3ElWPfnaSM-XvXqCxEAa-wfVI6BEgcs386s8C8v8,46
+zrb-1.8.3.dist-info/RECORD,,