aw-watcher-agent 0.2.0__py3-none-any.whl

aw_watcher_agent/__init__.py

@@ -0,0 +1,6 @@
+"""aw-watcher-agent: log AI coding-assistant sessions to a local aw-server."""
+
+from .client import AWClient, AWClientError, Event, DEFAULT_SERVER, utc_now_iso
+
+__all__ = ["AWClient", "AWClientError", "Event", "DEFAULT_SERVER", "utc_now_iso"]
+__version__ = "0.2.0"

aw_watcher_agent/cc_tailer.py

@@ -0,0 +1,262 @@
+"""Claude Code session log-tailer: zero-config ``app.agent.session`` blocks.
+
+Claude Code writes one JSONL transcript per session under
+``~/.claude/projects/<project-slug>/<session-id>.jsonl`` (``CLAUDE_CONFIG_DIR``
+moves the root). Every user/assistant row carries ``timestamp``, ``sessionId``
+and ``cwd``. We read only those fields — never prompts, replies or tool
+payloads — and turn each session into working blocks: consecutive rows closer
+than ``gap_s`` (default 15 min) belong to one block, so a session left open
+overnight does not paint the whole night as agent time.
+
+Each finished block becomes one event in the same ``app.agent.session`` bucket
+the lifecycle hooks write to, so hook users and tailer users see the same lane.
+This is the no-hook path: run it from a timer and Claude Code work appears on
+the Timeline without editing any harness configuration.
+
+A cursor per transcript records how many blocks were emitted. The trailing
+block is held back until it is older than ``gap_s``, so it is emitted once,
+complete, instead of growing under repeated runs.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sqlite3
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable
+
+from . import core
+from .client import AWClient, Event
+
+DEFAULT_GAP_S = 15 * 60
+_ROW_TYPES = ("user", "assistant")
+
+
+def default_projects_dir() -> Path:
+    """Root of Claude Code transcripts (honors ``CLAUDE_CONFIG_DIR``)."""
+    base = os.environ.get("CLAUDE_CONFIG_DIR") or os.path.expanduser("~/.claude")
+    return Path(base) / "projects"
+
+
+def transcripts(projects_dir: Path | None = None) -> list[Path]:
+    """All top-level session transcripts, oldest first (subagent logs excluded)."""
+    root = projects_dir or default_projects_dir()
+    if not root.exists():
+        return []
+    return sorted(root.glob("*/*.jsonl"), key=lambda p: p.stat().st_mtime)
+
+
+@dataclass
+class WorkBlock:
+    """One contiguous stretch of activity within a Claude Code session."""
+
+    session_id: str
+    workspace: str
+    start: datetime
+    end: datetime
+
+    def to_event(self) -> Event:
+        data = core.session_data(
+            {
+                "harness": "claude-code",
+                "session_id": self.session_id,
+                "workspace": self.workspace,
+            }
+        )
+        return Event(
+            timestamp=self.start.isoformat(),
+            duration=(self.end - self.start).total_seconds(),
+            data=data,
+        )
+
+
+def _parse_ts(ts: Any) -> datetime | None:
+    if not isinstance(ts, str):
+        return None
+    try:
+        dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)
+
+
+def parse_session(lines: Iterable[str], *, gap_s: float = DEFAULT_GAP_S) -> list[WorkBlock]:
+    """Split one transcript into working blocks separated by gaps > ``gap_s``.
+
+    Sidechain rows (subagent turns inlined in the parent log) are ignored; they
+    overlap the parent's own rows and would only blur block boundaries.
+    """
+    rows: list[tuple[datetime, str, str]] = []
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            rec = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(rec, dict) or rec.get("type") not in _ROW_TYPES:
+            continue
+        if rec.get("isSidechain"):
+            continue
+        ts = _parse_ts(rec.get("timestamp"))
+        sid = rec.get("sessionId")
+        if ts is None or not isinstance(sid, str) or not sid:
+            continue
+        cwd = rec.get("cwd")
+        rows.append((ts, sid, cwd if isinstance(cwd, str) else ""))
+
+    rows.sort(key=lambda r: r[0])
+    blocks: list[WorkBlock] = []
+    for ts, sid, cwd in rows:
+        last = blocks[-1] if blocks else None
+        if last and last.session_id == sid and (ts - last.end).total_seconds() <= gap_s:
+            last.end = ts
+            last.workspace = cwd or last.workspace
+        else:
+            blocks.append(WorkBlock(session_id=sid, workspace=cwd, start=ts, end=ts))
+    return blocks
+
+
+def _cursor_path(transcript: Path, server: str = "", hostname: str = "") -> Path:
+    identity = json.dumps([str(transcript.resolve()), server.rstrip("/"), hostname])
+    digest = hashlib.sha256(identity.encode()).hexdigest()
+    return core.state_dir() / f"cc-cursor-{digest}.json"
+
+
+def _read_emitted(
+    transcript: Path,
+    gap_s: float = DEFAULT_GAP_S,
+    *,
+    server: str = "",
+    hostname: str = "",
+    prefix_digests: list[str] | None = None,
+) -> int:
+    try:
+        data = json.loads(_cursor_path(transcript, server, hostname).read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return 0
+    count = data.get("emitted_blocks") if isinstance(data, dict) else None
+    if type(count) is not int or count < 0:
+        raise ValueError("Invalid Claude Code cursor: emitted_blocks must be a nonnegative integer")
+    if count > 0 and data.get("gap_s", DEFAULT_GAP_S) != gap_s:
+        raise ValueError("Cannot change --gap for a transcript with already emitted blocks")
+    if count > 0 and prefix_digests is not None:
+        if count > len(prefix_digests) or data.get("prefix_digest") != prefix_digests[count - 1]:
+            raise ValueError("Claude Code checkpointed prefix changed or cannot be verified")
+    return count
+
+
+def _prefix_digests(blocks: list[WorkBlock]) -> list[str]:
+    """Hash emitted event metadata incrementally, without storing transcript content."""
+    digest = hashlib.sha256()
+    prefixes = []
+    for block in blocks:
+        digest.update(json.dumps(block.to_event().to_payload(), sort_keys=True).encode())
+        digest.update(b"\n")
+        prefixes.append(digest.hexdigest())
+    return prefixes
+
+
+def _write_emitted(
+    transcript: Path,
+    count: int,
+    gap_s: float = DEFAULT_GAP_S,
+    *,
+    server: str = "",
+    hostname: str = "",
+    prefix_digest: str | None = None,
+) -> None:
+    path = _cursor_path(transcript, server, hostname)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    # The caller holds the transcript lock, so one fixed sibling temp is safe.
+    temporary = path.with_suffix(".tmp")
+    try:
+        temporary.write_text(
+            json.dumps({"emitted_blocks": count, "gap_s": gap_s, "prefix_digest": prefix_digest}),
+            encoding="utf-8",
+        )
+        temporary.replace(path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def emit_file(
+    client: AWClient,
+    hostname: str,
+    path: Path,
+    *,
+    gap_s: float = DEFAULT_GAP_S,
+    now: datetime | None = None,
+) -> int:
+    """Emit the finished, not-yet-emitted blocks of one transcript.
+
+    Returns the number of events posted. A block is finished once its last row
+    is more than ``gap_s`` old; the in-progress trailing block waits. If another
+    invocation owns this transcript, skip it until the next run.
+    """
+    lock_path = _cursor_path(path, client.server, hostname).with_suffix(".lock.sqlite3")
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    # SQLite provides a cross-platform process lock, released even on a crash.
+    # Keep this separate from the JSON cursor and never unlink the lock file.
+    lock = sqlite3.connect(lock_path, timeout=0)
+    try:
+        try:
+            lock.execute("BEGIN IMMEDIATE")
+        except sqlite3.OperationalError as exc:
+            if str(exc) == "database is locked":
+                return 0
+            raise
+        return _emit_file_locked(client, hostname, path, gap_s=gap_s, now=now)
+    finally:
+        lock.close()
+
+
+def _emit_file_locked(
+    client: AWClient,
+    hostname: str,
+    path: Path,
+    *,
+    gap_s: float,
+    now: datetime | None,
+) -> int:
+    now = now or datetime.now(timezone.utc)
+    text = path.read_text(encoding="utf-8", errors="replace")
+    lines = text.splitlines()
+    incomplete = False
+    if lines and not text.endswith("\n"):
+        try:
+            json.loads(lines[-1])
+        except json.JSONDecodeError:
+            incomplete = True
+    blocks = parse_session(lines, gap_s=gap_s)
+    # A partially written row may extend the last parsed block. Earlier blocks
+    # already have a complete successor establishing their idle boundary.
+    candidates = blocks[:-1] if incomplete else blocks
+    finished = [b for b in candidates if (now - b.end).total_seconds() > gap_s]
+    prefix_digests = _prefix_digests(finished)
+    emitted = _read_emitted(
+        path, gap_s, server=client.server, hostname=hostname, prefix_digests=prefix_digests
+    )
+    new = finished[emitted:]
+    if not new:
+        return 0
+
+    bucket = core.bucket_id(hostname)
+    client.ensure_bucket(bucket, core.BUCKET_TYPE, core.CLIENT_NAME, hostname)
+    for block in new:
+        client.post_event(bucket, block.to_event())
+        emitted += 1
+        _write_emitted(
+            path,
+            emitted,
+            gap_s,
+            server=client.server,
+            hostname=hostname,
+            prefix_digest=prefix_digests[emitted - 1],
+        )
+    return len(new)

aw_watcher_agent/cli.py

@@ -0,0 +1,287 @@
+"""``aw-watcher-agent`` CLI: emit AI-assistant session activity to a local aw-server.
+
+Subcommands:
+    ensure-bucket   Create the session bucket if missing.
+    emit-start      Record the start of an AI session (zero-duration placeholder).
+    emit-end        Replace the placeholder with one event carrying duration + outcome.
+
+Designed to be called from harness lifecycle hooks (e.g. Claude Code
+SessionStart/Stop). Failures are non-fatal by default (``--strict`` to opt in)
+so a watcher problem never breaks the agent session it observes.
+"""
+
+from __future__ import annotations
+
+import argparse
+import socket
+import sqlite3
+import sys
+from datetime import datetime, timedelta, timezone
+
+from .client import AWClient, AWClientError, Event, utc_now_iso
+from . import core
+
+
+def _hostname(explicit: str | None) -> str:
+    return explicit or socket.gethostname()
+
+
+def _parse_iso(ts: str) -> datetime:
+    return datetime.fromisoformat(ts)
+
+
+def _add_session_args(p: argparse.ArgumentParser) -> None:
+    p.add_argument("--harness", help="gptme / claude-code / codex")
+    p.add_argument("--model", help="resolved model id, e.g. claude-opus-4-7")
+    p.add_argument("--category", help="session category if known")
+    p.add_argument("--session-id", dest="session_id", help="harness session hash")
+    p.add_argument("--trigger", help="autonomous / interactive / timer")
+    p.add_argument("--workspace", help="workspace / agent name")
+    p.add_argument("--hostname", help="override hostname (default: socket.gethostname())")
+    p.add_argument("--server", default=core_default_server(), help="aw-server base URL")
+
+
+def core_default_server() -> str:
+    from .client import DEFAULT_SERVER
+
+    return DEFAULT_SERVER
+
+
+def cmd_ensure_bucket(args: argparse.Namespace) -> int:
+    client = AWClient(args.server)
+    host = _hostname(args.hostname)
+    bid = core.bucket_id(host)
+    created = client.ensure_bucket(bid, core.BUCKET_TYPE, core.CLIENT_NAME, host)
+    print(f"bucket {bid}: {'created' if created else 'already exists'}")
+    return 0
+
+
+def cmd_emit_start(args: argparse.Namespace) -> int:
+    client = AWClient(args.server)
+    host = _hostname(args.hostname)
+    bid = core.bucket_id(host)
+    client.ensure_bucket(bid, core.BUCKET_TYPE, core.CLIENT_NAME, host)
+
+    start = utc_now_iso()
+    data = core.session_data(vars(args))
+    event = Event(timestamp=start, duration=0.0, data=data)
+    # Use heartbeat, not POST /events: aw-server's events endpoint returns null,
+    # but heartbeat returns the created event (with id) so emit-end can delete
+    # this placeholder and leave a single clean block.
+    event_id = client.heartbeat(bid, event, pulsetime=0.0)
+
+    sid = args.session_id or start
+    core.write_state(sid, {"bucket_id": bid, "event_id": event_id, "start": start, "data": data})
+    print(f"session start emitted: {bid} event_id={event_id} session_id={sid}")
+    return 0
+
+
+def cmd_emit_end(args: argparse.Namespace) -> int:
+    client = AWClient(args.server)
+    host = _hostname(args.hostname)
+    bid = core.bucket_id(host)
+    client.ensure_bucket(bid, core.BUCKET_TYPE, core.CLIENT_NAME, host)
+
+    sid = args.session_id or ""
+    state = core.read_state(sid) if sid else None
+    end = utc_now_iso()
+
+    if state and state.get("start"):
+        start = state["start"]
+        duration = (_parse_iso(end) - _parse_iso(start)).total_seconds()
+        # Drop the zero-duration placeholder so we end with one clean block.
+        if state.get("event_id") is not None:
+            if not client.delete_event(state.get("bucket_id", bid), state["event_id"]):
+                print(
+                    f"warning: failed to delete placeholder event {state['event_id']} "
+                    f"from {state.get('bucket_id', bid)} — timeline may contain duplicate block",
+                    file=sys.stderr,
+                )
+    else:
+        # No recorded start (crash / hook gap): fall back to provided duration.
+        start = end
+        duration = float(args.duration or 0.0)
+
+    # Merge saved start metadata with any fields supplied at emit-end time.
+    # CLI args at emit-end take precedence (allows corrections), outcome appended.
+    saved_data: dict[str, str] = (state.get("data") or {}) if state else {}
+    cli_overrides = core.session_data(vars(args))
+    merged = {**saved_data, **cli_overrides}
+    if args.outcome:
+        merged["outcome"] = str(args.outcome)
+    data = merged
+    event = Event(timestamp=start, duration=max(duration, 0.0), data=data)
+    # pulsetime=0 forces a fresh event (the outcome field differs from any prior
+    # block anyway); heartbeat returns the id for logging where POST does not.
+    event_id = client.heartbeat(bid, event, pulsetime=0.0)
+    if sid:
+        core.clear_state(sid)
+    print(
+        f"session end emitted: {bid} event_id={event_id} "
+        f"duration={duration:.1f}s outcome={args.outcome}"
+    )
+    return 0
+
+
+def cmd_emit_activity(args: argparse.Namespace) -> int:
+    client = AWClient(args.server)
+    host = _hostname(args.hostname)
+    bid = core.activity_bucket_id(host)
+    client.ensure_bucket(bid, core.ACTIVITY_BUCKET_TYPE, core.CLIENT_NAME, host)
+
+    duration_ms = max(int(args.duration_ms or 0), 0)
+    duration_s = duration_ms / 1000.0
+    start = datetime.now(timezone.utc) - timedelta(milliseconds=duration_ms)
+    event = Event(
+        timestamp=start.isoformat(),
+        duration=duration_s,
+        data=core.activity_data(vars(args)),
+    )
+    event_id = client.heartbeat(bid, event, pulsetime=float(args.pulsetime))
+    print(
+        f"activity emitted: {bid} event_id={event_id} "
+        f"tool={args.tool} duration_ms={duration_ms}"
+    )
+    return 0
+
+
+def cmd_tail_codex(args: argparse.Namespace) -> int:
+    from pathlib import Path
+
+    from . import tailer
+
+    client = AWClient(args.server)
+    host = _hostname(args.hostname)
+
+    path: Path | None = Path(args.file) if args.file else tailer.latest_rollout()
+    if path is None:
+        print("no Codex rollout transcripts found", file=sys.stderr)
+        return 0
+    count = tailer.emit_file(client, host, path, pulsetime=args.pulsetime)
+    bid = core.activity_bucket_id(host)
+    print(f"codex activity emitted: {bid} events={count} file={path.name}")
+    return 0
+
+
+def cmd_tail_claude_code(args: argparse.Namespace) -> int:
+    from pathlib import Path
+
+    from . import cc_tailer
+
+    client = AWClient(args.server)
+    host = _hostname(args.hostname)
+    files = [Path(args.file)] if args.file else cc_tailer.transcripts()
+    if not files:
+        print("no Claude Code transcripts found", file=sys.stderr)
+        return 0
+    total = 0
+    failed = False
+    for path in files:
+        try:
+            total += cc_tailer.emit_file(client, host, path, gap_s=args.gap)
+        except (AWClientError, OSError, ValueError, sqlite3.Error) as exc:
+            failed = True
+            print(f"aw-watcher-agent: {path}: {exc}", file=sys.stderr)
+    print(
+        f"claude-code sessions emitted: {core.bucket_id(host)} "
+        f"events={total} transcripts={len(files)}"
+    )
+    return int(failed and args.strict)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="aw-watcher-agent", description=__doc__)
+    parser.add_argument("--strict", action="store_true", help="exit non-zero on errors")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_ensure = sub.add_parser("ensure-bucket", help="create the session bucket")
+    p_ensure.add_argument("--hostname")
+    p_ensure.add_argument("--server", default=core_default_server())
+    p_ensure.set_defaults(func=cmd_ensure_bucket)
+
+    p_start = sub.add_parser("emit-start", help="record session start")
+    _add_session_args(p_start)
+    p_start.set_defaults(func=cmd_emit_start)
+
+    p_end = sub.add_parser("emit-end", help="record session end with outcome")
+    _add_session_args(p_end)
+    p_end.add_argument("--outcome", help="productive / blocked / noop")
+    p_end.add_argument("--duration", type=float, help="fallback duration (s) if no start state")
+    p_end.set_defaults(func=cmd_emit_end)
+
+    p_activity = sub.add_parser("emit-activity", help="record one tool activity heartbeat")
+    _add_session_args(p_activity)
+    p_activity.add_argument("--tool", required=True, help="tool name, e.g. shell")
+    p_activity.add_argument(
+        "--status",
+        default="success",
+        help="coarse tool status, e.g. success / error / completed",
+    )
+    p_activity.add_argument(
+        "--duration-ms",
+        dest="duration_ms",
+        type=int,
+        default=0,
+        help="tool duration in milliseconds",
+    )
+    p_activity.add_argument(
+        "--pulsetime",
+        type=float,
+        default=5.0,
+        help="heartbeat merge window in seconds (default: 5.0)",
+    )
+    p_activity.set_defaults(func=cmd_emit_activity)
+
+    p_tail = sub.add_parser(
+        "tail-codex", help="emit per-tool activity from a Codex rollout transcript"
+    )
+    p_tail.add_argument(
+        "--file", help="rollout JSONL to process (default: latest under ~/.codex/sessions)"
+    )
+    p_tail.add_argument(
+        "--pulsetime",
+        type=float,
+        default=5.0,
+        help="heartbeat merge window in seconds (default: 5.0)",
+    )
+    p_tail.add_argument("--hostname")
+    p_tail.add_argument("--server", default=core_default_server())
+    p_tail.set_defaults(func=cmd_tail_codex)
+
+    p_cc = sub.add_parser(
+        "tail-claude-code",
+        help="emit session working blocks from Claude Code transcripts (no hooks needed)",
+    )
+    p_cc.add_argument(
+        "--file", help="transcript JSONL to process (default: all under ~/.claude/projects)"
+    )
+    p_cc.add_argument(
+        "--gap",
+        type=float,
+        default=15 * 60,
+        help="idle gap in seconds that splits a session into blocks (default: 900)",
+    )
+    p_cc.add_argument("--hostname")
+    p_cc.add_argument("--server", default=core_default_server())
+    p_cc.set_defaults(func=cmd_tail_claude_code)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        return int(args.func(args))
+    except (AWClientError, OSError, ValueError, sqlite3.Error) as exc:
+        msg = f"aw-watcher-agent: {exc}"
+        if args.strict:
+            print(msg, file=sys.stderr)
+            return 1
+        # Non-fatal by default: observing a session must never break it.
+        print(f"{msg} (ignored; use --strict to fail)", file=sys.stderr)
+        return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aw_watcher_agent/client.py

@@ -0,0 +1,150 @@
+"""Thin vendored ActivityWatch REST client (stdlib-only).
+
+Phase 1 of aw-watcher-agent keeps zero heavy dependencies: it talks to a local
+aw-server over its documented REST API using ``urllib`` instead of pulling in
+``aw-client``/``aw-core``. The watcher therefore stays pip-installable and light
+enough to ship as a hook target.
+
+API shapes were verified against a live aw-server v0.13.2:
+
+- ``GET  /api/0/info`` -> ``{hostname, version, ...}``
+- ``GET  /api/0/buckets/`` -> ``{bucket_id: {id, type, client, hostname, ...}}``
+- ``POST /api/0/buckets/{id}`` -> create bucket (idempotent-ish; 304 if exists)
+- ``POST /api/0/buckets/{id}/events`` -> insert event(s); returns event with ``id``
+- ``DELETE /api/0/buckets/{id}/events/{event_id}`` -> remove an event
+- ``POST /api/0/buckets/{id}/heartbeat?pulsetime=N`` -> merge-extend an event
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any
+
+DEFAULT_SERVER = "http://127.0.0.1:5600"
+
+
+def utc_now_iso() -> str:
+    """Current UTC time as an ISO 8601 string aw-server accepts."""
+    return datetime.now(timezone.utc).isoformat()
+
+
+@dataclass
+class Event:
+    """An ActivityWatch event: a timestamped, durationed bag of string data."""
+
+    timestamp: str
+    duration: float
+    data: dict[str, Any]
+
+    def to_payload(self) -> dict[str, Any]:
+        return {
+            "timestamp": self.timestamp,
+            "duration": self.duration,
+            "data": self.data,
+        }
+
+
+class AWClientError(RuntimeError):
+    """Raised when the aw-server returns an unrecoverable error."""
+
+
+class AWClient:
+    """Minimal aw-server REST client over the stdlib."""
+
+    def __init__(self, server: str = DEFAULT_SERVER, timeout: float = 5.0) -> None:
+        self.server = server.rstrip("/")
+        self.timeout = timeout
+
+    def _request(self, method: str, path: str, body: Any | None = None) -> tuple[int, Any]:
+        url = f"{self.server}{path}"
+        data = json.dumps(body).encode() if body is not None else None
+        req = urllib.request.Request(url, data=data, method=method)
+        if data is not None:
+            req.add_header("Content-Type", "application/json")
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read()
+                parsed = json.loads(raw) if raw else None
+                return resp.status, parsed
+        except urllib.error.HTTPError as exc:
+            raw = exc.read()
+            try:
+                parsed = json.loads(raw) if raw else None
+            except json.JSONDecodeError:
+                parsed = raw.decode(errors="replace")
+            return exc.code, parsed
+
+    # --- read ---------------------------------------------------------------
+
+    def info(self) -> dict[str, Any]:
+        status, body = self._request("GET", "/api/0/info")
+        if status != 200 or not isinstance(body, dict):
+            raise AWClientError(f"unexpected /info response: {status} {body!r}")
+        return body
+
+    def buckets(self) -> dict[str, Any]:
+        status, body = self._request("GET", "/api/0/buckets/")
+        if status != 200 or not isinstance(body, dict):
+            raise AWClientError(f"unexpected /buckets response: {status} {body!r}")
+        return body
+
+    # --- bucket lifecycle ---------------------------------------------------
+
+    def ensure_bucket(
+        self,
+        bucket_id: str,
+        event_type: str,
+        client_name: str,
+        hostname: str,
+    ) -> bool:
+        """Create the bucket if missing. Returns True if newly created.
+
+        Idempotent: an already-existing bucket is treated as success rather than
+        an error, so the watcher can call this on every session start.
+        """
+        if bucket_id in self.buckets():
+            return False
+        payload = {
+            "client": client_name,
+            "type": event_type,
+            "hostname": hostname,
+        }
+        status, body = self._request("POST", f"/api/0/buckets/{bucket_id}", payload)
+        # 200/201 = created, 304 = already existed (race with a parallel start)
+        if status in (200, 201, 304):
+            return status != 304
+        raise AWClientError(f"failed to create bucket {bucket_id}: {status} {body!r}")
+
+    # --- events -------------------------------------------------------------
+
+    def post_event(self, bucket_id: str, event: Event) -> int | None:
+        """Insert a single event. Returns the server-assigned event id if present."""
+        status, body = self._request(
+            "POST", f"/api/0/buckets/{bucket_id}/events", event.to_payload()
+        )
+        if status not in (200, 201):
+            raise AWClientError(f"failed to post event to {bucket_id}: {status} {body!r}")
+        if isinstance(body, dict):
+            return body.get("id")
+        if isinstance(body, list) and body and isinstance(body[0], dict):
+            return body[0].get("id")
+        return None
+
+    def delete_event(self, bucket_id: str, event_id: int) -> bool:
+        status, _ = self._request("DELETE", f"/api/0/buckets/{bucket_id}/events/{event_id}")
+        return status in (200, 204)
+
+    def heartbeat(self, bucket_id: str, event: Event, pulsetime: float) -> int | None:
+        """Merge-extend the latest event whose data matches, within ``pulsetime``."""
+        status, body = self._request(
+            "POST",
+            f"/api/0/buckets/{bucket_id}/heartbeat?pulsetime={pulsetime}",
+            event.to_payload(),
+        )
+        if status not in (200, 201):
+            raise AWClientError(f"failed to heartbeat {bucket_id}: {status} {body!r}")
+        return body.get("id") if isinstance(body, dict) else None

