@modelprofile.com/authswitch 3.0.0 → 3.2.0

package/ts/classes.claudestatus.ts

@@ -1,8 +1,107 @@
 import { credentialRecord, credentialText } from './classes.credentialstore.js';
-import type { IHarnessAccountStatus, IHarnessStatusSummary } from './interfaces.harness.js';
+import { plainText } from './formatting.js';
+import type { IHarnessAccountStatus, IHarnessUsageWindow, TUsageSeverity } from './interfaces.harness.js';
 
 class ClaudeStatusError extends Error {}
 
+interface IClaudeUsageWindows {
+  windows: IHarnessUsageWindow[];
+  /** Server rows whose reset group the window model cannot represent, named by kind and group. */
+  unsupported: string[];
+}
+
+/** Reset times are normalised to ISO 8601 UTC; an unparsable one rejects the whole usage response. */
+const resetTimestamp = (value: unknown): string | null => value == null ? null : new Date(String(value)).toISOString();
+
+const SERVER_NAME_LENGTH = 64;
+
+/** A server-supplied name becomes label text: no control characters, bounded by code points, and never blank. */
+const serverName = (value: unknown): string => {
+  const name = typeof value === 'string' ? Array.from(plainText(value).trim()).slice(0, SERVER_NAME_LENGTH).join('').trimEnd() : '';
+  if (!name) throw new Error('Unsupported Claude usage name.');
+  return name;
+};
+
+/** Keyed windows, read only from a usage body that carries no limits[] rows. */
+const KEYED_WINDOWS = [
+  ['five_hour', 'Claude five-hour', 18000, 'account'], ['seven_day', 'Claude weekly', 604800, 'account'],
+  ['seven_day_oauth_apps', 'OAuth apps weekly', 604800, 'feature'], ['seven_day_opus', 'Opus weekly', 604800, 'feature'], ['seven_day_sonnet', 'Sonnet weekly', 604800, 'feature'],
+] as const;
+
+const keyedWindows = (usage: Record<string, unknown>): IHarnessUsageWindow[] => {
+  const windows: IHarnessUsageWindow[] = [];
+  for (const [key, label, durationSeconds, scope] of KEYED_WINDOWS) {
+    if (usage[key] == null) continue;
+    const window = credentialRecord(usage[key]);
+    if (window.utilization == null) continue;
+    if (typeof window.utilization !== 'number' || !Number.isFinite(window.utilization) || window.utilization < 0) throw new Error('Unsupported Claude usage utilization.');
+    windows.push({ label, durationSeconds, scope, usedPercent: window.utilization, resetAt: resetTimestamp(window.resets_at) });
+  }
+  return windows;
+};
+
+/**
+ * The limits[] row groups the window model represents: each group's duration, the period word its
+ * labels use, and the kind of the group's unscoped account meter, which keeps the plain label.
+ */
+const LIMIT_GROUPS: ReadonlyMap<string, { durationSeconds: number; period: string; accountKind: string }> = new Map([
+  ['session', { durationSeconds: 18000, period: 'five-hour', accountKind: 'session' }],
+  ['weekly', { durationSeconds: 604800, period: 'weekly', accountKind: 'weekly_all' }],
+]);
+
+const isUsageSeverity = (value: unknown): value is TUsageSeverity => value === 'normal' || value === 'warning' || value === 'critical';
+
+/** A scope part is absent (null or omitted) or names the model or surface a row is for. */
+const scopeSubject = (value: unknown): string | undefined => value == null ? undefined : serverName(credentialRecord(value).display_name);
+
+/**
+ * The server's usage rows, in the server's order. An unscoped row is an account meter; a model- or
+ * surface-scoped row is a feature quota named by the server's own label. Rows are classified on the
+ * kind and group exactly as sent; only the text shown to users is sanitised. Every row is validated
+ * before a row in an unrepresentable group is set aside, so a malformed row can never hide behind one.
+ */
+const limitWindows = (rows: readonly unknown[]): IClaudeUsageWindows => {
+  const windows: IHarnessUsageWindow[] = [];
+  const unsupported = new Set<string>();
+  for (const value of rows) {
+    const row = credentialRecord(value);
+    const { kind, group } = row;
+    if (typeof kind !== 'string' || typeof group !== 'string') throw new Error('Unsupported Claude usage meter.');
+    const kindName = serverName(kind);
+    const groupName = serverName(group);
+    const usedPercent = row.percent;
+    if (typeof usedPercent !== 'number' || !Number.isFinite(usedPercent) || usedPercent < 0) throw new Error('Unsupported Claude usage percentage.');
+    const resetAt = resetTimestamp(row.resets_at);
+    const scope: Record<string, unknown> = row.scope == null ? {} : credentialRecord(row.scope);
+    const model = scopeSubject(scope.model);
+    const surface = scopeSubject(scope.surface);
+    const subject = model ?? surface;
+    const meter = LIMIT_GROUPS.get(group);
+    if (!meter) {
+      unsupported.add(`${kindName} in group ${groupName}`);
+      continue;
+    }
+    const severity = row.severity;
+    windows.push({
+      label: subject === undefined ? `Claude ${meter.period}${kind === meter.accountKind ? '' : ` (${kindName})`}` : `${subject} ${meter.period}`,
+      durationSeconds: meter.durationSeconds, scope: subject === undefined ? 'account' : 'feature', usedPercent, resetAt,
+      ...(isUsageSeverity(severity) ? { severity } : {}),
+      ...(row.is_active === true ? { headline: true as const } : {}),
+    });
+  }
+  return { windows, unsupported: [...unsupported] };
+};
+
+/**
+ * A usage body's windows. Its limits[] rows are authoritative whenever the server sends any; the keyed
+ * fields describe the same meters and are read only from a body without rows.
+ */
+const claudeUsageWindows = (usage: Record<string, unknown>): IClaudeUsageWindows => {
+  const limits = usage.limits;
+  if (limits != null && !Array.isArray(limits)) throw new Error('Unsupported Claude usage limits.');
+  return Array.isArray(limits) && limits.length ? limitWindows(limits) : { windows: keyedWindows(usage), unsupported: [] };
+};
+
 /** Read-only Claude Code OAuth account endpoints. No refresh, inference, or browser session is used. */
 export class ClaudeAccountStatus {
   constructor(private readonly fetcher: typeof fetch = globalThis.fetch) {}
@@ -64,18 +163,7 @@ export class ClaudeAccountStatus {
     } else result.problems.push(`Profile: ${profile.reason instanceof ClaudeStatusError ? profile.reason.message : 'Lookup failed.'}`);
     if (usage.status === 'fulfilled') {
       try {
-        const windows: NonNullable<IHarnessStatusSummary['usageWindows']> = [];
-        for (const [key, label, durationSeconds, scope] of [
-          ['five_hour', 'Claude five-hour', 18000, 'account'], ['seven_day', 'Claude weekly', 604800, 'account'],
-          ['seven_day_oauth_apps', 'OAuth apps weekly', 604800, 'feature'], ['seven_day_opus', 'Opus weekly', 604800, 'feature'], ['seven_day_sonnet', 'Sonnet weekly', 604800, 'feature'],
-        ] as const) {
-          if (usage.value[key] == null) continue;
-          const window = credentialRecord(usage.value[key]);
-          if (window.utilization == null) continue;
-          if (typeof window.utilization !== 'number' || !Number.isFinite(window.utilization) || window.utilization < 0) throw new Error();
-          const resetAt = window.resets_at == null ? null : new Date(String(window.resets_at)).toISOString();
-          windows.push({ label, durationSeconds, scope, usedPercent: window.utilization, resetAt });
-        }
+        const { windows, unsupported } = claudeUsageWindows(usage.value);
         result.summary = { ...result.summary, usageWindows: windows };
         for (const window of windows) result.facts.push({ section: 'Usage', summaryKey: 'usageWindows', label: window.label, value: `${window.usedPercent}% used; ${window.resetAt ? 'resets ' + window.resetAt : 'reset not scheduled'}` });
         if (usage.value.extra_usage != null) {
@@ -90,7 +178,7 @@ export class ClaudeAccountStatus {
           }
           if (limit !== undefined && limit > 0 && used !== undefined) result.facts.push({ section: 'Extra usage', label: 'Monthly budget used', value: `${Math.round(used / limit * 10000) / 100}%` });
         }
-        if (Array.isArray(usage.value.limits) && usage.value.limits.length) result.facts.push({ section: 'Availability', label: 'Additional limits', value: 'The service also returned limits without a supported reset-window contract.' });
+        if (unsupported.length) result.facts.push({ section: 'Availability', label: 'Unsupported limits', value: `The service returned limits without a supported reset window, which are not shown: ${unsupported.join(', ')}.` });
       } catch { result.problems.push('Claude usage response is unsupported; missing values were not inferred.'); }
     } else result.problems.push(`Usage: ${usage.reason instanceof ClaudeStatusError ? usage.reason.message : 'Lookup failed.'}`);
     result.facts.push({ section: 'Availability', label: 'Billing dates and earned resets', value: 'Renewal dates, cancellation dates and earned reset credits are not exposed by these Claude Code endpoints.' });

package/ts/classes.limits.ts

@@ -2,7 +2,7 @@ import * as plugins from './plugins.js';
 import { compactSince, compactUntil, credentialDriftNote, orderedUsageWindows } from './accounts.js';
 import { consoleHeading, consoleTable } from './classes.accountlist.js';
 import type { IAccountList, IAccountLimitRow, IAccountLimits, IActiveAccountDrift, IActiveAccountRow, IActiveAccounts, IHarnessAccountList } from './interfaces.list.js';
-import type { IHarnessCredentialDrift } from './interfaces.harness.js';
+import type { IHarnessCredentialDrift, TUsageSeverity } from './interfaces.harness.js';
 import { dim, plainText } from './formatting.js';
 
 type TListedAccount = IHarnessAccountList['accounts'][number];
@@ -35,7 +35,7 @@ const missingLimitReason = (accountArg: TListedAccount): string => {
   if (accountArg.status.summary?.usageWindows === undefined) {
     return availability[0] ?? 'This login does not expose a usage or quota API.';
   }
-  return 'The provider reported no usage window for this account.';
+  return 'The provider reported no usage window that authswitch can show for this account.';
 };
 
 const accountKeys = (harnessArg: IHarnessAccountList, accountArg: TListedAccount) => ({
@@ -49,10 +49,35 @@ const accountKeys = (harnessArg: IHarnessAccountList, accountArg: TListedAccount
 const harnessProblem = (harnessArg: IHarnessAccountList): string | null =>
   harnessArg.problems.length ? harnessArg.problems.map(plainText).join(' ') : null;
 
-/** Provider then account, keeping each account's windows in the order the adapter ranked them. */
-const byProviderThenAccount = <TRow extends { provider: string; account: string | null }>(rowsArg: TRow[]): TRow[] =>
-  [...rowsArg].sort((left, right) => left.provider.localeCompare(right.provider)
-    || (left.account ?? '').localeCompare(right.account ?? ''));
+/** The identity fields both condensed row types share; labels are for display, these are for order and grouping. */
+type TCondensedRow = Pick<IAccountLimitRow, 'harnessId' | 'provider' | 'account' | 'accountId' | 'slotId'>;
+
+/**
+ * Provider then account, keeping each account's windows in the order the adapter ranked them.
+ *
+ * Every harness and every account stays one consecutive run for the table's grouping: a harness is placed
+ * by its first provider name, so no other label sorts between its slots, and ids break label ties, so two
+ * harnesses sharing a label or two accounts sharing an email never interleave.
+ */
+const byProviderThenAccount = <TRow extends TCondensedRow>(rowsArg: TRow[]): TRow[] => {
+  const firstProvider = new Map<string, string>();
+  for (const row of rowsArg) {
+    const first = firstProvider.get(row.harnessId);
+    if (first === undefined || row.provider.localeCompare(first) < 0) firstProvider.set(row.harnessId, row.provider);
+  }
+  return [...rowsArg].sort((left, right) => firstProvider.get(left.harnessId)!.localeCompare(firstProvider.get(right.harnessId)!)
+    || left.harnessId.localeCompare(right.harnessId)
+    || left.provider.localeCompare(right.provider)
+    || (left.account ?? '').localeCompare(right.account ?? '')
+    || (left.slotId ?? '').localeCompare(right.slotId ?? '')
+    || (left.accountId ?? '').localeCompare(right.accountId ?? ''));
+};
+
+/** One colour line per harness: an OpenCode installation's slots share it. */
+const harnessRuns = (rowArg: TCondensedRow): string => rowArg.harnessId;
+
+/** One divider run per account identity; a provider-level row without an account is its own run. */
+const accountRuns = (rowArg: TCondensedRow): string => JSON.stringify([rowArg.harnessId, rowArg.slotId ?? null, rowArg.accountId]);
 
 const noteFor = (rowArg: { provider: string; account: string | null; unavailableReason: string | null }): string | null =>
   rowArg.unavailableReason === null ? null
@@ -80,7 +105,7 @@ export const accountLimits = (listArg: IAccountList): IAccountLimits => {
   for (const harness of listArg.harnesses) {
     const problem = harnessProblem(harness);
     const empty = {
-      limitType: null, scope: null, windowSeconds: null, usedPercent: null, resetAt: null, resetsIn: UNAVAILABLE,
+      limitType: null, scope: null, windowSeconds: null, usedPercent: null, resetAt: null, resetsIn: UNAVAILABLE, severity: null, headline: false,
     } as const;
     if (problem !== null) {
       rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, isActive: false, ...empty, unavailableReason: problem });
@@ -102,7 +127,7 @@ export const accountLimits = (listArg: IAccountList): IAccountLimits => {
           ...accountKeys(harness, account), isActive: account.isActive,
           limitType: plainText(window.label), scope: window.scope ?? 'account', windowSeconds: window.durationSeconds,
           usedPercent: window.usedPercent, resetAt: window.resetAt, resetsIn: compactUntil(window.resetAt, now, UNAVAILABLE),
-          unavailableReason: null,
+          severity: window.severity ?? null, headline: window.headline === true, unavailableReason: null,
         });
       }
     }
@@ -165,6 +190,13 @@ export const activeAccounts = (listArg: IAccountList): IActiveAccounts => {
 
 const percent = (rowArg: IAccountLimitRow): string => rowArg.usedPercent === null ? UNAVAILABLE : `${rowArg.usedPercent}%`;
 
+const SEVERITY_COLORS: Record<TUsageSeverity, plugins.smartconsole.TColorName | undefined> = { normal: undefined, warning: 'orange', critical: 'red' };
+
+/** The provider's own reading colours a window; without one, n/a and exhausted windows stand out. */
+const percentColor = (rowArg: IAccountLimitRow): plugins.smartconsole.TColorName | undefined =>
+  rowArg.severity !== null ? SEVERITY_COLORS[rowArg.severity]
+    : rowArg.usedPercent === null ? 'orange' : rowArg.usedPercent >= 100 ? 'red' : undefined;
+
 /** Condensed presentation for `authswitch limits` and `authswitch active`. */
 export class CondensedRenderer {
   constructor(private readonly out: plugins.smartconsole.SmartConsole) {}
@@ -183,9 +215,9 @@ export class CondensedRenderer {
       { key: 'account', title: 'Account', value: row => row.account ?? UNAVAILABLE, style: row => ({ bold: row.isActive }) },
       { key: 'limit', title: 'Limit type', value: row => row.limitType ?? UNAVAILABLE },
       { key: 'used', title: 'Used %', value: percent, align: 'right',
-        style: row => ({ foreground: row.usedPercent === null ? 'orange' : row.usedPercent >= 100 ? 'red' : undefined }) },
+        style: row => ({ foreground: percentColor(row) }) },
       { key: 'reset', title: 'Resets in', value: row => row.resetsIn, align: 'right' },
-    ]);
+    ], { divider: accountRuns, colorLine: harnessRuns });
     this.notes(limitsArg.notes, 'n/a — ');
   }
 
