@modelprofile.com/authswitch 3.2.0 → 4.0.0

package/ts/00_commitinfo_data.ts

@@ -2,7 +2,7 @@
  * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
-  name: '@modelprofile.com/authswitch',
-  version: '3.2.0',
-  description: 'Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status'
+  name: "@modelprofile.com/authswitch",
+  version: "4.0.0",
+  description: "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status"
 }

package/ts/accounts.ts

@@ -1,4 +1,4 @@
-import type { IAuthHarness, IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, IHarnessState, IHarnessUsageWindow } from './interfaces.harness.js';
+import type { IAccountType, IAuthHarness, IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, IHarnessState, IHarnessStatusOptions, IHarnessUsageWindow } from './interfaces.harness.js';
 import { plainText } from './formatting.js';
 
 export interface IAccountRow {
@@ -6,7 +6,11 @@ export interface IAccountRow {
   account: IHarnessAccount;
   status?: IHarnessAccountStatus;
 }
+/** A provider window length or a whole-minute bound: `5h`, `7d`, `2m`. */
 export const duration = (secondsArg: number): string => secondsArg % 86400 === 0 ? `${secondsArg / 86400}d` : secondsArg % 3600 === 0 ? `${secondsArg / 3600}h` : `${secondsArg / 60}m`;
+/** The same for a chosen duration that need not be whole minutes: `90s` reads `1m 30s`, never `1.5m`. */
+export const durationText = (secondsArg: number): string => secondsArg % 60 === 0 ? duration(secondsArg)
+  : secondsArg < 60 ? `${secondsArg}s` : `${Math.floor(secondsArg / 60)}m ${secondsArg % 60}s`;
 /** A countdown is a snapshot of the provider's deadline, not proof a quota has reset. */
 export const until = (timestampArg: string | null, nowArg: number): string => {
   if (timestampArg === null) return 'Not scheduled';
@@ -54,34 +58,110 @@ export const compactSince = (timestampArg: string | null, nowArg: number, unavai
   if (!Number.isFinite(elapsed)) return unavailableArg;
   return elapsed < 60000 ? '<1m' : twoUnits(elapsed);
 };
+const twoDigits = (valueArg: number): string => String(valueArg).padStart(2, '0');
+/**
+ * A timestamp in local calendar time: `2026-10-08`, or `2026-10-08 23:14` with the time. Human output never prints
+ * a raw ISO timestamp; an unknown or unparseable one reads as the caller's unavailable marker.
+ */
+const localTimestamp = (timestampArg: string | null, withTimeArg: boolean, unavailableArg: string): string => {
+  const time = timestampArg === null ? Number.NaN : Date.parse(timestampArg);
+  if (!Number.isFinite(time)) return unavailableArg;
+  const date = new Date(time);
+  const day = `${date.getFullYear()}-${twoDigits(date.getMonth() + 1)}-${twoDigits(date.getDate())}`;
+  return withTimeArg ? `${day} ${twoDigits(date.getHours())}:${twoDigits(date.getMinutes())}` : day;
+};
+export const localDate = (timestampArg: string | null, unavailableArg = 'n/a'): string => localTimestamp(timestampArg, false, unavailableArg);
+export const localDateTime = (timestampArg: string | null, unavailableArg = 'n/a'): string => localTimestamp(timestampArg, true, unavailableArg);
+/** A moment's local time of day with seconds, `14:02:07`, for a log line whose date is implied. */
+export const localTime = (timeArg: number): string => {
+  const date = new Date(timeArg);
+  return [date.getHours(), date.getMinutes(), date.getSeconds()].map(twoDigits).join(':');
+};
+const ISO_TIMESTAMP = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})/g;
+/** Provider text with every ISO 8601 timestamp in it rewritten as local date and time. */
+export const localiseTimestamps = (textArg: string): string => textArg.replace(ISO_TIMESTAMP, match => localDateTime(match, match));
+
 /**
  * One sentence for a credential file that no longer holds the account the last switch wrote.
  *
- * It names what the file holds now and how to put the intended account back, because the usual
- * cause -- a harness instance that kept running through the switch and then refreshed its
- * in-memory login -- leaves no other trace.
+ * It names what the file holds now and how to keep or undo that. A harness that picks up swaps live is only ever
+ * changed by a new login; one that does not can also have a running instance write its previous login back.
  */
-export const credentialDriftNote = (harnessIdArg: string, driftArg: IHarnessCredentialDrift): string =>
-  'The credential file changed since the last switch (likely a running instance refreshed the previous login). '
-  + (driftArg.currentLabel === null ? 'No login is active in that slot now. '
-    : `It now holds ${plainText(driftArg.currentLabel)}${driftArg.currentIsSaved ? ', which is saved' : ', which is not saved'}. `)
-  + (driftArg.expectedLabel === null ? 'Switch to the intended account again.'
-    : `Run authswitch ${plainText(harnessIdArg)} use ${plainText(driftArg.expectedLabel)} again.`);
+export const credentialDriftNote = (harnessArg: Pick<IAuthHarness, 'id' | 'liveSwap'>, driftArg: IHarnessCredentialDrift): string => {
+  const id = plainText(harnessArg.id);
+  const cause = harnessArg.liveSwap === true ? 'for example a new login' : 'for example a new login, or a running instance that wrote its previous login back';
+  const now = driftArg.currentLabel === null ? 'No login is active in that slot now'
+    : `It now holds ${plainText(driftArg.currentLabel)}, which is ${driftArg.currentIsSaved ? '' : 'not '}saved`;
+  const keep = driftArg.currentLabel !== null && !driftArg.currentIsSaved ? `authswitch ${id} stash --keep saves it, and ` : '';
+  const back = driftArg.expectedLabel === null ? 'switching to the intended account restores it' : `authswitch ${id} use ${plainText(driftArg.expectedLabel)} switches back`;
+  return `The active login changed outside authswitch since the last switch (${cause}). ${now}; ${keep}${back}.`;
+};
+/**
+ * The same finding as one table cell: which account was expected, what the slot holds now, and then every action
+ * that resolves it, one per line -- the same actions the sentence names, so the two views advise the same thing in a
+ * cell that has to stay narrow.
+ */
+export const credentialDriftProblem = (harnessIdArg: string, driftArg: IHarnessCredentialDrift): string => {
+  const id = plainText(harnessIdArg);
+  const expected = driftArg.expectedLabel === null ? 'a login that is no longer saved' : plainText(driftArg.expectedLabel);
+  const now = driftArg.currentLabel === null ? 'none' : `${plainText(driftArg.currentLabel)} (${driftArg.currentIsSaved ? 'saved' : 'not saved'})`;
+  const actions = [
+    ...(driftArg.currentLabel !== null && !driftArg.currentIsSaved ? [`authswitch ${id} stash --keep saves it`] : []),
+    driftArg.expectedLabel === null ? 'switching to the intended account restores it' : `authswitch ${id} use ${plainText(driftArg.expectedLabel)} switches back`,
+  ];
+  return [`Active login changed outside authswitch: expected ${expected},`, `now ${now}`, ...actions.map(action => `— ${action}`)].join('\n');
+};
+
+/** An account as prompts and reports name it: its label, qualified by its credential slot when it has one. */
+export const accountName = (accountArg: Pick<IHarnessAccount, 'label' | 'slotId'>): string =>
+  `${plainText(accountArg.label)}${accountArg.slotId ? ` (${plainText(accountArg.slotId)})` : ''}`;
 
