@eddyskywalker/dsh-chatgpt-subscription 0.36.1 → 0.37.0

package/lib/types/host/widget-board/line-quota.d.ts

@@ -0,0 +1,284 @@
+/**
+ * One normalizer per subscription line: that line's own `GET /status` payload
+ * folded into shape C's `quota` half.
+ *
+ * Every function here takes `unknown` on purpose. The input is a loopback HTTP
+ * response — read from a route this plugin owns but not necessarily at the same
+ * version it was written against — so the mapper cannot lean on a DTO type that
+ * the running host might not satisfy. A field that is missing, null, a string
+ * where a number was expected, or an array where an object was expected must
+ * degrade to "nothing measured", never to a thrown error: one line's odd
+ * payload must not be able to take the card down.
+ *
+ * THE THREE THINGS EACH ONE EXISTS TO GET RIGHT
+ *
+ * 1. Units. The lines disagree: codex states Unix SECONDS (resetsAt),
+ *    antigravity and cline-pass state ISO 8601 strings, kimi / minimax / qoder /
+ *    glm / step / command-code state milliseconds. Each normalizer knows which
+ *    family it holds and converts exactly once — nothing here guesses a unit
+ *    from a magnitude.
+ * 2. Percentages. Some lines state used percent, some a used fraction in
+ *    [0, 1], some only the remaining share. All of them leave here as used
+ *    percent in [0, 100].
+ * 3. Absence. Null is not zero. A window without a measurement is dropped
+ *    rather than drawn as a full bar, and a line that answered nothing leaves
+ *    `quota` null with the reason carried beside it.
+ *
+ * Windows are ordered shortest first, unstated lengths last — the order a card
+ * relies on to draw the tightest limit at the top. The sort is stable, so equal
+ * lengths keep the order the line listed them in.
+ */
+import type { LineCardQuota, LineCardWindow } from './line-contracts.ts';
+/** What one line's status payload says about its quota, accounts aside. */
+export interface LineQuotaFacts {
+    /** The normalized quota, or null when the payload carried nothing usable. */
+    quota: LineCardQuota | null;
+    /** Plan the line is metered on, when the payload states one. */
+    planLabel: string | null;
+    /**
+     * Account identity the payload itself states (usually a masked email).
+     *
+     * Null when the payload names no account, which is the caller's cue to fall
+     * back to the pool's own primary row.
+     */
+    accountLabel: string | null;
+    /** Whether the payload says a credential exists; null when it never said. */
+    signedIn: boolean | null;
+    /** The line's own reason its numbers are missing, when it reported one. */
+    error: string | null;
+}
+/**
+ * The ChatGPT line's quota, as `GET /status` answers it.
+ *
+ * Units: `QuotaWindowDto.resetsAt`, `resetCredits.expiresAt` and
+ * `quota.fetchedAt` are Unix SECONDS here (that line's own quota service
+ * multiplies them by 1000 further out), while everything else on the payload is
+ * already milliseconds. The bucket list also carries an older
+ * `primary`/`secondary` pair that some payload generations state instead of
+ * `windows`; both are read, so the card shows the same bars the settings card
+ * does.
+ *
+ * @param status - The route's `value`.
+ * @returns The facts.
+ */
+export declare function normalizeCodexQuota(status: unknown): LineQuotaFacts;
+/**
+ * The Kimi Code line's quota.
+ *
+ * Units: `resetsAt` and `fetchedAt` are already milliseconds. The fallback
+ * wallet (`extraUsage`) is stated in the currency's minor unit, so it is
+ * divided once and kept with its currency: a bare "75.00" would be read as
+ * provider credits by every other card on the board.
+ *
+ * @param status - The route's `value`.
+ * @returns The facts.
+ */
+export declare function normalizeKimiCodeQuota(status: unknown): LineQuotaFacts;
+/**
+ * The MiniMax Code line's quota.
+ *
+ * Units: milliseconds throughout (`resetsAtMs`, `fetchedAtMs`). The windows are
+ * keyed (`interval` / `weekly`) rather than labelled — the line leaves the
+ * wording to the client — and carry a REMAINING percent, sometimes only a
+ * remaining one; both are inverted into the used share here.
+ *
+ * @param status - The route's `value`.
+ * @returns The facts.
+ */
+export declare function normalizeMinimaxCodeQuota(status: unknown): LineQuotaFacts;
+/**
+ * The Antigravity line's quota.
+ *
+ * Units: the harder one of the set. Each allowance is stated as
+ * `remainingFraction` in [0, 1] (null when the service measured nothing, and
+ * NOT zero), named windows arrive as `window: '5h' | 'weekly'`, and reset
+ * instants as ISO 8601. Windows are grouped (Gemini models, third-party
+ * models); each bucket's label is prefixed with its group once there is more
+ * than one group, because "Weekly" twice on one card says nothing about which
+ * allowance it is.
+ *
+ * @param status - The route's `value`.
+ * @returns The facts.
+ */
+export declare function normalizeAntigravityQuota(status: unknown): LineQuotaFacts;
+/**
+ * The Command Code line's quota.
+ *
+ * Units: two different meter shapes, and both are needed. `windows[]` is
+ * already normalized (`usedPercent`, `windowDurationMins`, milliseconds);
+ * `meters[]` states a used FRACTION that is null whenever the service reports a
+ * spend meter instead of a bounded allowance, and only the ones that did state
+ * a fraction become bars. The credit balance is that line's own string, kept
+ * verbatim.
+ *
+ * @param status - The route's `value`.
+ * @returns The facts.
+ */
+export declare function normalizeCommandCodeQuota(status: unknown): LineQuotaFacts;
+/**
+ * The Claude line's quota.
+ *
+ * Units: millisecond `fetchedAt` / `observedAt`, ISO 8601 `resetsAt`, and a
+ * used share that may be stated as percent or as a fraction in [0, 1] — the
+ * three numeric fields are null together when the source said nothing, so the
+ * fraction is only consulted when the percent is absent.
+ *
+ * The line answers `quota: null` on a first read and only fills it after its
+ * own `POST /quota`; that is what the refresh capability exists for, so an
+ * empty first read is reported as-is rather than as an error.
+ *
+ * @param status - The route's `value`.
+ * @returns The facts.
+ */
+export declare function normalizeClaudeQuota(status: unknown): LineQuotaFacts;
+/**
+ * The GLM Coding Plan line's quota.
+ *
+ * Units: milliseconds (`resetsAt`, `fetchedAt`). Windows are keyed
+ * (`five-hour` / `weekly` / `monthly`) and their used percent is null when the
+ * upstream reported no bounded allowance — an unlimited plan states no
+ * fraction, and drawing that as 0% used would invent a measurement.
+ *
+ * @param status - The route's `value`.
+ * @returns The facts.
+ */
+export declare function normalizeGlmCodingPlanQuota(status: unknown): LineQuotaFacts;
+/**
+ * The Step Code line's quota.
+ *
+ * Units: milliseconds. Two payload generations share one snapshot: an older
+ * account has 5-hour and weekly windows, a newer one has `creditBuckets` — an
+ * absolute amount per bucket, with no percentage at all. The buckets become the
+ * card's credit figure (their remaining amounts summed) rather than being
+ * squeezed into a progress bar nobody measured; the `credit` window key, which
+ * names the same thing, is deliberately left without a bar for the same reason.
+ *
+ * @param status - The route's `value`.
+ * @returns The facts.
+ */
+export declare function normalizeStepCodeQuota(status: unknown): LineQuotaFacts;
+/**
+ * The Qoder line's quota.
+ *
+ * Units: milliseconds, with one sentinel: the account period ends at
+ * `253402214400000` (year 9999) for a subscription that never expires, and a
+ * card would print that as a real date, so the shared ceiling drops it.
+ *
+ * Qoder states ABSOLUTE amounts (total / used / remaining + unit), not windows.
+ * A ratio is derived only when both total and used are stated AND total is
+ * positive; anything else is reported as a credit balance instead of a bar.
+ *
+ * @param status - The route's `value`.
+ * @returns The facts.
+ */
+export declare function normalizeQoderQuota(status: unknown): LineQuotaFacts;
+/**
+ * The Cline Pass line's quota.
+ *
+ * Units: `percentUsed` is a percent, `resetsAt` is an ISO 8601 string, and the
+ * window's length is only stated as a gateway token (`five_hour` / `weekly` /
+ * `monthly`). The payload carries one reading PER ACCOUNT, so the row shown is
+ * the pool's active account when it has a reading, else the first account that
+ * did read something. An account that failed states its own reason, which is
+ * what the card shows instead of an empty frame.
+ *
+ * @param status - The route's `value`.
+ * @returns The facts.
+ */
+export declare function normalizeClinePassQuota(status: unknown): LineQuotaFacts;
+/**
+ * The OpenDesign line's quota.
+ *
+ * Units: this line's REAL allowance is the "Design Plan" window pair the console
+ * renders as a remaining percentage — a 5-hour window and a 7-day one, each
+ * stating an integer credit LIMIT and what is LEFT of it, plus an ISO reset
+ * instant. A bar is therefore the USED share, `(limit − remaining) / limit`;
+ * the remaining percentage is `100 − used` and is derived by whoever prints it.
+ *
+ * `quota.credits` keeps the WALLET balance, and only that: the spendable USD
+ * figure is a different quantity from a window's allowance, and folding one into
+ * the other is how a card ends up stating a percentage of the wrong thing.
+ *
+ * Absence is the honest half of this reader. The endpoint is only known to accept
+ * a browser session, so a control-key read may be refused; `codingPlan.error`
+ * then carries the reason and `windows` is empty. An empty list is reported as
+ * exactly that — never padded with a 0 % bar, which would claim a limit nobody
+ * observed — and the reason rides along so the card can say why.
+ *
+ * @param status - The route's `value`.
+ * @returns The facts.
+ */
+export declare function normalizeOpenDesignQuota(status: unknown): LineQuotaFacts;
+/**
+ * One pooled account's own quota, as a card row draws it.
+ *
+ * A row states a bar, the instant it reopens, and — since this reading is the
+ * only place any line computes an account's windows — the WHOLE list behind that
+ * bar. Never a plan, a label or an error: those belong to the pool's row.
+ *
+ * `null` in either scalar keeps the contract's own meaning — nobody measured that
+ * fact — and is what makes a half-known reading useless rather than half-true
+ * (see the two readers below). `windows` is then `[]` rather than a padded
+ * placeholder: a line that measured nothing has no window to show, and a 0 % bar
+ * would report a limit nobody observed.
+ */
+export interface LineAccountQuotaReading {
+    /** Share of the account's shortest window consumed, 0-100, or null. */
+    usedPercent: number | null;
+    /** Unix MILLISECONDS that window reopens, or null when nobody said. */
+    resetsAt: number | null;
+    /**
+     * Every window this account's quota stated, shortest first.
+     *
+     * Empty — never absent — when the line has no window vocabulary of its own
+     * (Qoder states absolute amounts, not percentages) or measured nothing.
+     */
+    windows: LineCardWindow[];
+}
+/**
+ * The Qoder account's own reading, from one `quota/usage` snapshot.
+ *
+ * Qoder states ABSOLUTE amounts per bucket (total / used / remaining), never a
+ * percentage, so a share is derived here only under the same rule
+ * {@link normalizeQoderQuota} already applies to the line-level card: BOTH a
+ * total (positive) and a used figure must be stated. A bucket that states
+ * amounts without a bounded allowance — a top-up balance, an org cap nobody
+ * measured — is not turned into a bar, and a snapshot with no such bucket
+ * answers null rather than a made-up zero.
+ *
+ * No window list accompanies it: this line has no percentage windows at all
+ * (its buckets are absolute amounts, and its only instant is the snapshot's own
+ * expiry), so `windows` is `[]` — the honest answer rather than a manufactured
+ * one-window list nobody measured.
+ *
+ * @param snapshot - The account's quota snapshot (`{ buckets, expiresAt }`).
+ * @returns The reading, or null when nothing bounded was measured.
+ */
+export declare function qoderAccountQuotaReading(snapshot: unknown): LineAccountQuotaReading | null;
+/**
+ * The MiniMax Code account's own reading, from one Token Plan snapshot.
+ *
+ * The window the row's BAR draws is the rolling 5-hour one — the line's own
+ * headline, and the tightest limit the plan has: its machine key is `interval`,
+ * and a payload that named no key is placed by its nominal length instead. The
+ * weekly window is deliberately NOT substituted (a row saying 5% while the
+ * 5-hour window is spent is worse than a row saying nothing), and an `unlimited`
+ * window states no share at all, so nothing becomes a bar.
+ *
+ * `windows` carries the WHOLE list all the same: this line states it — `interval`
+ * and `weekly`, each with a share and a reset instant — so an account can be
+ * opened up and show both of its limits instead of only the bar.
+ *
+ * @param quota - The parsed `MinimaxCodeQuota`.
+ * @returns The reading, or null when the 5-hour window measured nothing.
+ */
+export declare function minimaxAccountQuotaReading(quota: unknown): LineAccountQuotaReading | null;
+/**
+ * Every normalizer, keyed by the line id a card names.
+ *
+ * The registry looks a line up here; a line that is registered but has no entry
+ * falls back to nothing measured, so adding a pool without a normalizer
+ * degrades to "no quota window" instead of to a thrown error.
+ */
+export declare const LINE_QUOTA_NORMALIZERS: Readonly<Record<string, (status: unknown) => LineQuotaFacts>>;
+//# sourceMappingURL=line-quota.d.ts.map

