@askalf/dario 4.0.1 → 4.1.1

package/dist/tui/tabs/hits.js

@@ -32,13 +32,28 @@ export const HitsTab = {
     label: 'Hits',
     hotkey: 'h',
     initialState() {
-        return { buffer: [], selectedIdx: -1, subscribed: false, connectionError: null };
+        return { buffer: [], selectedIdx: -1, subscribed: false, connectionError: null, halt: null };
     },
     onMount(_state, ctx) {
         // Subscribe to the live stream. Each record is prepended-conceptually
         // (we push to the array and render in reverse, which keeps the
         // buffer's mutation simple — Array.push is O(1) while unshift is O(n)).
-        const close = ctx.client.subscribeAnalyticsStream((record) => {
+        //
+        // The same stream carries named events for overage-halt / -resume
+        // (v4.1, dario#288). The SSE event type is the second argument; we
+        // route on it.
+        const close = ctx.client.subscribeAnalyticsStream((payload, eventType) => {
+            if (eventType === 'overage_halt' || eventType === 'overage_warn') {
+                const state = payload;
+                ctx.setState((s) => ({ ...s, halt: state }));
+                return;
+            }
+            if (eventType === 'overage_resume') {
+                ctx.setState((s) => ({ ...s, halt: null }));
+                return;
+            }
+            // Default ('message') = RequestRecord
+            const record = payload;
             ctx.setState((s) => {
                 const next = {
                     ...s,
@@ -123,6 +138,16 @@ export const HitsTab = {
         const colIn = 8, colOut = 7, colLat = 7, colStatus = 5;
         lines.push(' ' + brand('Hits') +
             dim(`  ${state.buffer.length} buffered · ${state.subscribed ? fg('green', 'live') : fg('yellow', 'disconnected')}`));
+        // ── Overage-halt banner (v4.1, dario#288) ──────────────────
+        // Pinned at the top so it's always visible while scrolling the buffer.
+        if (state.halt) {
+            const since = formatTimestamp(state.halt.since);
+            const cooldown = formatRemaining(state.halt.cooldownUntil - Date.now());
+            const line1 = `  ${fg('red', '⚠ HALTED')}  overage detected at ${since} on ${state.halt.request.model}  (account=${state.halt.request.account})`;
+            const line2 = `  ${dim('→ New /v1/messages requests return 503 until')} ${fg('cyan', 'R')} ${dim('here, or')} ${fg('cyan', 'dario resume')}${dim(' from any shell. Auto-resume in')} ${cooldown}${dim('.')}`;
+            lines.push(line1);
+            lines.push(line2);
+        }
         lines.push('');
         // Header row (aligned with data rows)
         lines.push('  ' + dim(pad('time', colTime) +
@@ -133,7 +158,10 @@ export const HitsTab = {
             pad('st', colStatus)));
         for (let i = startIdx; i < endIdx; i++) {
             const r = newestFirst[i];
-            const marker = i === state.selectedIdx ? fg('cyan', '▎') : ' ';
+            const isOverage = r.claim === 'overage';
+            const marker = i === state.selectedIdx ? fg('cyan', '▎')
+                : isOverage ? fg('red', '!')
+                    : ' ';
             const row = marker + ' ' +
                 pad(formatTime(r.timestamp), colTime) +
                 pad(shortenModel(r.model), colModel) +
@@ -141,7 +169,16 @@ export const HitsTab = {
                 pad(formatTokens(r.outputTokens), colOut) +
                 pad(formatLatency(r.latencyMs), colLat) +
                 pad(formatStatus(r.status), colStatus);
-            lines.push(i === state.selectedIdx ? inverse(truncate(row, w - 2)) : truncate(row, w - 2));
+            // Overage rows render in red even when unselected; selection still
+            // wins via the inverse() wrapper so the user can drill into one.
+            let styled;
+            if (i === state.selectedIdx)
+                styled = inverse(truncate(row, w - 2));
+            else if (isOverage)
+                styled = fg('red', truncate(row, w - 2));
+            else
+                styled = truncate(row, w - 2);
+            lines.push(styled);
         }
         // Scroll hint
         if (newestFirst.length > listRows) {
@@ -221,3 +258,16 @@ function tokenBreakdown(r) {
         parts.push(`thinking ${r.thinkingTokens}`);
     return parts.join(' / ');
 }
+function formatTimestamp(ts) {
+    const d = new Date(ts);
+    return `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
+}
+function formatRemaining(ms) {
+    if (ms <= 0)
+        return fg('yellow', 'now');
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    return m < 60 ? `${m}m ${s % 60}s` : `${Math.floor(m / 60)}h ${m % 60}m`;
+}

package/dist/tui/tabs/status.d.ts

@@ -20,6 +20,7 @@
  *   └─────────────────────────────────────────────────┘
  */
 import type { Tab, TabContext } from '../tab.js';
+import type { OverageGuardStatus } from '../proxy-client.js';
 export interface StatusState {
     loading: boolean;
     /** Proxy /health response, or null if unreachable. */
@@ -31,6 +32,12 @@ export interface StatusState {
     } | null;
     /** Config-file load source: file | missing | invalid. */
     configSource: 'file' | 'missing' | 'invalid' | null;
+    /** Overage-guard state from /admin/resume — null if unreachable. */
+    overageGuard: OverageGuardStatus | null;
+    /** Transient: did we just attempt a manual resume? */
+    resumePending: boolean;
+    resumeMessage: string | null;
+    resumeKind: 'success' | 'info' | 'error' | null;
     /** Last refresh timestamp (ms). */
     lastRefreshAt: number;
     /** Error from the last refresh attempt, if any. */
@@ -43,3 +50,10 @@ export declare const StatusTab: Tab<StatusState>;
  * 'r' without re-running the full onMount flow.
  */
 export declare function refreshStatus(ctx: TabContext): Promise<StatusState>;
+/**
+ * Fire the manual-resume POST and update state. Called by TuiApp when the
+ * Status tab returns a state with resumePending=true (the `R` key path).
+ * Lives here next to refreshStatus so all status-tab-side-effects sit
+ * together.
+ */
+export declare function performResume(ctx: TabContext<StatusState>): Promise<Partial<StatusState>>;

package/dist/tui/tabs/status.js

@@ -30,6 +30,10 @@ export const StatusTab = {
             loading: true,
             health: null,
             configSource: null,
+            overageGuard: null,
+            resumePending: false,
+            resumeMessage: null,
+            resumeKind: null,
             lastRefreshAt: 0,
             error: null,
         };
@@ -37,12 +41,40 @@ export const StatusTab = {
     async onMount(_state, ctx) {
         return refreshStatus(ctx);
     },
+    onTick(state, ctx) {
+        // Drive the async side-effects that onKey can't fire directly.
+        if (state.resumePending) {
+            void performResume(ctx).then((delta) => ctx.setState(delta));
+            return;
+        }
+        // Poll the overage-guard state every 2s so the halt countdown stays
+        // current without the user having to press `r`. Cheap GET; the proxy
+        // is on loopback. Skip when the rest of the status is still loading.
+        if (!state.loading && state.overageGuard !== null && state.overageGuard.halted) {
+            // While halted, refresh every 2s so the countdown updates.
+            const since = Date.now() - state.lastRefreshAt;
+            if (since >= 2000) {
+                void ctx.client.getOverageGuard().then((g) => {
+                    if (g)
+                        ctx.setState({ overageGuard: g, lastRefreshAt: Date.now() });
+                });
+            }
+        }
+    },
     onKey(state, key) {
-        // `r` triggers a manual refresh by signaling the parent to call
-        // onMount again. The parent watches for a sentinel state.
+        // `r` triggers a manual refresh — signal the parent to call onMount again.
         if (key.name === 'printable' && key.ch === 'r' && !key.ctrl) {
             return { ...state, loading: true };
         }
+        // `R` (shift-r) resumes the overage-guard halt state when one is active.
+        // Returning a sentinel state with resumePending=true signals the parent
+        // to fire the async resume() call.
+        if (key.name === 'printable' && key.ch === 'R' && !key.ctrl) {
+            if (state.overageGuard?.halted) {
+                return { ...state, resumePending: true, resumeMessage: 'Resuming…', resumeKind: 'info' };
+            }
+            return { ...state, resumeMessage: 'Nothing to resume — proxy is not halted.', resumeKind: 'info' };
+        }
         return undefined;
     },
     render(state, dim_) {
@@ -75,12 +107,52 @@ export const StatusTab = {
                     : dim('not loaded');
         lines.push('  ' + renderKvRow('Source', sourceLabel, w - 4));
         lines.push('');
+        // ── Overage-guard section (v4.1, dario#288) ────────────────
+        if (state.overageGuard) {
+            lines.push(' ' + brand('Overage-guard'));
+            if (state.overageGuard.halted && state.overageGuard.state) {
+                const s = state.overageGuard.state;
+                const remainingMs = Math.max(0, s.cooldownUntil - Date.now());
+                const remaining = formatDuration(remainingMs);
+                // Red banner header — this is the loud surface when halted
+                lines.push('  ' + fg('red', '⚠ HALTED') + '  ' + dim(`overage detected ${formatAgo(s.since)} ago`));
+                lines.push('  ' + renderKvRow('Request', `${s.request.model}  ${dim('account=' + s.request.account)}`, w - 4));
+                lines.push('  ' + renderKvRow('Cause', `representative-claim = ${fg('red', s.request.claim)}`, w - 4));
+                lines.push('  ' + renderKvRow('Auto-resume in', remaining === '0s' ? fg('yellow', 'now (cooldown elapsed)') : remaining, w - 4));
+                lines.push('  ' + renderKvRow('Manual resume', `press ${fg('cyan', 'R')} here, or ${fg('cyan', 'dario resume')} from any shell`, w - 4));
+            }
+            else {
+                lines.push('  ' + renderKvRow('State', fg('green', 'normal'), w - 4));
+                const cfg = state.overageGuard.config;
+                lines.push('  ' + renderKvRow('Mode', `${cfg.enabled ? fg('green', 'enabled') : fg('yellow', 'disabled')}  ${dim(`behavior=${cfg.behavior}  cooldown=${formatDuration(cfg.cooldownMs)}`)}`, w - 4));
+            }
+            if (state.resumeMessage) {
+                const c = state.resumeKind === 'error' ? 'red' : state.resumeKind === 'success' ? 'green' : 'cyan';
+                lines.push('  ' + fg(c, state.resumeMessage));
+            }
+            lines.push('');
+        }
         // ── Footer hint ────────────────────────────────────────────
         lines.push('');
-        lines.push(' ' + dim(`Last refresh: ${formatAgo(state.lastRefreshAt)}. Press ${fg('cyan', 'r')} to refresh.`));
+        const resumeHint = state.overageGuard?.halted ? ` · ${fg('cyan', 'R')} resume` : '';
+        lines.push(' ' + dim(`Last refresh: ${formatAgo(state.lastRefreshAt)}. ${fg('cyan', 'r')} refresh${resumeHint}.`));
         return lines.join('\n');
     },
 };
+function formatDuration(ms) {
+    if (ms <= 0)
+        return '0s';
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    const rs = s % 60;
+    if (m < 60)
+        return rs > 0 ? `${m}m ${rs}s` : `${m}m`;
+    const h = Math.floor(m / 60);
+    const rm = m % 60;
+    return rm > 0 ? `${h}h ${rm}m` : `${h}h`;
+}
 /**
  * Refresh the Status tab's data — probe /health, load config file
  * metadata. Exported separately so the parent can re-invoke on key
@@ -98,14 +170,48 @@ export async function refreshStatus(ctx) {
     catch (e) {
         error = e.message;
     }
+    // Overage-guard state — best-effort; never throws (proxy-client wraps the
+    // GET in try/catch and returns null). Surface as 'unknown' when null.
+    const overageGuard = await ctx.client.getOverageGuard();
     return {
         loading: false,
         health,
         configSource: fileResult.source,
+        overageGuard,
+        resumePending: false,
+        resumeMessage: null,
+        resumeKind: null,
         lastRefreshAt: Date.now(),
         error,
     };
 }
+/**
+ * Fire the manual-resume POST and update state. Called by TuiApp when the
+ * Status tab returns a state with resumePending=true (the `R` key path).
+ * Lives here next to refreshStatus so all status-tab-side-effects sit
+ * together.
+ */
+export async function performResume(ctx) {
+    try {
+        const result = await ctx.client.resume();
+        const refreshed = await ctx.client.getOverageGuard();
+        return {
+            overageGuard: refreshed,
+            resumePending: false,
+            resumeMessage: result.wasHalted
+                ? `Resumed at ${result.resumedAt}.`
+                : 'Already running normally — no-op.',
+            resumeKind: 'success',
+        };
+    }
+    catch (e) {
+        return {
+            resumePending: false,
+            resumeMessage: `Resume failed: ${e.message}`,
+            resumeKind: 'error',
+        };
+    }
+}
 function formatOauth(label, expiresIn) {
     if (label === 'healthy') {
         return fg('green', expiresIn ? `healthy (expires in ${expiresIn})` : 'healthy');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "4.0.1",
+  "version": "4.1.1",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {