oc-codex-multi-auth 6.21.0 → 6.23.0

package/dist/tui.js

@@ -1,13 +1,67 @@
-import { getCodexTuiMaskEmail, getCodexTuiMaskEmailInQuotaDetails, loadPluginConfig, } from "./lib/config.js";
+import { getCodexTuiMaskEmail, getCodexTuiMaskEmailInQuotaDetails, getQuotaDisplay, getQuotaStatus, loadPluginConfig, } from "./lib/config.js";
+import { PROVIDER_ID } from "./lib/constants.js";
+import { fetchTuiQuotaOverview, mergeOverviewWithLatestAccount, toQuotaOverviewAccounts, } from "./lib/tui-quota-overview.js";
 import { createUsageAccountFingerprint, ensureCodexUsageAccessToken, fetchCodexUsage, formatUsageWindowLabel, getUsageLeftPercent, hasUsageWindow, parseCodexUsagePayload, resolveCodexUsageAccountId, resolveCodexUsageActiveAccount, } from "./lib/codex-usage.js";
-import { formatPromptStatusText, formatQuotaDetailsText, resolveQuotaPromptTone, } from "./lib/tui-status.js";
-import { createTuiQuotaSnapshot, getTuiQuotaCachePath, isFreshTuiQuotaSnapshot, isTuiQuotaSnapshot, readTuiQuotaSnapshot, writeTuiQuotaSnapshot, } from "./lib/tui-quota-cache.js";
+import { formatPromptStatusText, formatQuotaDetailsText, formatQuotaOverviewStatusLines, formatQuotaResetsStatusLines, resolveQuotaOverviewTone, resolveQuotaPromptTone, } from "./lib/tui-status.js";
+import { createTuiQuotaSnapshot, getTuiQuotaCachePath, getTuiQuotaOverviewCachePath, isFreshTuiQuotaSnapshot, isTuiQuotaSnapshot, readTuiQuotaSnapshot, writeTuiQuotaSnapshot, } from "./lib/tui-quota-cache.js";
 import { loadAccounts } from "./lib/storage.js";
 const CACHE_KEY = "oc-codex-multi-auth:tui-status:v2";
 const REFRESH_INTERVAL_MS = 5 * 60 * 1000;
 const EVENT_REFRESH_DEBOUNCE_MS = 750;
 const ACCOUNT_POLL_INTERVAL_MS = 1_000;
+// The status line is the one surface that reads this configuration once and
+// then renders it for the rest of the session, so it is the only one where an
+// edit would otherwise need a restart to be seen. `loadPluginConfig` already
+// re-reads the file on every call and only skips re-parsing when the bytes are
+// unchanged, so polling it costs one read of a file measured in hundreds of
+// bytes.
+const CONFIG_POLL_INTERVAL_MS = 2_000;
+// Re-reading three numbers off the laid-out node, which is cheap enough to do
+// often and has to be: the first pass happens before any layout exists, and
+// until it is picked up the line is budgeting against the whole terminal.
+const LAYOUT_MEASURE_INTERVAL_MS = 500;
 let inFlightRefresh;
+let inFlightOverview;
+async function refreshQuotaOverviewInner(api) {
+    try {
+        const now = Date.now();
+        const snapshot = await fetchTuiQuotaOverview({
+            cachePath: getTuiQuotaOverviewCachePath(api.state.path.state),
+            now,
+        });
+        if (!snapshot || snapshot.accounts.length === 0) {
+            return { type: "unavailable" };
+        }
+        const merged = mergeOverviewWithLatestAccount(snapshot, await readSharedQuotaStatus(api));
+        return {
+            type: "ready",
+            accounts: toQuotaOverviewAccounts(merged),
+            // Judged on the poll, not on the merged account: one account read a
+            // moment ago does not make a five-minute-old reading of the other six
+            // current.
+            stale: !isFreshTuiQuotaSnapshot(merged, now),
+        };
+    }
+    catch {
+        return { type: "unavailable" };
+    }
+}
+/**
+ * Coalesce concurrent refreshes.
+ *
+ * Every session event that can move a quota schedules one of these, and
+ * without this guard a burst of tool completions would start several passes
+ * over the whole pool at once. The pass itself is already cheap while the
+ * cache is fresh - it reads one file - so the events can stay wired to it.
+ */
+function refreshQuotaOverview(api) {
+    if (inFlightOverview)
+        return inFlightOverview;
+    inFlightOverview = refreshQuotaOverviewInner(api).finally(() => {
+        inFlightOverview = undefined;
+    });
+    return inFlightOverview;
+}
 function isStoredQuotaStatus(value) {
     return isTuiQuotaSnapshot(value);
 }