package/lib/types/host/widget-board/line-quota.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-quota.d.ts","sourceRoot":"","sources":["../../../../src/host/widget-board/line-quota.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,KAAK,EAEV,aAAa,EAEb,cAAc,EACf,MAAM,qBAAqB,CAAA;AAE5B,2EAA2E;AAC3E,MAAM,WAAW,cAAc;IAC7B,6EAA6E;IAC7E,KAAK,EAAE,aAAa,GAAG,IAAI,CAAA;IAC3B,gEAAgE;IAChE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB;;;;;OAKG;IACH,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,6EAA6E;IAC7E,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAA;IACxB,2EAA2E;IAC3E,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CACrB;AAiZD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAmDnE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CA6BtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAkCzE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAgCzE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAmCzE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAwBpE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAsB3E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAmCtE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAsCnE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CA4BvE;AAsED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CA+BxE;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,uBAAuB;IACtC,uEAAuE;IACvE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,uEAAuE;IACvE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB;;;;;OAKG;IACH,OAAO,EAAE,cAAc,EAAE,CAAA;CAC1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,OAAO,GAAG,uBAAuB,GAAG,IAAI,CAY1F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,GAAG,IAAI,CAmBzF;AA0CD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,cAAc,CAAC,CAYhG,CAAA"}