@askalf/dario 6.6.2 → 6.6.4

package/README.md

@@ -368,7 +368,7 @@ Type `dario` with no arguments for a full-screen control panel: live request str
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset=".github/readme/tui-analytics-dark.svg">
-  <img alt="The dario TUI Analytics tab: requests per minute, tokens in and out, thinking tokens, average latency, subscription percentage, a per-model bar chart, per-account rate-limit bars for the 5-hour and 7-day windows, and a billing breakdown." src=".github/readme/tui-analytics-light.svg" width="100%">
+  <img alt="The dario TUI Analytics tab: requests per minute, tokens in and out, thinking tokens, average latency, subscription percentage, the lifetime API-equivalent spend from the ledger, a per-model bar chart, per-account rate-limit bars for the 5-hour and 7-day windows, and a billing breakdown." src=".github/readme/tui-analytics-light.svg" width="100%">
 </picture>
 
 <sub>Both screenshots are rendered from the real TUI against a fixture proxy by <a href="scripts/readme/tui.mjs"><code>scripts/readme/tui.mjs</code></a>, so a layout change shows up here instead of rotting a mock-up. The numbers are illustrative; the pixels are not.</sub>
@@ -663,6 +663,14 @@ Two easy ways to help beyond code: **star the repo**, the clearest signal this i
 | [@anupamme](https://github.com/anupamme) | Refresh-lock ownership by server-issued lock id ([#1059](https://github.com/askalf/dario/pull/1059)) |
 | [@LiveNathan](https://github.com/LiveNathan) | Never send or stamp empty text blocks ([#1067](https://github.com/askalf/dario/pull/1067)), empty final user turn from CC's stream-interruption retry ([#1092](https://github.com/askalf/dario/issues/1092), as [@NathanLively](https://github.com/NathanLively)) |
 
+### Sponsors
+
+<!-- sponsors:start -->
+dario is funded by its users through [GitHub Sponsors](https://github.com/sponsors/askalf) — the live-test seats it is checked against before every release are the biggest line item. Sponsors at $25/month and up are listed here.
+<!-- sponsors:end -->
+
+<sub>This block and the thank-you in each release's notes come from <a href="scripts/sponsors.mjs"><code>scripts/sponsors.mjs</code></a>, which reads the public sponsor list; <code>sponsors-readme.yml</code> opens a PR when it changes. Private sponsors are never named.</sub>
+
 ## Disclaimers
 
 **dario is an independent, unofficial, third-party project.** Not affiliated with, endorsed by, or sponsored by Anthropic, OpenAI, or any vendor referenced here. Provided as-is, no warranty. You are solely responsible for compliance with your subscription's terms, the security of your credentials, and the content you send through the proxy. Not for safety-critical, regulated, or production environments without your own review. Full text: [DISCLAIMER.md](DISCLAIMER.md).

package/dist/doctor-core.d.ts

@@ -52,6 +52,33 @@ export declare function continuationReadiness(input: {
     status: CheckStatus;
     detail: string;
 };
+/**
+ * Ledger readiness (v6.6.4). The ledger is a file the proxy writes a few
+ * seconds after each request; the number it feeds (`dario usage`, the TUI's
+ * API-equivalent row) only ever moves if that write lands. A bind mount that
+ * came up read-only, a home directory the proxy cannot create, a file a
+ * root-owned rig left behind — each of these looks exactly like "no traffic"
+ * from the outside. This row says whether the file can be written, when it
+ * last was, and what it holds. File and configuration only: the proxy's own
+ * unflushed records are not visible here.
+ */
+export declare function ledgerReadiness(input: {
+    enabled: boolean;
+    path: string;
+    exists: boolean;
+    writable: boolean;
+    /** Why the file could not be parsed, when it exists and could not be. */
+    parseError?: string;
+    /** Epoch ms of the file's `updated` stamp, when it parsed. */
+    updatedAtMs?: number;
+    requests?: number;
+    apiEquivalentCost?: number;
+    since?: string;
+    nowMs?: number;
+}): {
+    status: CheckStatus;
+    detail: string;
+};
 export declare function failoverReadiness(input: {
     chain: readonly string[];
     codexAccounts: number;

package/dist/doctor-core.js

@@ -64,6 +64,50 @@ export function continuationReadiness(input) {
                 : 'the chain has nowhere to go for a second hop (see Failover)'),
     };
 }
+/**
+ * Ledger readiness (v6.6.4). The ledger is a file the proxy writes a few
+ * seconds after each request; the number it feeds (`dario usage`, the TUI's
+ * API-equivalent row) only ever moves if that write lands. A bind mount that
+ * came up read-only, a home directory the proxy cannot create, a file a
+ * root-owned rig left behind — each of these looks exactly like "no traffic"
+ * from the outside. This row says whether the file can be written, when it
+ * last was, and what it holds. File and configuration only: the proxy's own
+ * unflushed records are not visible here.
+ */
+export function ledgerReadiness(input) {
+    if (!input.enabled) {
+        return { status: 'info', detail: 'off — no lifetime API-equivalent numbers (unset DARIO_LEDGER / drop --no-ledger)' };
+    }
+    if (!input.exists) {
+        return input.writable
+            ? { status: 'ok', detail: `no file yet at ${input.path} — it appears after the first request through the proxy` }
+            : { status: 'warn', detail: `cannot write ${input.path} — the ledger will never record anything (check the directory's owner and mount)` };
+    }
+    if (input.parseError) {
+        return { status: 'warn', detail: `${input.path} is unreadable (${input.parseError}) — the proxy moves it aside and starts fresh on its next start; the history in it is lost` };
+    }
+    const now = input.nowMs ?? Date.now();
+    const age = typeof input.updatedAtMs === 'number' ? Math.max(0, now - input.updatedAtMs) : null;
+    const ageText = age === null ? 'last write unknown' : `last write ${describeAge(age)} ago`;
+    const usd = typeof input.apiEquivalentCost === 'number' ? `$${input.apiEquivalentCost >= 100 ? Math.round(input.apiEquivalentCost).toLocaleString('en-US') : input.apiEquivalentCost.toFixed(2)}` : '$?';
+    const body = `${(input.requests ?? 0).toLocaleString('en-US')} requests since ${(input.since ?? '').slice(0, 10) || '?'}, ${usd} API-equivalent; ${ageText}`;
+    if (!input.writable) {
+        return { status: 'warn', detail: `${body} — file is read-only now, so nothing since then is being saved (${input.path})` };
+    }
+    return { status: 'ok', detail: `${body} (${input.path})` };
+}
+function describeAge(ms) {
+    const s = Math.round(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.round(s / 60);
+    if (m < 60)
+        return `${m}m`;
+    const h = Math.round(m / 60);
+    if (h < 48)
+        return `${h}h`;
+    return `${Math.round(h / 24)}d`;
+}
 export function failoverReadiness(input) {
     const { chain, codexAccounts, backends } = input;
     const hasCodex = codexAccounts > 0;
@@ -1200,6 +1244,54 @@ export async function runChecks(opts = {}) {
     catch (err) {
         checks.push({ status: 'warn', label: 'Failover', detail: `check failed: ${err.message}` });
     }
+    // ---- Ledger (v6.6.4) — see ledgerReadiness() for the why. The default
+    // port's file; DARIO_LEDGER_PATH is honoured like the proxy honours it.
+    try {
+        const { resolveLedgerPath, ledgerDisabledByEnv, readLedgerFile, summarizeLedger } = await import('./ledger.js');
+        const { access, constants } = await import('node:fs/promises');
+        const path = resolveLedgerPath(3456);
+        const enabled = !ledgerDisabledByEnv();
+        let exists = false;
+        let writable = false;
+        try {
+            await access(path, constants.F_OK);
+            exists = true;
+        }
+        catch { /* no file yet */ }
+        // The proxy creates missing directories on its first flush, so test the
+        // nearest ancestor that exists — a fresh install has no ~/.dario yet.
+        let probe = exists ? path : dirname(path);
+        while (!exists) {
+            try {
+                await access(probe, constants.F_OK);
+                break;
+            }
+            catch { /* climb */ }
+            const up = dirname(probe);
+            if (up === probe)
+                break;
+            probe = up;
+        }
+        try {
+            await access(probe, constants.W_OK);
+            writable = true;
+        }
+        catch { /* not writable */ }
+        const { file, error } = exists ? await readLedgerFile(path) : { file: null, error: undefined };
+        const summary = file ? summarizeLedger(file, path) : null;
+        const verdict = ledgerReadiness({
+            enabled, path, exists, writable,
+            parseError: error,
+            updatedAtMs: file ? Date.parse(file.updated) : undefined,
+            requests: summary?.requests,
+            apiEquivalentCost: summary?.apiEquivalentCost,
+            since: summary?.since,
+        });
+        checks.push({ status: verdict.status, label: 'Ledger', detail: verdict.detail });
+    }
+    catch (err) {
+        checks.push({ status: 'warn', label: 'Ledger', detail: `check failed: ${err.message}` });
+    }
     // ---- CC sub-agent (v3.26, direction #2)
     try {
         const { loadSubagentStatus } = await import('./subagent.js');

package/docs/api-equivalent-spend.md

@@ -60,6 +60,18 @@ is never overwritten in place. Days past 730 roll off the front.
 The test suite pins `DARIO_LEDGER_PATH` to a temp directory, so a suite run
 does not add stub traffic to the operator's file.
 
+`dario doctor` has a **Ledger** row (6.6.4): whether the default port's file
+(or `DARIO_LEDGER_PATH`) can be written, when it was last written, and what
+it holds. A bind mount that came up read-only, a home the proxy cannot
+create, a file a root-owned rig left behind — from the outside each looks
+exactly like "no traffic", and the number stops moving without a word. The
+row reads the file only; records the proxy has not flushed yet are not in it.
+
+```
+  [ OK ]  Ledger  160 requests since 2026-09-12, $1.74 API-equivalent; last write 3s ago (/home/dario/.dario/ledger.json)
+  [WARN]  Ledger  cannot write /home/dario/.dario/ledger.json — the ledger will never record anything (check the directory's owner and mount)
+```
+
 ## Reading it
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.6.2",
+  "version": "6.6.4",
   "description": "Use your Claude and ChatGPT subscriptions in Cursor, Cline, Aider, Claude Code and the Agent SDK — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint: either plan answers either wire shape, with automatic failover when one hits its limit.",
   "type": "module",
   "bin": {