-export const accountPlan = (rowArg: IAccountRow): string => {
-  const subscription = rowArg.status?.summary?.subscription;
-  return subscription ? `${plainText(subscription.plan)}${subscription.source === 'stored' ? ' (stored; unverified)' : ' (live)'}` : rowArg.status ? 'Unavailable' : 'Loading';
+/**
+ * How every view marks a plan that comes from the saved login because the provider did not confirm it: the
+ * word both earlier plan cells used, kept short so the type line of a limits cell does not wrap.
+ */
+const STORED_PLAN_MARK = 'unverified';
+/**
+ * How an account type reads in every view: the provider's plan name with its first letter capitalised
+ * (`max` reads `Max`), and a plan taken from the stored login marked `Plus, unverified`. The text holds no
+ * parentheses, so it reads the same inside a badge part. Nothing is invented: an unknown type is null, and
+ * each view decides how to show that.
+ */
+export const accountTypeText = (typeArg: IAccountType | null | undefined): string | null => {
+  if (!typeArg) return null;
+  const plan = plainText(typeArg.plan);
+  return `${plan.charAt(0).toUpperCase()}${plan.slice(1)}${typeArg.source === 'stored' ? `, ${STORED_PLAN_MARK}` : ''}`;
 };
+export const accountPlan = (rowArg: IAccountRow): string =>
+  accountTypeText(rowArg.status?.summary?.subscription) ?? (rowArg.status ? 'Unavailable' : 'Loading');
 type TAccountStatusRow = Pick<IAccountRow, 'status'>;
 /**
- * How a single-value summary names a window among the windows it shows. An account window is named by
- * its period while it is the only shown account window of that period; a feature window, or an account
- * window sharing its period with another, is named by its own label, so no meter reads as another's.
+ * Whether a window among the shown ones is named by its label. An account window is named by its period while it is
+ * the only shown account window of that period; a feature window, or an account window sharing its period with
+ * another, is named by its own label, so no meter reads as another's.
+ */
+const namedByLabel = (windowArg: IHarnessUsageWindow, shownArg: readonly IHarnessUsageWindow[]): boolean =>
+  windowArg.scope === 'feature' || shownArg.some(other => other !== windowArg && other.scope !== 'feature' && other.durationSeconds === windowArg.durationSeconds);
+const periodName = (secondsArg: number): string => secondsArg === 604800 ? 'weekly' : duration(secondsArg);
+/** How a single-value summary names a window among the windows it shows: `Weekly`, `5h`, or its label. */
+export const usageWindowName = (windowArg: IHarnessUsageWindow, shownArg: readonly IHarnessUsageWindow[]): string => {
+  if (namedByLabel(windowArg, shownArg)) return plainText(windowArg.label);
+  const period = periodName(windowArg.durationSeconds);
+  return `${period.charAt(0).toUpperCase()}${period.slice(1)}`;
+};
+/**
+ * How every view prints a provider's usage reading: the nearest whole percent, except that a window the provider
+ * reports below 100% never reads as `100%` -- that is the one reading acted on as exhausted, and a window with
+ * capacity left must not claim it. The tables, the switch badge and the watch share this text, so none of them
+ * shows a different number for the same window.
  */
-export const usageWindowName = (windowArg: IHarnessUsageWindow, shownArg: readonly IHarnessUsageWindow[]): string =>
-  windowArg.scope === 'feature' || shownArg.some(other => other !== windowArg && other.scope !== 'feature' && other.durationSeconds === windowArg.durationSeconds)
-    ? plainText(windowArg.label)
-    : windowArg.durationSeconds === 604800 ? 'Weekly' : duration(windowArg.durationSeconds);
+export const usagePercentText = (usedPercentArg: number): string => {
+  const whole = Math.round(usedPercentArg);
+  return `${whole >= 100 && usedPercentArg < 100 ? 99 : whole}%`;
+};
+/** A shown window in one compact line: `weekly 4% · 5d 1h`, `Fable weekly 100% · 2d`. */
+export const compactUsageLine = (windowArg: IHarnessUsageWindow, shownArg: readonly IHarnessUsageWindow[], nowArg: number): string =>
+  `${namedByLabel(windowArg, shownArg) ? plainText(windowArg.label) : periodName(windowArg.durationSeconds)} ${usagePercentText(windowArg.usedPercent)} · ${compactUntil(windowArg.resetAt, nowArg)}`;
 /** Order by scope and actual duration: a provider's primary slot need not be five hours. */
 export const orderedUsageWindows = (windowsArg: readonly IHarnessUsageWindow[] = []): IHarnessUsageWindow[] => [...windowsArg].sort((left, right) =>
   Number(left.scope === 'feature') - Number(right.scope === 'feature') ||
@@ -113,29 +193,117 @@ export const accountQuotaSummary = (rowArg: TAccountStatusRow, nowArg: number):
     ...windows.slice(1).filter(window => window.usedPercent >= 100).map(window => `${usageWindowName(window, windows)} exhausted\nResets in: ${until(window.resetAt, nowArg)}`),
   ] : [])].join('\n');
 };
+/** The badge's usage meters: the general account windows a switch decision weighs, never a feature quota. */
+const BADGE_WINDOWS = [['5h', 18000], ['w', 604800]] as const;
+/**
+ * The account window a badge part reads: the only account window of that period, or the provider's headline
+ * pick among several. Any other choice would be a guess, so the part is left out and no meter reads as another's.
+ */
+const badgeWindow = (windowsArg: readonly IHarnessUsageWindow[], secondsArg: number): IHarnessUsageWindow | undefined => {
+  const matches = windowsArg.filter(window => window.scope !== 'feature' && window.durationSeconds === secondsArg);
+  const candidates = matches.length > 1 ? matches.filter(window => window.headline === true) : matches;
+  return candidates.length === 1 ? candidates[0] : undefined;
+};
+/**
+ * What a switch activates, in one line: ` (type:Max) (5h:63%) (w:88%)`, appended to the account label.
+ *
+ * Each part is the provider's own reading as a whole percent, and is omitted when it was not
+ * reported; with no part known the badge is empty, so a missing reading never reads as zero usage.
+ */
+export const accountBadge = (statusArg: IHarnessAccountStatus | undefined): string => {
+  const type = accountTypeText(statusArg?.summary?.subscription);
+  const windows = statusArg?.summary?.usageWindows ?? [];
+  return [
+    ...(type === null ? [] : [`type:${type}`]),
+    ...BADGE_WINDOWS.flatMap(([name, seconds]) => {
+      const window = badgeWindow(windows, seconds);
+      return window === undefined ? [] : [`${name}:${usagePercentText(window.usedPercent)}`];
+    }),
+  ].map(part => ` (${part})`).join('');
+};
+/** How many accounts' statuses are read at once, so a long account list never floods a provider. */
+const STATUS_LOOKUP_CONCURRENCY = 4;
+/**
+ * Bounded status lookups: at most four accounts at a time, started in order, each handed the caller's signal.
+ * A lookup that fails reports undefined; once the signal aborts, no further lookup starts. A callback that throws
+ * rejects the call, and no other lookup starts after it. No lookup activates, switches or clears a login, though an
+ * adapter may renew the tokens of the saved copy it reads (`IAuthHarness.readAccountStatus`).
+ */
+const lookupStatuses = async (
+  harnessArg: IAuthHarness,
+  accountIdsArg: readonly string[],
+  optionsArg: IHarnessStatusOptions & { onStatus: (indexArg: number, statusArg: IHarnessAccountStatus | undefined) => void | Promise<void> },
+): Promise<void> => {
+  let next = 0;
+  let failed = false;
+  const worker = async (): Promise<void> => {
+    while (!failed && next < accountIdsArg.length && !optionsArg.signal?.aborted) {
+      const index = next++;
+      let status: IHarnessAccountStatus | undefined;
+      try { status = await harnessArg.readAccountStatus(accountIdsArg[index], { signal: optionsArg.signal, session: optionsArg.session }); }
+      catch { status = undefined; }
+      try { await optionsArg.onStatus(index, status); }
+      catch (error) { failed = true; throw error; }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(STATUS_LOOKUP_CONCURRENCY, accountIdsArg.length) }, worker));
+};
+/** How long a switch waits for the badges of the accounts it offers or activates. */
+const ACCOUNT_BADGE_TIMEOUT_MS = 2500;
+/**
+ * The badge of every named account whose status answered before one shared deadline.
+ *
+ * Never fatal, and it never changes which account is in use: a switch must not wait on a provider past this deadline, nor fail because
+ * usage could not be read, so a lookup that fails or misses the deadline contributes no badge and the
+ * caller shows the label alone. At the deadline every lookup still running is cancelled, so no request
+ * outlives the call and keeps the command from exiting.
+ */
+export const readAccountBadges = async (
+  harnessArg: IAuthHarness,
+  accountIdsArg: readonly string[],
+  timeoutMsArg = ACCOUNT_BADGE_TIMEOUT_MS,
+): Promise<Map<string, string>> => {
+  const badges = new Map<string, string>();
+  if (!accountIdsArg.length) return badges;
+  const cancel = new AbortController();
+  const lookups = lookupStatuses(harnessArg, accountIdsArg, { signal: cancel.signal, onStatus: (index, status) => {
+    if (status !== undefined && !cancel.signal.aborted) badges.set(accountIdsArg[index], accountBadge(status));
+  } });
+  // A referenced timer: the command must stay alive until the deadline even when a stalled lookup holds nothing open.
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const deadline = new Promise<void>(resolve => { timer = setTimeout(resolve, timeoutMsArg); });
+  try { await Promise.race([lookups, deadline]); }
+  finally { clearTimeout(timer); cancel.abort(); }
+  return badges;
+};
 export const accountState = (rowArg: IAccountRow): string => `${rowArg.account.isActive ? '* active, ' : ''}${rowArg.account.isStashed ? 'saved' : 'not saved'}`;
 export const accountDetails = (rowArg: IAccountRow): string => [
   plainText(rowArg.account.label), accountState(rowArg),
-  ...(rowArg.account.savedAt ? ['Saved: ' + plainText(rowArg.account.savedAt)] : []),
+  ...(rowArg.account.savedAt ? ['Saved: ' + localDateTime(rowArg.account.savedAt)] : []),
   ...rowArg.account.details.map(plainText),
-  ...(rowArg.status?.facts.map(factArg => `${plainText(factArg.label)}: ${plainText(factArg.value)}`) ?? ['Loading account status…']),
+  ...(rowArg.status?.facts.map(factArg => `${plainText(factArg.label)}: ${localiseTimestamps(plainText(factArg.value))}`) ?? ['Loading account status…']),
   ...(rowArg.status?.problems.map(problemArg => `Unavailable: ${plainText(problemArg)}`) ?? []),
 ].join('\n');
 
-/** Read-only, bounded parallel status lookup. No account is switched to inspect it. */
-export const readAccountRows = async (
-  harnessArg: IAuthHarness,
-  optionsArg: { signal?: AbortSignal; onUpdate?: (rowsArg: IAccountRow[], stateArg: IHarnessState) => void | Promise<void> } = {},
-): Promise<{ rows: IAccountRow[]; state: IHarnessState }> => {
+export interface IAccountRowsOptions extends IHarnessStatusOptions {
+  onUpdate?: (rowsArg: IAccountRow[], stateArg: IHarnessState) => void | Promise<void>;
+  /** Which accounts' statuses to read; every account by default. A row that is not read keeps no status. */
+  lookup?: (accountArg: IHarnessAccount) => boolean;
+}
+
+/**
+ * Bounded parallel status lookup. No account is activated, switched or cleared to inspect it -- an adapter may renew
+ * the tokens of the saved copy it reads, and nothing else; the signal cancels lookups in flight, and a session lets
+ * the adapters reuse slow-changing lookups across repeated reads.
+ */
+export const readAccountRows = async (harnessArg: IAuthHarness, optionsArg: IAccountRowsOptions = {}): Promise<{ rows: IAccountRow[]; state: IHarnessState }> => {
   const state = await harnessArg.readState();
   const rows = state.accounts.map(account => ({ harness: harnessArg, account } as IAccountRow));
+  const read = rows.filter(row => optionsArg.lookup?.(row.account) ?? true);
   await optionsArg.onUpdate?.(rows, state);
-  for (let index = 0; index < rows.length && !optionsArg.signal?.aborted; index += 4) {
-    await Promise.all(rows.slice(index, index + 4).map(async row => {
-      try { row.status = await harnessArg.readAccountStatus(row.account.id); }
-      catch { row.status = { facts: [], problems: ['Could not read account status.'] }; }
-      if (!optionsArg.signal?.aborted) await optionsArg.onUpdate?.(rows, state);
-    }));
-  }
+  await lookupStatuses(harnessArg, read.map(row => row.account.id), { signal: optionsArg.signal, session: optionsArg.session, onStatus: async (index, status) => {
+    read[index].status = status ?? { facts: [], problems: ['Could not read account status.'] };
+    if (!optionsArg.signal?.aborted) await optionsArg.onUpdate?.(rows, state);
+  } });
   return { rows, state };
 };

package/ts/classes.accountlist.ts

@@ -1,12 +1,6 @@
-import * as plugins from './plugins.js';
-import { accountQuotaSummary, orderedUsageWindows, readAccountRows, duration, until } from './accounts.js';
-import type { IAuthHarness, IHarnessAccountStatus, IHarnessStatusFact } from './interfaces.harness.js';
+import { readAccountRows } from './accounts.js';
+import type { IAuthHarness, IHarnessAccountStatus } from './interfaces.harness.js';
 import type { IAccountList, IHarnessAccountList } from './interfaces.list.js';
-import { bold, dim, orange, plainText } from './formatting.js';
-
-type TListedAccount = IHarnessAccountList['accounts'][number];
-type TNamedAccount = TListedAccount & { name: string };
-interface IDisplayFact { account: number; label: string; value: string; }
 
 /** Allowlist the public data contract: never serialize a harness or its credential-bearing internals. */
 const publicStatus = (statusArg: IHarnessAccountStatus): IHarnessAccountStatus => {
@@ -50,211 +44,3 @@ export const readAccountList = async (harnessesArg: IAuthHarness[]): Promise<IAc
     harnesses,
   };
 };
