@modelprofile.com/authswitch 3.1.0 → 3.3.0

package/ts/classes.limits.ts

@@ -1,8 +1,8 @@
 import * as plugins from './plugins.js';
-import { compactSince, compactUntil, credentialDriftNote, orderedUsageWindows } from './accounts.js';
+import { accountTypeText, 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, TUsageSeverity } from './interfaces.harness.js';
+import type { IAccountType, IHarnessCredentialDrift, TUsageSeverity } from './interfaces.harness.js';
 import { dim, plainText } from './formatting.js';
 
 type TListedAccount = IHarnessAccountList['accounts'][number];
@@ -46,13 +46,47 @@ const accountKeys = (harnessArg: IHarnessAccountList, accountArg: TListedAccount
   ...(accountArg.slotId === undefined ? {} : { slotId: plainText(accountArg.slotId) }),
 });
 
+/** The account's plan, sanitised like every other label and copied so that no two rows share one object. */
+const accountType = (accountArg: TListedAccount): IAccountType | null => {
+  const subscription = accountArg.status.summary?.subscription;
+  return subscription === undefined ? null : { plan: plainText(subscription.plan), source: subscription.source };
+};
+
 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 Provider cell per provider name within a harness; two harnesses that share a label stay apart. */
+const providerRuns = (rowArg: TCondensedRow): string => JSON.stringify([rowArg.harnessId, rowArg.provider]);
+
+/** 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
@@ -83,23 +117,23 @@ export const accountLimits = (listArg: IAccountList): IAccountLimits => {
       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 });
+      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, isActive: false, accountType: null, ...empty, unavailableReason: problem });
       continue;
     }
     if (!harness.accounts.length) {
-      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, isActive: false, ...empty,
+      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, isActive: false, accountType: null, ...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) });
+        rows.push({ ...accountKeys(harness, account), isActive: account.isActive, accountType: accountType(account), ...empty, unavailableReason: missingLimitReason(account) });
         continue;
       }
       for (const window of windows) {
         rows.push({
-          ...accountKeys(harness, account), isActive: account.isActive,
+          ...accountKeys(harness, account), isActive: account.isActive, accountType: accountType(account),
           limitType: plainText(window.label), scope: window.scope ?? 'account', windowSeconds: window.durationSeconds,
           usedPercent: window.usedPercent, resetAt: window.resetAt, resetsIn: compactUntil(window.resetAt, now, UNAVAILABLE),
           severity: window.severity ?? null, headline: window.headline === true, unavailableReason: null,
@@ -129,14 +163,14 @@ export const activeAccounts = (listArg: IAccountList): IActiveAccounts => {
       return index < 0 ? null : activeDrift(harness, drifts.splice(index, 1)[0]);
     };
     if (problem !== null) {
-      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, savedAt: null, savedAgo: UNAVAILABLE, source: 'none', unavailableReason: problem, drift: null });
+      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, accountType: null, savedAt: null, savedAgo: UNAVAILABLE, source: 'none', unavailableReason: problem, drift: null });
       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,
+        harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, accountType: 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.`
@@ -146,7 +180,7 @@ export const activeAccounts = (listArg: IAccountList): IActiveAccounts => {
     } else {
       for (const account of active) {
         rows.push({
-          ...accountKeys(harness, account),
+          ...accountKeys(harness, account), accountType: accountType(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.',
@@ -163,6 +197,13 @@ export const activeAccounts = (listArg: IAccountList): IActiveAccounts => {
   return { schemaVersion: 1, generatedAt: listArg.generatedAt, complete: listArg.complete, active, notes: [...collectNotes(active), ...driftNotes, ...unattached] };
 };
 
+/**
+ * The Account cell: the label, and the account type beneath it, dim. An unknown type keeps its line as
+ * `n/a`, so every account cell has the same shape; a provider row without an account has no type to name.
+ */
+const accountCell = (rowArg: IAccountLimitRow): plugins.smartconsole.TText => rowArg.account === null ? UNAVAILABLE
+  : plugins.smartconsole.color.concat(`${rowArg.account}\n`, plugins.smartconsole.color.text(accountTypeText(rowArg.accountType) ?? UNAVAILABLE, { dim: true, bold: false }));
+
 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' };
@@ -184,15 +225,18 @@ export class CondensedRenderer {
 
   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 }) },
