claude-finops 0.16.0 → 0.17.1

package/finops/procs.py

@@ -1,4 +1,4 @@
-"""Running agent sessions (Claude Code, Codex, Gemini CLI, Cursor) and the actions the dashboard can take on them.
+"""Running Claude Code sessions and the actions the dashboard can take on them.
 
 Source of truth is ~/.claude/sessions/<pid>.json (written by Claude Code), checked
 against the live process table. A signal is only ever sent to a PID that, at the
@@ -191,194 +191,6 @@ def act(pid, action):
     return {"ok": True, "message": msg}
 
 
-# ------------------------------------------------------------ other agents ----
-# Codex, Gemini CLI and Cursor keep no pid registry, so a session counts as running
-# when its transcript was written recently. A CLI session is tied to a process by
-# working directory; Cursor sessions live inside the IDE and are never signalled.
-LIVE_WINDOW_S = 20 * 60
-BUSY_WINDOW_S = 60
-AGENT_BINS = {"codex": ("codex",), "gemini": ("gemini",)}
-RESUME = {"codex": "codex resume {sid}", "gemini": "gemini --resume"}
-
-
-def _is_agent(p, agent):
-    if agent == "claude":
-        return _is_claude(p)
-    words = [os.path.basename(w.strip('"').replace("\\", "/")).lower()
-             for w in (p["command"] or "").split()[:3]]
-    return any(w in AGENT_BINS.get(agent, ()) or w in tuple(b + ".exe" for b in AGENT_BINS.get(agent, ()))
-               for w in words)
-
-
-def _cwd_of(pid):
-    if os.name == "nt":
-        return None
-    try:
-        out = subprocess.run(["lsof", "-a", "-d", "cwd", "-p", str(pid), "-Fn"],
-                             capture_output=True, text=True, timeout=5).stdout
-    except (OSError, subprocess.TimeoutExpired):
-        return None
-    return next((l[1:] for l in out.splitlines() if l.startswith("n")), None)
-
-
-def _recent(pattern, now):
-    out = []
-    for fp in glob.glob(pattern, recursive=True):
-        try:
-            age = now - os.path.getmtime(fp)
-        except OSError:
-            continue
-        if age <= LIVE_WINDOW_S:
-            out.append((fp, age))
-    return out
-
-
-def _codex_live(fp, pricing):
-    meta, model, steps, tokens, ctx, cost, prev = {}, "unknown", 0, 0, None, 0.0, None
-    with open(fp, errors="replace") as fh:
-        for line in fh:
-            try:
-                r = json.loads(line)
-            except ValueError:
-                continue
-            typ, p = r.get("type"), r.get("payload") or {}
-            if typ == "session_meta":
-                meta = p
-            elif typ == "turn_context":
-                model = p.get("model") or model
-            elif typ == "event_msg" and p.get("type") == "token_count" and p.get("info"):
-                tot = tuple(sorted(((p["info"] or {}).get("total_token_usage") or {}).items()))
-                if tot == prev:
-                    continue
-                prev = tot
-                last = (p["info"] or {}).get("last_token_usage") or {}
-                cached = int(last.get("cached_input_tokens") or 0)
-                inp, out = int(last.get("input_tokens") or 0), int(last.get("output_tokens") or 0)
-                steps += 1
-                tokens += inp + out
-                ctx = inp
-                if pricing.is_known(model):
-                    cost += pricing.estimate(model, max(inp - cached, 0), out, cached)
-    return {"session_id": meta.get("id"), "cwd": meta.get("cwd"), "version": meta.get("cli_version"),
-            "model": model, "steps": steps, "tokens": tokens, "context": ctx, "est_cost_usd": cost}
-
-
-def _gemini_live(fp, pricing):
-    with open(fp, errors="replace") as fh:
-        d = json.load(fh)
-    steps, tokens, ctx, cost, model = 0, 0, None, 0.0, None
-    for m in d.get("messages") or []:
-        if m.get("type") != "gemini":
-            continue
-        t = m.get("tokens") or {}
-        model = m.get("model") or model
-        cached, inp = int(t.get("cached") or 0), int(t.get("input") or 0)
-        out = int(t.get("output") or 0) + int(t.get("thoughts") or 0)
-        steps += 1
-        tokens += inp + out
-        ctx = inp
-        if pricing.is_known(model):
-            cost += pricing.estimate(model, max(inp - cached, 0), out, cached)
-    return {"session_id": d.get("sessionId"), "cwd": None, "model": model, "steps": steps,
-            "tokens": tokens, "context": ctx, "est_cost_usd": cost}
-
-
-def _cursor_live(fp, pricing):
-    steps = 0
-    with open(fp, errors="replace") as fh:
-        for line in fh:
-            if '"tool_use"' in line:
-                steps += line.count('"tool_use"')
-    slug = os.path.relpath(fp, os.path.join(HOME, ".cursor", "projects")).split(os.sep)[0]
-    guess = "/" + slug.replace("-", "/")
-    return {"session_id": os.path.splitext(os.path.basename(fp))[0],
-            "cwd": guess if os.path.isdir(guess) else None, "project_hint": slug.rsplit("-", 1)[-1],
-            "model": None, "steps": steps, "tokens": None, "context": None, "est_cost_usd": None}
-
-
-LIVE_SOURCES = {
-    "codex": (os.path.join(HOME, ".codex", "sessions", "**", "*.jsonl"), _codex_live),
-    "gemini": (os.path.join(HOME, ".gemini", "tmp", "*", "chats", "*.json"), _gemini_live),
-    "cursor": (os.path.join(HOME, ".cursor", "projects", "*", "agent-transcripts", "*", "*.jsonl"), _cursor_live),
-}
-
-
-def list_agent_sessions(pricing, agents=None, procs=None):
-    procs = procs if procs is not None else _ps()
-    now = time.time()
-    cli = {a: [(pid, p) for pid, p in procs.items() if _is_agent(p, a)] for a in AGENT_BINS}
-    cwds = {}
-    out = []
-    for agent, (pattern, parse) in LIVE_SOURCES.items():
-        if agents and agent not in agents:
-            continue
-        for fp, age in _recent(pattern, now):
-            try:
-                st = parse(fp, pricing)
-            except (OSError, ValueError):
-                continue
-            match = None
-            for pid, p in cli.get(agent, []):
-                if pid not in cwds:
-                    cwds[pid] = _cwd_of(pid)
-                if st.get("cwd") is None or cwds[pid] == st.get("cwd"):
-                    match = (pid, p)
-                    break
-            ctx = st.get("context") or 0
-            cwd = st.get("cwd")
-            out.append({
-                "agent": agent, "pid": match[0] if match else None,
-                "signalable": bool(match), "session_id": st.get("session_id"), "name": None,
-                "cwd": cwd, "project": os.path.basename(cwd or "") or st.get("project_hint") or agent,
-                "status": "busy" if age <= BUSY_WINDOW_S else "idle", "version": st.get("version"),
-                "model": st.get("model"), "uptime": match[1]["etime"] if match else "",
-                "memory_mb": round(match[1]["rss_kb"] / 1024) if match else None,
-                "hosts_dashboard": False, "transcript": fp, "last_write_s": age,
-                "steps": st.get("steps"), "tokens": st.get("tokens"), "context": st.get("context"),
-                "est_cost_usd": st.get("est_cost_usd"),
-                "resume": RESUME.get(agent, "").format(sid=st.get("session_id") or "") or None,
-                "severity": "high" if ctx >= 300_000 else "medium" if ctx >= 150_000 else "ok",
-            })
-    return out
-
-
-def act_agent(pid, action, agent):
-    """Signal a Codex / Gemini CLI process — only one the live list currently shows."""
-    if action not in ACTIONS:
-        return {"ok": False, "error": f"unknown action {action}"}
-    if agent not in AGENT_BINS:
-        return {"ok": False, "error": "This agent's sessions can't be stopped from here."}
-    procs = _ps()
-    p = procs.get(pid)
-    if not p or not _is_agent(p, agent):
-        return {"ok": False, "error": "Process is no longer running."}
-    live = [s for s in list_agent_sessions(_NoPricing(), [agent], procs) if s["pid"] == pid]
-    if not live:
-        return {"ok": False, "error": "Not a live session the dashboard shows; refusing."}
-    sig, msg = ACTIONS[action]
-    try:
-        os.kill(pid, sig)
-    except ProcessLookupError:
-        return {"ok": False, "error": "Process already exited."}
-    except PermissionError:
-        return {"ok": False, "error": "Not permitted to signal this process."}
-    res = {"ok": True, "message": msg.replace("`claude --resume`", "its resume command"),
-           "resume": live[0]["resume"]}
-    if action in ("close", "kill"):
-        for _ in range(20):
-            time.sleep(0.1)
-            if pid not in _ps():
-                res["exited"] = True
-                return res
-        res["exited"] = False
-    return res
-
-
-class _NoPricing:
-    def is_known(self, model):
-        return False
-
-
 # ---------------------------------------------------------------- handover ----
 HANDOFFS = os.path.join(HOME, ".claude", "finops-handoffs")
 EDIT_TOOLS = {"Edit", "Write", "MultiEdit", "NotebookEdit"}

package/finops/segments.py

@@ -19,8 +19,8 @@ Boundaries this can see:
 from datetime import datetime
 
 # Multipliers are derived per model from the price table rather than hardcoded: the
-# 0.1x read / 1.25x 5m / 2.0x 1h shape holds for Anthropic, but Gemini reads at 0.25x
-# and OpenAI writes at 1.0x, so a fixed constant would quietly corrupt those agents.
+# 0.1x read / 1.25x 5m / 2.0x 1h shape holds for today's Claude models, but a fixed
+# constant would quietly go wrong the day a model is priced differently.
 READ = "cache_read"
 W5M = "cache_write_5m"
 W1H = "cache_write_1h"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-finops",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "description": "Local FinOps dashboard for Claude Code: what you used, what it cost, why it cost that much, and what to change. Reads your own transcripts, no API key, no data leaves the machine.",
   "bin": {
     "claude-finops": "bin/claude-finops.js"
@@ -33,10 +33,7 @@
     "dashboard",
     "finops",
     "analytics",
-    "cli",
-    "codex",
-    "gemini-cli",
-    "cursor"
+    "cli"
   ],
   "license": "MIT",
   "private": false,