aw_watcher_agent/core.py

@@ -0,0 +1,112 @@
+"""Session bucket conventions and crash-robust state for aw-watcher-agent.
+
+A session is modelled as a single event in the ``app.agent.session`` bucket.
+``emit-start`` posts a zero-duration start event and records its server id; on
+``emit-end`` we delete that placeholder and post one clean event carrying the
+full duration plus ``outcome``. This yields exactly one Timeline block per
+session with complete metadata.
+
+Why not heartbeat-extend the start event? ActivityWatch only merges consecutive
+events with *identical* ``data``. ``outcome`` is unknown until the session ends
+and changes the payload, so a heartbeat with the outcome would not merge with
+the start event. Delete-then-repost keeps a single block while still recording
+the outcome. If ``emit-end`` never runs (crash), the zero-duration start event
+still marks that the session began.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+BUCKET_TYPE = "app.agent.session"
+CLIENT_NAME = "aw-watcher-agent"
+
+# Per-tool activity events live in their own bucket type. Phase 2 originally
+# proposed reusing the session bucket to keep "AI work" as a single Timeline
+# lane, but session events (one long block spanning the whole run) and per-tool
+# events (many short blocks) overlap in time, which ActivityWatch cannot render
+# as a single clean lane. A sibling bucket keeps both lanes honest; aw-webui can
+# still stack them. See the Phase 2 PR for the design note.
+ACTIVITY_BUCKET_TYPE = "app.agent.activity"
+
+# Stable session fields (everything except outcome, which is end-only).
+START_FIELDS = ("harness", "model", "category", "session_id", "trigger", "workspace")
+ACTIVITY_FIELDS = (
+    "harness",
+    "session_id",
+    "tool",
+    "status",
+    "model",
+    "category",
+    "trigger",
+    "workspace",
+)
+
+
+def bucket_id(hostname: str) -> str:
+    """Bucket id following the ``aw-watcher-<name>_<hostname>`` convention."""
+    return f"{CLIENT_NAME}_{hostname}"
+
+
+def activity_bucket_id(hostname: str) -> str:
+    """Bucket id for per-tool activity events (sibling of the session bucket)."""
+    return f"{CLIENT_NAME}-activity_{hostname}"
+
+
+def state_dir() -> Path:
+    """Per-session state directory (honors XDG_STATE_HOME)."""
+    base = os.environ.get("XDG_STATE_HOME") or os.path.expanduser("~/.local/state")
+    return Path(base) / CLIENT_NAME
+
+
+def state_path(session_id: str) -> Path:
+    safe = "".join(c if c.isalnum() or c in "-_." else "_" for c in session_id)
+    return state_dir() / f"session-{safe}.json"
+
+
+def write_state(session_id: str, payload: dict[str, Any]) -> Path:
+    path = state_path(session_id)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload), encoding="utf-8")
+    return path
+
+
+def read_state(session_id: str) -> dict[str, Any] | None:
+    path = state_path(session_id)
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def clear_state(session_id: str) -> None:
+    path = state_path(session_id)
+    try:
+        path.unlink()
+    except FileNotFoundError:
+        pass
+
+
+def session_data(args: dict[str, Any], *, outcome: str | None = None) -> dict[str, str]:
+    """Build the event ``data`` map from CLI args, dropping empty values."""
+    data = {f: str(args[f]) for f in START_FIELDS if args.get(f)}
+    if outcome:
+        data["outcome"] = str(outcome)
+    return data
+
+
+def activity_data(args: dict[str, Any]) -> dict[str, str]:
+    """Build per-tool activity event data, dropping empty values.
+
+    Raises ValueError if 'tool' is absent or empty — it is the semantic
+    discriminator for per-tool heartbeats and cannot be safely omitted.
+    """
+    if not args.get("tool"):
+        raise ValueError("activity_data: 'tool' is required but missing or empty")
+    return {f: str(args[f]) for f in ACTIVITY_FIELDS if args.get(f)}

aw_watcher_agent/tailer.py

@@ -0,0 +1,256 @@
+"""Codex transcript log-tailer: emit per-tool ``app.agent.activity`` heartbeats.
+
+Phase 2 fallback for harnesses that cannot host an in-process gptme plugin hook.
+Codex writes rollout transcripts to ``~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl``.
+Each line is ``{"timestamp", "type", "payload"}``. A tool call is a
+``response_item`` whose ``payload.type == "function_call"`` (carrying ``name``,
+``call_id``, ``arguments``); its result is a later ``function_call_output`` with
+the matching ``call_id``. We pair them, compute a duration, derive a coarse
+status from the output, and emit one activity event per call into the
+``aw-watcher-agent-activity_<hostname>`` bucket.
+
+The parser (:func:`parse_rollout`) is pure and stdlib-only so it is testable
+without a live aw-server or a real Codex session. Emission (:func:`emit_file`)
+reuses the vendored :class:`~aw_watcher_agent.client.AWClient` and heartbeats so
+adjacent calls of the same tool merge into a single Timeline block.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Iterable, cast
+
+from .client import AWClient, Event
+from . import core
+
+# Codex marks shell exits as "Process exited with code N" / "exited with code N".
+_EXIT_CODE_RE = re.compile(r"exited with code (\d+)")
+
+
+# ---------------------------------------------------------------------------
+# Cursor helpers: prevent duplicate emission when tail-codex is re-run on the
+# same rollout file (e.g. from a timer).  We persist the 0-based index and
+# timestamp of the last emitted activity so emit_file only sends new calls.
+# ---------------------------------------------------------------------------
+
+
+def _cursor_path(rollout_path: Path) -> Path:
+    """Path to the cursor state file for a given rollout."""
+    safe = re.sub(r"[^a-zA-Z0-9._-]", "_", str(rollout_path.absolute()))
+    return core.state_dir() / f"cursor-{safe}.json"
+
+
+def _read_cursor(rollout_path: Path) -> dict[str, Any] | None:
+    """Last-emitted cursor for *rollout_path*, or ``None``."""
+    path = _cursor_path(rollout_path)
+    if not path.exists():
+        return None
+    try:
+        return cast(dict[str, Any], json.loads(path.read_text(encoding="utf-8")))
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def _write_cursor(rollout_path: Path, last_index: int, last_timestamp: str) -> None:
+    """Persist the cursor after emitting activities."""
+    path = _cursor_path(rollout_path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload: dict[str, Any] = {"last_index": last_index, "last_timestamp": last_timestamp}
+    path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+
+def default_sessions_dir() -> Path:
+    """Root of Codex rollout transcripts (honors ``CODEX_HOME``)."""
+    base = os.environ.get("CODEX_HOME") or os.path.expanduser("~/.codex")
+    return Path(base) / "sessions"
+
+
+def latest_rollout(sessions_dir: Path | None = None) -> Path | None:
+    """Most recently modified ``rollout-*.jsonl`` under ``sessions_dir``."""
+    root = sessions_dir or default_sessions_dir()
+    if not root.exists():
+        return None
+    files = sorted(root.rglob("rollout-*.jsonl"), key=lambda p: p.stat().st_mtime)
+    return files[-1] if files else None
+
+
+@dataclass
+class ToolActivity:
+    """One paired Codex tool call: name, coarse status, and wall-clock duration."""
+
+    tool: str
+    status: str
+    duration_ms: int
+    timestamp: str  # ISO 8601 start time (the function_call timestamp)
+    call_id: str
+    session_id: str
+    paired: bool = True  # False when function_call_output not yet in transcript
+
+    def to_event(self, *, min_duration_s: float = 0.0) -> Event:
+        """Build an AW event. ``data`` excludes duration so same-tool/status
+        calls merge under heartbeat; the per-call duration drives the block."""
+        data = core.activity_data(
+            {
+                "harness": "codex",
+                "session_id": self.session_id,
+                "tool": self.tool,
+                "status": self.status,
+            }
+        )
+        return Event(
+            timestamp=self.timestamp,
+            duration=max(self.duration_ms / 1000.0, min_duration_s),
+            data=data,
+        )
+
+
+def _status_from_output(output: Any) -> str:
+    """Coarse success/error/completed status from a function_call_output."""
+    if not isinstance(output, str) or not output.strip():
+        return "completed"
+    match = _EXIT_CODE_RE.search(output)
+    if match:
+        return "success" if match.group(1) == "0" else "error"
+    return "completed"
+
+
+def _parse_ts(ts: str) -> datetime | None:
+    try:
+        # Codex stamps RFC3339 with a trailing 'Z'; fromisoformat wants +00:00.
+        return datetime.fromisoformat(ts.replace("Z", "+00:00"))
+    except (ValueError, AttributeError):
+        return None
+
+
+def _iter_records(lines: Iterable[str]) -> Iterable[dict[str, Any]]:
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            obj = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(obj, dict):
+            yield obj
+
+
+def parse_rollout(lines: Iterable[str]) -> tuple[str, list[ToolActivity]]:
+    """Parse Codex rollout JSONL into ``(session_id, [ToolActivity, ...])``.
+
+    Pairs each ``function_call`` with its matching ``function_call_output`` by
+    ``call_id``. A call with no output (crash/truncation) is still emitted with
+    a zero duration and ``completed`` status so the Timeline marks that it ran.
+    """
+    session_id = ""
+    # Preserve call order; map call_id -> pending call record.
+    pending: dict[str, dict[str, Any]] = {}
+    order: list[str] = []
+
+    for rec in _iter_records(lines):
+        payload = rec.get("payload")
+        if not isinstance(payload, dict):
+            continue
+        ptype = payload.get("type")
+
+        if rec.get("type") == "session_meta" and not session_id:
+            sid = payload.get("id")
+            if isinstance(sid, str):
+                session_id = sid
+            continue
+
+        if ptype == "function_call":
+            call_id = payload.get("call_id")
+            if not isinstance(call_id, str) or call_id in pending:
+                continue
+            pending[call_id] = {
+                "tool": str(payload.get("name") or "unknown"),
+                "start": rec.get("timestamp"),
+            }
+            order.append(call_id)
+        elif ptype == "function_call_output":
+            call_id = payload.get("call_id")
+            call = pending.get(call_id) if isinstance(call_id, str) else None
+            if call is not None:
+                call["end"] = rec.get("timestamp")
+                call["status"] = _status_from_output(payload.get("output"))
+
+    activities: list[ToolActivity] = []
+    for call_id in order:
+        call = pending[call_id]
+        start = call.get("start")
+        if not isinstance(start, str):
+            continue
+        duration_ms = 0
+        end = call.get("end")
+        if isinstance(end, str):
+            t0, t1 = _parse_ts(start), _parse_ts(end)
+            if t0 and t1:
+                duration_ms = max(int((t1 - t0).total_seconds() * 1000), 0)
+        activities.append(
+            ToolActivity(
+                tool=call["tool"],
+                status=call.get("status", "completed"),
+                duration_ms=duration_ms,
+                timestamp=start,
+                call_id=call_id,
+                session_id=session_id,
+                paired="end" in call,
+            )
+        )
+    return session_id, activities
+
+
+def emit_file(
+    client: AWClient,
+    hostname: str,
+    path: Path,
+    *,
+    pulsetime: float = 5.0,
+) -> int:
+    """Parse one rollout file and emit **new** tool activities since the last run.
+
+    Uses a cursor file (alongside the rollout) to skip previously-emitted
+    calls, so timer-driven runs do not duplicate historical heartbeats.
+    Returns the count of activities actually emitted this invocation.
+
+    ``pulsetime`` controls heartbeat merging: consecutive same-tool/same-status
+    calls within this many seconds collapse into a single Timeline block.
+    """
+    cursor = _read_cursor(path)
+    last_index = cursor.get("last_index", -1) if cursor else -1
+
+    text = path.read_text(encoding="utf-8", errors="replace")
+    _, activities = parse_rollout(text.splitlines())
+
+    # Only emit calls that are new since the last cursor position.
+    new = activities[last_index + 1 :]
+    if not new:
+        return 0
+
+    # Stop short of trailing unpaired (in-flight) calls so the cursor never
+    # advances past a call whose output hasn't arrived yet.  Unpaired calls in
+    # the middle of the list (orphaned by a crash) are still emitted.
+    last_paired_pos = len(new) - 1
+    while last_paired_pos >= 0 and not new[last_paired_pos].paired:
+        last_paired_pos -= 1
+
+    to_emit = new[: last_paired_pos + 1]
+    if not to_emit:
+        return 0
+
+    bucket = core.activity_bucket_id(hostname)
+    client.ensure_bucket(bucket, core.ACTIVITY_BUCKET_TYPE, core.CLIENT_NAME, hostname)
+    for activity in to_emit:
+        client.heartbeat(bucket, activity.to_event(), pulsetime=pulsetime)
+
+    # Advance the cursor to the last emitted (paired) activity.
+    final_index = last_index + len(to_emit)
+    final_ts = to_emit[-1].timestamp
+    _write_cursor(path, final_index, final_ts)
+    return len(to_emit)

aw_watcher_agent-0.2.0.dist-info/METADATA

@@ -0,0 +1,188 @@
+Metadata-Version: 2.5
+Name: aw-watcher-agent
+Version: 0.2.0
+Summary: ActivityWatch watcher for AI coding assistants (gptme, Claude Code, Codex)
+License-Expression: MIT
+Keywords: activitywatch,ai-agents,aw-watcher,gptme,time-tracking
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# aw-watcher-agent
+
+An [ActivityWatch](https://activitywatch.net) watcher for **AI coding
+assistants** (gptme, Claude Code, Codex). It logs agent sessions and per-tool
+activity to your **local** aw-server, so AI work shows up in the aw-webui
+Timeline alongside window/AFK data instead of looking like idle time.
+
+**Status:** alpha (`0.2.0`). Session tracking and the Codex log-tailer work and
+are dogfooded against a local aw-server, as is the Claude Code log-tailer. A
+native gptme plugin hook for per-tool events and an aw-webui "AI work" view are
+not built yet.
+
+This is the controller use case behind
+[ActivityWatch/activitywatch#1215](https://github.com/ActivityWatch/activitywatch/issues/1215).
+
+## Design
+
+- **Local-only, privacy-first.** Writes go only to your own aw-server
+  (default `http://127.0.0.1:5600`). No hosted aggregation and no transcripts —
+  only coarse metadata (harness, model, category, tool name, status, counts).
+- **No dependencies.** A small vendored stdlib REST client instead of
+  `aw-client` / `aw-core`, so it is light enough to call from a lifecycle hook.
+- **One clean Timeline block per session.** `emit-start` posts a zero-duration
+  placeholder; `emit-end` deletes it and posts a single event with the full
+  duration plus `outcome`. If the session crashes before `emit-end`, the
+  placeholder still marks that it started.
+- **Never breaks the session it observes.** Errors are reported on stderr and
+  the CLI exits 0, unless you pass `--strict`.
+
+## Install
+
+```bash
+pipx install aw-watcher-agent   # or: pip install aw-watcher-agent / uv tool install aw-watcher-agent
+# latest unreleased master:
+pip install "git+https://github.com/gptme/gptme-contrib#subdirectory=packages/aw-watcher-agent"
+# or, from a gptme-contrib checkout:
+pip install -e packages/aw-watcher-agent
+```
+
+This installs the `aw-watcher-agent` command. You need a running aw-server
+(ActivityWatch's default on port 5600).
+
+## Usage
+
+### Sessions
+
+```bash
+# Create the session bucket (idempotent; emit-start also does this)
+aw-watcher-agent ensure-bucket
+
+# At session start
+aw-watcher-agent emit-start \
+  --harness claude-code --model claude-opus-4-7 \
+  --category code --session-id 8531 --trigger autonomous --workspace myagent
+
+# At session end (reads the saved start state, records duration + outcome)
+aw-watcher-agent emit-end --session-id 8531 --outcome productive
+```
+
+Events land in the bucket `aw-watcher-agent_<hostname>` (type
+`app.agent.session`), which appears in aw-webui automatically.
+
+Session flags (shared by `emit-start`, `emit-end` and `emit-activity`):
+`--harness`, `--model`, `--category`, `--session-id`, `--trigger`,
+`--workspace`, `--hostname` (default: the machine hostname) and `--server`
+(aw-server base URL). `emit-end` additionally takes `--outcome` and
+`--duration` (seconds; used only when no start state was recorded). Values
+passed to `emit-end` override the ones saved at start.
+
+Start state is kept per session id under
+`$XDG_STATE_HOME/aw-watcher-agent/` (default `~/.local/state/aw-watcher-agent/`).
+
+### Claude Code without hooks (log-tailer)
+
+`tail-claude-code` reads the transcripts Claude Code already writes under
+`~/.claude/projects/` (or `$CLAUDE_CONFIG_DIR/projects`) and posts one
+session event per working block, so Claude Code work shows up on the Timeline
+with no harness configuration:
+
+```bash
+aw-watcher-agent tail-claude-code            # every transcript
+aw-watcher-agent tail-claude-code --gap 600  # split blocks on 10 min idle
+```
+
+Only `timestamp`, `sessionId` and `cwd` are read; prompts, replies and tool
+payloads are never touched. A session is split into blocks on idle gaps
+longer than `--gap` (default 15 min), so a session left open overnight is not
+counted as agent time. The trailing block is held back until it has been idle
+for `--gap`, and a per-transcript cursor records each successful post. Overlapping
+invocations skip transcripts already being processed. Cursor writes are atomic;
+retrying a failed later post does not replay the checkpointed prefix. Once blocks
+have been emitted, changing `--gap` for that transcript is rejected rather than
+posting overlapping representations. A digest of the checkpointed event metadata
+also rejects historical inserts, rewrites or truncation that change already emitted
+blocks; it does not silently skip or replay them. Only a missing cursor starts a
+new import: unreadable, corrupt or older count-only cursors fail closed. Preserve
+such a cursor and reconcile the destination events before resetting it, since
+removing it reimports the transcript. A failed transcript is reported on stderr
+without preventing other transcripts from being processed; `--strict` returns
+nonzero after the scan if any failed. This is not transactional exactly-once
+delivery: a crash after the server accepts a post but before its checkpoint can
+still duplicate that last event on retry. Events land in the same session bucket
+as the hooks below, with `harness=claude-code` and `workspace` set to the project
+directory. Use either the tailer or lifecycle hooks for a session, not both.
+
+### Wiring into Claude Code (or any harness with lifecycle hooks)
+
+Point your harness's session-start / session-end hooks (for Claude Code:
+`SessionStart` / `SessionEnd` in `settings.json`) at `emit-start` / `emit-end`,
+passing the same `--session-id` to both. Do not use Claude Code's `Stop` hook for
+`emit-end`: it fires after every response, so the first turn closes the session
+and each later turn posts an empty 0s event. Keep the `SessionEnd` hook
+synchronous (not `async`) so the post finishes before the process exits.
+
+### Per-tool activity
+
+Tool calls go to a sibling bucket, `aw-watcher-agent-activity_<hostname>`
+(type `app.agent.activity`). Adjacent calls with the same tool and status within
+`--pulsetime` seconds (default 5) merge into one Timeline block.
+
+Emit a single tool event yourself, e.g. from a post-tool hook:
+
+```bash
+aw-watcher-agent emit-activity --harness claude-code --session-id 8531 \
+  --tool shell --status success --duration-ms 1200
+```
+
+### Per-tool activity from Codex (log-tailer)
+
+Codex can't host an in-process hook, so `tail-codex` reads its rollout
+transcripts (`~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl`), pairs each
+`function_call` with its `function_call_output`, derives a coarse
+`success` / `error` / `completed` status, and emits one activity event per call:
+
+```bash
+# Process the most recent rollout transcript
+aw-watcher-agent tail-codex
+
+# Or a specific transcript, with a custom merge window
+aw-watcher-agent tail-codex --file ~/.codex/sessions/2026/05/29/rollout-...jsonl --pulsetime 5
+```
+
+A cursor per transcript (in the same state directory) records what was already
+emitted, so it is safe to run `tail-codex` repeatedly from a timer or after
+each Codex run.
+
+## Command reference
+
+| Command | Purpose |
+|---------|---------|
+| `ensure-bucket` | Create the session bucket if missing |
+| `emit-start` | Record session start (zero-duration placeholder) |
+| `emit-end` | Replace the placeholder with one event carrying duration + `--outcome` |
+| `emit-activity` | Record one tool-activity heartbeat (`--tool` required) |
+| `tail-codex` | Emit per-tool activity from a Codex rollout transcript |
+| `tail-claude-code` | Emit session working blocks from Claude Code transcripts (no hooks) |
+
+Global flag: `--strict` (exit non-zero on errors). Run
+`aw-watcher-agent <command> --help` for all options.
+
+## Related
+
+- [gptme-sessions](../gptme-sessions/README.md) — session tracking and
+  analytics on the agent side (this watcher puts the same sessions on your
+  ActivityWatch timeline).
+- [gptme-activity-summary](../gptme-activity-summary/README.md) — summarizes
+  agent activity, including ActivityWatch data.

aw_watcher_agent-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+aw_watcher_agent/__init__.py,sha256=wpMwwnWSSYcRxwqK6BRNRpMSyZ23_KCY_VPY_mp6xRM,265
+aw_watcher_agent/cc_tailer.py,sha256=afF28xiA3n7PWVHs23vupfigOSC1Mk3nDSQjR9TSLM4,9205
+aw_watcher_agent/cli.py,sha256=6UhlXhuLoOg0qxFUm5mcRAJ1nyRyDqrEkM_P7qRuuLE,10610
+aw_watcher_agent/client.py,sha256=LWOolub0ShatCtfI5s3yhqwcd5rWT2DMHW_eFPcgysQ,5789
+aw_watcher_agent/core.py,sha256=nI3saWR_jhY7h2adn6o_UyP2U9fzolW8KkMpzSPi-RI,4020
+aw_watcher_agent/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aw_watcher_agent/tailer.py,sha256=HmfNZ7lPzQ0mmuI2JyUTXo9WZBH1LIoV1w5oX0ZEofg,9513
+aw_watcher_agent-0.2.0.dist-info/METADATA,sha256=fvT59ToNGnfmalTFXGjZ-dQib_nJbb2bg6INGvy43M0,8573
+aw_watcher_agent-0.2.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+aw_watcher_agent-0.2.0.dist-info/entry_points.txt,sha256=bHLex5eNKGx3q4mKR6sImdHXSLM-dWsFwVMaGuFVDJ8,63
+aw_watcher_agent-0.2.0.dist-info/RECORD,,

aw_watcher_agent-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

aw_watcher_agent-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aw-watcher-agent = aw_watcher_agent.cli:main