soothe-cli 0.6.5__tar.gz → 0.6.7__tar.gz

{soothe_cli-0.6.5 → soothe_cli-0.6.7}/.gitignore

@@ -217,5 +217,4 @@ _bmad
 __MACOSX
 .qoder
 .soothe
-deploy/config.yml
 .backups/

{soothe_cli-0.6.5 → soothe_cli-0.6.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.6.5
+Version: 0.6.7
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/mirasoth/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io

soothe_cli-0.6.7/src/soothe_cli/cli/commands/status_cmd.py

@@ -0,0 +1,367 @@
+"""Daemon status CLI command for client-side validation.
+
+Provides lightweight status checks for the soothe daemon from the client side,
+useful for validating daemon connectivity before running commands.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from typing import Annotated, Any
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from soothe_sdk.client import WebSocketClient, is_daemon_live, websocket_url_from_config
+
+from soothe_cli.config.loader import load_config
+
+console = Console()
+
+# Create status command group
+status_app = typer.Typer(help="Check daemon and client status", no_args_is_help=False)
+
+
+async def _fetch_status(ws_url: str, timeout: float = 5.0) -> dict[str, Any]:
+    """Fetch daemon status via WebSocket RPC.
+
+    Args:
+        ws_url: WebSocket URL to connect to.
+        timeout: Request timeout in seconds.
+
+    Returns:
+        Status dict from daemon, or error dict on failure.
+    """
+    client = WebSocketClient(url=ws_url)
+    try:
+        await client.connect()
+        status = await client.fetch_daemon_status(timeout=timeout)
+        return status
+    except Exception as e:
+        return {"error": str(e)}
+    finally:
+        await client.close()
+
+
+async def _fetch_ready_state(ws_url: str, timeout: float = 5.0) -> dict[str, Any] | None:
+    """Fetch daemon readiness state via WebSocket handshake.
+
+    The daemon sends a daemon_ready message on connect with its state.
+
+    Args:
+        ws_url: WebSocket URL.
+        timeout: Timeout for handshake.
+
+    Returns:
+        daemon_ready message dict or None.
+    """
+    import websockets
+
+    try:
+        async with asyncio.timeout(timeout):
+            async with websockets.connect(ws_url) as ws:
+                # Read initial messages - daemon sends status then daemon_ready
+                for _ in range(3):
+                    msg = await ws.recv()
+                    data = json.loads(msg)
+                    if data.get("type") == "daemon_ready":
+                        return data
+    except Exception:
+        pass
+    return None
+
+
+def _render_connection_table(config: Any, ws_url: str) -> Table:
+    """Render connection settings table."""
+    table = Table(title="Connection Settings")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value", style="green")
+
+    table.add_row("WebSocket URL", ws_url)
+    table.add_row("Daemon Host", config.daemon_host)
+    table.add_row("Daemon Port", str(config.daemon_port))
+    table.add_row("Soothe Home", str(config.soothe_home))
+
+    return table
+
+
+def _render_daemon_table(
+    ws_url: str,
+    running: bool,
+    port_live: bool,
+    active_threads: int,
+    daemon_pid: int | None,
+    ready_state: dict[str, Any] | None = None,
+) -> Table:
+    """Render daemon status table."""
+    table = Table(title="Daemon Status")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value", style="green")
+
+    table.add_row("WebSocket URL", ws_url)
+    table.add_row("Running", "[green]Yes[/green]" if running else "[red]No[/red]")
+    table.add_row("Port Live", "[green]Yes[/green]" if port_live else "[red]No[/red]")
+    table.add_row("Active Threads", str(active_threads))
+    if daemon_pid:
+        table.add_row("Daemon PID", str(daemon_pid))
+
+    if ready_state:
+        state = ready_state.get("state", "unknown")
+        state_color = {
+            "ready": "green",
+            "degraded": "yellow",
+            "error": "red",
+            "starting": "blue",
+            "warming": "blue",
+            "stopped": "dim",
+        }.get(state, "white")
+        table.add_row("Readiness", f"[{state_color}]{state}[/{state_color}]")
+        if ready_state.get("message"):
+            table.add_row("Message", ready_state["message"])
+
+    return table
+
+
+@status_app.command("daemon")
+def daemon_status(
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Output as JSON."),
+    ] = False,
+    verbose: Annotated[
+        bool,
+        typer.Option("--verbose", "-v", help="Show detailed status."),
+    ] = False,
+) -> None:
+    """Check daemon status from client side.
+
+    Validates that the soothe daemon is running and responsive.
+
+    Examples:
+        soothe status daemon
+        soothe status daemon --json
+        soothe status daemon -v
+    """
+    config = load_config()
+    ws_url = websocket_url_from_config(config)
+
+    # Quick liveness check
+    live = asyncio.run(is_daemon_live(ws_url, timeout=5.0))
+
+    if not live:
+        if json_output:
+            console.print_json(
+                json.dumps(
+                    {
+                        "status": "not_running",
+                        "websocket_url": ws_url,
+                        "message": "Daemon not reachable",
+                    }
+                )
+            )
+        else:
+            console.print(
+                Panel(
+                    f"WebSocket URL: {ws_url}\n"
+                    "Status: [red]Not running[/red]\n"
+                    "Hint: Start with 'soothed start'",
+                    title="Daemon Status",
+                    border_style="red",
+                )
+            )
+        sys.exit(1)
+
+    # Fetch detailed status
+    status = asyncio.run(_fetch_status(ws_url, timeout=5.0))
+
+    if "error" in status:
+        if json_output:
+            console.print_json(
+                json.dumps(
+                    {
+                        "status": "error",
+                        "websocket_url": ws_url,
+                        "error": status["error"],
+                    }
+                )
+            )
+        else:
+            console.print(
+                Panel(
+                    f"WebSocket URL: {ws_url}\nError: [red]{status['error']}[/red]",
+                    title="Daemon Status",
+                    border_style="red",
+                )
+            )
+        sys.exit(1)
+
+    # Get readiness state for verbose mode
+    ready_state = None
+    if verbose:
+        ready_state = asyncio.run(_fetch_ready_state(ws_url, timeout=5.0))
+
+    if json_output:
+        output = {
+            "status": "running",
+            "websocket_url": ws_url,
+            "running": status.get("running", True),
+            "port_live": status.get("port_live", True),
+            "active_threads": status.get("active_threads", 0),
+            "daemon_pid": status.get("daemon_pid"),
+        }
+        if ready_state:
+            output["readiness_state"] = ready_state.get("state", "unknown")
+            output["readiness_message"] = ready_state.get("message")
+        console.print_json(json.dumps(output))
+        return
+
+    # Render daemon status table
+    running = status.get("running", True)
+    port_live = status.get("port_live", True)
+    active_threads = status.get("active_threads", 0)
+    daemon_pid = status.get("daemon_pid")
+
+    table = _render_daemon_table(
+        ws_url, running, port_live, active_threads, daemon_pid, ready_state
+    )
+    console.print(table)
+
+
+@status_app.command("connection")
+def connection_status(
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Output as JSON."),
+    ] = False,
+) -> None:
+    """Check client-daemon connection settings.
+
+    Shows the WebSocket URL and connection parameters the CLI will use.
+
+    Examples:
+        soothe status connection
+        soothe status connection --json
+    """
+    config = load_config()
+    ws_url = websocket_url_from_config(config)
+
+    if json_output:
+        console.print_json(
+            json.dumps(
+                {
+                    "websocket_url": ws_url,
+                    "daemon_host": config.daemon_host,
+                    "daemon_port": config.daemon_port,
+                    "soothe_home": str(config.soothe_home),
+                }
+            )
+        )
+        return
+
+    table = _render_connection_table(config, ws_url)
+    console.print(table)
+
+
+@status_app.callback(invoke_without_command=True)
+def status_main(
+    ctx: typer.Context,
+    show_help: Annotated[
+        bool,
+        typer.Option("-h", "--help", is_flag=True, help="Show this message and exit."),
+    ] = False,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Output as JSON."),
+    ] = False,
+) -> None:
+    """Show overall daemon and connection status (default when no subcommand)."""
+    if show_help:
+        typer.echo(ctx.get_help())
+        raise typer.Exit(code=0)
+
+    if ctx.invoked_subcommand is not None:
+        return
+
+    config = load_config()
+    ws_url = websocket_url_from_config(config)
+
+    # Check daemon liveness
+    live = asyncio.run(is_daemon_live(ws_url, timeout=5.0))
+
+    if json_output:
+        output: dict[str, Any] = {
+            "daemon": {
+                "status": "running" if live else "not_running",
+                "websocket_url": ws_url,
+            },
+            "connection": {
+                "daemon_host": config.daemon_host,
+                "daemon_port": config.daemon_port,
+                "soothe_home": str(config.soothe_home),
+            },
+        }
+        if live:
+            status = asyncio.run(_fetch_status(ws_url, timeout=5.0))
+            if "error" not in status:
+                output["daemon"]["running"] = status.get("running", True)
+                output["daemon"]["port_live"] = status.get("port_live", True)
+                output["daemon"]["active_threads"] = status.get("active_threads", 0)
+                output["daemon"]["daemon_pid"] = status.get("daemon_pid")
+        console.print_json(json.dumps(output))
+        return
+
+    # Render combined status with tables
+    if not live:
+        console.print(
+            Panel(
+                f"WebSocket URL: {ws_url}\n"
+                f"Daemon Host: {config.daemon_host}\n"
+                f"Daemon Port: {config.daemon_port}\n"
+                f"Soothe Home: {config.soothe_home}\n\n"
+                "Daemon Status: [red]Not running[/red]\n"
+                "Hint: Start with 'soothed start'",
+                title="Soothe Status",
+                border_style="red",
+            )
+        )
+        sys.exit(1)
+
+    # Fetch detailed daemon status
+    status = asyncio.run(_fetch_status(ws_url, timeout=5.0))
+
+    if "error" in status:
+        console.print(
+            Panel(
+                f"WebSocket URL: {ws_url}\n"
+                f"Daemon Host: {config.daemon_host}\n"
+                f"Daemon Port: {config.daemon_port}\n"
+                f"Soothe Home: {config.soothe_home}\n\n"
+                f"Daemon Status: [red]Error[/red]\n"
+                f"Error: {status['error']}",
+                title="Soothe Status",
+                border_style="red",
+            )
+        )
+        sys.exit(1)
+
+    # Render both tables
+    connection_table = _render_connection_table(config, ws_url)
+    console.print(connection_table)
+
+    running = status.get("running", True)
+    port_live = status.get("port_live", True)
+    active_threads = status.get("active_threads", 0)
+    daemon_pid = status.get("daemon_pid")
+
+    daemon_table = _render_daemon_table(ws_url, running, port_live, active_threads, daemon_pid)
+    console.print(daemon_table)
+
+
+__all__ = [
+    "status_app",
+    "daemon_status",
+    "connection_status",
+]

{soothe_cli-0.6.5 → soothe_cli-0.6.7}/src/soothe_cli/cli/main.py

@@ -202,7 +202,9 @@ def main(
 
 from soothe_cli.cli.commands.autopilot_cmd import app as _autopilot_app  # noqa: E402
 from soothe_cli.cli.commands.loop_cmd import loop_app as _loop_app  # noqa: E402
+from soothe_cli.cli.commands.status_cmd import status_app as _status_app  # noqa: E402
 
+# status_app has custom default behavior (shows combined status), skip add_help_alias
 for _sub_app, _name in (
     (_loop_app, "loop"),
     (_autopilot_app, "autopilot"),
@@ -210,6 +212,9 @@ for _sub_app, _name in (
     add_help_alias(_sub_app)
     app.add_typer(_sub_app, name=_name)
 
+# status_app has its own callback for default behavior
+app.add_typer(_status_app, name="status")
+
 
 # ---------------------------------------------------------------------------
 # Help Command

{soothe_cli-0.6.5 → soothe_cli-0.6.7}/src/soothe_cli/tui/textual_adapter.py

@@ -564,6 +564,48 @@ def _resolve_step_widget_for_tool(
     return None
 
 
+def _fallback_ingest_subgraph_tool_on_step_card(
+    adapter: TextualUIAdapter,
+    router: StepTaskRouter,
+    *,
+    lookup_id: str,
+    display_key: str,
+    tool_name: str,
+    args: dict[str, Any],
+    raw_args: str = "",
+    ns_key: tuple[str, ...],
+) -> bool:
+    """Best-effort fallback when namespace routing cannot resolve a parent task.
+
+    This keeps subgraph tool activity visible on the step card (as orphan rows)
+    instead of dropping it entirely when task binding arrives late or never.
+    """
+    lookup = str(lookup_id or "").strip()
+    display = str(display_key or "").strip()
+    if not lookup:
+        return False
+    if is_inner_subgraph_task_tool_id(lookup):
+        return False
+    parsed_sid, type_code, _, _ = parse_unified_tool_call_id(lookup)
+    bound_step_id = parsed_sid or router.step_id_for_tool(lookup)
+    step_w = _resolve_step_widget_for_tool(
+        adapter,
+        router,
+        bound_step_id=bound_step_id,
+        ns_key=ns_key,
+    )
+    if step_w is None:
+        return False
+    row_id = lookup if type_code == "t" else (display or lookup)
+    if step_w.has_tool_call_row(row_id):
+        step_w.update_tool_args(row_id, args)
+    else:
+        step_w.add_tool_call(row_id, tool_name, args, raw_args=raw_args)
+    adapter._tool_to_step[row_id] = step_w
+    adapter._tool_display_by_call_id[row_id] = step_w
+    return True
+
+
 async def sync_pending_step_cards_from_plan(
     adapter: TextualUIAdapter,
     *,
@@ -912,7 +954,7 @@ async def apply_tool_call_wire_update(
 
     _merge_buf, display_key = canonical_subgraph_tool_ids(ns_key, tcid, task_scope=ts)
     if display_key:
-        router.try_route_subgraph_tool(
+        routed = router.try_route_subgraph_tool(
             ns_key=ns_key,
             lookup_id=tcid,
             display_key=display_key,
@@ -922,6 +964,16 @@ async def apply_tool_call_wire_update(
             tool_to_step=adapter._tool_to_step,
             tool_display_by_call_id=adapter._tool_display_by_call_id,
         )
+        if not routed:
+            _fallback_ingest_subgraph_tool_on_step_card(
+                adapter,
+                router,
+                lookup_id=tcid,
+                display_key=display_key,
+                tool_name=name,
+                args=display_args,
+                ns_key=ns_key,
+            )
     return True
 
 
@@ -2344,7 +2396,7 @@ async def execute_task_textual(
                                             ns_key, str(lookup_id), task_scope=ts_disp
                                         )
                                         display_key = display_key or str(lookup_id)
-                                        router.try_route_subgraph_tool(
+                                        routed = router.try_route_subgraph_tool(
                                             ns_key=ns_key,
                                             lookup_id=str(lookup_id),
                                             display_key=display_key,
@@ -2355,6 +2407,17 @@ async def execute_task_textual(
                                             tool_to_step=adapter._tool_to_step,
                                             tool_display_by_call_id=adapter._tool_display_by_call_id,
                                         )
+                                        if not routed:
+                                            _fallback_ingest_subgraph_tool_on_step_card(
+                                                adapter,
+                                                router,
+                                                lookup_id=str(lookup_id),
+                                                display_key=display_key,
+                                                tool_name=buffer_name,
+                                                args=parsed_args,
+                                                raw_args=raw_args_stream,
+                                                ns_key=ns_key,
+                                            )
 
                                 tool_call_buffers.pop(buffer_key, None)
 

{soothe_cli-0.6.5 → soothe_cli-0.6.7}/src/soothe_cli/tui/widgets/messages.py

@@ -1511,6 +1511,8 @@ class CognitionStepMessage(Vertical):
             return True
         if self._iter_task_delegation_rows():
             return True
+        if self._orphan_subgraph_tool_rows_for_preview():
+            return True
         return bool(self._main_agent_tool_rows_for_preview())
 
     @staticmethod
@@ -1529,6 +1531,43 @@ class CognitionStepMessage(Vertical):
         """Direct main-agent tool rows (excludes task delegations and subgraph tools)."""
         return [r for r in self._rows if self._row_counts_for_step_status_line(r)]
 
+    def _orphan_subgraph_tool_rows_for_preview(self) -> list[_StepToolRow]:
+        """Subgraph tool rows whose parent task delegation row is missing.
+
+        Some streams deliver ``t`` tool rows before/without a visible ``s:task`` row.
+        Keep these rows visible on the step card so users still see tool activity.
+        """
+        task_parent_ids: set[str] = set()
+        for task_row in self._iter_task_delegation_rows():
+            key = self._task_delegation_dedupe_key(task_row)
+            if key:
+                task_parent_ids.add(key)
+
+        out: list[_StepToolRow] = []
+        for row in self._rows:
+            if row.is_task_row:
+                continue
+            if not self._row_belongs_to_step(row):
+                continue
+            tcid = str(row.tool_call_id or "").strip()
+            if not tcid:
+                continue
+            if is_step_level_task_tool_id(tcid) or is_inner_subgraph_task_tool_id(tcid):
+                continue
+            parsed_sid, type_code, _, _ = parse_unified_tool_call_id(tcid)
+            if parsed_sid and parsed_sid != self._step_id:
+                continue
+
+            parent_id = str(row.parent_tool_call_id or "").strip()
+            if parent_id and is_step_level_task_tool_id(parent_id):
+                parent_id = normalize_step_task_tool_call_id(self._step_id, parent_id)
+            has_visible_parent = bool(parent_id and parent_id in task_parent_ids)
+
+            # Keep unresolved/unparented task-subgraph tool rows visible.
+            if type_code == "t" and not has_visible_parent:
+                out.append(row)
+        return out
+
     def _append_tool_activity_lines(
         self,
         parts: list[object],
@@ -1927,7 +1966,8 @@ class CognitionStepMessage(Vertical):
 
         task_rows = self._iter_task_delegation_rows()
         main_preview = self._latest_preview_rows(self._main_agent_tool_rows_for_preview())
-        if not task_rows and not main_preview and not self._subagent_notes:
+        orphan_preview = self._latest_preview_rows(self._orphan_subgraph_tool_rows_for_preview())
+        if not task_rows and not main_preview and not orphan_preview and not self._subagent_notes:
             if not self._subagent_notes_by_task:
                 return Content("")
 
@@ -2009,6 +2049,17 @@ class CognitionStepMessage(Vertical):
                 animate_running=self._status == "running",
             )
 
+        if orphan_preview:
+            first_block = False
+            self._append_tool_activity_lines(
+                parts,
+                orphan_preview,
+                gutter=branch_gutter,
+                g=g,
+                colors=colors,
+                animate_running=self._status == "running",
+            )
+
         for note in self._subagent_notes:
             t = (note or "").strip()
             if not t: