@modelprofile.com/authswitch 2.2.0 → 2.3.0

package/ts/classes.limits.ts

@@ -0,0 +1,187 @@
+import * as plugins from './plugins.js';
+import { compactSince, compactUntil, orderedUsageWindows } from './accounts.js';
+import { consoleHeading, consoleTable } from './classes.accountlist.js';
+import type { IAccountList, IAccountLimitRow, IAccountLimits, IActiveAccountRow, IActiveAccounts, IHarnessAccountList } from './interfaces.list.js';
+import { dim, plainText } from './formatting.js';
+
+type TListedAccount = IHarnessAccountList['accounts'][number];
+
+const UNAVAILABLE = 'n/a';
+const NONE = 'none';
+
+/**
+ * Provider naming stays data-driven.
+ *
+ * A harness that owns exactly one credential slot is its own provider; one that owns several (an
+ * OpenCode installation with an OpenAI and an Anthropic login) has to say which slot a row is about.
+ */
+const providerName = (harnessArg: IHarnessAccountList, accountArg?: TListedAccount): string => {
+  const slots = new Set(harnessArg.accounts.map(account => account.slotId).filter((slot): slot is string => slot !== undefined));
+  return accountArg?.slotId !== undefined && slots.size > 1
+    ? `${plainText(harnessArg.label)} / ${plainText(accountArg.slotId)}`
+    : plainText(harnessArg.label);
+};
+
+/**
+ * Why an account contributes no numbers.
+ *
+ * The provider's own explanation is preferred over ours, and a failed lookup is never presented as a
+ * missing capability: the two have different fixes.
+ */
+const missingLimitReason = (accountArg: TListedAccount): string => {
+  if (accountArg.status.problems.length) return accountArg.status.problems.map(plainText).join(' ');
+  const availability = accountArg.status.facts.filter(fact => fact.section === 'Availability').map(fact => plainText(fact.value));
+  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.';
+};
+
+const accountKeys = (harnessArg: IHarnessAccountList, accountArg: TListedAccount) => ({
+  harnessId: harnessArg.id,
+  provider: providerName(harnessArg, accountArg),
+  account: plainText(accountArg.label),
+  accountId: accountArg.id,
+  ...(accountArg.slotId === undefined ? {} : { slotId: plainText(accountArg.slotId) }),
+});
+
+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 ?? ''));
+
+const noteFor = (rowArg: { provider: string; account: string | null; unavailableReason: string | null }): string | null =>
+  rowArg.unavailableReason === null ? null
+    : `${rowArg.provider}${rowArg.account === null ? '' : ` · ${rowArg.account}`}: ${rowArg.unavailableReason}`;
+
+const collectNotes = (rowsArg: { provider: string; account: string | null; unavailableReason: string | null }[]): string[] =>
+  [...new Set(rowsArg.map(noteFor).filter((note): note is string => note !== null))];
+
+/**
+ * One row per account and limit type, projected from the account list.
+ *
+ * Nothing here talks to a provider: the list is already the read-only, per-account-isolated lookup,
+ * so a single failing account costs its own rows a number and nothing else.
+ */
+export const accountLimits = (listArg: IAccountList): IAccountLimits => {
+  const now = Date.parse(listArg.generatedAt);
+  const rows: IAccountLimitRow[] = [];
+  for (const harness of listArg.harnesses) {
+    const problem = harnessProblem(harness);
+    const empty = {
+      limitType: null, scope: null, windowSeconds: null, usedPercent: null, resetAt: null, resetsIn: UNAVAILABLE,
+    } as const;
+    if (problem !== null) {
+      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, isActive: false, ...empty, unavailableReason: problem });
+      continue;
+    }
+    if (!harness.accounts.length) {
+      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, isActive: false, ...empty,
+        unavailableReason: harness.saveUnavailableReason === null ? 'No accounts are known for this harness.' : plainText(harness.saveUnavailableReason) });
+      continue;
+    }
+    for (const account of harness.accounts) {
+      const windows = orderedUsageWindows(account.status.summary?.usageWindows);
+      if (!windows.length) {
+        rows.push({ ...accountKeys(harness, account), isActive: account.isActive, ...empty, unavailableReason: missingLimitReason(account) });
+        continue;
+      }
+      for (const window of windows) {
+        rows.push({
+          ...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,
+        });
+      }
+    }
+  }
+  const limits = byProviderThenAccount(rows);
+  return { schemaVersion: 1, generatedAt: listArg.generatedAt, complete: listArg.complete, limits, notes: collectNotes(limits) };
+};
+
+/**
+ * One row per active credential slot.
+ *
+ * A harness with no active login still gets a row: "nothing is active here" is an answer, and
+ * silently dropping the provider would read as "this provider does not exist".
+ */
+export const activeAccounts = (listArg: IAccountList): IActiveAccounts => {
+  const now = Date.parse(listArg.generatedAt);
+  const rows: IActiveAccountRow[] = [];
+  for (const harness of listArg.harnesses) {
+    const problem = harnessProblem(harness);
+    if (problem !== null) {
+      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, savedAt: null, savedAgo: UNAVAILABLE, source: 'none', unavailableReason: problem });
+      continue;
+    }
+    const active = harness.accounts.filter(account => account.isActive);
+    if (!active.length) {
+      const stashed = harness.accounts.filter(account => account.isStashed);
+      rows.push({
+        harnessId: harness.id, provider: providerName(harness), account: null, accountId: null,
+        savedAt: null, savedAgo: UNAVAILABLE, source: stashed.length ? 'stash only' : 'none',
+        unavailableReason: harness.saveUnavailableReason !== null ? plainText(harness.saveUnavailableReason)
+          : stashed.length ? `No login is active; ${stashed.length} saved account(s) can be activated with authswitch ${plainText(harness.id)} use.`
+            : `No login is active and none is saved. ${plainText(harness.loginHint)}`,
+      });
+      continue;
+    }
+    for (const account of active) {
+      rows.push({
+        ...accountKeys(harness, account),
+        savedAt: account.savedAt, savedAgo: compactSince(account.savedAt, now, UNAVAILABLE),
+        source: 'credential file',
+        unavailableReason: account.isStashed ? null : 'This active login is not saved yet; authswitch cannot restore it after a switch.',
+      });
+    }
+  }
+  const active = byProviderThenAccount(rows);
+  return { schemaVersion: 1, generatedAt: listArg.generatedAt, complete: listArg.complete, active, notes: collectNotes(active) };
+};
+
+const percent = (rowArg: IAccountLimitRow): string => rowArg.usedPercent === null ? UNAVAILABLE : `${rowArg.usedPercent}%`;
+
+/** Condensed presentation for `authswitch limits` and `authswitch active`. */
+export class CondensedRenderer {
+  constructor(private readonly out: plugins.smartconsole.SmartConsole) {}
+
+  private notes(notesArg: string[], prefixArg: string): void {
+    if (!notesArg.length) return;
+    process.stdout.write('\n');
+    for (const note of notesArg) process.stdout.write(`${dim(`${prefixArg}${note}`)}\n`);
+  }
+
+  public async renderLimits(limitsArg: IAccountLimits): Promise<void> {
+    consoleHeading('Account limits');
+    if (!limitsArg.limits.length) { process.stdout.write(`${dim('No harnesses registered.')}\n`); return; }
+    await consoleTable(this.out, limitsArg.limits, [
+      { key: 'provider', title: 'Provider', value: row => row.provider },
+      { 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 }) },
+      { key: 'reset', title: 'Resets in', value: row => row.resetsIn, align: 'right' },
+    ]);
+    this.notes(limitsArg.notes, 'n/a — ');
+  }
+
+  public async renderActive(activeArg: IActiveAccounts): Promise<void> {
+    consoleHeading('Active accounts');
+    if (!activeArg.active.length) { process.stdout.write(`${dim('No harnesses registered.')}\n`); return; }
+    await consoleTable(this.out, activeArg.active, [
+      { key: 'provider', title: 'Provider', value: row => row.provider },
+      { key: 'account', title: 'Account', value: row => row.account ?? NONE,
+        style: row => ({ bold: row.account !== null, foreground: row.account === null ? 'orange' : undefined }) },
+      // The absolute timestamp stays in --json; one screen is worth more here than one more column.
+      { key: 'saved', title: 'Saved', value: row => row.savedAt === null ? (row.account === null ? UNAVAILABLE : 'not saved') : `${row.savedAgo} ago`, align: 'right',
+        style: row => ({ foreground: row.savedAt === null && row.account !== null ? 'orange' : undefined }) },
+      { key: 'source', title: 'Source', value: row => row.source,
+        style: row => ({ foreground: row.source === 'credential file' ? 'green' : 'orange' }) },
+    ]);
+    this.notes(activeArg.notes, 'note — ');
+  }
+}

