@askalf/dario 6.22.2 → 6.22.3

package/dist/proxy.js

@@ -68,6 +68,7 @@ import { waitForIdle, drainThenClose, shutdownTimers, DEFAULT_SHUTDOWN_GRACE_MS
 import { clampTimerMs } from './timer-ms.js';
 import { upstreamDeadline } from './upstream-deadline.js';
 import { redactSecrets } from './redact.js';
+import { parseRequestLogQuery, readRequestLog } from './request-log.js';
 import { BAKED_BASE_MODELS, withLongContextVariants, buildOpenAIModelsList, getModelCatalog, getCachedBases, resolveAliasAgainst, prewarmModelCatalog, retryModelCatalogNow, isSuspendedModel } from './model-catalog.js';
 import { classifyUpstreamRejection, diagnosticSnippet, POOL_PARKED } from './upstream-rejection.js';
 import { ProviderCooldowns, canAttempt, allProvidersCooled, cooldownRetryAfterMs, parseRetryAfterMs, ALL_PROVIDERS_RATE_LIMITED, } from './provider-cooldown.js';
@@ -1146,7 +1147,7 @@ export function sanitizeError(err) {
  * inherit read-only auth by accident.
  */
 export const ANALYTICS_READ_PATHS = [
-    '/analytics', '/analytics/ledger', '/analytics/stream', '/analytics/view', '/analytics/donuts.svg', '/metrics',
+    '/analytics', '/analytics/ledger', '/analytics/requests', '/analytics/stream', '/analytics/view', '/analytics/donuts.svg', '/metrics',
 ];
 export function isAnalyticsReadPath(urlPath) {
     return ANALYTICS_READ_PATHS.includes(urlPath);
@@ -3369,6 +3370,27 @@ export async function startProxy(opts = {}) {
             res.end(JSON.stringify({ path: ledger.path, ...ledger.snapshot(), priced: ledger.priced() }));
             return;
         }
+        // The request log read back by byte offset (request-log.ts), for a reader
+        // that cannot share the file. A 404 says the log is off, as the ledger's does.
+        if (urlPath === '/analytics/requests' && req.method === 'GET') {
+            if (!logFilePath) {
+                res.writeHead(404, JSON_HEADERS);
+                res.end(JSON.stringify({ error: 'request log disabled', hint: 'start with --log-file=<path> / DARIO_LOG_FILE' }));
+                return;
+            }
+            const { after, mark } = parseRequestLogQuery(req.url ?? '/');
+            try {
+                const page = await readRequestLog(logFilePath, after, mark);
+                res.writeHead(200, JSON_HEADERS);
+                res.end(JSON.stringify(page));
+            }
+            catch (err) {
+                console.error(`[dario] request log read failed: ${sanitizeError(err)}`);
+                res.writeHead(500, JSON_HEADERS);
+                res.end(JSON.stringify({ error: 'request log unreadable' }));
+            }
+            return;
+        }
         // Analytics live stream — SSE of new RequestRecord JSON, one event
         // per record as it lands. Drives the v4 TUI's Hits tab. Sends a
         // backlog of the most-recent 50 records on connect so a freshly-

package/dist/request-log.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The `--log-file` request log by byte offset, for GET /analytics/requests.
+ *
+ * A page is whole lines. The last line of a read may still be on its way to
+ * disk, so anything after the final newline waits for the next read. A line too
+ * long for a page can never be served, so once it is complete it is passed over
+ * and counted, or a reader would stop there for good.
+ *
+ * An offset means nothing in a different file, and a replacement can be longer
+ * than the reader's offset, so the size alone cannot show it. Each page carries
+ * a mark, a hash of the first and last KiB of what has been read. A reader hands
+ * it back with the offset, and a mark that no longer matches sends it to the
+ * start. Every line opens with its own timestamp, so a different log differs at
+ * the head: that covers a rename, a truncation and a reused inode alike, where a
+ * file identity would miss a log truncated in place and grown past the offset.
+ *
+ * The log is append-only, and the mark is built on that. Hashing all of what has
+ * been read would cost a pass over the whole file per page, so an edit to the
+ * middle of it that keeps both ends is the one change this cannot see. Nothing in
+ * dario rewrites the file, and a rotation does not leave its first line in place.
+ */
+export declare const REQUEST_LOG_PAGE_BYTES: number;
+export interface RequestLogPage {
+    /** The file's size at this read. `size - next` is what is still unread. */
+    size: number;
+    /** The offset to ask for next. Equal to `after` when no whole line is ready. */
+    next: number;
+    /** Hand this back with `next`. Empty at the start of the file, where there is nothing to check. */
+    mark: string;
+    records: unknown[];
+    /** Whole lines that did not parse. They are passed over, and counted here so that is visible. */
+    unreadable: number;
+}
+/** `?after=` and `?mark=` from a request URL. Anything unusable reads as the start of the file. */
+export declare function parseRequestLogQuery(url: string): {
+    after: number;
+    mark: string;
+};
+/**
+ * One page of the log from byte `after`. A log with nothing in it yet is an
+ * empty page, not an error. `pageBytes` is the caller's, never the request's.
+ */
+export declare function readRequestLog(path: string, after?: number, mark?: string, pageBytes?: number): Promise<RequestLogPage>;

package/dist/request-log.js

@@ -0,0 +1,107 @@
+/**
+ * The `--log-file` request log by byte offset, for GET /analytics/requests.
+ *
+ * A page is whole lines. The last line of a read may still be on its way to
+ * disk, so anything after the final newline waits for the next read. A line too
+ * long for a page can never be served, so once it is complete it is passed over
+ * and counted, or a reader would stop there for good.
+ *
+ * An offset means nothing in a different file, and a replacement can be longer
+ * than the reader's offset, so the size alone cannot show it. Each page carries
+ * a mark, a hash of the first and last KiB of what has been read. A reader hands
+ * it back with the offset, and a mark that no longer matches sends it to the
+ * start. Every line opens with its own timestamp, so a different log differs at
+ * the head: that covers a rename, a truncation and a reused inode alike, where a
+ * file identity would miss a log truncated in place and grown past the offset.
+ *
+ * The log is append-only, and the mark is built on that. Hashing all of what has
+ * been read would cost a pass over the whole file per page, so an edit to the
+ * middle of it that keeps both ends is the one change this cannot see. Nothing in
+ * dario rewrites the file, and a rotation does not leave its first line in place.
+ */
+import { createHash } from 'node:crypto';
+import { open } from 'node:fs/promises';
+export const REQUEST_LOG_PAGE_BYTES = 1024 * 1024;
+/** Longer than a log line, so each end of a mark takes in a line's timestamp and request number. */
+const MARK_BYTES = 1024;
+/** `?after=` and `?mark=` from a request URL. Anything unusable reads as the start of the file. */
+export function parseRequestLogQuery(url) {
+    const params = new URL(url, 'http://dario.invalid').searchParams;
+    const after = Number(params.get('after'));
+    return {
+        after: Number.isSafeInteger(after) && after > 0 ? after : 0,
+        mark: params.get('mark') ?? '',
+    };
+}
+async function markAt(file, offset) {
+    const length = Math.min(MARK_BYTES, offset);
+    if (length <= 0)
+        return '';
+    const hash = createHash('sha256');
+    const window = Buffer.alloc(MARK_BYTES);
+    for (const start of [0, offset - length]) {
+        const { bytesRead } = await file.read(window, 0, length, start);
+        hash.update(window.subarray(0, bytesRead));
+    }
+    return hash.digest('hex').slice(0, 32);
+}
+/** The offset just past the next newline at or after `from`, or null when none has reached disk yet. */
+async function pastNextNewline(file, from, scratch) {
+    let at = from;
+    for (;;) {
+        const { bytesRead } = await file.read(scratch, 0, scratch.length, at);
+        if (bytesRead === 0)
+            return null;
+        const newline = scratch.subarray(0, bytesRead).indexOf(0x0a);
+        if (newline >= 0)
+            return at + newline + 1;
+        at += bytesRead;
+    }
+}
+/**
+ * One page of the log from byte `after`. A log with nothing in it yet is an
+ * empty page, not an error. `pageBytes` is the caller's, never the request's.
+ */
+export async function readRequestLog(path, after = 0, mark = '', pageBytes = REQUEST_LOG_PAGE_BYTES) {
+    let file;
+    try {
+        file = await open(path, 'r');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return { size: 0, next: 0, mark: '', records: [], unreadable: 0 };
+        throw err;
+    }
+    try {
+        const { size } = await file.stat();
+        if (after > size || (after > 0 && mark && await markAt(file, after) !== mark)) {
+            return { size, next: 0, mark: '', records: [], unreadable: 0 };
+        }
+        const page = Buffer.alloc(pageBytes);
+        const { bytesRead } = await file.read(page, 0, pageBytes, after);
+        const end = page.subarray(0, bytesRead).lastIndexOf(0x0a);
+        if (end < 0) {
+            const past = bytesRead === pageBytes ? await pastNextNewline(file, after + pageBytes, page) : null;
+            if (past !== null)
+                return { size, next: past, mark: await markAt(file, past), records: [], unreadable: 1 };
+            return { size, next: after, mark: await markAt(file, after), records: [], unreadable: 0 };
+        }
+        const records = [];
+        let unreadable = 0;
+        for (const line of page.subarray(0, end).toString('utf-8').split('\n')) {
+            if (!line)
+                continue;
+            try {
+                records.push(JSON.parse(line));
+            }
+            catch {
+                unreadable++;
+            }
+        }
+        const next = after + end + 1;
+        return { size, next, mark: await markAt(file, next), records, unreadable };
+    }
+    finally {
+        await file.close();
+    }
+}

package/docs/analytics.md

@@ -11,6 +11,7 @@ Every surface below is a view over those two. Nothing here collects anything new
 | `GET /analytics` | window summary (with `window.perFiveMinutes`, the hour in twelve bins) + `queue` snapshot + `overage` (the halt state, for a reader who cannot open `/admin/resume`) + `lifetime` ledger summary | JSON |
 | `GET /analytics/ledger` | the ledger's per-day table, with `priced`: the same rows as USD at each day's rate | JSON |
 | `GET /analytics/stream` | live tail of request records (drives the TUI) | SSE |
+| `GET /analytics/requests` | the `--log-file` request log by byte offset: `?after=<next>&mark=<mark>` gives `{ size, next, mark, records, unreadable }`, up to 1 MiB of whole lines. Hand back `next` and `mark` together. The mark covers the first and last KiB of what has been read: when it no longer matches, the file was replaced or truncated and `next` is 0. The log is append-only, so an edit to the middle of what was read that keeps both ends is not detected. Survives a restart, which the stream does not. 404 when the log is off | JSON |
 | `GET /metrics` | the same state as Prometheus text exposition | text/plain 0.0.4 |
 | `GET /analytics/donuts.svg` | spend by model / by key / by billing | SVG |
 | `GET /analytics/view` | the server-rendered summary (the page before 6.17; still served) | HTML fragment |

package/docs/cli-and-endpoints.md

@@ -22,7 +22,7 @@
 | `GET /health` · `GET /livez` | Serviceability (503 when not) · liveness. `/health?probe=1` sends one real request |
 | `GET /status` · `GET /accounts` · `GET /analytics` | OAuth detail · per-seat utilization and grant age · per-account / per-model stats and burn rate |
 | `POST /v1/messages/count_tokens` · `POST /v1/complete` | Token counting and the legacy Text Completions shape |
-| `GET /analytics/stream` · `GET /analytics/ledger` · `GET /codex` | Live analytics over SSE · the ledger's per-day table · ChatGPT-seat status and utilisation (used %, window, reset, headroom), read without spending or exposing a token |
+| `GET /analytics/stream` · `GET /analytics/requests` · `GET /analytics/ledger` · `GET /codex` | Live analytics over SSE · the `--log-file` request log by byte offset · the ledger's per-day table · ChatGPT-seat status and utilisation (used %, window, reset, headroom), read without spending or exposing a token |
 | `/admin/*` | Provisioning, `GET /admin/accounts`, `/admin/keys`, `POST /admin/resume`; only with `DARIO_ADMIN=1` ([admin API](admin-api.md)) |
 
 Flags: [commands.md](commands.md), plus `dario --help --all` for the ones it doesn't list yet (`--effort`, `--max-tokens`, `--model-alias`, `--fast-model`, session rotation, concurrency caps, the pacing knobs behind `--stealth`) · env vars grouped by task, for Docker / k8s / systemd: [configuration.md](configuration.md) · SDK examples: [usage.md](usage.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.22.2",
+  "version": "6.22.3",
   "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, opt-in failover when one hits its limit, and a ledger of what each plan absorbed.",
   "type": "module",
   "bin": {