@@ -203,7 +235,7 @@ export class CondensedRenderer {
         style: row => ({ foreground: row.savedAt === null && row.account !== null ? 'orange' : undefined }) },
       { key: 'source', title: 'Source', value: row => row.drift === null ? row.source : `${row.source} (changed)`,
         style: row => ({ foreground: row.drift !== null ? 'red' : row.source === 'credential file' ? 'green' : 'orange' }) },
-    ]);
+    ], { colorLine: harnessRuns });
     this.notes(activeArg.notes, 'note — ');
   }
 }

package/ts/classes.tui.ts

@@ -1,6 +1,6 @@
 import * as plugins from './plugins.js';
 import type { IAuthHarness, IHarnessOutcome, IHarnessProcess, IHarnessState, IHarnessStopOutcome } from './interfaces.harness.js';
-import { accountDetails, accountPlan, accountQuotaSummary, accountResets, accountState, accountUsageWindows, usagePeriod, until, readAccountRows, type IAccountRow } from './accounts.js';
+import { accountDetails, accountPlan, accountQuotaSummary, accountResets, accountState, accountUsageWindows, usageWindowName, until, readAccountRows, type IAccountRow } from './accounts.js';
 import { plainText } from './formatting.js';
 import { AuthSwitchOperations } from './classes.operations.js';
 import { describeHarnessProcesses, describeStopOutcome } from './classes.harnessprocesses.js';