package/ts/interfaces.list.ts

@@ -17,3 +17,58 @@ export interface IHarnessAccountList {
   /** A state lookup failure is distinct from an empty account list. */
   problems: string[];
 }
+
+/** Credential-free, versioned output of limits --json. One entry per account and limit type. */
+export interface IAccountLimits {
+  schemaVersion: 1;
+  generatedAt: string;
+  complete: boolean;
+  limits: IAccountLimitRow[];
+  /** Why a row has no numbers. Never a substitute for a value. */
+  notes: string[];
+}
+
+export interface IAccountLimitRow {
+  harnessId: string;
+  /** Harness label, qualified by the credential slot when the harness owns several. */
+  provider: string;
+  /** The account's public label, which is its email wherever the provider reports one. */
+  account: string | null;
+  accountId: string | null;
+  slotId?: string;
+  isActive: boolean;
+  /** The provider's own window name, or null when no limit data is available. */
+  limitType: string | null;
+  scope: 'account' | 'feature' | null;
+  windowSeconds: number | null;
+  /** Never inferred: null means the provider reported no percentage, not zero usage. */
+  usedPercent: number | null;
+  resetAt: string | null;
+  /** Human countdown for the same `resetAt`, relative to `generatedAt`. */
+  resetsIn: string;
+  unavailableReason: string | null;
+}
+
+/** Credential-free, versioned output of active --json. One entry per active credential slot. */
+export interface IActiveAccounts {
+  schemaVersion: 1;
+  generatedAt: string;
+  complete: boolean;
+  active: IActiveAccountRow[];
+  notes: string[];
+}
+
+export interface IActiveAccountRow {
+  harnessId: string;
+  provider: string;
+  account: string | null;
+  accountId: string | null;
+  slotId?: string;
+  /** When authswitch last saved this login; null when it was never stashed. */
+  savedAt: string | null;
+  /** Human elapsed time for the same `savedAt`, relative to `generatedAt`. */
+  savedAgo: string;
+  /** Where the shown account comes from. Whether it is also saved is the `savedAt` field's answer. */
+  source: 'credential file' | 'stash only' | 'none';
+  unavailableReason: string | null;
+}