agentmetry 0.9.6__tar.gz → 0.9.8__tar.gz

{agentmetry-0.9.6 → agentmetry-0.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentmetry
-Version: 0.9.6
+Version: 0.9.8
 Summary: Local-first flight recorder for AI coding agents: hash-chained audit trail, MITRE-mapped sequence detection, DLP
 Project-URL: Homepage, https://agentmetry.ai
 Project-URL: Source, https://github.com/blitzcrieg1/agentmetry

{agentmetry-0.9.6 → agentmetry-0.9.8}/agentmetry/api/main.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import os
+import subprocess
+import sys
 from contextlib import asynccontextmanager
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
@@ -76,6 +79,34 @@ def _start_forwarders() -> list[asyncio.Task]:
     return tasks
 
 
+def start_transcript_watcher(watcher_path: Path) -> subprocess.Popen:
+    """Start the Antigravity transcript watcher, tied to this process's life.
+
+    Its stdin is a pipe only this process holds, and the lifeline variable
+    tells it to exit at end-of-file. When this process dies, however it dies,
+    the pipe closes and the watcher follows. Without it each restart left a
+    watcher behind, and every one of them recorded every Antigravity call.
+    """
+    return subprocess.Popen(
+        [sys.executable, str(watcher_path)],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        env={**os.environ, "AGENTMETRY_WATCHER_LIFELINE": "1"},
+    )
+
+
+def stop_transcript_watcher(process: subprocess.Popen) -> None:
+    """Close the lifeline, then terminate. Closing alone is enough; terminate is
+    for a watcher that predates the lifeline."""
+    try:
+        if process.stdin:
+            process.stdin.close()
+    except OSError:
+        pass
+    process.terminate()
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     from agentmetry.core.audit.migrate import backfill_db_from_jsonl
@@ -177,17 +208,11 @@ async def lifespan(app: FastAPI):
         )
 
     # Launch transcript watcher for Antigravity in the background
-    import subprocess
-    import sys
     watcher_process = None
     try:
         watcher_path = Path(__file__).resolve().parents[4] / "scripts" / "antigravity_transcript_watcher.py"
         if watcher_path.exists():