@@ -215,7 +269,242 @@ export function shouldRefreshQuotaForEvent(event) {
             return false;
     }
 }
-function createPromptStatus(api, solid, options) {
+export function readPromptStatusOptions() {
+    const pluginConfig = loadPluginConfig();
+    return {
+        maskEmail: getCodexTuiMaskEmail(pluginConfig),
+        maskEmailInQuotaDetails: getCodexTuiMaskEmailInQuotaDetails(pluginConfig),
+        quotaDisplay: getQuotaDisplay(pluginConfig),
+        quotaStatus: getQuotaStatus(pluginConfig),
+    };
+}
+/**
+ * Whether two readings of the configuration would render the same line.
+ *
+ * Compared field by field rather than by identity: every poll builds a fresh
+ * object, so identity always differs and pushing it into a signal would
+ * re-render the status line every two seconds forever.
+ */
+export function samePromptStatusOptions(left, right) {
+    const leftStatus = left.quotaStatus;
+    const rightStatus = right.quotaStatus;
+    return (left.maskEmail === right.maskEmail &&
+        left.maskEmailInQuotaDetails === right.maskEmailInQuotaDetails &&
+        left.quotaDisplay === right.quotaDisplay &&
+        leftStatus.screens.length === rightStatus.screens.length &&
+        leftStatus.screens.every((screen, position) => screen === rightStatus.screens[position]) &&
+        leftStatus.rotateMs === rightStatus.rotateMs &&
+        leftStatus.layout === rightStatus.layout &&
+        leftStatus.accountNames === rightStatus.accountNames &&
+        leftStatus.order === rightStatus.order &&
+        leftStatus.multipliers === rightStatus.multipliers &&
+        leftStatus.allotment === rightStatus.allotment &&
+        leftStatus.resetTimes === rightStatus.resetTimes &&
+        leftStatus.resetCredits === rightStatus.resetCredits &&
+        leftStatus.recovery === rightStatus.recovery &&
+        leftStatus.rows === rightStatus.rows &&
+        leftStatus.showFor === rightStatus.showFor);
+}
+/**
+ * Columns on the prompt's bottom row that belong to the model label beside
+ * this line, plus the gap between them.
+ *
+ * A constant rather than the label's measured width, and that is the whole
+ * point. The row lays both boxes out by their content, so a label with no room
+ * left is SHRUNK to whatever this line did not take - measuring it would make
+ * the budget a function of the line's own length, and every render would
+ * ratchet it further down. The row's width is the one number on that row that
+ * this line cannot influence.
+ *
+ * 40 is measured against the real TUI: "Build - Big Pickle OpenCode Zen" is 31
+ * characters, and at 80 columns a 48-character line was ellipsized through its
+ * middle AND pushed the label onto a second row.
+ */
+const PROMPT_LABEL_RESERVED_CHARS = 40;
+const MAX_LAYOUT_WALK_DEPTH = 8;
+function asLayoutNode(value) {
+    return typeof value === "object" && value !== null ? value : undefined;
+}
+function layoutSize(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0
+        ? value
+        : undefined;
+}
+function layoutChildren(node) {
+    if (typeof node.getChildren !== "function")
+        return [];
+    try {
+        const children = node.getChildren();
+        if (!Array.isArray(children))
+            return [];
+        return children
+            .map((child) => asLayoutNode(child))
+            .filter((child) => Boolean(child));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Measure the row this line sits on, by walking up to it.
+ *
+ * The walk looks for the nearest ancestor laid out as a row with something else
+ * in it - the prompt's bottom row, where the model label is the something else.
+ * That row stretches to the prompt's inner width, which is the number the
+ * terminal width fails to be whenever a sidebar is open, and the only number on
+ * that row this line does not influence.
+ *
+ * Every hop is guarded and the whole thing returns nothing rather than a guess:
+ * before the first layout pass there are no widths to read, and a host that
+ * rearranges its prompt must degrade to the width heuristic rather than compute
+ * a budget from numbers that no longer mean what they did.
+ */
+export function measureStatusSlot(node) {
+    const chain = [];
+    let current = asLayoutNode(node);
+    for (let depth = 0; current && depth < MAX_LAYOUT_WALK_DEPTH; depth += 1) {
+        chain.push(current);
+        current = asLayoutNode(current.parent);
+    }
+    for (const [position, ancestor] of chain.entries()) {
+        if (position === 0)
+            continue;
+        if (ancestor.primaryAxis !== "row")
+            continue;
+        const rowWidth = layoutSize(ancestor.width);
+        if (!rowWidth)
+            continue;
+        const children = layoutChildren(ancestor);
+        if (children.length < 2)
+            continue;
+        const mine = chain[position - 1];
+        if (!mine || !children.includes(mine))
+            continue;
+        const availableChars = rowWidth - PROMPT_LABEL_RESERVED_CHARS;
+        if (availableChars < 1)
+            continue;
+        return { availableChars };
+    }
+    return {};
+}
+function toQuotaOverviewOptions(options, now) {
+    // Spelled out rather than spread: `QuotaStatusConfig` calls the free/used
+    // wording `quotaDisplay` and its own screen list `screens`, while
+    // `QuotaOverviewOptions.mode` IS the wording - spreading one over the other
+    // silently renders every percentage as headroom.
+    return {
+        mode: options.quotaDisplay,
+        layout: options.quotaStatus.layout,
+        names: options.quotaStatus.accountNames,
+        order: options.quotaStatus.order,
+        multipliers: options.quotaStatus.multipliers,
+        allotment: options.quotaStatus.allotment,
+        resetTimes: options.quotaStatus.resetTimes,
+        resetCredits: options.quotaStatus.resetCredits,
+        recovery: options.quotaStatus.recovery,
+        maskEmail: options.maskEmail,
+        now,
+    };
+}
+/**
+ * The pool-wide status line's data pipeline.
+ *
+ * Kept apart from the active-account one rather than branching inside it:
+ * that one maintains a serving-account fingerprint, a snapshot revision and a
+ * one-second identity poll, all of which exist to answer "which account is
+ * this" - the question this mode is built to stop asking.
+ */
+function createOverviewQuotaController(api, solid) {
+    const [state, setState] = solid.createSignal({
+        type: "loading",
+    });
+    const refresh = () => {
+        void refreshQuotaOverview(api).then(setState, () => {
+            setState({ type: "unavailable" });
+        });
+    };
+    let refreshTimeout;
+    const scheduleRefresh = () => {
+        if (refreshTimeout)
+            clearTimeout(refreshTimeout);
+        refreshTimeout = setTimeout(() => {
+            refreshTimeout = undefined;
+            refresh();
+        }, EVENT_REFRESH_DEBOUNCE_MS);
+    };
+    refresh();
+    const interval = setInterval(refresh, REFRESH_INTERVAL_MS);
+    const disposers = [
+        api.event.on("message.updated", (event) => {
+            if (shouldRefreshQuotaForEvent(event))
+                scheduleRefresh();
+        }),
+        api.event.on("message.part.updated", (event) => {
+            if (shouldRefreshQuotaForEvent(event))
+                scheduleRefresh();
+        }),
+        api.event.on("session.idle", (event) => {
+            if (shouldRefreshQuotaForEvent(event))
+                scheduleRefresh();
+        }),
+        api.event.on("session.status", (event) => {
+            if (shouldRefreshQuotaForEvent(event))
+                scheduleRefresh();
+        }),
+        api.event.on("session.error", (event) => {
+            if (shouldRefreshQuotaForEvent(event))
+                scheduleRefresh();
+        }),
+    ];
+    return {
+        screens: ["overview", "resets"],
+        lines(screen, options, layout) {
+            const current = state();
+            if (current.type !== "ready") {
+                // Blank while the first pass runs; a placeholder swapped out a
+                // moment later is exactly the flicker this mode removes. The
+                // reset screen stays blank either way - it has nothing to add
+                // to a pool nobody has read yet.
+                if (screen === "resets")
+                    return [];
+                return current.type === "loading" ? [] : ["limits ?"];
+            }
+            const render = screen === "resets"
+                ? formatQuotaResetsStatusLines
+                : formatQuotaOverviewStatusLines;
+            return render({
+                accounts: current.accounts,
+                options: toQuotaOverviewOptions(options, Date.now()),
+                width: api.renderer.width,
+                availableChars: layout.availableChars,
+                maxRows: layout.maxRows,
+            });
+        },
+        tone(screen) {
+            const current = state();
+            if (current.type === "ready") {
+                // The reset screen only appears once nothing has headroom left,
+                // so the pool tone it would otherwise carry is always danger and
+                // says nothing. Warning is the honest colour for "here is the
+                // thing you can still do about it".
+                if (screen === "resets") {
+                    return current.stale ? "stale" : "warning";
+                }
+                return resolveQuotaOverviewTone(current.accounts, current.stale);
+            }
+            return current.type === "loading" ? "unknown" : "warning";
+        },
+        dispose() {
+            clearInterval(interval);
+            if (refreshTimeout)
+                clearTimeout(refreshTimeout);
+            for (const dispose of disposers)
+                dispose();
+        },
+    };
+}
+/** The serving-account pipeline: the status line's original behaviour. */
+function createActiveQuotaController(api, solid) {
     const [quota, setQuota] = solid.createSignal({
         type: "loading",
     });
@@ -303,29 +592,217 @@ function createPromptStatus(api, solid, options) {
         if (shouldRefreshQuotaForEvent(event))
             scheduleRefresh();
     });
-    solid.onCleanup(() => {
-        clearInterval(interval);
-        clearInterval(accountInterval);
-        if (refreshTimeout)
-            clearTimeout(refreshTimeout);
-        disposeMessageUpdated();
-        disposeMessagePartUpdated();
-        disposeSessionIdle();
-        disposeSessionStatus();
-        disposeSessionError();
-    });
-    const node = solid.createElement("text");
-    solid.spread(node, {
-        get content() {
-            return formatPromptStatusText({
+    return {
+        screens: ["active"],
+        lines(_screen, options) {
+            const text = formatPromptStatusText({
                 quota: quota(),
                 width: api.renderer.width,
                 maskEmail: options.maskEmail,
+                quotaDisplay: options.quotaDisplay,
             });
+            return text ? [text] : [];
+        },
+        tone() {
+            return resolveQuotaPromptTone(quota());
+        },
+        dispose() {
+            clearInterval(interval);
+            clearInterval(accountInterval);
+            if (refreshTimeout)
+                clearTimeout(refreshTimeout);
+            disposeMessageUpdated();
+            disposeMessagePartUpdated();
+            disposeSessionIdle();
+            disposeSessionStatus();
+            disposeSessionError();
+        },
+    };
+}
+/**
+ * The status-line node, which outlives any change to how it is configured.
+ *
+ * Both the shape of the line and the pipeline behind it come from a file the
+ * user edits while sessions are open, so this polls that file and swaps the
+ * pipeline underneath a node the renderer keeps mounted. The alternative -
+ * re-registering the slot - would ask the renderer to replace a live node, and
+ * a mode change is exactly when it must not blink.
+ */
+/**
+ * The pipelines a set of screens needs, and which screen each one answers.
+ *
+ * `resets` is served by the pool pipeline rather than one of its own: it needs
+ * every account's windows and banked credits, which is exactly what that
+ * pipeline already gathers, and a second poller reading the same endpoint for
+ * the same numbers would double the request cost to say the same thing.
+ */
+function createQuotaControllers(api, solid, screens) {
+    const controllers = [];
+    if (screens.includes("active")) {
+        controllers.push(createActiveQuotaController(api, solid));
+    }
+    if (screens.includes("overview") || screens.includes("resets")) {
+        controllers.push(createOverviewQuotaController(api, solid));
+    }
+    return controllers;
+}
+/**
+ * Whether the account pool is worth naming for the model in front of the user.
+ *
+ * Unknown counts as yes. A line the user asked for should not disappear
+ * because a fresh session has no message to read a provider off yet, and being
+ * told about a pool one model does not draw from is a smaller wrong than being
+ * told nothing while it runs out.
+ */
+export function showsQuotaForSession(params) {
+    if (params.audience === "always")
+        return true;
+    return !params.providerID || params.providerID === PROVIDER_ID;
+}
+function getString(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : undefined;
+}
+/**
+ * The provider actually serving this session, newest statement first.
+ *
+ * A message records what ran, which is the only reliable answer once a session
+ * has moved off the configured default; the configured model is the fallback
+ * for a session that has not run anything yet.
+ */
+function resolveSessionProviderId(api, sessionID) {
+    if (sessionID) {
+        try {
+            const messages = api.state.session.messages(sessionID);
+            for (let position = messages.length - 1; position >= 0; position -= 1) {
+                const message = messages[position];
+                if (message?.role !== "assistant")
+                    continue;
+                const providerID = getString(message.providerID);
+                if (providerID)
+                    return providerID;
+            }
+        }
+        catch {
+            // The session may not be in the store yet; fall through to config.
+        }
+    }
+    const configured = getString(api.state.config.model);
+    if (!configured)
+        return undefined;
+    const slashIndex = configured.indexOf("/");
+    return slashIndex > 0 ? configured.slice(0, slashIndex) : undefined;
+}
+/**
+ * The status-line node, which outlives any change to how it is configured.
+ *
+ * Both the shape of the line and the pipelines behind it come from a file the
+ * user edits while sessions are open, so this polls that file and swaps the
+ * pipelines underneath a node the renderer keeps mounted. The alternative -
+ * re-registering the slot - would ask the renderer to replace a live node, and
+ * a screen change is exactly when it must not blink.
+ */
+function createPromptStatus(api, solid, initialOptions, sessionID) {
+    const [options, setOptions] = solid.createSignal(initialOptions);
+    const [metrics, setMetrics] = solid.createSignal({});
+    const [rotation, setRotation] = solid.createSignal(0);
+    let controllers = createQuotaControllers(api, solid, initialOptions.quotaStatus.screens);
+    let controllerScreens = initialOptions.quotaStatus.screens;
+    let rotationInterval;
+    const node = solid.createElement("text");
+    const restartRotation = (screens) => {
+        if (rotationInterval)
+            clearInterval(rotationInterval);
+        rotationInterval = undefined;
+        if (screens.length < 2)
+            return;
+        rotationInterval = setInterval(() => {
+            setRotation((tick) => tick + 1);
+        }, options().quotaStatus.rotateMs);
+    };
+    restartRotation(controllerScreens);
+    const remeasure = () => {
+        const next = measureStatusSlot(node);
+        if (next.availableChars === metrics().availableChars)
+            return;
+        setMetrics(next);
+    };
+    const measureInterval = setInterval(remeasure, LAYOUT_MEASURE_INTERVAL_MS);
+    const configInterval = setInterval(() => {
+        const next = readPromptStatusOptions();
+        if (samePromptStatusOptions(options(), next))
+            return;
+        const nextScreens = next.quotaStatus.screens;
+        const screensChanged = nextScreens.length !== controllerScreens.length ||
+            nextScreens.some((screen, position) => screen !== controllerScreens[position]);
+        // The swap happens BEFORE the signal that re-renders against it. The
+        // other order leaves the line blank until something else happens to
+        // change: the render triggered by `setOptions` would read the outgoing
+        // pipelines, find none of them serving the incoming screens, subscribe
+        // to nothing, and never hear the new pipeline resolve.
+        if (screensChanged) {
+            for (const controller of controllers)
+                controller.dispose();
+            controllers = createQuotaControllers(api, solid, nextScreens);
+            controllerScreens = nextScreens;
+            setRotation(0);
+        }
+        setOptions(next);
+        restartRotation(nextScreens);
+    }, CONFIG_POLL_INTERVAL_MS);
+    solid.onCleanup(() => {
+        clearInterval(configInterval);
+        clearInterval(measureInterval);
+        if (rotationInterval)
+            clearInterval(rotationInterval);
+        for (const controller of controllers)
+            controller.dispose();
+    });
+    /**
+     * The screen on show right now, picked from the ones that have something to
+     * say. A screen with nothing to render is skipped rather than shown blank,
+     * which is what lets `resets` sit in the rotation permanently and only
+     * appear on the day it matters.
+     */
+    const current = () => {
+        const currentOptions = options();
+        if (!showsQuotaForSession({
+            audience: currentOptions.quotaStatus.showFor,
+            providerID: resolveSessionProviderId(api, sessionID),
+        })) {
+            return undefined;
+        }
+        const layout = {
+            availableChars: metrics().availableChars,
+            maxRows: currentOptions.quotaStatus.rows,
+        };
+        const rendered = [];
+        for (const screen of currentOptions.quotaStatus.screens) {
+            const controller = controllers.find((candidate) => candidate.screens.includes(screen));
+            if (!controller)
+                continue;
+            const lines = controller.lines(screen, currentOptions, layout);
+            if (lines.length > 0)
+                rendered.push({ screen, lines });
+        }
+        if (rendered.length === 0)
+            return undefined;
+        return rendered[Math.abs(rotation()) % rendered.length];
+    };
+    solid.spread(node, {
+        get content() {
+            // A newline is how one text node becomes two rows: the renderer
+            // measures the content it was given, so the node grows to match
+            // instead of the slot having to add and remove child nodes.
+            return current()?.lines.join("\n") ?? "";
         },
         get fg() {
-            const current = quota();
-            const tone = resolveQuotaPromptTone(current);
+            const screen = current()?.screen;
+            const controller = screen
+                ? controllers.find((candidate) => candidate.screens.includes(screen))
+                : undefined;
+            const tone = screen && controller ? controller.tone(screen) : "unknown";
             if (tone === "danger")
                 return api.theme.current.error;
             if (tone === "warning" || tone === "stale") {
@@ -335,18 +812,27 @@ function createPromptStatus(api, solid, options) {
                 return api.theme.current.success;
             return api.theme.current.textMuted;
         },
+        // The host centres this slot against a model label that wraps to two
+        // rows on a narrow terminal, which put a one-row line on the bottom
+        // row and left the top one empty. Reading starts at the top.
+        alignSelf: "flex-start",
         selectable: false,
         truncate: true,
         wrapMode: "none",
     }, false);
     return node;
 }
-function showQuotaDetails(api, options) {
+function showQuotaDetails(api) {
+    // Read at open time, not at startup: the dialog is one keystroke away from
+    // the line it explains, and the two disagreeing about `used` vs `free`
+    // after an edit would be worse than either being stale alone.
+    const options = readPromptStatusOptions();
     void refreshQuotaStatus(api).then((status) => {
         api.ui.dialog.replace(() => api.ui.DialogAlert({
             title: "Codex quota",
             message: formatQuotaDetailsText(status, Date.now(), {
                 maskEmail: options.maskEmail && options.maskEmailInQuotaDetails,
+                quotaDisplay: options.quotaDisplay,
             }),
             onConfirm: () => api.ui.dialog.clear(),
         }));
@@ -361,11 +847,7 @@ function showQuotaDetails(api, options) {
 const module = {
     id: "oc-codex-multi-auth.status",
     async tui(api) {
-        const pluginConfig = loadPluginConfig();
-        const promptOptions = {
-            maskEmail: getCodexTuiMaskEmail(pluginConfig),
-            maskEmailInQuotaDetails: getCodexTuiMaskEmailInQuotaDetails(pluginConfig),
-        };
+        const promptOptions = readPromptStatusOptions();
         const [{ createElement, spread }, { createSignal, onCleanup }] = await Promise.all([import("@opentui/solid"), import("solid-js")]);
         const solid = {
             createElement,
@@ -375,7 +857,7 @@ const module = {
         };
         api.slots.register({
             slots: {
-                session_prompt_right: () => createPromptStatus(api, solid, promptOptions),
+                session_prompt_right: (_ctx, props) => createPromptStatus(api, solid, promptOptions, props.session_id),
             },
         });
         const disposeCommand = api.command.register(() => [
@@ -384,7 +866,7 @@ const module = {
                 value: "codex.quota.details",
                 description: "Show active account usage, reset times, source, and last refresh.",
                 category: "Codex",
-                onSelect: () => showQuotaDetails(api, promptOptions),
+                onSelect: () => showQuotaDetails(api),
             },
         ]);
         api.lifecycle.onDispose(disposeCommand);