-
-export const consoleWidth = (): number => process.stdout.columns ?? 100;
-export const consoleHeading = (textArg: string): void => { process.stdout.write(`\n${bold(textArg)}\n`); };
-
-/**
- * One table implementation for every command, including the label-per-line fallback on narrow terminals.
- *
- * `groupsArg` is smartconsole's optional visual grouping: a divider between runs of consecutive rows with
- * different keys, and a colour line along the left edge per run. Keys are identities, never display labels,
- * and the caller orders the rows so that every group is one run. Below 40 columns the fallback separates
- * divider runs with one dim rule line; it has no left edge, so it draws no colour line.
- */
-export const consoleTable = async <TRow>(
-  outArg: plugins.smartconsole.SmartConsole,
-  rowsArg: TRow[],
-  columnsArg: plugins.smartconsole.IBackendTableColumn<TRow>[],
-  groupsArg?: NoInfer<plugins.smartconsole.IBackendTableGroups<TRow>>,
-): Promise<void> => {
-  if (!rowsArg.length) return;
-  const width = consoleWidth();
-  if (width < 40) {
-    // smartconsole's run semantics: null and undefined are the same key.
-    const dividerKeys = rowsArg.map(row => groupsArg?.divider?.(row) ?? null);
-    const rule = `  ${dim('─'.repeat(Math.max(1, width - 4)))}\n\n`;
-    rowsArg.forEach((row, index) => {
-      if (index > 0 && dividerKeys[index] !== dividerKeys[index - 1]) process.stdout.write(rule);
-      process.stdout.write(columnsArg.map(column => `  ${column.title}: ${String(column.value(row) ?? 'Unavailable').replace(/\n/g, '\n    ')}`).join('\n') + '\n\n');
-    });
-    return;
-  }
-  await outArg.table(rowsArg, {
-    columns: columnsArg, overflow: 'wrap', groups: groupsArg,
-    theme: { header: { bold: true, foreground: 'cyan' }, border: { dim: true } },
-  });
-};
-
-/** List tables that repeat one account across rows divide it from the next account by its id. */
-const accountDividers: plugins.smartconsole.IBackendTableGroups<{ accountId: string | null }> = { divider: row => row.accountId };
-
-/**
- * Names every account of one harness by its label, numbering each later account that repeats a label
- * (`alice@example.com (2)`), so all tables name an account alike and the metric columns stay distinct.
- */
-const nameAccounts = (accountsArg: TListedAccount[]): TNamedAccount[] => {
-  const labels = accountsArg.map(account => plainText(account.label));
-  const taken = new Set(labels);
-  return accountsArg.map((account, index) => {
-    const label = labels[index];
-    let name = label;
-    if (labels.indexOf(label) < index) {
-      for (let ordinal = 2; taken.has(name); ordinal++) name = `${label} (${ordinal})`;
-      taken.add(name);
-    }
-    return { ...account, name };
-  });
-};
-
-/** Shared, provider-independent list presentation. Adapters supply grouping metadata. */
-export class AccountListRenderer {
-  constructor(private readonly out: plugins.smartconsole.SmartConsole) {}
-  private get width(): number { return consoleWidth(); }
-  private heading(textArg: string): void { consoleHeading(textArg); }
-
-  public async render(listArg: IAccountList): Promise<void> {
-    const now = Date.parse(listArg.generatedAt);
-    if (!listArg.harnesses.length) process.stdout.write('No harnesses registered.\n');
-    for (const harness of listArg.harnesses) {
-      this.heading(plainText(harness.label));
-      if (harness.problems.length) {
-        for (const problem of harness.problems) process.stdout.write(`${orange('Unavailable')}: ${plainText(problem)}\n`);
-        continue;
-      }
-      if (!harness.accounts.length) {
-        process.stdout.write(`${dim(plainText(harness.saveUnavailableReason ?? 'No known accounts. ' + harness.loginHint))}\n`);
-        continue;
-      }
-      const accounts = nameAccounts(harness.accounts);
-      await this.overview(accounts, now);
-      const schedules = accounts.flatMap(account => orderedUsageWindows(account.status.summary?.usageWindows).map(window => ({ accountId: account.id, account: account.name, window })));
-      for (const feature of [false, true]) {
-        const scopedSchedules = schedules.filter(row => (row.window.scope === 'feature') === feature);
-        if (!scopedSchedules.length) continue;
-        this.heading(feature ? 'Feature-specific limits' : 'Usage & reset schedule');
-        await consoleTable(this.out, scopedSchedules, [
-          { key: 'account', title: 'Account', value: row => row.account },
-          { key: 'window', title: 'Window', value: row => `${plainText(row.window.label)} (${duration(row.window.durationSeconds)})` },
-          { key: 'usage', title: 'Usage', value: row => `${row.window.usedPercent}% used\n${Math.max(0, 100 - row.window.usedPercent)}% left` },
-          { key: 'reset', title: 'Reset in', value: row => until(row.window.resetAt, now) },
-        ], accountDividers);
-      }
-      const resets = accounts.flatMap(account => (account.status.summary?.resets?.details ?? []).map(reset => ({ accountId: account.id, account: account.name, reset })));
-      if (resets.length) {
-        this.heading('Earned reset details');
-        await consoleTable(this.out, resets, [
-          { key: 'account', title: 'Account', value: row => row.account },
-          { key: 'kind', title: 'Type', value: row => plainText(row.reset.kind) },
-          { key: 'status', title: 'Status', value: row => plainText(row.reset.status) },
-          { key: 'expiry', title: 'Expires (UTC)', value: row => row.reset.expiresAt === null ? 'Not reported' : plainText(row.reset.expiresAt).replace('T', '\n').replace('.000Z', '').replace(/Z$/, '') },
-        ], accountDividers);
-      }
-      const groups = new Map<string, IDisplayFact[]>();
-      const add = (section: string, fact: IDisplayFact) => { const group = groups.get(section) ?? []; group.push(fact); groups.set(section, group); };
-      accounts.forEach((account, index) => {
-        for (const fact of account.status.facts) {
-          if (!this.covered(fact, account.status)) add(plainText(fact.section ?? 'Additional information'), { account: index, label: plainText(fact.label), value: plainText(fact.value) });
-        }
-      });
-      for (const [section, facts] of groups) await this.facts(section, facts, accounts);
-      const saved = accounts.flatMap((account, index) => [
-        ...(account.savedAt ? [{ account: index, label: 'Saved (UTC)', value: plainText(account.savedAt) }] : []),
-        ...account.details.map((detail, detailIndex) => ({ account: index, label: `Note ${detailIndex + 1}`, value: plainText(detail) })),
-      ]);
-      await this.facts('Saved logins', saved, accounts);
-      const issues: { accountId: string | null; account: string; issue: string }[] = accounts.flatMap(account =>
-        account.status.problems.map(problem => ({ accountId: account.id, account: account.name, issue: plainText(problem) })));
-      if (harness.saveUnavailableReason) issues.push({ accountId: null, account: 'Harness', issue: plainText(harness.saveUnavailableReason) });
-      if (issues.length) {
-        this.heading('Availability & actions');
-        await consoleTable(this.out, issues, [
-          { key: 'account', title: 'Account', value: row => row.account },
-          { key: 'issue', title: 'Unavailable / action needed', value: row => row.issue },
-        ], accountDividers);
-      }
-    }
-  }
-
-  private async overview(accountsArg: TNamedAccount[], nowArg: number): Promise<void> {
-    const rows = accountsArg;
-    const state = (account: TListedAccount) => `${account.isActive ? '* active\n' : ''}${account.isStashed ? 'saved' : 'not saved'}${account.status.problems.length ? '\n! partial status' : ''}`;
-    const plan = (account: TListedAccount) => account.status.summary?.subscription ? `${plainText(account.status.summary.subscription.plan)} (${account.status.summary.subscription.source})${account.status.summary.subscription.source === 'stored' ? '\nunverified' : ''}` : 'Unavailable';
-    const billing = (account: TListedAccount) => {
-      const info = account.status.summary?.billing;
-      if (!info) return 'Unavailable';
-      const dates = [
-        ...(info.renewsAt ? [`${info.autoRenew === true ? 'Renews' : 'Renewal boundary'}: ${plainText(info.renewsAt)}`] : []),
-        ...(info.cancelsAt ? [`Cancels: ${plainText(info.cancelsAt)}`] : []),
-        ...(info.expiresAt ? [`Expires: ${plainText(info.expiresAt)}`] : []),
-      ];
-      return [...(info.hasActiveSubscription === undefined ? [] : [info.hasActiveSubscription ? 'Subscription active' : 'No active subscription']),
-        info.autoRenew === true ? 'Auto-renew on' : info.autoRenew === false ? 'Auto-renew off' : 'Auto-renew unknown', ...dates,
-        ...(!dates.length ? ['Date unavailable'] : [])].join('\n');
-    };
-    const resets = (account: TListedAccount) => account.status.summary?.resets === undefined ? 'Unavailable' : String(account.status.summary.resets.available);
-    const usage = (account: TListedAccount) => accountQuotaSummary(account, nowArg);
-    const columns: plugins.smartconsole.IBackendTableColumn<typeof rows[number]>[] = [
-      { key: 'account', title: 'Account', value: row => row.name, style: row => ({ bold: row.isActive }) },
-    ];
-    if (this.width >= 100) columns.push(
-      { key: 'state', title: 'Login', value: state, style: row => ({ foreground: row.isStashed ? 'green' : 'orange' }) },
-      { key: 'plan', title: 'Plan', value: plan },
-      { key: 'usage', title: 'Usage / reset', value: usage },
-      { key: 'resets', title: 'Resets', value: resets, align: 'right' },
-    );
-    if (this.width >= 120) columns.splice(3, 0, { key: 'billing', title: 'Renewal / cancellation', value: billing });
-    else if (this.width >= 100) columns[2] = { key: 'plan', title: 'Plan / billing', value: row => `${plan(row)}\n${row.status.summary?.billing ? billing(row) : 'Billing unavailable'}` };
-    else if (this.width >= 60) columns.push(
-      { key: 'login', title: 'Login / plan', value: row => `${state(row)}\n${plan(row)}\n${row.status.summary?.billing ? billing(row) : 'Billing unavailable'}` },
-      { key: 'usage', title: 'Usage / resets', value: row => `${usage(row)}\nEarned resets: ${resets(row)}` },
-    );
-    else columns.push({ key: 'status', title: 'Status', value: row => `${state(row)}\nPlan: ${plan(row)}\nBilling: ${billing(row)}\nUsage: ${usage(row)}\nEarned resets: ${resets(row)}` });
-    await consoleTable(this.out, rows, columns);
-  }
-
-  private covered(factArg: IHarnessStatusFact, statusArg: IHarnessAccountStatus): boolean {
-    const summary = statusArg.summary;
-    if (!summary) return false;
-    switch (factArg.summaryKey) {
-      case 'subscription': return summary.subscription !== undefined;
-      case 'billing': return summary.billing !== undefined;
-      case 'usageWindows': return summary.usageWindows !== undefined;
-      case 'resets': return summary.resets !== undefined;
-      case 'resetDetails': return summary.resets?.details !== undefined;
-      default: return false;
-    }
-  }
-
-  /** Compare like metrics across accounts, keeping duplicate labels as separate rows. */
-  private async facts(titleArg: string, factsArg: IDisplayFact[], accountsArg: TNamedAccount[]): Promise<void> {
-    if (!factsArg.length) return;
-    this.heading(titleArg);
-    const valueBudget = Math.max(10, Math.min(40, Math.max(...factsArg.map(fact => Math.max(fact.value.length, accountsArg[fact.account].name.length))) + 3));
-    const perPage = Math.max(1, Math.min(6, Math.floor((this.width - 30) / valueBudget)));
-    const accountIndices = accountsArg.map((_, index) => index).filter(index => factsArg.some(fact => fact.account === index));
-    for (let start = 0; start < accountIndices.length; start += perPage) {
-      const indices = accountIndices.slice(start, start + perPage);
-      const metrics = new Map<string, { label: string; values: Map<number, string> }>();
-      const occurrences = new Map<string, number>();
-      for (const fact of factsArg.filter(fact => indices.includes(fact.account))) {
-        const occurrenceKey = JSON.stringify([fact.account, fact.label]);
-        const occurrence = occurrences.get(occurrenceKey) ?? 0;
-        occurrences.set(occurrenceKey, occurrence + 1);
-        const key = JSON.stringify([fact.label, occurrence]);
-        const metric = metrics.get(key) ?? { label: fact.label, values: new Map<number, string>() };
-        metric.values.set(fact.account, fact.value);
-        metrics.set(key, metric);
-      }
-      if (this.width < 40) {
-        for (const index of indices) {
-          process.stdout.write(`  Account: ${accountsArg[index].name}\n`);
-          for (const metric of metrics.values()) if (metric.values.has(index)) process.stdout.write(`  - ${metric.label}: ${metric.values.get(index)}\n`);
-        }
-      } else await consoleTable(this.out, [...metrics.values()], [
-        { key: 'metric', title: 'Metric', value: row => row.label },
-        ...indices.map(index => ({ key: String(index), title: accountsArg[index].name, value: (row: { values: Map<number, string> }) => row.values.get(index) ?? 'Not reported' })),
-      ]);
-    }
-  }
-}