-            watcher_process = subprocess.Popen(
-                [sys.executable, str(watcher_path)],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
+            watcher_process = start_transcript_watcher(watcher_path)
             logger.info("Started Antigravity transcript watcher (PID: %s)", watcher_process.pid)
     except Exception as exc:
         logger.warning("Failed to start Antigravity transcript watcher: %s", exc)
@@ -201,7 +226,7 @@ async def lifespan(app: FastAPI):
     for task in bridge_tasks:
         task.cancel()
     if watcher_process:
-        watcher_process.terminate()
+        stop_transcript_watcher(watcher_process)
 
 
 app = FastAPI(

{agentmetry-0.9.6 → agentmetry-0.9.8}/agentmetry/api/routes/audit.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Literal
@@ -100,7 +101,7 @@ class ExternalIngestBody(BaseModel):
 
     source_app: str = Field(
         ...,
-        description="cursor | claude | antigravity | codex | mcp_proxy | qwen | kimi | qoder | codebuddy | trae | crewai | opensre",
+        description="cursor | claude | antigravity | codex | copilot | mcp_proxy | qwen | kimi | qoder | codebuddy | trae | crewai | opensre | zcode | grok_bot",
     )
     event_type: str = Field(
         ...,
@@ -228,7 +229,7 @@ async def audit_tail(
     ),
     sources: str | None = Query(
         None,
-        description="Comma-separated source apps: agentmetry,cursor,claude,antigravity,mcp_proxy",
+        description="Comma-separated source.app values. Known names include cursor, claude, codex, copilot, antigravity, qwen, kimi, qoder, codebuddy, mcp_proxy, trae, crewai, opensre",
     ),
     since_minutes: int | None = Query(
         None,
@@ -308,6 +309,29 @@ async def audit_session(
     }
 
 
+@router.get("/session/{correlation_id}/tree", dependencies=[Depends(require_api_key)])
+async def audit_session_tree(
+    correlation_id: str,
+    limit: int = Query(20000, ge=1, le=50000),
+    around_utc: str = Query("", max_length=40),
+):
+    """One session folded into investigation-tree nodes.
+
+    Each ask, its answer and the call it led to become one node, so a detection
+    that cites the ask and a policy verdict recorded on it land on the call
+    they belong to. A session longer than `limit` is windowed on `around_utc`
+    (a detection's first_seen_utc) when given. See `core/audit/session_tree.py`.
+    """
+    from agentmetry.core.audit.session_tree import session_tree
+
+    if not settings.audit_export_enabled:
+        return {"correlation_id": correlation_id, "enabled": False, "nodes": [], "summary": {}, "truncated": False}
+    try:
+        return await asyncio.to_thread(session_tree, correlation_id, limit, around_utc)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+
 @router.get("/detections/{correlation_id}", dependencies=[Depends(require_api_key)])
 async def audit_detections(correlation_id: str):
     """Run correlated behavioral rules over one session and return detections.
@@ -452,6 +476,18 @@ async def audit_export_evidence():
     )
 
 
+@router.get("/machine", dependencies=[Depends(require_api_key)])
+async def machine_view():
+    """This machine's agents, posture, MCP servers and tool policy.
+
+    Read-only. The payload is the local dashboard's "This machine" page. It
+    carries no command lines, paths, or secret values.
+    """
+    from agentmetry.core.diagnostics.machine_view import snapshot
+
+    return await asyncio.to_thread(snapshot)
+
+
 @router.get("/status", dependencies=[Depends(require_api_key)])
 async def audit_status():
     """Freshness + per-source counts so the dashboard can show 'last event N min ago'.

{agentmetry-0.9.6 → agentmetry-0.9.8}/agentmetry/cli/__init__.py

@@ -529,6 +529,93 @@ def cmd_install(args: argparse.Namespace) -> int:
 _HOOK_INSTALLERS = ("cursor", "claude", "codex", "qwen", "kimi", "qoder", "codebuddy", "copilot")
 
 
+
+
+def cmd_cloud(args: argparse.Namespace) -> int:
+    """Poll a vendor cloud-agent API once and record what it exposes.
+
+    Everything this records passes through the same external ingest as the
+    hooks: canonicalized server-side, hash-chained, detected against. The
+    key comes from the environment (CURSOR_API_KEY, ANTHROPIC_COMPLIANCE_KEY)
+    and is never logged.
+    """
+    import os
+
+    import httpx
+
+    from agentmetry.core.audit.cloud_bridge import (
+        fetch_claude_messages,
+        fetch_claude_sessions,
+        fetch_cursor_agents,
+        fetch_cursor_runs,
+        map_claude_messages,
+        map_claude_session,
+        map_cursor_agent,
+        map_outbound_poll,
+    )
+
+    base = (args.url or "").strip() or None
+    posted = 0
+
+    def post(payload: dict) -> bool:
+        nonlocal posted
+        url = os.environ.get("AGENTMETRY_URL", "http://127.0.0.1:8000").rstrip("/")
+        key = os.environ.get("AGENTMETRY_API_KEY", "")
+        headers = {"Content-Type": "application/json"}
+        if key:
+            headers["Authorization"] = f"Bearer {key}"
+        resp = httpx.post(f"{url}/api/v1/audit/ingest", json=payload, headers=headers, timeout=15)
+        ok = resp.status_code < 300
+        if ok:
+            posted += 1
+        else:
+            print(f"  ingest refused ({resp.status_code}): {resp.text[:120]}")
+        return ok
+
+    if args.provider == "cursor":
+        api_key = os.environ.get("CURSOR_API_KEY", "")
+        if not api_key:
+            print("CURSOR_API_KEY is not set.")
+            return 2
+        cursor_base = base or __import__("agentmetry.core.audit.cloud_bridge", fromlist=["CURSOR_DEFAULT_BASE"]).CURSOR_DEFAULT_BASE
+        post(map_outbound_poll("cursor_cloud", "GET", f"{cursor_base.rstrip('/')}/v1/agents"))
+        for agent in fetch_cursor_agents(api_key, cursor_base):
+            runs = []
+            if not args.skip_runs:
+                try:
+                    runs = fetch_cursor_runs(str(agent.get("id")), api_key, base or "https://api.cursor.com")
+                except httpx.HTTPError as exc:
+                    print(f"  runs fetch failed for {agent.get('id')}: {exc}")
+            for payload in map_cursor_agent(agent, runs):
+                post(payload)
+        print(f"cursor: {posted} events recorded.")
+        return 0
+
+    if args.provider == "claude":
+        api_key = os.environ.get("ANTHROPIC_COMPLIANCE_KEY", "")
+        if not api_key:
+            print("ANTHROPIC_COMPLIANCE_KEY is not set (a Compliance Access Key with read:compliance_user_data, not an admin key).")
+            return 2
+        kind = "remote" if args.remote else "local"
+        claude_base = base or "https://api.anthropic.com"
+        post(map_outbound_poll("claude_cloud", "GET", f"{claude_base.rstrip('/')}/v1/compliance/apps/sessions/{kind}"))
+        sessions = fetch_claude_sessions(api_key, kind=kind, base=claude_base, limit=args.limit)
+        for session in sessions[: args.limit]:
+            post(map_claude_session(session))
+            try:
+                messages = fetch_claude_messages(api_key, kind, str(session.get("id")), base or "https://api.anthropic.com")
+            except httpx.HTTPError as exc:
+                print(f"  messages fetch failed for {session.get('id')}: {exc}")
+                continue
+            for payload in map_claude_messages(session, messages):
+                post(payload)
+        print(f"claude ({kind}): {posted} events recorded.")
+        return 0
+
+    print(f"unknown provider: {args.provider}")
+    return 2
+
+
 def _hooks_status() -> int:
     """Coverage as an exit code, for a deployment tool rather than a person.
 
@@ -581,6 +668,21 @@ def cmd_hooks(args: argparse.Namespace) -> int:
     from agentmetry.core.audit import hook_bootstrap
     from agentmetry.core.diagnostics import hook_coverage
 
+    if args.action == "install":
+        # Before --managed too: a managed install would put the temporary path
+        # into machine-wide policy files.
+        reason = hook_bootstrap.ephemeral_environment()
+        if reason:
+            print(
+                f"Not installing hooks: {reason}. That cache can be deleted at any "
+                "time, and every hook would then fail (most agents silently stop "
+                "recording; Copilot CLI blocks every tool call). Install Agentmetry "
+                "somewhere that stays, then run this again:\n"
+                "  uv tool install agentmetry   (or: pipx install agentmetry, or: pip install agentmetry)\n"
+                "  agentmetry hooks install",
+                file=sys.stderr,
+            )
+            return 1
     if getattr(args, "managed", False):
         return _hooks_managed(args)
     if args.action == "status":
@@ -1419,6 +1521,11 @@ def main(argv: list[str] | None = None) -> int:
     sub.add_parser("status", help="orchestrator health and audit export status")
     stats = sub.add_parser("stats", help="audit trail metrics for dogfood (events, detections)")
     stats.add_argument("--days", type=int, default=7)
+    cloud = sub.add_parser("cloud", help="record what a vendor cloud-agent API exposes (Cursor, Claude)")
+    cloud.add_argument("provider", choices=("cursor", "claude"))
+    cloud.add_argument("--url", default="", help="vendor API base override")
+    cloud.add_argument("--limit", type=int, default=10, help="max sessions/agents per poll")
+    cloud.add_argument("--skip-runs", action="store_true", help="cursor: agents only, skip per-run fetch")
     detections = sub.add_parser("detections", help="list detections for one session")
     detections.add_argument("correlation_id", help="correlation_id / session id")
     disposition = sub.add_parser("disposition", help="close an audit detection from the shell")
@@ -1610,6 +1717,7 @@ def main(argv: list[str] | None = None) -> int:
         "hook": cmd_hook,
         "status": cmd_status,
         "stats": cmd_stats,
+        "cloud": cmd_cloud,
         "detections": cmd_detections,
         "disposition": cmd_disposition,
         "logs": cmd_logs,

agentmetry-0.9.8/agentmetry/core/audit/antigravity_trajectory.py

@@ -0,0 +1,81 @@
+"""Read tool calls out of an Antigravity conversation database.
+
+The installed hook only matches `run_command`, so file reads, writes, search
+and the other tools never reach the trail. The conversation database stores
+every step. The payload is a protobuf blob. The tool name is a length-prefixed
+ASCII field and the arguments are the JSON object that follows it. That framing
+was read off a real database on 2026-10-16. A blob that does not match it
+yields nothing.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+from typing import Any, Iterator
+
+
+def _varint(buf: bytes, index: int) -> tuple[int, int]:
+    value = 0
+    shift = 0
+    while index < len(buf) and shift <= 28:
+        byte = buf[index]
+        index += 1
+        value |= (byte & 0x7F) << shift
+        if not byte & 0x80:
+            return value, index
+        shift += 7
+    raise ValueError("truncated varint")
+
+
+def iter_tool_calls(payload: bytes) -> Iterator[tuple[str, dict[str, Any]]]:
+    """Yield (tool name, arguments) from one step payload."""
+    index = 0
+    while True:
+        marker = payload.find(b"\x12", index)
+        if marker < 0 or marker + 2 >= len(payload):
+            return
+        name_len = payload[marker + 1]
+        if name_len == 0 or name_len > 64 or name_len & 0x80:
+            index = marker + 1
+            continue
+        name_at = marker + 2
+        name_end = name_at + name_len
+        if name_end >= len(payload) or payload[name_end] != 0x1A:
+            index = marker + 1
+            continue
+        name = payload[name_at:name_end]
+        if not name.isascii() or not all(chr(c).isalnum() or c == ord("_") for c in name):
+            index = marker + 1
+            continue
+        try:
+            json_len, json_at = _varint(payload, name_end + 1)
+        except ValueError:
+            index = marker + 1
+            continue
+        blob = payload[json_at : json_at + json_len]
+        if not blob.startswith(b"{"):
+            index = marker + 1
+            continue
+        try:
+            args = json.loads(blob)
+        except json.JSONDecodeError:
+            index = marker + 1
+            continue
+        if isinstance(args, dict):
+            yield name.decode("ascii"), args
+        index = json_at + max(json_len, 1)
+
+
+def tool_names(db_path: Path) -> dict[str, int]:
+    """Count tool names in one conversation database. Arguments are not returned."""
+    counts: dict[str, int] = {}
+    uri = f"file:{Path(db_path).as_posix()}?mode=ro"
+    with sqlite3.connect(uri, uri=True) as con:
+        for (payload,) in con.execute("SELECT step_payload FROM steps"):
+            if not isinstance(payload, (bytes, bytearray)):
+                continue
+            for name, _args in iter_tool_calls(payload):
+                counts[name] = counts.get(name, 0) + 1
+    return counts