dooers-cli 0.8.2__tar.gz → 0.9.0__tar.gz

{dooers_cli-0.8.2 → dooers_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dooers-cli
-Version: 0.8.2
+Version: 0.9.0
 Summary: Dooers CLI — push agents to Dooers, manage agent records, authenticate from the terminal
 Project-URL: Repository, https://github.com/Dooers-ai/dooers-cli
 Author-email: Dooers <dev@dooers.ai>
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: dooers-protocol>=0.7.0
+Requires-Dist: dooers-protocol>=0.8.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: pydantic>=2.13.2
 Requires-Dist: pyyaml>=6.0.2
@@ -57,8 +57,27 @@ dooers agents show ag_8h2k
 # push (reads dooers.yaml in cwd unless agent_id given)
 dooers validate
 dooers push [<agent_id>] [--tag latest] [--env prod|stg|dev]
+
+# logs (same agent resolution as push)
+dooers logs [<agent_id>] [--since 15m] [--limit 100] [--json]
+dooers logs --follow          # tail; Ctrl-C to stop
 ```
 
+### `dooers logs`
+
+Reads the deployment logs of an agent from `dooers-push`.
+
+| Flag | Default | Meaning |
+|---|---|---|
+| `--since` | `15m` | How far back to start — a duration: `45s`, `15m`, `1h`, `2h30m`. |
+| `--limit` | `100` | Max entries per request (the server caps at 1000). |
+| `--follow`, `-f` | off | Poll every 2s and print new entries until interrupted. |
+| `--json` | off | One compact JSON object per line (`timestamp`, `severity`, `message`) instead of formatted text. |
+
+Default output is `HH:MM:SS  LEVEL  message`, with the level colourised
+(ERROR/CRITICAL red, WARNING yellow, DEBUG/DEFAULT dim). Times are shown in the
+timestamp's own zone (UTC, as emitted) — never converted to the local clock.
+
 ## Global config (precedence: flag > env > default)
 
 | Setting | Flag | Env var | Default |

dooers_cli-0.9.0/README.md

@@ -0,0 +1,59 @@
+# dooers (CLI)
+
+The Dooers CLI. Installed by agent creators.
+
+```bash
+pip install dooers
+```
+
+## Commands
+
+```bash
+# auth (email prompts if omitted)
+dooers login you@example.com
+dooers whoami
+dooers logout
+
+# agents
+dooers agents list
+dooers agents create --name my-agent
+dooers agents show ag_8h2k
+
+# push (reads dooers.yaml in cwd unless agent_id given)
+dooers validate
+dooers push [<agent_id>] [--tag latest] [--env prod|stg|dev]
+
+# logs (same agent resolution as push)
+dooers logs [<agent_id>] [--since 15m] [--limit 100] [--json]
+dooers logs --follow          # tail; Ctrl-C to stop
+```
+
+### `dooers logs`
+
+Reads the deployment logs of an agent from `dooers-push`.
+
+| Flag | Default | Meaning |
+|---|---|---|
+| `--since` | `15m` | How far back to start — a duration: `45s`, `15m`, `1h`, `2h30m`. |
+| `--limit` | `100` | Max entries per request (the server caps at 1000). |
+| `--follow`, `-f` | off | Poll every 2s and print new entries until interrupted. |
+| `--json` | off | One compact JSON object per line (`timestamp`, `severity`, `message`) instead of formatted text. |
+
+Default output is `HH:MM:SS  LEVEL  message`, with the level colourised
+(ERROR/CRITICAL red, WARNING yellow, DEBUG/DEFAULT dim). Times are shown in the
+timestamp's own zone (UTC, as emitted) — never converted to the local clock.
+
+## Global config (precedence: flag > env > default)
+
+| Setting | Flag | Env var | Default |
+|---|---|---|---|
+| Core API host | `--core-url` | `DOOERS_CORE_URL` | `https://api.dooers.ai` |
+| dooers-push host | `--push-url` | `DOOERS_PUSH_URL` | `https://host.dooers.ai` |
+| Target environment | `--env` | `DOOERS_ENV` | `prod` |
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run poe dev
+```

{dooers_cli-0.8.2 → dooers_cli-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dooers-cli"
-version = "0.8.2"
+version = "0.9.0"
 description = "Dooers CLI — push agents to Dooers, manage agent records, authenticate from the terminal"
 readme = "README.md"
 license = "MIT"
@@ -26,7 +26,7 @@ dependencies = [
     "pydantic>=2.13.2",
     "pyyaml>=6.0.2",
     "tqdm>=4.66.4",
-    "dooers-protocol>=0.7.0",
+    "dooers-protocol>=0.8.0",
 ]
 
 [tool.uv.sources]

{dooers_cli-0.8.2 → dooers_cli-0.9.0}/src/dooers/cli/cli.py

@@ -7,14 +7,19 @@ import warnings
 # frames; suppress so every command stays quiet when both packages share `dooers.*`.
 warnings.filterwarnings(
     "ignore",
-    message=r'Field name "schema" in "SettingsPublicSchemaResultPayload" shadows an attribute in parent "BaseModel"',
+    message=(
+        r'Field name "schema" in "SettingsPublicSchemaResultPayload" '
+        r'shadows an attribute in parent "BaseModel"'
+    ),
     category=UserWarning,
 )
 
-import typer
+# E402 below is deliberate: the filter above must be installed before anything
+# imports the models that trigger the warning.
+import typer  # noqa: E402
 
-from . import agents, auth, org, push, validate
-from .settings import Settings
+from . import agents, auth, logs, org, push, validate  # noqa: E402
+from .settings import Settings  # noqa: E402
 
 app = typer.Typer(
     name="dooers",
@@ -49,6 +54,10 @@ app.command(
     help="Validate dooers.yaml, Dockerfile, and SDK dependency/import conventions.",
 )(validate.validate)
 app.command(name="push", help="Archive cwd and push it as a new build of an agent.")(push.push)
+app.command(
+    name="logs",
+    help="Show an agent's deployment logs; --follow to tail them.",
+)(logs.logs)
 
 
 if __name__ == "__main__":

{dooers_cli-0.8.2 → dooers_cli-0.9.0}/src/dooers/cli/config.py

@@ -8,6 +8,26 @@ from dooers.protocol.agents import AgentManifest
 MANIFEST_FILENAME = "dooers.yaml"
 
 
+class MissingAgentIdError(RuntimeError):
+    """No agent id was given and no dooers.yaml was found to read one from."""
+
+
+def resolve_agent_id(explicit: str | None, manifest: AgentManifest | None) -> str:
+    """Resolve which agent a command targets: the explicit argument wins, else dooers.yaml.
+
+    The single rule shared by every command that takes an optional agent id
+    (`dooers push`, `dooers logs`) — do not re-derive it per command.
+    """
+    if explicit is not None:
+        return explicit
+    if manifest is None:
+        raise MissingAgentIdError(
+            f"Missing {MANIFEST_FILENAME}. Run `dooers agents create` first "
+            f"or pass an agent_id explicitly."
+        )
+    return manifest.agent_id
+
+
 def read_manifest(directory: Path | None = None) -> AgentManifest | None:
     """Read and validate dooers.yaml from `directory` (default: cwd).
 

dooers_cli-0.9.0/src/dooers/cli/logs.py

@@ -0,0 +1,266 @@
+"""`dooers logs` — read (and optionally tail) the deployment logs of an agent.
+
+Reads `GET /v1/agents/{id}/logs` on dooers-push. In `--follow` mode the command
+re-polls with `since` pinned to the newest timestamp already printed, so each
+poll fetches a small overlapping window; the overlap is filtered client-side by
+`_Cursor` rather than trusting the server to be exclusive on the boundary.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+import time
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass, field
+from datetime import datetime
+
+import typer
+from dooers.protocol.logs import LogEntry
+from pydantic import ValidationError
+
+from dooers.cli import config
+from dooers.cli.push_client import (
+    PushClient,
+    PushClientError,
+    PushTransientError,
+    friendly_push_error,
+)
+from dooers.cli.settings import Settings
+from dooers.cli.token_store import TokenStore, is_token_expired
+
+#: How long `--follow` waits between polls.
+POLL_INTERVAL_S = 2.0
+
+#: `--since` grammar: an optional hours/minutes/seconds run, in that order ("2h30m").
+_DURATION = re.compile(r"(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?", re.IGNORECASE)
+
+#: Fractional seconds in an RFC3339 timestamp. Cloud Logging emits nanoseconds,
+#: which `datetime.fromisoformat` rejects before Python 3.11.
+_FRACTION = re.compile(r"\.(\d+)")
+
+
+def _parse_since(value: str) -> str:
+    """Validate a `--since` duration ("15m", "1h", "2h30m", "45s") and return it.
+
+    Returned unchanged (lowercased) rather than converted: the endpoint takes the
+    same duration grammar, and passing the user's own window back keeps the
+    request self-describing in logs.
+    """
+    text = value.strip().lower()
+    match = _DURATION.fullmatch(text)
+    if not match or not any(match.groups()):
+        raise typer.BadParameter(
+            f"invalid duration {value!r} — use a window like 15m, 45s, 1h, or 2h30m"
+        )
+    return text
+
+
+def _parse_timestamp(timestamp: str) -> datetime | None:
+    """Parse an RFC3339 timestamp, or None if it is not one.
+
+    Normalizes the two shapes `datetime.fromisoformat` cannot take on Python 3.10:
+    a trailing `Z`, and sub-microsecond precision.
+    """
+    text = timestamp.strip()
+    if text.endswith(("Z", "z")):
+        text = text[:-1] + "+00:00"
+    text = _FRACTION.sub(lambda m: "." + m.group(1)[:6], text)
+    try:
+        return datetime.fromisoformat(text)
+    except ValueError:
+        return None
+
+
+def _printable(text: str) -> str:
+    """Make `text` safe for the active stdout encoding.
+
+    Log messages are arbitrary agent output. On a non-UTF-8 console (cp1252 on
+    Windows) an emoji in one line would otherwise raise UnicodeEncodeError and
+    kill the tail; replacing the character is the right trade here.
+    """
+    encoding = getattr(sys.stdout, "encoding", None) or "utf-8"
+    try:
+        return text.encode(encoding, errors="replace").decode(encoding, errors="replace")
+    except LookupError:  # pragma: no cover — unknown codec name on stdout
+        return text
+
+
+def _style_severity(severity: str) -> str:
+    """Colourise the level column: ERROR/CRITICAL red, WARNING yellow, DEBUG/DEFAULT dim."""
+    label = f"{severity:<8}"
+    level = severity.upper()
+    if level in ("ERROR", "CRITICAL"):
+        return typer.style(label, fg=typer.colors.RED)
+    if level == "WARNING":
+        return typer.style(label, fg=typer.colors.YELLOW)
+    if level in ("DEBUG", "DEFAULT"):
+        return typer.style(label, dim=True)
+    return label
+
+
+def format_entry(entry: LogEntry) -> str:
+    """One human-readable line: `HH:MM:SS  LEVEL  message`.
+
+    The clock is shown in the timestamp's own zone (UTC, as Cloud Logging emits
+    it) — never converted — so two people reading the same tail see the same time.
+    """
+    parsed = _parse_timestamp(entry.timestamp)
+    clock = parsed.strftime("%H:%M:%S") if parsed else entry.timestamp
+    return f"{clock}  {_style_severity(entry.severity)}  {_printable(entry.message)}"
+
+
+def format_entry_json(entry: LogEntry) -> str:
+    """One compact JSON object per line, ASCII-escaped so any console can print it."""
+    return json.dumps(entry.model_dump(), separators=(",", ":"))
+
+
+@dataclass
+class _Cursor:
+    """High-water mark of what has already been printed.
+
+    Entries older than `newest` are dropped; entries *at* `newest` are dropped only
+    if that exact `(timestamp, message)` was already printed, so a burst sharing one
+    timestamp survives an overlapping poll window.
+    """
+
+    newest: str | None = None
+    printed_at_newest: set[tuple[str, str]] = field(default_factory=set)
+
+    def take_new(self, entries: Iterable[LogEntry]) -> list[LogEntry]:
+        """Return the not-yet-printed entries, oldest first, advancing the mark."""
+        fresh: list[LogEntry] = []
+        for entry in sorted(entries, key=lambda e: e.timestamp):
+            key = (entry.timestamp, entry.message)
+            if self.newest is not None:
+                if entry.timestamp < self.newest:
+                    continue
+                if entry.timestamp == self.newest and key in self.printed_at_newest:
+                    continue
+            if self.newest is None or entry.timestamp > self.newest:
+                self.newest = entry.timestamp
+                self.printed_at_newest = {key}
+            else:
+                self.printed_at_newest.add(key)
+            fresh.append(entry)
+        return fresh
+
+
+def emit(entries: Iterable[LogEntry], cursor: _Cursor, *, json_output: bool) -> int:
+    """Print the entries `cursor` has not seen yet. Returns how many were printed."""
+    fresh = cursor.take_new(entries)
+    for entry in fresh:
+        typer.echo(format_entry_json(entry) if json_output else format_entry(entry))
+    return len(fresh)
+
+
+def follow_logs(
+    client: PushClient,
+    agent_id: str,
+    *,
+    cursor: _Cursor,
+    since: str,
+    limit: int,
+    json_output: bool = False,
+    sleep: Callable[[float], object] = time.sleep,
+    interval_s: float = POLL_INTERVAL_S,
+    max_polls: int | None = None,
+) -> None:
+    """Poll for new entries forever (or `max_polls` times, for tests).
+
+    Transient failures are tolerated — a tail must outlive a 503 — and warned about
+    once per outage. A PushClientError is a real 4xx and propagates to the caller.
+    """
+    warned = False
+    polls = 0
+    while max_polls is None or polls < max_polls:
+        polls += 1
+        sleep(interval_s)
+        try:
+            resp = client.get_logs(agent_id, since=cursor.newest or since, limit=limit)
+        except PushTransientError as e:
+            if not warned:
+                typer.echo(f"Warning: log stream interrupted ({e}); retrying…", err=True)
+                warned = True
+            continue
+        warned = False
+        emit(resp.entries, cursor, json_output=json_output)
+
+
+def logs(
+    ctx: typer.Context,
+    agent_id: str | None = typer.Argument(
+        None,
+        help="Agent ID. If omitted, reads agent_id from ./dooers.yaml.",
+    ),
+    follow: bool = typer.Option(
+        False, "--follow", "-f", help="Keep polling and print new entries as they arrive."
+    ),
+    since: str = typer.Option(
+        "15m", "--since", help="How far back to start: a duration like 15m, 45s, 1h, 2h30m."
+    ),
+    limit: int = typer.Option(
+        100, "--limit", help="Max entries per request (server caps at 1000)."
+    ),
+    json_output: bool = typer.Option(
+        False, "--json", help="Print one compact JSON object per line instead of formatted text."
+    ),
+) -> None:
+    """Show the deployment logs of an agent."""
+    settings: Settings = ctx.obj
+    window = _parse_since(since)
+
+    # Resolve agent_id from arg or manifest (same rule as `dooers push`). The
+    # manifest is only read when it is actually needed, so an explicit id still
+    # works from a directory with a broken dooers.yaml.
+    manifest = None
+    if agent_id is None:
+        try:
+            manifest = config.read_manifest()
+        except ValidationError as e:
+            typer.echo(f"Invalid {config.MANIFEST_FILENAME}: {e}", err=True)
+            raise typer.Exit(code=1) from e
+    try:
+        target_agent_id = config.resolve_agent_id(agent_id, manifest)
+    except config.MissingAgentIdError as e:
+        typer.echo(str(e), err=True)
+        raise typer.Exit(code=1) from e
+
+    store = TokenStore()
+    token = store.load()
+    if not token or is_token_expired(token, store=store):
+        typer.echo("Not authenticated. Run `dooers login`.", err=True)
+        raise typer.Exit(code=1)
+
+    client = PushClient(base_url=settings.push_url, token=token)
+    cursor = _Cursor()
+
+    try:
+        resp = client.get_logs(target_agent_id, since=window, limit=limit)
+    except PushClientError as e:
+        code = e.envelope.error_code if e.envelope else None
+        typer.echo(f"Logs failed: {friendly_push_error(code, str(e))}", err=True)
+        raise typer.Exit(code=1) from e
+
+    printed = emit(resp.entries, cursor, json_output=json_output)
+    if not follow:
+        if printed == 0 and not json_output:
+            typer.echo(f"No log entries in the last {window}.", err=True)
+        return
+
+    try:
+        follow_logs(
+            client,
+            target_agent_id,
+            cursor=cursor,
+            since=window,
+            limit=limit,
+            json_output=json_output,
+        )
+    except KeyboardInterrupt:
+        raise typer.Exit(code=0) from None
+    except PushClientError as e:
+        code = e.envelope.error_code if e.envelope else None
+        typer.echo(f"\nLogs failed: {friendly_push_error(code, str(e))}", err=True)
+        raise typer.Exit(code=1) from e

{dooers_cli-0.8.2 → dooers_cli-0.9.0}/src/dooers/cli/push.py

@@ -116,17 +116,13 @@ def push(
     settings: Settings = ctx.obj
     target_env = env or settings.env
 
-    # Resolve agent_id from arg or manifest.
+    # Resolve agent_id from arg or manifest (same rule as `dooers logs`).
     manifest = config.read_manifest()
-    if agent_id is None:
-        if manifest is None:
-            typer.echo(
-                f"Missing {config.MANIFEST_FILENAME}. Run `dooers agents create` first "
-                f"or pass an agent_id explicitly.",
-                err=True,
-            )
-            raise typer.Exit(code=1)
-        agent_id = manifest.agent_id
+    try:
+        agent_id = config.resolve_agent_id(agent_id, manifest)
+    except config.MissingAgentIdError as e:
+        typer.echo(str(e), err=True)
+        raise typer.Exit(code=1) from e
 
     # Client-side hosting guard. The dooers-push server is the authoritative
     # gate (it checks the org's hosting plan feature); this is a fast local

{dooers_cli-0.8.2 → dooers_cli-0.9.0}/src/dooers/cli/push_client.py

@@ -4,6 +4,7 @@ from pathlib import Path
 
 import httpx
 from dooers.protocol.errors import ErrorCode, ErrorEnvelope
+from dooers.protocol.logs import LogsResponse
 from dooers.protocol.push import BuildStatusResponse, PushAcceptedResponse
 from dooers.protocol.teardown import TeardownResponse
 
@@ -82,6 +83,34 @@ class PushClient:
         self._raise_for_status(r)
         return BuildStatusResponse.model_validate(r.json())
 
+    def get_logs(
+        self,
+        agent_id: str,
+        *,
+        since: str | None = None,
+        limit: int = 100,
+        page_token: str | None = None,
+    ) -> LogsResponse:
+        """Read recent log entries for an agent.
+
+        `since` is an RFC3339 timestamp or a duration like `15m`. Raises
+        PushTransientError on 5xx/network so a `--follow` caller survives blips;
+        raises PushClientError on a 4xx envelope.
+        """
+        url = f"{self.base_url}/v1/agents/{agent_id}/logs"
+        params: dict[str, str] = {"limit": str(limit)}
+        if since is not None:
+            params["since"] = since
+        if page_token is not None:
+            params["page_token"] = page_token
+        try:
+            r = httpx.get(url, headers=self._headers, params=params, timeout=self._timeout)
+        except httpx.HTTPError as e:
+            raise PushTransientError(f"logs request failed: {e}") from e
+
+        self._raise_for_status(r)
+        return LogsResponse.model_validate(r.json())
+
     def teardown(self, agent_id: str, env: str = "prod") -> TeardownResponse:
         url = f"{self.base_url}/v1/agents/{agent_id}"
         headers = {"Authorization": f"Bearer {self.token}"}

{dooers_cli-0.8.2 → dooers_cli-0.9.0}/tests/test_env_prod.py

@@ -6,7 +6,8 @@ from dooers.cli.env_prod import upsert_agent_seed_secret
 def test_upsert_creates_env_prod(tmp_path: Path) -> None:
     path = upsert_agent_seed_secret(tmp_path, "secret-one-time-key-abc")
     assert path.name == "env.prod"
-    assert path.read_text(encoding="utf-8").strip().endswith("AGENT_SEED_SECRET=secret-one-time-key-abc")
+    written = path.read_text(encoding="utf-8").strip()
+    assert written.endswith("AGENT_SEED_SECRET=secret-one-time-key-abc")
 
 
 def test_upsert_replaces_existing_line(tmp_path: Path) -> None:

dooers_cli-0.9.0/tests/test_logs.py

@@ -0,0 +1,439 @@
+"""`dooers logs` — one-shot render, --json shape, --since parsing, follow-mode dedupe.
+
+Follow mode is driven through the `sleep` / `max_polls` seam on `follow_logs`, so no
+test here ever waits on a real clock.
+"""
+
+from collections.abc import Iterator
+
+import httpx
+import pytest
+import respx
+import typer
+from dooers.protocol.logs import LogEntry, LogsResponse
+from typer.testing import CliRunner
+
+from dooers.cli.cli import app
+from dooers.cli.logs import _Cursor, _parse_since, emit, follow_logs
+from dooers.cli.push_client import PushClient, PushClientError, PushTransientError
+
+runner = CliRunner()
+
+PUSH = "https://push.test"
+A = "550e8400-e29b-41d4-a716-446655440000"
+ROOT = ["--push-url", PUSH, "--env", "dev"]
+
+
+def _auth(monkeypatch: pytest.MonkeyPatch) -> None:
+    class _Tok:
+        def load(self) -> str:
+            return "tok"
+
+    monkeypatch.setattr("dooers.cli.logs.TokenStore", _Tok)
+    monkeypatch.setattr("dooers.cli.logs.is_token_expired", lambda token, store: False)
+
+
+def _entry(timestamp: str, severity: str = "INFO", message: str = "hello") -> dict[str, str]:
+    return {"timestamp": timestamp, "severity": severity, "message": message}
+
+
+def _logs_response(*entries: dict[str, str], next_page_token: str | None = None) -> httpx.Response:
+    return httpx.Response(
+        200,
+        json={
+            "agent_id": A,
+            "service_name": "agent-svc",
+            "region": "us-central1",
+            "entries": list(entries),
+            "next_page_token": next_page_token,
+        },
+    )
+
+
+# --------------------------------------------------------------------------- wiring
+
+
+def test_root_help_lists_logs() -> None:
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "logs" in result.stdout
+
+
+def test_logs_help_lists_flags() -> None:
+    result = runner.invoke(app, ["logs", "--help"])
+    assert result.exit_code == 0
+    out = result.stdout
+    for flag in ("--follow", "--since", "--limit", "--json"):
+        assert flag in out
+
+
+# ----------------------------------------------------------------------- one-shot
+
+
+@respx.mock
+def test_one_shot_renders_entries(monkeypatch: pytest.MonkeyPatch) -> None:
+    _auth(monkeypatch)
+    route = respx.get(f"{PUSH}/v1/agents/{A}/logs").mock(
+        return_value=_logs_response(
+            _entry("2026-08-07T12:00:00Z", "INFO", "server started"),
+            _entry("2026-08-07T12:00:05Z", "ERROR", "boom"),
+        )
+    )
+
+    result = runner.invoke(app, ROOT + ["logs", A])
+
+    assert result.exit_code == 0, result.output
+    assert route.called
+    assert "12:00:00" in result.output
+    assert "INFO" in result.output
+    assert "server started" in result.output
+    assert "12:00:05" in result.output
+    assert "ERROR" in result.output
+    assert "boom" in result.output
+
+
+@respx.mock
+def test_one_shot_sends_default_since_and_limit(monkeypatch: pytest.MonkeyPatch) -> None:
+    _auth(monkeypatch)
+    respx.get(f"{PUSH}/v1/agents/{A}/logs").mock(
+        return_value=_logs_response(_entry("2026-08-07T12:00:00Z"))
+    )
+
+    result = runner.invoke(app, ROOT + ["logs", A])
+
+    assert result.exit_code == 0, result.output
+    params = respx.calls.last.request.url.params
+    assert params["since"] == "15m"
+    assert params["limit"] == "100"
+
+
+@respx.mock
+def test_entries_print_oldest_first_even_if_server_returns_newest_first(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _auth(monkeypatch)
+    respx.get(f"{PUSH}/v1/agents/{A}/logs").mock(
+        return_value=_logs_response(
+            _entry("2026-08-07T12:00:09Z", "INFO", "second"),
+            _entry("2026-08-07T12:00:01Z", "INFO", "first"),
+        )
+    )
+
+    result = runner.invoke(app, ROOT + ["logs", A])
+
+    assert result.exit_code == 0, result.output
+    assert result.output.index("first") < result.output.index("second")
+
+
+@respx.mock
+def test_json_output_shape(monkeypatch: pytest.MonkeyPatch) -> None:
+    _auth(monkeypatch)
+    respx.get(f"{PUSH}/v1/agents/{A}/logs").mock(
+        return_value=_logs_response(
+            _entry("2026-08-07T12:00:00Z", "INFO", "one"),
+            _entry("2026-08-07T12:00:01Z", "ERROR", "two"),
+        )
+    )
+
+    result = runner.invoke(app, ROOT + ["logs", A, "--json"])
+
+    assert result.exit_code == 0, result.output
+    lines = [line for line in result.output.splitlines() if line.strip()]
+    assert lines == [
+        '{"timestamp":"2026-08-07T12:00:00Z","severity":"INFO","message":"one"}',
+        '{"timestamp":"2026-08-07T12:00:01Z","severity":"ERROR","message":"two"}',
+    ]
+
+
+@respx.mock
+def test_agent_id_falls_back_to_manifest(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+    from dooers.protocol import PROTOCOL_VERSION
+    from dooers.protocol.agents import AgentManifest
+
+    from dooers.cli import config
+
+    _auth(monkeypatch)
+    config.write_manifest(
+        AgentManifest(
+            protocol_version=PROTOCOL_VERSION,
+            agent_id=A,
+            name="A",
+            organization_id="o1",
+        ),
+        directory=tmp_path,
+    )
+    monkeypatch.chdir(tmp_path)
+    route = respx.get(f"{PUSH}/v1/agents/{A}/logs").mock(
+        return_value=_logs_response(_entry("2026-08-07T12:00:00Z", "INFO", "from manifest"))
+    )
+
+    result = runner.invoke(app, ROOT + ["logs"])
+
+    assert result.exit_code == 0, result.output
+    assert route.called
+    assert "from manifest" in result.output
+
+
+def test_missing_agent_id_and_manifest_exits_1(
+    monkeypatch: pytest.MonkeyPatch, tmp_path
+) -> None:
+    _auth(monkeypatch)
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(app, ROOT + ["logs"])
+
+    assert result.exit_code == 1
+    assert "dooers.yaml" in result.output
+
+
+@respx.mock
+def test_client_error_exits_1(monkeypatch: pytest.MonkeyPatch) -> None:
+    _auth(monkeypatch)
+    respx.get(f"{PUSH}/v1/agents/{A}/logs").mock(
+        return_value=httpx.Response(
+            404,
+            json={"error_code": "not_found", "message": "agent not found", "correlation_id": "c1"},
+        )
+    )
+
+    result = runner.invoke(app, ROOT + ["logs", A])
+
+    assert result.exit_code == 1
+    assert "agent not found" in result.output
+
+
+# ------------------------------------------------------------------------- --since
+
+
+@pytest.mark.parametrize("value", ["15m", "1h", "2h30m", "45s", "1h30m15s", "90S"])
+def test_parse_since_accepts_durations(value: str) -> None:
+    assert _parse_since(value) == value.strip().lower()
+
+
+@pytest.mark.parametrize("value", ["", "banana", "15", "m15", "5x", "1d", "-5m", "30m2h"])
+def test_parse_since_rejects_garbage(value: str) -> None:
+    with pytest.raises(typer.BadParameter):
+        _parse_since(value)
+
+
+def test_bad_since_exits_nonzero(monkeypatch: pytest.MonkeyPatch) -> None:
+    _auth(monkeypatch)
+    result = runner.invoke(app, ROOT + ["logs", A, "--since", "banana"])
+    assert result.exit_code != 0
+    assert "banana" in result.output
+
+
+# -------------------------------------------------------------------------- follow
+
+
+class _FakeClient:
+    """Yields a scripted sequence of get_logs outcomes (response or exception)."""
+
+    def __init__(self, script: list[object]) -> None:
+        self._it: Iterator[object] = iter(script)
+        self.calls: list[str | None] = []
+
+    def get_logs(
+        self,
+        agent_id: str,
+        *,
+        since: str | None = None,
+        limit: int = 100,
+        page_token: str | None = None,
+    ) -> LogsResponse:
+        self.calls.append(since)
+        item = next(self._it, None)
+        if isinstance(item, Exception):
+            raise item
+        if item is None:
+            return _response([])
+        assert isinstance(item, LogsResponse)
+        return item
+
+
+def _response(entries: list[LogEntry]) -> LogsResponse:
+    return LogsResponse(
+        agent_id=A, service_name="agent-svc", region="us-central1", entries=entries
+    )
+
+
+def _e(timestamp: str, message: str, severity: str = "INFO") -> LogEntry:
+    return LogEntry(timestamp=timestamp, severity=severity, message=message)
+
+
+def test_follow_prints_only_new_entries_from_overlapping_window(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    cursor = _Cursor()
+    first = [_e("2026-08-07T12:00:00Z", "one"), _e("2026-08-07T12:00:01Z", "two")]
+    # Second poll re-returns the tail of the first window plus two new lines.
+    second = [
+        _e("2026-08-07T12:00:01Z", "two"),
+        _e("2026-08-07T12:00:02Z", "three"),
+        _e("2026-08-07T12:00:03Z", "four"),
+    ]
+    emit(first, cursor, json_output=False)
+    capsys.readouterr()
+
+    client = _FakeClient([_response(second)])
+    follow_logs(
+        client,  # type: ignore[arg-type]
+        A,
+        cursor=cursor,
+        since="15m",
+        limit=100,
+        sleep=lambda *_: None,
+        max_polls=1,
+    )
+
+    out = capsys.readouterr().out
+    assert "three" in out
+    assert "four" in out
+    assert "two" not in out  # already printed by the first batch
+    # The poll narrowed its window to the newest timestamp already printed.
+    assert client.calls == ["2026-08-07T12:00:01Z"]
+
+
+def test_follow_keeps_distinct_messages_sharing_one_timestamp(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    cursor = _Cursor()
+    emit([_e("2026-08-07T12:00:00Z", "first")], cursor, json_output=False)
+    capsys.readouterr()
+
+    client = _FakeClient(
+        [
+            _response(
+                [
+                    _e("2026-08-07T12:00:00Z", "first"),  # dupe: same ts + message
+                    _e("2026-08-07T12:00:00Z", "second"),  # same ts, new message
+                ]
+            )
+        ]
+    )
+    follow_logs(
+        client,  # type: ignore[arg-type]
+        A,
+        cursor=cursor,
+        since="15m",
+        limit=100,
+        sleep=lambda *_: None,
+        max_polls=1,
+    )
+
+    out = capsys.readouterr().out
+    assert "second" in out
+    assert out.count("first") == 0
+
+
+def test_follow_tolerates_transient_error(capsys: pytest.CaptureFixture[str]) -> None:
+    cursor = _Cursor()
+    client = _FakeClient(
+        [
+            PushTransientError("transient upstream error (HTTP 503)"),
+            PushTransientError("transient upstream error (HTTP 503)"),
+            _response([_e("2026-08-07T12:00:02Z", "recovered")]),
+        ]
+    )
+
+    follow_logs(
+        client,  # type: ignore[arg-type]
+        A,
+        cursor=cursor,
+        since="15m",
+        limit=100,
+        sleep=lambda *_: None,
+        max_polls=3,
+    )
+
+    captured = capsys.readouterr()
+    assert "recovered" in captured.out
+    assert len(client.calls) == 3  # the blips did not abort the loop
+    assert captured.err.count("Warning:") == 1  # warned once per outage, not per poll
+
+
+def test_follow_aborts_on_client_error() -> None:
+    cursor = _Cursor()
+    client = _FakeClient([PushClientError("agent not found")])
+
+    with pytest.raises(PushClientError):
+        follow_logs(
+            client,  # type: ignore[arg-type]
+            A,
+            cursor=cursor,
+            since="15m",
+            limit=100,
+            sleep=lambda *_: None,
+            max_polls=3,
+        )
+
+
+def test_follow_never_sleeps_for_real() -> None:
+    """The poll interval goes through the injected sleep, so tests stay instant."""
+    slept: list[float] = []
+    client = _FakeClient([_response([])])
+
+    follow_logs(
+        client,  # type: ignore[arg-type]
+        A,
+        cursor=_Cursor(),
+        since="15m",
+        limit=100,
+        sleep=lambda s: slept.append(s),
+        max_polls=1,
+    )
+
+    assert slept == [2.0]
+
+
+# -------------------------------------------------------------- PushClient.get_logs
+
+
+@respx.mock
+def test_get_logs_parses_response() -> None:
+    respx.get(f"{PUSH}/v1/agents/{A}/logs").mock(
+        return_value=_logs_response(
+            _entry("2026-08-07T12:00:00Z", "WARNING", "slow"), next_page_token="tok"
+        )
+    )
+
+    resp = PushClient(PUSH, token="t").get_logs(A, since="15m", limit=50, page_token="p1")
+
+    assert isinstance(resp, LogsResponse)
+    assert resp.service_name == "agent-svc"
+    assert resp.next_page_token == "tok"
+    assert [e.severity for e in resp.entries] == ["WARNING"]
+    params = respx.calls.last.request.url.params
+    assert params["since"] == "15m"
+    assert params["limit"] == "50"
+    assert params["page_token"] == "p1"
+
+
+@respx.mock
+def test_get_logs_503_raises_transient() -> None:
+    respx.get(f"{PUSH}/v1/agents/{A}/logs").mock(
+        return_value=httpx.Response(503, text="service unavailable")
+    )
+    with pytest.raises(PushTransientError):
+        PushClient(PUSH, token="t").get_logs(A)
+
+
+@respx.mock
+def test_get_logs_network_error_raises_transient() -> None:
+    respx.get(f"{PUSH}/v1/agents/{A}/logs").mock(side_effect=httpx.ConnectError("boom"))
+    with pytest.raises(PushTransientError):
+        PushClient(PUSH, token="t").get_logs(A)
+
+
+@respx.mock
+def test_get_logs_404_raises_client_error() -> None:
+    respx.get(f"{PUSH}/v1/agents/{A}/logs").mock(
+        return_value=httpx.Response(
+            404,
+            json={"error_code": "not_found", "message": "agent not found", "correlation_id": "c1"},
+        )
+    )
+    with pytest.raises(PushClientError) as exc:
+        PushClient(PUSH, token="t").get_logs(A)
+    assert not isinstance(exc.value, PushTransientError)
+    assert "agent not found" in str(exc.value)

{dooers_cli-0.8.2 → dooers_cli-0.9.0}/uv.lock

@@ -232,7 +232,7 @@ toml = [
 
 [[package]]
 name = "dooers-cli"
-version = "0.8.2"
+version = "0.9.0"
 source = { editable = "." }
 dependencies = [
     { name = "dooers-protocol" },
@@ -278,7 +278,7 @@ provides-extras = ["dev"]
 
 [[package]]
 name = "dooers-protocol"
-version = "0.7.0"
+version = "0.8.0"
 source = { editable = "../dooers-protocol" }
 dependencies = [
     { name = "pydantic" },

dooers_cli-0.8.2/README.md

@@ -1,40 +0,0 @@
-# dooers (CLI)
-
-The Dooers CLI. Installed by agent creators.
-
-```bash
-pip install dooers
-```
-
-## Commands
-
-```bash
-# auth (email prompts if omitted)
-dooers login you@example.com
-dooers whoami
-dooers logout
-
-# agents
-dooers agents list
-dooers agents create --name my-agent
-dooers agents show ag_8h2k
-
-# push (reads dooers.yaml in cwd unless agent_id given)
-dooers validate
-dooers push [<agent_id>] [--tag latest] [--env prod|stg|dev]
-```
-
-## Global config (precedence: flag > env > default)
-
-| Setting | Flag | Env var | Default |
-|---|---|---|---|
-| Core API host | `--core-url` | `DOOERS_CORE_URL` | `https://api.dooers.ai` |
-| dooers-push host | `--push-url` | `DOOERS_PUSH_URL` | `https://host.dooers.ai` |
-| Target environment | `--env` | `DOOERS_ENV` | `prod` |
-
-## Development
-
-```bash
-uv sync --extra dev
-uv run poe dev
-```