cctrack 0.4.0__tar.gz → 0.4.1__tar.gz

{cctrack-0.4.0 → cctrack-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cctrack
-Version: 0.4.0
+Version: 0.4.1
 Summary: Claude Code cost tracker — scans JSONL logs and reports token usage + estimated cost
 Project-URL: Homepage, https://github.com/rappdw/cctrack
 Project-URL: Repository, https://github.com/rappdw/cctrack
@@ -86,11 +86,14 @@ Daily breakdown:
 
 ## Remote aggregation
 
-With `--remote`, cctrack SSHs to each host (one call per host) and streams back all JSONL content for local parsing. Requires SSH key auth.
+With `--remote`, cctrack SSHs to each host and streams back both the JSONL logs and the host's statusline hook data (`~/.claude/cctrack/`) for local parsing, so authoritative hook costs from every machine are summed per day. Requires SSH key auth.
 
 ```bash
 # Aggregate this machine + DGX server + laptop
 cctrack --remote dgx macbook-air
+
+# For accurate aggregate costs, install the hook on each host too
+cctrack --install-hook --remote dgx macbook-air
 ```
 
 ## Rate card

{cctrack-0.4.0 → cctrack-0.4.1}/README.md

@@ -61,11 +61,14 @@ Daily breakdown:
 
 ## Remote aggregation
 
-With `--remote`, cctrack SSHs to each host (one call per host) and streams back all JSONL content for local parsing. Requires SSH key auth.
+With `--remote`, cctrack SSHs to each host and streams back both the JSONL logs and the host's statusline hook data (`~/.claude/cctrack/`) for local parsing, so authoritative hook costs from every machine are summed per day. Requires SSH key auth.
 
 ```bash
 # Aggregate this machine + DGX server + laptop
 cctrack --remote dgx macbook-air
+
+# For accurate aggregate costs, install the hook on each host too
+cctrack --install-hook --remote dgx macbook-air
 ```
 
 ## Rate card

{cctrack-0.4.0 → cctrack-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cctrack"
-version = "0.4.0"
+version = "0.4.1"
 description = "Claude Code cost tracker — scans JSONL logs and reports token usage + estimated cost"
 readme = "README.md"
 license = "MIT"

{cctrack-0.4.0 → cctrack-0.4.1}/src/cctrack/__init__.py

@@ -126,6 +126,84 @@ def parse_remote_events(host: str) -> list[dict]:
     return all_events
 
 
+HOOK_FILE_SEP = "___CCTRACK_HOOK_FILE___"
+MONTHLY_FILE_SEP = "___CCTRACK_MONTHLY_FILE___"
+
+# Hook data locations on remote hosts: the host's own cctrack dir plus any
+# Sandy sandbox equivalents (mirrors discover_hook_data_dirs).
+REMOTE_HOOK_DIRS = "~/.claude/cctrack ~/.sandy/sandboxes"
+
+
+def fetch_remote_hook_data(host: str) -> str:
+    """SSH to host and cat all statusline JSONL + monthly summary files.
+    Returns raw output with file-type separators."""
+    remote_cmd = (
+        f"find {REMOTE_HOOK_DIRS} -name 'statusline*.jsonl' "
+        f"-exec echo '{HOOK_FILE_SEP}' \\; -exec cat {{}} \\; 2>/dev/null; "
+        f"find {REMOTE_HOOK_DIRS} -name 'monthly-*.json' "
+        f"-exec echo '{MONTHLY_FILE_SEP}' \\; -exec cat {{}} \\; 2>/dev/null; "
+        f"true"
+    )
+    cmd = ["ssh", "-o", "ConnectTimeout=10", "-o", "BatchMode=yes", host, remote_cmd]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+        if result.returncode != 0 and not result.stdout:
+            print(f"  Warning: SSH to {host} failed: {result.stderr.strip()}", file=sys.stderr)
+            return ""
+        return result.stdout
+    except subprocess.TimeoutExpired:
+        print(f"  Warning: SSH to {host} timed out", file=sys.stderr)
+        return ""
+    except FileNotFoundError:
+        print(f"  Warning: ssh command not found", file=sys.stderr)
+        return ""
+
+
+def parse_remote_hook_data(host: str) -> tuple[list[dict], dict]:
+    """Fetch and parse hook data from a remote host.
+    Returns (hook_events, monthly_summaries) in the same shapes as
+    parse_hook_events and load_monthly_hook_summaries."""
+    raw = fetch_remote_hook_data(host)
+    if not raw:
+        return [], {}
+
+    # Statusline chunks come first, monthly chunks after (find order above).
+    head, _, monthly_raw = raw.partition(MONTHLY_FILE_SEP)
+
+    lines: list[str] = []
+    for chunk in head.split(HOOK_FILE_SEP):
+        lines.extend(chunk.splitlines())
+    events = _hook_events_from_lines(lines)
+
+    monthly: dict[str, dict] = {}
+    for chunk in monthly_raw.split(MONTHLY_FILE_SEP):
+        chunk = chunk.strip()
+        if not chunk:
+            continue
+        try:
+            data = json.loads(chunk)
+        except (json.JSONDecodeError, ValueError):
+            continue
+        for date_str, day_data in data.get("days", {}).items():
+            entry = {
+                "cost": float(day_data.get("cost", 0.0)),
+                "sessions": int(day_data.get("sessions", 0)),
+            }
+            merge_monthly_summaries(monthly, {date_str: entry})
+    return events, monthly
+
+
+def merge_monthly_summaries(target: dict, source: dict) -> None:
+    """Merge per-date {cost, sessions} summaries from source into target,
+    summing where dates overlap (e.g. same day on multiple hosts)."""
+    for date_str, data in source.items():
+        if date_str in target:
+            target[date_str]["cost"] += data["cost"]
+            target[date_str]["sessions"] += data["sessions"]
+        else:
+            target[date_str] = dict(data)
+
+
 # ── Hook infrastructure ───────────────────────────────────────────────
 
 HOOK_SCRIPT = """\
@@ -485,59 +563,42 @@ def parse_events(files: list[str]) -> list[dict]:
 
 # ── Hook data parsing ──────────────────────────────────────────────────
 
-def parse_hook_events(cctrack_dir: Path | None = None) -> list[dict]:
-    """Parse statusline-*.jsonl files. For each (session_id, date) pair, keeps the
+def _hook_events_from_lines(lines) -> list[dict]:
+    """Parse statusline JSONL lines. For each (session_id, date) pair, keeps the
     entry with the latest _ts — the session's cumulative values as of end-of-day
-    for that date. Also reads legacy statusline.jsonl for migration.
-    Returns list of {date_str, session_id, cost_usd, input_tokens, output_tokens,
-    cache_read, cache_write, model}."""
-    if cctrack_dir is None:
-        cctrack_dir = CCTRACK_DIR
-    if not cctrack_dir.exists():
-        return []
-
+    for that date. Returns list of {date_str, session_id, cost_usd, input_tokens,
+    output_tokens, cache_read, cache_write, model}."""
     by_session_day: dict[tuple[str, str], dict] = {}
 
-    files = sorted(cctrack_dir.glob("statusline-*.jsonl"))
-    legacy = cctrack_dir / "statusline.jsonl"
-    if legacy.exists():
-        files.append(legacy)
-
-    for filepath in files:
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
         try:
-            with open(filepath, "r", errors="replace") as f:
-                for line in f:
-                    line = line.strip()
-                    if not line:
-                        continue
-                    try:
-                        entry = json.loads(line)
-                    except (json.JSONDecodeError, ValueError):
-                        continue
+            entry = json.loads(line)
+        except (json.JSONDecodeError, ValueError):
+            continue
 
-                    session_id = entry.get("session_id", "")
-                    if not session_id:
-                        continue
+        session_id = entry.get("session_id", "")
+        if not session_id:
+            continue
 
-                    ts = entry.get("_ts", "")
-                    if not ts:
-                        continue
+        ts = entry.get("_ts", "")
+        if not ts:
+            continue
 
-                    try:
-                        dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
-                    except (ValueError, AttributeError):
-                        continue
-                    date_str = dt.strftime("%Y-%m-%d")
+        try:
+            dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+        except (ValueError, AttributeError):
+            continue
+        date_str = dt.strftime("%Y-%m-%d")
 
-                    key = (session_id, date_str)
-                    if key in by_session_day:
-                        if ts <= by_session_day[key].get("_ts", ""):
-                            continue
+        key = (session_id, date_str)
+        if key in by_session_day:
+            if ts <= by_session_day[key].get("_ts", ""):
+                continue
 
-                    entry["_date_str"] = date_str
-                    by_session_day[key] = entry
-        except (OSError, IOError):
-            continue
+        by_session_day[key] = entry
 
     results = []
     for (session_id, date_str), entry in by_session_day.items():
@@ -555,6 +616,31 @@ def parse_hook_events(cctrack_dir: Path | None = None) -> list[dict]:
     return results
 
 
+def parse_hook_events(cctrack_dir: Path | None = None) -> list[dict]:
+    """Parse statusline-*.jsonl files from a local hook data directory.
+    Also reads legacy statusline.jsonl for migration. See _hook_events_from_lines
+    for the per-(session, date) dedup semantics."""
+    if cctrack_dir is None:
+        cctrack_dir = CCTRACK_DIR
+    if not cctrack_dir.exists():
+        return []
+
+    files = sorted(cctrack_dir.glob("statusline-*.jsonl"))
+    legacy = cctrack_dir / "statusline.jsonl"
+    if legacy.exists():
+        files.append(legacy)
+
+    lines: list[str] = []
+    for filepath in files:
+        try:
+            with open(filepath, "r", errors="replace") as f:
+                lines.extend(f.readlines())
+        except (OSError, IOError):
+            continue
+
+    return _hook_events_from_lines(lines)
+
+
 def compute_hook_deltas(events: list[dict]) -> list[dict]:
     """Convert per-(session, date) cumulative records into per-(session, date)
     daily deltas. For each session, sorts its records by date and computes
@@ -1138,21 +1224,33 @@ def main():
         except (ValueError, AttributeError):
             pass
 
-    hook_dirs = discover_hook_data_dirs()
-    if hook_dirs:
-        all_hook_events: list[dict] = []
-        all_monthly: dict[str, dict] = {}
-        for hdir in hook_dirs:
-            rollup_old_hook_files(hdir)
-            all_hook_events.extend(compute_hook_deltas(parse_hook_events(hdir)))
-            for date_str, data in load_monthly_hook_summaries(hdir).items():
-                if date_str in all_monthly:
-                    all_monthly[date_str]["cost"] += data["cost"]
-                    all_monthly[date_str]["sessions"] += data["sessions"]
-                else:
-                    all_monthly[date_str] = dict(data)
-        if all_hook_events or all_monthly:
-            hook_daily = aggregate_hook_data(all_hook_events, all_monthly)
+    all_hook_events: list[dict] = []
+    all_monthly: dict[str, dict] = {}
+
+    for hdir in discover_hook_data_dirs():
+        rollup_old_hook_files(hdir)
+        all_hook_events.extend(compute_hook_deltas(parse_hook_events(hdir)))
+        merge_monthly_summaries(all_monthly, load_monthly_hook_summaries(hdir))
+
+    # Remote hook data: each host's deltas are computed independently so a
+    # session's cumulative history never mixes across hosts.
+    if args.remote:
+        for host in args.remote:
+            remote_hook_events, remote_monthly = parse_remote_hook_data(host)
+            all_hook_events.extend(compute_hook_deltas(remote_hook_events))
+            merge_monthly_summaries(all_monthly, remote_monthly)
+
+    if all_hook_events or all_monthly:
+        hook_daily = aggregate_hook_data(all_hook_events, all_monthly)
+
+    # Hook coverage may start earlier than the local install date (e.g. a
+    # remote host installed the hook first). Treat the earliest observed
+    # hook date as the effective install date so those days count as
+    # authoritative rather than being scaled by the accuracy factor.
+    if hook_daily:
+        earliest_hook_date = min(hook_daily.keys())
+        if hook_install_date is None or earliest_hook_date < hook_install_date:
+            hook_install_date = earliest_hook_date
 
     # Suggest hook if not installed
     if not is_hook_installed():

{cctrack-0.4.0 → cctrack-0.4.1}/tests/test_hook_reporting.py

@@ -259,6 +259,107 @@ def test_compute_hook_deltas_multiple_sessions_independent():
     assert by_key[("2026-04-15", "sB")] == 4.0
 
 
+# ── Remote hook data tests ─────────────────────────────────────────────
+
+def _remote_raw(hook_chunks: list[list[dict]], monthly_chunks: list[dict]) -> str:
+    """Build a raw SSH output stream the way fetch_remote_hook_data returns it."""
+    parts = []
+    for entries in hook_chunks:
+        parts.append(cctrack.HOOK_FILE_SEP)
+        for e in entries:
+            parts.append(json.dumps(e))
+    for doc in monthly_chunks:
+        parts.append(cctrack.MONTHLY_FILE_SEP)
+        parts.append(json.dumps(doc))
+    return "\n".join(parts) + "\n"
+
+
+def test_parse_remote_hook_data_basic():
+    """Statusline entries and monthly summaries are both parsed from the stream."""
+    raw = _remote_raw(
+        hook_chunks=[
+            [make_hook_entry(session_id="r1", ts="2026-04-15T10:00:00+00:00", cost_usd=3.00)],
+            [make_hook_entry(session_id="r2", ts="2026-04-16T10:00:00+00:00", cost_usd=7.00)],
+        ],
+        monthly_chunks=[
+            {"month": "2026-01", "days": {"2026-01-10": {"cost": 10.0, "sessions": 2}}},
+        ],
+    )
+    with patch("cctrack.fetch_remote_hook_data", return_value=raw):
+        events, monthly = cctrack.parse_remote_hook_data("fakehost")
+    assert len(events) == 2
+    by_session = {e["session_id"]: e for e in events}
+    assert by_session["r1"]["cost_usd"] == 3.00
+    assert by_session["r2"]["date_str"] == "2026-04-16"
+    assert monthly == {"2026-01-10": {"cost": 10.0, "sessions": 2}}
+
+
+def test_parse_remote_hook_data_dedup_across_files():
+    """Same (session, date) in multiple remote files: latest _ts wins."""
+    raw = _remote_raw(
+        hook_chunks=[
+            [make_hook_entry(session_id="rA", ts="2026-04-15T10:00:00+00:00", cost_usd=2.00)],
+            [make_hook_entry(session_id="rA", ts="2026-04-15T18:00:00+00:00", cost_usd=6.00)],
+        ],
+        monthly_chunks=[],
+    )
+    with patch("cctrack.fetch_remote_hook_data", return_value=raw):
+        events, monthly = cctrack.parse_remote_hook_data("fakehost")
+    assert len(events) == 1
+    assert events[0]["cost_usd"] == 6.00
+
+
+def test_parse_remote_hook_data_empty():
+    with patch("cctrack.fetch_remote_hook_data", return_value=""):
+        events, monthly = cctrack.parse_remote_hook_data("fakehost")
+    assert events == []
+    assert monthly == {}
+
+
+def test_parse_remote_hook_data_malformed_monthly_skipped():
+    raw = (cctrack.HOOK_FILE_SEP + "\n"
+           + json.dumps(make_hook_entry(session_id="ok", cost_usd=1.0)) + "\n"
+           + cctrack.MONTHLY_FILE_SEP + "\n"
+           + "not json\n")
+    with patch("cctrack.fetch_remote_hook_data", return_value=raw):
+        events, monthly = cctrack.parse_remote_hook_data("fakehost")
+    assert len(events) == 1
+    assert monthly == {}
+
+
+def test_fetch_remote_hook_data_timeout():
+    with patch("subprocess.run", side_effect=cctrack.subprocess.TimeoutExpired("ssh", 60)):
+        result = cctrack.fetch_remote_hook_data("fakehost")
+    assert result == ""
+
+
+def test_merge_monthly_summaries_sums_overlapping_dates():
+    """Same date on two hosts sums cost and sessions."""
+    target = {"2026-01-10": {"cost": 10.0, "sessions": 2}}
+    cctrack.merge_monthly_summaries(target, {
+        "2026-01-10": {"cost": 5.0, "sessions": 1},
+        "2026-01-11": {"cost": 3.0, "sessions": 1},
+    })
+    assert target["2026-01-10"] == {"cost": 15.0, "sessions": 3}
+    assert target["2026-01-11"] == {"cost": 3.0, "sessions": 1}
+
+
+def test_remote_and_local_hook_costs_sum_per_date():
+    """Regression: a date covered by hooks on two hosts must sum both hosts'
+    costs, not keep just one host's value."""
+    local_events = cctrack.compute_hook_deltas([
+        {"date_str": "2026-06-11", "session_id": "local_s", "cost_usd": 9.05,
+         "input_tokens": 0, "output_tokens": 0, "cache_read": 0, "cache_write": 0, "model": "m"},
+    ])
+    remote_events = cctrack.compute_hook_deltas([
+        {"date_str": "2026-06-11", "session_id": "air_s", "cost_usd": 340.90,
+         "input_tokens": 0, "output_tokens": 0, "cache_read": 0, "cache_write": 0, "model": "m"},
+    ])
+    hook_daily = cctrack.aggregate_hook_data(local_events + remote_events)
+    assert abs(hook_daily["2026-06-11"]["cost"] - 349.95) < 0.001
+    assert hook_daily["2026-06-11"]["sessions"] == 2
+
+
 # ── aggregate_hook_data tests ──────────────────────────────────────────
 
 def test_aggregate_hook_data_single_day():