coding-agent-wrapper 0.1.0__py3-none-any.whl

caw/auth/status.py

@@ -0,0 +1,241 @@
+"""Display status of auth files — symlink state, token expiry, last modified."""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+from .manifest import Manifest
+
+console = Console()
+
+AUTH_DIR = Path.home() / ".caw" / "auth"
+
+
+@dataclass
+class AuthFileStatus:
+    """Status of a single managed auth file."""
+
+    agent: str
+    file: str  # host_original relative path
+    type: str  # "credential" or "config"
+    strategy: str  # "symlink" or "copy"
+    symlink_state: str  # "linked", "wrong_target", "not_linked", "missing", "n/a"
+    exists: bool  # whether the canonical file exists in auth dir
+    token_expiry: str | None  # human-readable token info, or None
+
+
+def _check_token_expiry(auth_dir: Path, agent_name: str) -> str | None:
+    """Check token expiry for known agents. Returns human-readable status or None."""
+    try:
+        if agent_name == "claude":
+            cred_path = auth_dir / "claude" / "credentials.json"
+            if cred_path.exists():
+                with open(cred_path) as f:
+                    creds = json.load(f)
+                expires_at = creds.get("claudeAiOauth", {}).get("expiresAt")
+                if expires_at:
+                    dt = datetime.fromtimestamp(expires_at / 1000, tz=timezone.utc)
+                    now = datetime.now(timezone.utc)
+                    if dt < now:
+                        delta = now - dt
+                        return f"EXPIRED ({_format_delta(delta)} ago)"
+                    else:
+                        delta = dt - now
+                        return f"valid ({_format_delta(delta)} remaining)"
+    except Exception:
+        pass
+    return None
+
+
+def _format_delta(delta) -> str:
+    """Format a timedelta to a human-readable string."""
+    total_seconds = int(delta.total_seconds())
+    if total_seconds < 60:
+        return f"{total_seconds}s"
+    elif total_seconds < 3600:
+        return f"{total_seconds // 60}m"
+    elif total_seconds < 86400:
+        return f"{total_seconds // 3600}h {(total_seconds % 3600) // 60}m"
+    else:
+        return f"{total_seconds // 86400}d {(total_seconds % 86400) // 3600}h"
+
+
+def _format_mtime(path: Path) -> str:
+    """Format last modified time of a file."""
+    try:
+        # Resolve symlinks to get the actual file's mtime
+        real_path = path.resolve()
+        mtime = real_path.stat().st_mtime
+        dt = datetime.fromtimestamp(mtime, tz=timezone.utc)
+        now = datetime.now(timezone.utc)
+        delta = now - dt
+        return f"{_format_delta(delta)} ago"
+    except Exception:
+        return "unknown"
+
+
+def get_status(
+    agents: list[str] | None = None,
+    auth_dir: str | Path | None = None,
+) -> list[AuthFileStatus]:
+    """Return structured status of all managed auth files.
+
+    Args:
+        agents: Agent names to include, or None for all.
+        auth_dir: Custom auth directory. Defaults to ~/.caw/auth/.
+
+    Returns:
+        List of AuthFileStatus for each managed file.
+
+    Raises:
+        FileNotFoundError: If the manifest.json doesn't exist in auth_dir.
+    """
+    resolved_dir = Path(auth_dir) if auth_dir else AUTH_DIR
+    manifest_path = resolved_dir / "manifest.json"
+    if not manifest_path.exists():
+        raise FileNotFoundError(f"No manifest.json found at {manifest_path}")
+
+    manifest = Manifest.load(manifest_path)
+    host_home = Path(manifest.host_home)
+    agent_names = set(agents) if agents and "all" not in agents else set(manifest.agents.keys())
+
+    results: list[AuthFileStatus] = []
+    for agent_name, agent_manifest in manifest.agents.items():
+        if agent_name not in agent_names:
+            continue
+
+        token_info = _check_token_expiry(resolved_dir, agent_name)
+
+        for mf in agent_manifest.files:
+            canonical = resolved_dir / mf.src
+            original = host_home / mf.host_original
+
+            # Determine symlink state
+            if mf.strategy == "symlink":
+                if original.is_symlink():
+                    if original.resolve() == canonical.resolve():
+                        symlink_state = "linked"
+                    else:
+                        symlink_state = "wrong_target"
+                elif original.exists():
+                    symlink_state = "not_linked"
+                else:
+                    symlink_state = "missing"
+            else:
+                symlink_state = "n/a"
+
+            results.append(
+                AuthFileStatus(
+                    agent=agent_name,
+                    file=mf.host_original,
+                    type=mf.type,
+                    strategy=mf.strategy,
+                    symlink_state=symlink_state,
+                    exists=canonical.exists(),
+                    token_expiry=token_info if mf.type == "credential" else None,
+                )
+            )
+
+    return results
+
+
+def get_docker_flags(auth_dir: str | Path | None = None) -> str:
+    """Return the Docker ``-v`` flag for mounting the auth directory.
+
+    Args:
+        auth_dir: Custom auth directory. Defaults to ~/.caw/auth/.
+
+    Returns:
+        A string like ``-v /path/to/auth:/tmp/caw_auth:rw``.
+
+    Raises:
+        FileNotFoundError: If the manifest.json doesn't exist in auth_dir.
+    """
+    resolved_dir = Path(auth_dir) if auth_dir else AUTH_DIR
+    manifest_path = resolved_dir / "manifest.json"
+    if not manifest_path.exists():
+        raise FileNotFoundError(f"No manifest.json found at {manifest_path}")
+
+    manifest = Manifest.load(manifest_path)
+    return f"-v {resolved_dir}:{manifest.mount_point}:rw"
+
+
+def status(agents: list[str] | None = None, auth_dir: str | Path | None = None) -> None:
+    """Show status of all managed auth files.
+
+    Args:
+        agents: Agent names to show, or None for all.
+        auth_dir: Custom auth directory. Defaults to ~/.caw/auth/.
+    """
+    resolved_dir = Path(auth_dir) if auth_dir else AUTH_DIR
+    manifest_path = resolved_dir / "manifest.json"
+    if not manifest_path.exists():
+        console.print("[yellow]No auth directory found.[/yellow] Run `caw auth setup` first.")
+        return
+
+    manifest = Manifest.load(manifest_path)
+    host_home = Path(manifest.host_home)
+
+    agent_names = set(agents) if agents and "all" not in agents else set(manifest.agents.keys())
+
+    table = Table(title="caw auth status", show_lines=True)
+    table.add_column("Agent", style="bold")
+    table.add_column("File", style="dim")
+    table.add_column("Type")
+    table.add_column("Strategy")
+    table.add_column("Symlink State")
+    table.add_column("Last Modified")
+    table.add_column("Token")
+
+    for agent_name, agent_manifest in manifest.agents.items():
+        if agent_name not in agent_names:
+            continue
+
+        token_info = _check_token_expiry(resolved_dir, agent_name)
+
+        for i, mf in enumerate(agent_manifest.files):
+            canonical = resolved_dir / mf.src
+            original = host_home / mf.host_original
+
+            # Check symlink state
+            if mf.strategy == "symlink":
+                if original.is_symlink():
+                    target = os.readlink(str(original))
+                    if original.resolve() == canonical.resolve():
+                        symlink_state = "[green]linked[/green]"
+                    else:
+                        symlink_state = f"[yellow]wrong target[/yellow] ({target})"
+                elif original.exists():
+                    symlink_state = "[yellow]not linked[/yellow] (regular file)"
+                else:
+                    symlink_state = "[red]missing[/red]"
+            else:
+                symlink_state = "[dim]n/a (copy)[/dim]"
+
+            # Last modified
+            mtime = _format_mtime(canonical) if canonical.exists() else "[red]missing[/red]"
+
+            # Token info only on first row per agent
+            token_col = token_info if (i == 0 and token_info) else ""
+
+            table.add_row(
+                agent_name if i == 0 else "",
+                mf.host_original,
+                mf.type,
+                mf.strategy,
+                symlink_state,
+                mtime,
+                token_col,
+            )
+
+    console.print(table)
+
+    # Docker flags hint
+    console.print(f"\n[dim]Docker mount flag: -v {resolved_dir}:{manifest.mount_point}:rw[/dim]")