@@ -140,9 +140,10 @@ export class AuthSwitchTui {
     const tabs = ui.tabs([{ title: 'Account details', content: details }, { title: 'Activity log', content: ui.logs }]);
     await ui.run({
       view: () => {
-        const usage = accountUsageWindows({ status: table.selected?.status })?.slice(0, 2).map(window => ui.progress(
-          `${usagePeriod(window)} (${window.usedPercent}% used; reset in ${until(window.resetAt, Date.now())})`, Math.min(100, window.usedPercent), 100,
-        )) ?? [];
+        const shown = accountUsageWindows({ status: table.selected?.status }) ?? [];
+        const usage = shown.slice(0, 2).map(window => ui.progress(
+          `${usageWindowName(window, shown)} (${window.usedPercent}% used; reset in ${until(window.resetAt, Date.now())})`, Math.min(100, window.usedPercent), 100,
+        ));
         const accountView = ui.column([
           ui.panel(`${plainText(harness.label)} accounts`, table),
           ui.panel('Status and diagnostics', ui.column([...usage, tabs])),

package/ts/interfaces.harness.ts

@@ -108,20 +108,32 @@ export interface IHarnessStatusFact {
   summaryKey?: 'subscription' | 'billing' | 'usageWindows' | 'resets' | 'resetDetails';
 }
 
+/** The provider's own reading of a usage window. Adapters set it only when the provider reports one of these. */
+export type TUsageSeverity = 'normal' | 'warning' | 'critical';
+
+export interface IHarnessUsageWindow {
+  label: string;
+  /**
+   * Feature-specific quotas (a model, a surface, a product feature) do not determine the general
+   * account summary unless the provider picks one as its headline. Omission means account.
+   */
+  scope?: 'account' | 'feature';
+  durationSeconds: number;
+  usedPercent: number;
+  resetAt: string | null;
+  /** Omitted when the provider gives no reading; consumers then apply their own thresholds. */
+  severity?: TUsageSeverity;
+  /** Set when the provider picks this window as the one a single-value summary shows. */
+  headline?: true;
+}
+
 export interface IHarnessStatusSummary {
   /** A plan name does not imply an active billing status. */
   subscription?: { plan: string; source: 'live' | 'stored' };
   /** Live billing information only. Never infer these fields from a plan or entitlement expiry. */
   billing?: { hasActiveSubscription?: boolean; autoRenew?: boolean; renewsAt?: string; cancelsAt?: string; expiresAt?: string };
   /** Missing windows are unknown, not unused. Times are ISO 8601 UTC. */
-  usageWindows?: {
-    label: string;
-    /** Feature-specific quotas do not determine the general account summary. Omission means account. */
-    scope?: 'account' | 'feature';
-    durationSeconds: number;
-    usedPercent: number;
-    resetAt: string | null;
-  }[];
+  usageWindows?: IHarnessUsageWindow[];
   resets?: {
     available: number;
     /** May be a partial list. Omission means the detail lookup was unavailable. */

package/ts/interfaces.list.ts

@@ -1,4 +1,4 @@
-import type { IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift } from './interfaces.harness.js';
+import type { IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, TUsageSeverity } from './interfaces.harness.js';
 
 /** Credential-free, versioned output of list --json. Missing status fields stay omitted. */
 export interface IAccountList {
@@ -48,6 +48,10 @@ export interface IAccountLimitRow {
   resetAt: string | null;
   /** Human countdown for the same `resetAt`, relative to `generatedAt`. */
   resetsIn: string;
+  /** The provider's reading of this window; null when it gave none or the row has no window. */
+  severity: TUsageSeverity | null;
+  /** Whether the provider picks this window as the one a single-value summary shows. */
+  headline: boolean;
   unavailableReason: string | null;
 }