chatdeck 0.2.0__tar.gz → 0.2.1__tar.gz

{chatdeck-0.2.0/src/chatdeck.egg-info → chatdeck-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatdeck
-Version: 0.2.0
+Version: 0.2.1
 Summary: A local dashboard for your Claude Code chats: what's running, what needs you, and what it costs.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/Abdifatah09/chatdeck

{chatdeck-0.2.0 → chatdeck-0.2.1}/src/chatdeck/__init__.py

@@ -1,2 +1,2 @@
 """chatdeck: a local dashboard for Claude Code chats."""
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{chatdeck-0.2.0 → chatdeck-0.2.1}/src/chatdeck/hooks.py

@@ -5,7 +5,7 @@
   their status line looks the same as before.
 - Notification (`chatdeck hook waiting`): marks a chat as waiting on a permission prompt or a
   question. The dashboard treats the mark as cleared once the transcript moves on."""
-import json, os, re, shutil, subprocess, sys, time
+import json, os, re, shlex, shutil, subprocess, sys, time
 
 from . import config
 
@@ -55,9 +55,9 @@ def command():
     """How settings.json should call chatdeck: the absolute path of the installed command,
     or this Python running the package from wherever it lives."""
     exe = shutil.which("chatdeck")
-    if exe: return exe
+    if exe: return shlex.quote(exe)
     src = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    return f"PYTHONPATH={src} {sys.executable} -m chatdeck"
+    return f"PYTHONPATH={shlex.quote(src)} {shlex.quote(sys.executable)} -m chatdeck"
 
 
 def _ours(cmd):

{chatdeck-0.2.0 → chatdeck-0.2.1}/src/chatdeck/server.py

@@ -3,7 +3,7 @@ Lists running sessions (claude agents --json) and saved transcripts under
 ~/.claude/projects, and can view, search, rename, export and delete saved chats, stop
 sessions, add and delete projects, and open chats in a terminal (see terminals.py). Binds 127.0.0.1 only; every API call needs
 the per-run token embedded in the page (custom header => cross-site pages can't call it)."""
-import json, os, glob, secrets, shlex, signal, subprocess, threading, time
+import json, os, glob, secrets, shlex, signal, subprocess, sys, threading, time
 from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
 from urllib.parse import urlparse, parse_qs, quote
 
@@ -28,19 +28,25 @@ INDEX = transcripts.Index(PROJECTS)
 LIMITS = usage.LimitHistory(os.path.join(DATA, "limits-history.jsonl"))
 
 _agents = (0.0, {})
+_agents_ok = True   # did the latest fetch work?
 _agents_lock = threading.Lock()
 def _fetch_agents():
-    global _agents
+    """Refresh the cache; True if that worked. A failed check (non-zero exit, timeout, no output) keeps the last good list."""
+    global _agents, _agents_ok
+    _agents_ok = False
     try:
         if config.DEMO:
             with open(os.path.join(DATA, "demo-agents.json")) as f: out = f.read()
         else:
-            out = subprocess.run(["claude", "agents", "--json"], capture_output=True, text=True, timeout=30).stdout
-        res = {s["sessionId"]: s for s in json.loads(out or "[]") if s.get("sessionId")}
+            r = subprocess.run(["claude", "agents", "--json"], capture_output=True, text=True, timeout=30)
+            if r.returncode != 0 or not r.stdout.strip(): return False
+            out = r.stdout
+        res = {s["sessionId"]: s for s in json.loads(out) if s.get("sessionId")}
         with _agents_lock: _agents = (time.time(), res)
+        _agents_ok = True
+        return True
     except Exception:
-        pass
-    return _agents[1]
+        return False
 
 def _agents_loop():
     while True:
@@ -49,7 +55,16 @@ def _agents_loop():
 def agents(fresh=False):
     """Running sessions. Normal reads use the list a background thread keeps fresh, so pages never wait;
     destructive actions (delete/stop) ask for a fresh copy first."""
-    return _fetch_agents() if fresh else _agents[1]
+    if fresh: _fetch_agents()
+    return _agents[1]
+
+def agents_checked():
+    """A fresh running-sessions list, or None if we couldn't get one. Destructive actions use this, so a
+    failed check can never look like 'nothing is running'."""
+    act = agents(fresh=True)
+    return act if _agents_ok else None
+
+NO_CHECK = "couldn't check which chats are running"
 
 def waiting(act, chats):
     """{sid: message} for running chats stuck on a permission prompt or question. A mark from the
@@ -177,7 +192,9 @@ def transcript(sid):
 
 def delete(sids):
     """Delete saved chats. Their projects stay listed, empty, until the project itself is deleted."""
-    act = agents(fresh=True); done, refused = [], []; kept = added_projects(); keep = False
+    act = agents_checked()
+    if act is None: return {"deleted": [], "refused": list(sids), "error": NO_CHECK}
+    done, refused = [], []; kept = added_projects(); keep = False
     for sid in sids:
         p = transcript(sid)
         if not p or sid in act:
@@ -243,7 +260,9 @@ def compact(sid):
 
 def stop(sid):
     if config.DEMO: return DEMO_OFF
-    a = agents(fresh=True).get(sid)
+    act = agents_checked()
+    if act is None: return {"ok": False, "error": NO_CHECK}
+    a = act.get(sid)
     if not a or not a.get("pid"): return {"ok": False, "error": "not running"}
     pid = int(a["pid"])
     cmd = subprocess.run(["ps", "-o", "command=", "-p", str(pid)], capture_output=True, text=True).stdout
@@ -289,7 +308,8 @@ def add_project(path):
 def delete_project(proj):
     """Take a project off the list: delete its saved chats and forget it was added. Its folder is never touched.
     Refused while any of its chats are running, so nothing is half-deleted."""
-    act = agents(fresh=True)
+    act = agents_checked()
+    if act is None: return {"ok": False, "error": NO_CHECK}
     chats = INDEX.all()
     if any((chat_project(chats[sid][1], a.get("cwd")) if sid in chats else project(a.get("cwd"))) == proj for sid, a in act.items()):
         return {"ok": False, "error": "it has running chats - stop them first"}
@@ -372,15 +392,35 @@ class H(BaseHTTPRequestHandler):
         if self.path == "/api/open-running": return self.send(200, open_running(body.get("sid", "")))
         self.send(404, {"error": "not found"})
 
+CODE = os.path.dirname(os.path.abspath(__file__))
+def _code_stamp():
+    """When chatdeck's Python files last changed. The page is read from disk on every request, so only these go stale."""
+    return max((os.path.getmtime(p) for p in glob.glob(os.path.join(CODE, "*.py"))), default=0)
+
+def _watch_code(httpd, restart):
+    """Stop the server once its code changes (a git pull or reinstall), so serve() can start the new code.
+    Waits until the files stop changing, so it never starts on a half-finished pull."""
+    start = seen = _code_stamp()
+    while True:
+        time.sleep(2); now = _code_stamp()
+        if now != start and now == seen: restart.set(); httpd.shutdown(); return
+        seen = now
+
 def serve(port):
-    """Run the dashboard until stopped. Raises OSError if the port is taken."""
+    """Run the dashboard until stopped. Raises OSError if the port is taken. Restarts itself when its code changes."""
     httpd = ThreadingHTTPServer(("127.0.0.1", port), H)
     os.makedirs(DATA, exist_ok=True)
     pidfile = os.path.join(DATA, "server.pid")
     with open(pidfile, "w") as f: f.write(str(os.getpid()))
     threading.Thread(target=_agents_loop, daemon=True).start()
+    restart = threading.Event()
+    threading.Thread(target=_watch_code, args=(httpd, restart), daemon=True).start()
     try:
         httpd.serve_forever()
     finally:
-        try: os.remove(pidfile)
-        except OSError: pass
+        httpd.server_close()
+        if not restart.is_set():
+            try: os.remove(pidfile)
+            except OSError: pass
+    # same pid, so server.pid and the desktop bubble stay valid; the open page reloads when its old token is refused
+    os.execv(sys.executable, [sys.executable, "-m", "chatdeck", "serve", "--port", str(port)])

{chatdeck-0.2.0 → chatdeck-0.2.1}/src/chatdeck/static/index.html

@@ -166,7 +166,7 @@ function renderUsage(U){if(!U)return;const t=U.today,w=U.week_tot,fresh=a=>a[0]+
   else lim=`<div class="meta" style="margin-bottom:8px;white-space:normal">Plan limits appear here once a Claude session updates its status line (needs the status-line hook – see README).</div>`;
   $("usage").innerHTML=`<div class="ugrid"><div class="tile"><div class="v">${k(fresh(t))}</div><div class="l">tokens today</div></div>
    <div class="tile"><div class="v">${k(fresh(w))}</div><div class="l">last 7 days</div></div>
-   <div class="tile"><div class="v">${U.cost_24h?("$"+U.cost_24h.toFixed(2)):"–"}</div><div class="l">API-equivalent cost (24h)</div></div></div>
+   <div class="tile"><div class="v">${U.cost_24h?("$"+U.cost_24h.toFixed(2)):"–"}</div><div class="l">total cost of chats active in 24h</div></div></div>
    ${lim}<div class="chart">${U.week.map((x,i)=>`<div class="${i===6?"today":""}" style="height:${Math.round(x[1]/max*100)}%" title="${k(x[1])} tokens"><span>${dn(x[0])}</span></div>`).join("")}</div>
    <div class="proj">Top this week: ${U.by_project.map(([p,n])=>`<b>${esc(p)}</b> ${k(n)}`).join(" · ")||"–"}</div>`}
 
@@ -255,7 +255,7 @@ function onSearch(){render();clearTimeout(searchT);const q=$("q").value.trim();i
 
 /* actions */
 async function del(sids){if(!sids.length)return false;if(!confirm(`Delete ${sids.length} saved chat${sids.length>1?"s":""} permanently?`))return false;
-  const r=await getJ("/api/delete",{sids});sids.forEach(s=>sel.delete(s));toast(`Deleted ${r.deleted.length}`+(r.refused.length?` · ${r.refused.length} skipped (running)`:""));refresh(true);return true}
+  const r=await getJ("/api/delete",{sids});if(r.error){toast("Couldn't delete: "+r.error,4000);return false}sids.forEach(s=>sel.delete(s));toast(`Deleted ${r.deleted.length}`+(r.refused.length?` · ${r.refused.length} skipped (running)`:""));refresh(true);return true}
 /* when no terminal could be opened, hand over the command to paste instead */
 async function opened(r,msg){if(r.ok)return toast(msg);if(r.copy){try{await navigator.clipboard.writeText(r.copy);toast("Couldn't open a terminal – command copied, paste it into one")}catch{prompt("Run this in a terminal:",r.copy)}}else toast("Couldn't open: "+(r.error||"unknown error"))}
 /* projects: add a folder by its path; delete takes the project off the list along with its saved chats */

{chatdeck-0.2.0 → chatdeck-0.2.1}/src/chatdeck/usage.py

@@ -19,8 +19,11 @@ class LimitHistory:
         self.path = path; self.keep = keep; self.samples = []; self.lock = threading.Lock()
         try:
             with open(path) as f:
-                self.samples = [json.loads(l) for l in f if l.strip()]
-        except (FileNotFoundError, ValueError):
+                for l in f:
+                    try: s = json.loads(l)
+                    except ValueError: continue
+                    if isinstance(s, dict) and all(k in s for k in "wtpr"): self.samples.append(s)
+        except OSError:
             pass
 
     def add(self, at, data):
@@ -58,12 +61,13 @@ class LimitHistory:
             s = [x for x in self.samples if x["w"] == key]
         if not s: return None
         cur = s[-1]
+        if now >= cur["r"]: return {"eta": None, "rate": None}   # that window has already reset
         win = [x for x in s if x["r"] == cur["r"] and x["t"] >= cur["t"] - lookback]
         if len(win) < 2 or cur["t"] - win[0]["t"] < 900: return {"eta": None, "rate": None}
         rate = (cur["p"] - win[0]["p"]) / (cur["t"] - win[0]["t"])   # % per second
         if rate <= 0: return {"eta": None, "rate": 0}
         eta = cur["t"] + (100 - cur["p"]) / rate
-        return {"eta": eta if eta < cur["r"] else None, "rate": round(rate * 3600, 1)}
+        return {"eta": eta if now <= eta < cur["r"] else None, "rate": round(rate * 3600, 1)}
 
 
 def summary(entries, status_dir, history, today=None, project=None):
@@ -84,7 +88,7 @@ def summary(entries, status_dir, history, today=None, project=None):
         try:
             with open(f) as fh: d = json.load(fh)
             at = os.path.getmtime(f)
-            if at > now - 86400: cost += float((d.get("cost") or {}).get("total_cost_usd") or 0)
+            if at > now - 86400: cost += float((d.get("cost") or {}).get("total_cost_usd") or 0)   # lifetime cost; status files keep no history
             if d.get("rate_limits"):
                 limits = {"data": d["rate_limits"], "at": at}
                 history.add(at, d["rate_limits"])

{chatdeck-0.2.0 → chatdeck-0.2.1/src/chatdeck.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatdeck
-Version: 0.2.0
+Version: 0.2.1
 Summary: A local dashboard for your Claude Code chats: what's running, what needs you, and what it costs.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/Abdifatah09/chatdeck

{chatdeck-0.2.0 → chatdeck-0.2.1}/src/chatdeck.egg-info/SOURCES.txt

@@ -26,4 +26,7 @@ src/chatdeck/static/logo.svg
 src/chatdeck/windows/bubble.ps1
 src/chatdeck/windows/focus_wt.ps1
 src/chatdeck/windows/start.ps1
-tests/test_chatdeck.py
+tests/test_chatdeck.py
+tests/test_delete_safety.py
+tests/test_hook_quoting.py
+tests/test_usage_fixes.py

{chatdeck-0.2.0 → chatdeck-0.2.1}/tests/test_chatdeck.py

@@ -121,11 +121,11 @@ class ForecastTest(unittest.TestCase):
         return h
 
     def test_eta_from_pace(self):
-        f = self.hist([(0, 10), (1800, 20)]).forecast("five_hour")   # 10% per 30 min
+        f = self.hist([(0, 10), (1800, 20)]).forecast("five_hour", T0 + 1800)   # 10% per 30 min
         self.assertEqual(f["rate"], 20.0); self.assertAlmostEqual(f["eta"], T0 + 1800 + 4 * 3600)
 
     def test_no_eta_when_reset_comes_first(self):
-        f = self.hist([(0, 10), (1800, 20)], reset=5000).forecast("five_hour")
+        f = self.hist([(0, 10), (1800, 20)], reset=5000).forecast("five_hour", T0 + 1800)
         self.assertIsNone(f["eta"]); self.assertGreater(f["rate"], 0)
 
     def test_needs_enough_history_and_ignores_old_window(self):
@@ -133,7 +133,7 @@ class ForecastTest(unittest.TestCase):
         h = self.hist([(0, 90)], reset=100)
         h.add(T0 + 1000, {"five_hour": {"used_percentage": 1, "resets_at": T0 + 20000}})
         h.add(T0 + 2000, {"five_hour": {"used_percentage": 1, "resets_at": T0 + 20000}})
-        self.assertEqual(h.forecast("five_hour")["rate"], 0)
+        self.assertEqual(h.forecast("five_hour", T0 + 2000)["rate"], 0)
 
     def test_history_survives_restart(self):
         h = self.hist([(0, 10), (1800, 20)])

chatdeck-0.2.1/tests/test_delete_safety.py

@@ -0,0 +1,59 @@
+import json, os, subprocess, sys, tempfile, unittest, unittest.mock
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+os.environ["CHATDECK_DIR"] = tempfile.mkdtemp()   # never touch the real ~/.chatdeck
+from chatdeck import config, server
+
+SID = "11111111-2222-3333-4444-555555555555"
+RUNNING = json.dumps([{"sessionId": SID, "pid": 1}])
+
+
+def done(code, out=""): return subprocess.CompletedProcess([], code, out, "")
+
+
+class DeleteSafetyTest(unittest.TestCase):
+    def setUp(self):
+        self.dir = tempfile.mkdtemp(); os.makedirs(os.path.join(self.dir, "-w-proj"))
+        self.path = os.path.join(self.dir, "-w-proj", SID + ".jsonl")
+        with open(self.path, "w") as f: f.write("{}\n")
+        for k, v in [("PROJECTS", self.dir), ("INDEX", server.transcripts.Index(self.dir))]:
+            p = unittest.mock.patch.object(server, k, v); p.start(); self.addCleanup(p.stop)
+        p = unittest.mock.patch.object(config, "DEMO", False); p.start(); self.addCleanup(p.stop)
+        server._agents = (0.0, {})
+
+    def run_delete(self, **kw):
+        with unittest.mock.patch.object(server.subprocess, "run", **kw): return server.delete([SID])
+
+    def test_nonzero_exit_refuses(self):
+        r = self.run_delete(return_value=done(1))
+        self.assertEqual((r["deleted"], r["refused"]), ([], [SID])); self.assertIn("couldn't check", r["error"])
+        self.assertTrue(os.path.exists(self.path))
+
+    def test_empty_stdout_refuses(self):
+        r = self.run_delete(return_value=done(0, ""))
+        self.assertEqual(r["refused"], [SID]); self.assertTrue(os.path.exists(self.path))
+
+    def test_timeout_refuses(self):
+        r = self.run_delete(side_effect=subprocess.TimeoutExpired("claude", 30))
+        self.assertEqual(r["refused"], [SID]); self.assertTrue(os.path.exists(self.path))
+
+    def test_failure_keeps_last_good_cache(self):
+        self.run_delete(return_value=done(0, RUNNING)); self.run_delete(return_value=done(1))
+        self.assertIn(SID, server.agents())
+
+    def test_running_chat_refused(self):
+        r = self.run_delete(return_value=done(0, RUNNING))
+        self.assertEqual(r["refused"], [SID]); self.assertNotIn("error", r); self.assertTrue(os.path.exists(self.path))
+
+    def test_deleted_when_check_succeeds_and_not_running(self):
+        r = self.run_delete(return_value=done(0, "[]"))
+        self.assertEqual((r["deleted"], r["refused"]), ([SID], [])); self.assertFalse(os.path.exists(self.path))
+
+    def test_delete_project_and_stop_refuse_on_failed_check(self):
+        with unittest.mock.patch.object(server.subprocess, "run", return_value=done(1)):
+            self.assertFalse(server.delete_project("/w/proj")["ok"])
+            self.assertFalse(server.stop(SID)["ok"])
+        self.assertTrue(os.path.exists(self.path))
+
+
+if __name__ == "__main__": unittest.main()

chatdeck-0.2.1/tests/test_hook_quoting.py

@@ -0,0 +1,66 @@
+import json, os, shlex, sys, tempfile, unittest, unittest.mock
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+os.environ["CHATDECK_DIR"] = tempfile.mkdtemp()   # never touch the real ~/.chatdeck
+from chatdeck import config, hooks
+
+SPACED = "/Users/jo smith/.local/bin/chatdeck"
+
+
+class QuotingTest(unittest.TestCase):
+    def setUp(self):
+        self.path = os.path.join(tempfile.mkdtemp(), "settings.json")
+        config.save({})   # other tests may have left a wrapped status line behind
+
+    def write(self, d):
+        with open(self.path, "w") as f: json.dump(d, f)
+
+    def read(self):
+        with open(self.path) as f: return json.load(f)
+
+    def old_install(self):
+        old = SPACED + " hook"
+        self.write({"statusLine": {"type": "command", "command": old + " statusline"},
+                    "hooks": {"Notification": [{"matcher": hooks.WAITING_MATCHER,
+                                                "hooks": [{"type": "command", "command": old + " waiting"}]}]}})
+
+    def test_command_quotes_spaced_paths(self):
+        with unittest.mock.patch("shutil.which", return_value=SPACED):
+            self.assertEqual(shlex.split(hooks.command()), [SPACED])
+        with unittest.mock.patch("shutil.which", return_value=None), \
+             unittest.mock.patch.object(sys, "executable", "/opt/my py/python3"):
+            parts = shlex.split(hooks.command())
+        self.assertTrue(parts[0].startswith("PYTHONPATH="))
+        self.assertEqual(parts[1:], ["/opt/my py/python3", "-m", "chatdeck"])
+
+    def test_normal_path_unchanged(self):
+        with unittest.mock.patch("shutil.which", return_value="/usr/local/bin/chatdeck"):
+            self.assertEqual(hooks.command(), "/usr/local/bin/chatdeck")
+
+    def test_install_writes_quoted_commands_and_uninstall_removes(self):
+        with unittest.mock.patch("shutil.which", return_value=SPACED):
+            hooks.install(self.path)
+        s = self.read()
+        self.assertEqual(shlex.split(s["statusLine"]["command"]), [SPACED, "hook", "statusline"])
+        self.assertEqual(shlex.split(s["hooks"]["Notification"][0]["hooks"][0]["command"]), [SPACED, "hook", "waiting"])
+        hooks.uninstall(self.path)
+        self.assertEqual(self.read(), {})
+
+    def test_reinstall_over_old_unquoted_install(self):
+        self.old_install()
+        with unittest.mock.patch("shutil.which", return_value=SPACED):
+            hooks.install(self.path)
+        s = self.read()
+        self.assertEqual(shlex.split(s["statusLine"]["command"]), [SPACED, "hook", "statusline"])
+        self.assertEqual(len(s["hooks"]["Notification"]), 1)
+        self.assertEqual(len(s["hooks"]["Notification"][0]["hooks"]), 1)
+        self.assertNotIn("statusline_command", config.load())   # old install wasn't mistaken for the user's own
+
+    def test_uninstall_removes_old_unquoted_install(self):
+        self.old_install()
+        hooks.uninstall(self.path)
+        self.assertEqual(self.read(), {})
+
+
+if __name__ == "__main__":
+    unittest.main()

chatdeck-0.2.1/tests/test_usage_fixes.py

@@ -0,0 +1,46 @@
+import json, os, sys, tempfile, time, unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+os.environ["CHATDECK_DIR"] = tempfile.mkdtemp()   # never touch the real ~/.chatdeck
+from chatdeck import usage
+
+
+T = time.time() - 3600
+
+
+def sample(t, p, r=10000, w="five_hour"): return {"t": t, "w": w, "p": p, "r": r}
+
+
+class HistoryTest(unittest.TestCase):
+    def path(self, *lines):
+        p = os.path.join(tempfile.mkdtemp(), "h.jsonl")
+        with open(p, "w") as f: f.write("\n".join(lines) + "\n")
+        return p
+
+    def test_corrupt_and_malformed_lines_skipped(self):
+        good = [sample(T + 1, 5), sample(T + 2, 6)]
+        h = usage.LimitHistory(self.path(json.dumps(good[0]), '{"t": 3, "w": "five', '{"w": "five_hour"}', "[1]", json.dumps(good[1])))
+        self.assertEqual(h.samples, good)
+        h.add(T + 5, {"five_hour": {"used_percentage": 7, "resets_at": 10000}})   # no KeyError
+        self.assertEqual(len(h.samples), 3)
+
+    def test_stale_window_has_no_eta(self):
+        h = usage.LimitHistory(self.path()); h.samples = [sample(0, 10), sample(3600, 20)]
+        self.assertEqual(h.forecast("five_hour", now=5000)["rate"], 10.0)
+        self.assertEqual(h.forecast("five_hour", now=10000), {"eta": None, "rate": None})
+        self.assertIsNone(h.forecast("five_hour", now=9000)["eta"])   # eta (36000) is past the reset
+        h.samples = [sample(0, 10, 99999), sample(3600, 20, 99999)]
+        self.assertEqual(h.forecast("five_hour", now=3700)["eta"], 3600 + 80 * 360)
+        self.assertIsNone(h.forecast("five_hour", now=3600 + 80 * 360 + 1)["eta"])
+
+    def test_cost_counts_only_recent_status_files(self):
+        d = tempfile.mkdtemp()
+        for name, cost, age in (("a", 1.5, 100), ("b", 2.0, 3 * 86400)):
+            p = os.path.join(d, name + ".json")
+            with open(p, "w") as f: json.dump({"cost": {"total_cost_usd": cost}}, f)
+            os.utime(p, (time.time() - age,) * 2)
+        h = usage.LimitHistory(os.path.join(d, "h.jsonl"))
+        self.assertEqual(usage.summary([], d, h)["cost_24h"], 1.5)
+
+
+if __name__ == "__main__": unittest.main()