caw/cli.py

@@ -0,0 +1,50 @@
+"""caw CLI — main entry point."""
+
+from __future__ import annotations
+
+import signal
+import sys
+
+import typer
+
+from caw.auth.cli import app as auth_app
+
+app = typer.Typer(
+    name="caw",
+    help="Coding Agent Wrapper — tools for managing coding agents.",
+    no_args_is_help=True,
+)
+
+app.add_typer(auth_app, name="auth")
+
+
+@app.command()
+def viewer(
+    host: str = typer.Option("0.0.0.0", "--host", "-h", help="Host to bind to."),
+    port: int = typer.Option(0, "--port", "-p", help="Port to bind to (0 = auto)."),
+):
+    """Launch the trajectory viewer web UI."""
+    from caw.viewer import start_viewer_server
+
+    server = start_viewer_server(
+        host=host,
+        port=port or None,
+    )
+    typer.echo(f"Trajectory viewer running at {server.url}")
+    typer.echo("Press Ctrl+C to stop.")
+
+    signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
+    try:
+        signal.pause()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.stop()
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

caw/display.py

@@ -0,0 +1,223 @@
+"""Rich console display for live agent output."""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+from enum import Enum
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from caw.models import TextBlock, ThinkingBlock, ToolUse, UsageStats
+
+LOG_ENV_VAR = "CAW_LOG"
+
+
+class DisplayMode(str, Enum):
+    """Print modes for agent output."""
+
+    FULL = "full"
+    SHORT = "short"
+    RESULT = "result"
+    OFF = "off"
+
+
+def _truncate(text: str, max_len: int = 40) -> str:
+    """Truncate text to max_len chars, adding ellipsis if needed."""
+    text = text.replace("\n", " ").strip()
+    if len(text) <= max_len:
+        return text
+    return text[: max_len - 1] + "…"
+
+
+def _first_n_lines(text: str, n: int = 3) -> str:
+    """Return the first n lines of text."""
+    lines = text.splitlines()
+    if len(lines) <= n:
+        return text
+    return "\n".join(lines[:n]) + f"\n… ({len(lines) - n} more lines)"
+
+
+class Display:
+    """Mode-aware console display for agent events.
+
+    Uses ``rich.text.Text`` objects (not markup strings) to avoid
+    escaping issues with model output containing ``[brackets]``.
+    """
+
+    def __init__(self, mode: DisplayMode | str = DisplayMode.SHORT) -> None:
+        if isinstance(mode, str):
+            mode = DisplayMode(mode)
+        self.mode = mode
+        self.console = Console()
+        self._lock = threading.RLock()
+        self._last_result_text: str = ""
+        self._pending_text: TextBlock | None = None
+
+    # ------------------------------------------------------------------
+    # Event handlers
+    # ------------------------------------------------------------------
+
+    def on_metadata(self, **kwargs: str) -> None:
+        """Print metadata key-value pairs (agent, model, session, etc.)."""
+        with self._lock:
+            if self.mode == DisplayMode.OFF:
+                return
+            pairs = [f"{k}={v}" for k, v in kwargs.items() if v]
+            if not pairs:
+                return
+            line = Text()
+            line.append("[Metadata] ", style="dim bold")
+            line.append("  ".join(pairs), style="dim")
+            self.console.print(line)
+
+    def _flush_pending_text(self, bold: bool = False) -> None:
+        """Print any buffered text block. Called with bold=True for the final one."""
+        if self._pending_text is None:
+            return
+        block = self._pending_text
+        self._pending_text = None
+
+        style = "bold" if bold else ""
+        line = Text()
+        line.append("[Assistant] ", style="bold blue")
+        if self.mode == DisplayMode.FULL:
+            line.append(block.text, style=style)
+        else:
+            line.append(_truncate(block.text), style=style)
+        self.console.print(line)
+
+    def on_user_message(self, message: str) -> None:
+        """Print the user's message."""
+        with self._lock:
+            if self.mode in (DisplayMode.RESULT, DisplayMode.OFF):
+                return
+
+            line = Text()
+            line.append("[User] ", style="bold green")
+            if self.mode == DisplayMode.FULL:
+                line.append(message, style="bold")
+            else:
+                line.append(_truncate(message), style="bold")
+            self.console.print(line)
+
+    def on_text(self, block: TextBlock) -> None:
+        """Buffer an assistant text block (printed on next event or at turn end)."""
+        with self._lock:
+            if self.mode == DisplayMode.OFF:
+                return
+
+            if self.mode == DisplayMode.RESULT:
+                self._last_result_text = block.text
+                return
+
+            # Flush any previous text block (not the final one, so not bold)
+            self._flush_pending_text(bold=False)
+            self._pending_text = block
+
+    def on_thinking(self, block: ThinkingBlock) -> None:
+        """Print a thinking block."""
+        with self._lock:
+            if self.mode in (DisplayMode.RESULT, DisplayMode.OFF):
+                return
+
+            line = Text()
+            line.append("[Thinking] ", style="dim magenta")
+            if self.mode == DisplayMode.FULL:
+                line.append(block.text, style="dim")
+            else:
+                line.append(_truncate(block.text), style="dim")
+            self.console.print(line)
+
+    def on_tool_call(self, block: ToolUse) -> None:
+        """Print a tool call (args only — result not yet known)."""
+        with self._lock:
+            if self.mode in (DisplayMode.RESULT, DisplayMode.OFF):
+                return
+
+            self._flush_pending_text(bold=False)
+
+            line = Text()
+            line.append("[Tool] ", style="bold yellow")
+            line.append(block.name, style="bold cyan")
+            line.append(" ")
+
+            if self.mode == DisplayMode.FULL:
+                args_str = json.dumps(block.arguments, indent=2)
+                line.append(args_str, style="dim")
+            else:
+                args_str = json.dumps(block.arguments, separators=(",", ":"))
+                line.append(_truncate(args_str), style="dim")
+            self.console.print(line)
+
+    def on_tool_result(self, block: ToolUse) -> None:
+        """Print a tool result (output now available on the block)."""
+        with self._lock:
+            if self.mode in (DisplayMode.RESULT, DisplayMode.OFF):
+                return
+
+            tag_style = "bold red" if block.is_error else "bold yellow"
+            line = Text()
+            line.append("[Result] ", style=tag_style)
+            line.append(block.name, style="bold cyan")
+
+            output = block.output
+            if output:
+                line.append("\n")
+                text = self.mode == DisplayMode.FULL and output or _first_n_lines(output)
+                # Parse ANSI escapes so colorful tool output keeps its colors;
+                # uncolored portions fall back to the dim base style.
+                result_text = Text.from_ansi(text, style="dim")
+                line.append_text(result_text)
+            self.console.print(line)
+
+    def on_turn_end(self, result: str, usage: UsageStats, duration_ms: int) -> None:
+        """Print end-of-turn stats or deferred result text."""
+        with self._lock:
+            if self.mode == DisplayMode.OFF:
+                return
+
+            if self.mode == DisplayMode.RESULT:
+                if self._last_result_text:
+                    self.console.print(Panel(self._last_result_text, border_style="green", expand=False))
+                    self._last_result_text = ""
+                return
+
+            # Flush the last text block as bold (it's the final assistant message)
+            self._flush_pending_text(bold=True)
+
+            # Stats as metadata
+            tokens = f"{usage.input_tokens}in/{usage.output_tokens}out"
+            meta: dict[str, str] = {
+                "duration": f"{duration_ms}ms",
+                "tokens": tokens,
+            }
+            if usage.cost_usd:
+                meta["cost"] = f"${usage.cost_usd:.4f}"
+            self.on_metadata(**meta)
+
+
+# -- Global display singleton --------------------------------------------------
+
+_global_display: Display | None = None
+_global_display_resolved = False
+
+
+def get_global_display() -> Display | None:
+    """Return the global Display. Falls back to CAW_LOG env var on first call."""
+    global _global_display, _global_display_resolved
+    if _global_display is None and not _global_display_resolved:
+        _global_display_resolved = True
+        env_mode = os.environ.get(LOG_ENV_VAR, "short")
+        _global_display = Display(mode=env_mode)
+    return _global_display
+
+
+def set_global_display(display: Display | None) -> None:
+    """Set (or clear) the global Display instance."""
+    global _global_display, _global_display_resolved
+    _global_display = display
+    _global_display_resolved = True