+    // The span callbacks record these exact rows, so the table renders this array as it is.
+    const rows = limitsArg.limits;
+    if (!rows.length) { process.stdout.write(`${dim('No harnesses registered.')}\n`); return; }
+    await consoleTable(this.out, rows, [
+      { key: 'provider', title: 'Provider', value: row => row.provider, rowSpan: plugins.smartconsole.rowSpansBy(rows, providerRuns) },
+      { key: 'account', title: 'Account', value: row => row.account ?? UNAVAILABLE, render: accountCell,
+        style: row => ({ bold: row.isActive }), rowSpan: plugins.smartconsole.rowSpansBy(rows, accountRuns) },
       { key: 'limit', title: 'Limit type', value: row => row.limitType ?? UNAVAILABLE },
       { key: 'used', title: 'Used %', value: percent, align: 'right',
         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 — ');
   }
 
@@ -210,7 +254,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.opencodeharness.ts

@@ -4,7 +4,7 @@ import { CredentialStore, credentialHash, credentialRecord, credentialText, read
 import { HarnessProcesses } from './classes.harnessprocesses.js';
 import { CodexAccountStatus } from './classes.codexstatus.js';
 import { writeSecretFileAtomically } from './helpers.js';
-import type { IHarnessAccountStatus, IHarnessLoginOptions, IHarnessLoginProvider, IHarnessProcessControl } from './interfaces.harness.js';
+import type { IHarnessAccountStatus, IHarnessLoginOptions, IHarnessLoginProvider, IHarnessProcessControl, IHarnessStatusOptions } from './interfaces.harness.js';
 import { beginSavedOpenAiLogin, openCodeCredentialFromLogin } from './classes.login.js';
 import { plainText } from './formatting.js';
 
@@ -100,12 +100,12 @@ export class OpenCodeHarness extends FileHarness {
     writeSecretFileAtomically(this.file, raw);
     if (readCredentialDocument(this.file).raw !== raw) throw new Error('Active login verification failed. The outgoing login remains saved.');
   }
-  public async readAccountStatus(id: string): Promise<IHarnessAccountStatus> {
+  public async readAccountStatus(id: string, optionsArg?: IHarnessStatusOptions): Promise<IHarnessAccountStatus> {
     const account = this.readCredential(id);
     if (account.slotId === 'openai' && account.credential.type === 'oauth') {
       const info = this.openAiInfo(account.credential);
       if (!info.accountId) return { facts: [], problems: ['The OpenAI login has no account ID for a status lookup.'] };
-      return this.status.readCredential(credentialText(account.credential.access)!, info.accountId, info.plan);
+      return this.status.readCredential(credentialText(account.credential.access)!, info.accountId, info.plan, optionsArg);
     }
     return { facts: [
       { section: 'Authentication', label: 'Provider', value: account.slotId },

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, usageWindowName, until, readAccountRows, type IAccountRow } from './accounts.js';
+import { accountBadge, 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';
@@ -115,11 +115,14 @@ export class AuthSwitchTui {
         const verified = await harness.readState();
         if (!verified.accounts.some(account => account.isActive && account.isStashed && account.id === active.id)) { footer.setText('The current login could not be verified as saved. Switching was cancelled.'); return; }
       }
-      if (!await screen.confirm(`Switch ${plainText(harness.label)} to ${plainText(target.label)}?`, { confirmLabel: 'Switch' })) return;
+      // The dashboard already holds this account's status, so the badge costs no further lookup.
+      const badge = accountBadge(rows.find(row => row.account.id === target.id)?.status);
+      if (!await screen.confirm(`Switch ${plainText(harness.label)} to ${plainText(target.label)}${badge}?`, { confirmLabel: 'Switch' })) return;
       if (screen.signal.aborted) return;
       const outcome = await this.operations.run(harness, { harnessId: harness.id, action: 'switch', accountId: target.id },
         message => screen.confirm(message), settleInstances(screen));
-      await refresh(screen); showOutcome(outcome);
+      await refresh(screen);
+      if (showOutcome(outcome)) ui.logs.append(`Now active: ${plainText(target.label)}${badge}`);
     };
     const remove = async (screen: plugins.smartconsole.ITuiContext): Promise<void> => {
       const selected = table.selected;

package/ts/interfaces.harness.ts

@@ -127,9 +127,20 @@ export interface IHarnessUsageWindow {
   headline?: true;
 }
 
+/**
+ * The provider's own name for an account's plan, and where that name comes from.
+ *
+ * `live` was read from the provider in this lookup; `stored` is the last name the saved login
+ * carries, which is the only answer available while a provider cannot be reached.
+ */
+export interface IAccountType {
+  plan: string;
+  source: 'live' | 'stored';
+}
+
 export interface IHarnessStatusSummary {
   /** A plan name does not imply an active billing status. */
-  subscription?: { plan: string; source: 'live' | 'stored' };
+  subscription?: IAccountType;
   /** 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. */
@@ -146,6 +157,12 @@ export interface IHarnessOutcome {
   problems: string[];
 }
 
+/** A read-only status lookup. */
+export interface IHarnessStatusOptions {
+  /** Cancels the lookup's requests; an adapter still bounds each request with its own timeout. */
+  signal?: AbortSignal;
+}
+
 /** A single text-only inference request. Credentials remain inside the adapter. */
 export interface IHarnessPreuseOptions {
   prompt: string;
@@ -171,7 +188,7 @@ export interface IAuthHarness {
   readState(): THarnessResult<IHarnessState>;
   /** Running instances of this harness, when the adapter owns their lifecycle. */
   readonly processes?: IHarnessProcessControl;
-  readAccountStatus(accountIdArg: string): Promise<IHarnessAccountStatus>;
+  readAccountStatus(accountIdArg: string, optionsArg?: IHarnessStatusOptions): Promise<IHarnessAccountStatus>;
   readonly loginProviders?: IHarnessLoginProvider[];
   beginLogin?(options: IHarnessLoginOptions): Promise<IHarnessLoginHandle>;
   /** Optional quota-consuming capability; never changes the active login. */

package/ts/interfaces.list.ts

@@ -1,4 +1,4 @@
-import type { IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, TUsageSeverity } from './interfaces.harness.js';
+import type { IAccountType, IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, TUsageSeverity } from './interfaces.harness.js';
 
 /** Credential-free, versioned output of list --json. Missing status fields stay omitted. */
 export interface IAccountList {
@@ -39,6 +39,8 @@ export interface IAccountLimitRow {
   accountId: string | null;
   slotId?: string;
   isActive: boolean;
+  /** The adapter's plan name (`max`, `pro`), sanitised but not display-formatted; null when none is known or the row names no account. */
+  accountType: IAccountType | null;
   /** The provider's own window name, or null when no limit data is available. */
   limitType: string | null;
   scope: 'account' | 'feature' | null;
@@ -70,6 +72,8 @@ export interface IActiveAccountRow {
   account: string | null;
   accountId: string | null;
   slotId?: string;
+  /** The adapter's plan name (`max`, `pro`), sanitised but not display-formatted; null when none is known or the row names no account. */
+  accountType: IAccountType | null;
   /** 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`. */