logtap 0.3.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

logtap/cli/commands/tail.py

@@ -1,6 +1,7 @@
 """Tail command for logtap CLI - real-time log streaming."""
 
-from typing import Optional
+import json
+from typing import List, Optional
 
 import typer
 from rich.console import Console
@@ -9,12 +10,12 @@ console = Console()
 
 
 def tail(
-    filename: str = typer.Argument(
-        "syslog",
-        help="Name of the log file to tail.",
+    target: str = typer.Argument(
+        ...,
+        help="Run name or file path to tail.",
     ),
-    server: str = typer.Option(
-        "http://localhost:8000",
+    server: Optional[str] = typer.Option(
+        None,
         "--server",
         "-s",
         help="URL of the logtap server.",
@@ -24,10 +25,10 @@ def tail(
         False,
         "--follow",
         "-f",
-        help="Follow log output (like tail -f). Requires WebSocket support.",
+        help="Follow log output (like tail -f).",
     ),
     lines: int = typer.Option(
-        10,
+        50,
         "--lines",
         "-n",
         help="Number of lines to show initially.",
@@ -39,22 +40,206 @@ def tail(
         help="API key for authentication.",
         envvar="LOGTAP_API_KEY",
     ),
+    mode: str = typer.Option(
+        "auto",
+        "--mode",
+        "-m",
+        help="Resolution mode: auto, runs, or files.",
+    ),
+    since: Optional[int] = typer.Option(
+        None,
+        "--since",
+        help="Resume from cursor (exclusive). For runs mode only.",
+    ),
+    tag: Optional[List[str]] = typer.Option(
+        None,
+        "--tag",
+        "-t",
+        help="Filter by tag (key=value, repeatable). For runs mode only.",
+    ),
+    output: str = typer.Option(
+        "pretty",
+        "--output",
+        "-o",
+        help="Output format: pretty, plain, or jsonl.",
+    ),
 ) -> None:
     """
-    Tail a log file, optionally following new entries.
+    Tail a run or file, optionally following new entries.
+
+    For ML training logs (runs mode):
+        logtap tail run1 -f
+        logtap tail run1 --since 5000 -f
+        logtap tail run1 --tag node=gpu1
 
-    Example:
-        logtap tail syslog
+    For static files (legacy mode):
+        logtap tail syslog --server http://mybox:8000
         logtap tail auth.log -f
-        logtap tail syslog --lines 100
     """
-    import httpx
 
-    # First, get initial lines
+    # If no server specified and target looks like a path, use local file mode
+    if server is None:
+        if "/" in target or "\\" in target or target.startswith("."):
+            console.print("[red]Error: Local file tailing requires --server[/red]")
+            console.print("[dim]For runs: logtap tail run1 --server http://collector:8000[/dim]")
+            console.print(
+                "[dim]For files: logtap tail syslog --server http://fileserver:8000[/dim]"
+            )
+            raise typer.Exit(1)
+        # Default to localhost
+        server = "http://localhost:8000"
+
     headers = {}
     if api_key:
         headers["X-API-Key"] = api_key
 
+    # Determine mode
+    use_runs_mode = False
+    if mode == "runs":
+        use_runs_mode = True
+    elif mode == "files":
+        use_runs_mode = False
+    else:
+        # Auto mode: check server capabilities and run existence
+        use_runs_mode = _detect_runs_mode(server, target, headers)
+
+    if use_runs_mode:
+        _tail_run(server, target, headers, follow, lines, since, tag, output)
+    else:
+        _tail_file(server, target, headers, follow, lines, output)
+
+
+def _detect_runs_mode(server: str, target: str, headers: dict) -> bool:
+    """Detect if server supports runs and target exists as a run."""
+    import httpx
+
+    try:
+        with httpx.Client(timeout=5) as client:
+            # Check health endpoint for capabilities
+            response = client.get(f"{server}/health", headers=headers)
+            if response.status_code == 200:
+                data = response.json()
+                features = data.get("features", [])
+                if "runs" in features:
+                    # Check if run exists
+                    run_response = client.get(f"{server}/runs/{target}", headers=headers)
+                    if run_response.status_code == 200:
+                        return True
+    except Exception:
+        pass
+
+    return False
+
+
+def _tail_run(
+    server: str,
+    run_id: str,
+    headers: dict,
+    follow: bool,
+    lines: int,
+    since: Optional[int],
+    tags: Optional[List[str]],
+    output: str,
+) -> None:
+    """Tail a run using SSE."""
+    import httpx
+
+    # Build URL with query params
+    params = {"tail": lines, "follow": str(follow).lower()}
+    if since is not None:
+        params["since"] = since
+    if tags:
+        params["tag"] = tags
+
+    url = f"{server}/runs/{run_id}/stream"
+
+    try:
+        with httpx.Client(timeout=None) as client:
+            with client.stream("GET", url, headers=headers, params=params) as response:
+                if response.status_code == 401:
+                    console.print("[red]Error: Unauthorized. Check your API key.[/red]")
+                    raise typer.Exit(1)
+                elif response.status_code == 404:
+                    console.print(f"[red]Error: Run '{run_id}' not found.[/red]")
+                    raise typer.Exit(1)
+                elif response.status_code >= 400:
+                    console.print(f"[red]Error: Server returned {response.status_code}[/red]")
+                    raise typer.Exit(1)
+
+                # Track if this is a reconnect (user provided --since)
+                is_reconnect = since is not None
+
+                # Parse SSE stream
+                buffer = ""
+                for chunk in response.iter_text():
+                    buffer += chunk
+                    while "\n\n" in buffer:
+                        event_str, buffer = buffer.split("\n\n", 1)
+                        _process_sse_event(event_str, output, is_reconnect)
+
+    except httpx.ConnectError:
+        console.print(f"[red]Error: Could not connect to {server}[/red]")
+        console.print("[dim]Is the collector running? Start with: logtap collect[/dim]")
+        raise typer.Exit(1)
+    except KeyboardInterrupt:
+        console.print("\n[dim]Stopped.[/dim]")
+
+
+def _process_sse_event(event_str: str, output: str, is_reconnect: bool) -> None:
+    """Process a single SSE event."""
+    event_type = None
+    data = None
+
+    for line in event_str.split("\n"):
+        if line.startswith(":"):
+            # Comment (heartbeat)
+            continue
+        elif line.startswith("event: "):
+            event_type = line[7:]
+        elif line.startswith("data: "):
+            data = line[6:]
+        # Note: id: lines are parsed by SSE but not used for now
+
+    if event_type == "meta" and data:
+        try:
+            meta = json.loads(data)
+            if meta.get("gap") and meta.get("missed"):
+                # Gap detected - warn user about missed lines
+                console.print(
+                    f"[yellow]reconnected (missed {meta['missed']} lines)[/yellow]",
+                    stderr=True,
+                )
+            elif is_reconnect:
+                # Clean reconnect - show cursor position
+                cursor = meta.get("cursor_earliest", meta.get("cursor_latest", "?"))
+                console.print(f"[dim]resumed at cursor {cursor}[/dim]", stderr=True)
+        except Exception:
+            pass
+    elif event_type == "line" and data:
+        try:
+            line_data = json.loads(data)
+            if output == "jsonl":
+                console.print(data)
+            elif output == "plain":
+                console.print(line_data["line"])
+            else:
+                # Pretty output - just the line
+                console.print(line_data["line"])
+        except Exception:
+            pass
+
+
+def _tail_file(
+    server: str,
+    filename: str,
+    headers: dict,
+    follow: bool,
+    lines: int,
+    output: str,
+) -> None:
+    """Tail a static file (legacy mode)."""
+    import httpx
+
     params = {
         "filename": filename,
         "limit": lines,
@@ -64,9 +249,15 @@ def tail(
         with httpx.Client(timeout=30.0) as client:
             response = client.get(f"{server}/logs", params=params, headers=headers)
 
-        if response.status_code != 200:
-            error_detail = response.json().get("detail", response.text)
-            console.print(f"[bold red]Error:[/bold red] {error_detail}")
+        if response.status_code == 401:
+            console.print("[red]Error: Unauthorized. Check your API key.[/red]")
+            raise typer.Exit(1)
+        elif response.status_code != 200:
+            try:
+                error_detail = response.json().get("detail", response.text)
+            except Exception:
+                error_detail = response.text
+            console.print(f"[red]Error:[/red] {error_detail}")
             raise typer.Exit(1)
 
         data = response.json()
@@ -74,7 +265,10 @@ def tail(
 
         # Print initial lines
         for line in log_lines:
-            console.print(line)
+            if output == "jsonl":
+                console.print(json.dumps({"line": line}))
+            else:
+                console.print(line)
 
         if follow:
             console.print()
@@ -91,13 +285,16 @@ def tail(
                 ws_url = f"{ws_url}/logs/stream?filename={filename}"
 
                 extra_headers = {}
-                if api_key:
-                    extra_headers["X-API-Key"] = api_key
+                if headers.get("X-API-Key"):
+                    extra_headers["X-API-Key"] = headers["X-API-Key"]
 
                 try:
                     async with websockets.connect(ws_url, extra_headers=extra_headers) as ws:
                         async for message in ws:
-                            console.print(message)
+                            if output == "jsonl":
+                                console.print(json.dumps({"line": message}))
+                            else:
+                                console.print(message)
                 except websockets.exceptions.InvalidStatusCode as e:
                     if e.status_code == 404:
                         console.print("[yellow]Streaming not available.[/yellow]")
@@ -113,9 +310,9 @@ def tail(
                 console.print("\n[dim]Stopped.[/dim]")
 
     except httpx.ConnectError:
-        console.print(f"[bold red]Error:[/bold red] Could not connect to {server}")
+        console.print(f"[red]Error:[/red] Could not connect to {server}")
         console.print("[dim]Is the logtap server running? Start it with 'logtap serve'[/dim]")
         raise typer.Exit(1)
     except Exception as e:
-        console.print(f"[bold red]Error:[/bold red] {e}")
+        console.print(f"[red]Error:[/red] {e}")
         raise typer.Exit(1)

logtap/cli/main.py

@@ -3,11 +3,11 @@
 import typer
 
 from logtap import __version__
-from logtap.cli.commands import files, query, serve, tail
+from logtap.cli.commands import collect, doctor, files, ingest, query, runs, serve, tail
 
 app = typer.Typer(
     name="logtap",
-    help="A CLI-first log access tool for Unix systems. Remote log file access without SSH.",
+    help="tail -f for GPU clouds. Survives disconnects, aggregates multi-node.",
     rich_markup_mode="rich",
     no_args_is_help=True,
 )
@@ -32,14 +32,21 @@ def main(
     ),
 ) -> None:
     """
-    logtap - Remote log file access without SSH.
+    logtap - tail -f for GPU clouds.
 
-    Start a server with 'logtap serve' or query a remote server with 'logtap query'.
+    Start a collector with 'logtap collect', pipe logs with 'logtap ingest',
+    and tail from anywhere with 'logtap tail'.
     """
     pass
 
 
-# Add commands
+# Primary commands (new ML workflow)
+app.command()(collect.collect)
+app.command()(ingest.ingest)
+app.command()(runs.runs)
+app.command()(doctor.doctor)
+
+# Legacy commands (file-based workflow)
 app.command()(serve.serve)
 app.command()(query.query)
 app.command()(tail.tail)