@modelprofile.com/authswitch 3.2.0 → 3.3.0

package/ts/classes.codexstatus.ts

@@ -1,5 +1,5 @@
 import type { ICodexIdentity } from './interfaces.js';
-import type { IHarnessAccountStatus, IHarnessStatusSummary } from './interfaces.harness.js';
+import type { IHarnessAccountStatus, IHarnessStatusOptions, IHarnessStatusSummary } from './interfaces.harness.js';
 import { commitinfo } from './00_commitinfo_data.js';
 
 // Verified Chromium-compatible billing request profile, independent of any locally installed browser.
@@ -39,7 +39,7 @@ class StatusRequestError extends Error {}
 export class CodexAccountStatus {
   constructor(private readonly fetcher: typeof fetch = globalThis.fetch) {}
 
-  public async read(rawArg: string, identityArg: ICodexIdentity): Promise<IHarnessAccountStatus> {
+  public async read(rawArg: string, identityArg: ICodexIdentity, optionsArg: IHarnessStatusOptions = {}): Promise<IHarnessAccountStatus> {
     if (identityArg.kind !== 'chatgpt') return {
       facts: [{ label: 'Authentication', value: 'API key' }, { label: 'Subscription and usage', value: 'Not exposed by Codex for API-key logins' }], problems: [],
     };
@@ -47,18 +47,18 @@ export class CodexAccountStatus {
     try { accessToken = text(record(record(JSON.parse(rawArg)).tokens).access_token); }
     catch { return { facts: [], problems: ['The login has no usable access token. Log in again with Codex, then save the account.'] }; }
     if (!identityArg.accountId) return { facts: [], problems: ['The login has no account ID for a status lookup.'] };
-    return this.readCredential(accessToken, identityArg.accountId, identityArg.planType);
+    return this.readCredential(accessToken, identityArg.accountId, identityArg.planType, optionsArg);
   }
 
   /** Read the ChatGPT account directly, independent of a harness's on-disk format. */
-  public async readCredential(accessToken: string, accountId: string, planType?: string | null): Promise<IHarnessAccountStatus> {
+  public async readCredential(accessToken: string, accountId: string, planType?: string | null, optionsArg: IHarnessStatusOptions = {}): Promise<IHarnessAccountStatus> {
     const result: IHarnessAccountStatus = { facts: [], problems: [] };
     const identityArg = { accountId, planType };
     const sections = await Promise.allSettled([
-      this.get('wham/usage', accessToken, identityArg.accountId),
-      this.get('wham/rate-limit-reset-credits', accessToken, identityArg.accountId),
-      this.get('wham/profiles/me', accessToken, identityArg.accountId),
-      this.get('accounts/check/v4-2023-04-27', accessToken, identityArg.accountId),
+      this.get('wham/usage', accessToken, identityArg.accountId, optionsArg.signal),
+      this.get('wham/rate-limit-reset-credits', accessToken, identityArg.accountId, optionsArg.signal),
+      this.get('wham/profiles/me', accessToken, identityArg.accountId, optionsArg.signal),
+      this.get('accounts/check/v4-2023-04-27', accessToken, identityArg.accountId, optionsArg.signal),
     ]);
     const usage = sections[0];
     if (usage.status === 'fulfilled' && usage.value.account_id != null && usage.value.account_id !== identityArg.accountId) {
@@ -92,8 +92,9 @@ export class CodexAccountStatus {
     return result;
   }
 
-  private async get(pathArg: string, tokenArg: string, accountIdArg: string): Promise<Record<string, unknown>> {
-    const signal = AbortSignal.timeout(10_000);
+  private async get(pathArg: string, tokenArg: string, accountIdArg: string, cancelArg?: AbortSignal): Promise<Record<string, unknown>> {
+    const timeout = AbortSignal.timeout(10_000);
+    const signal = cancelArg ? AbortSignal.any([cancelArg, timeout]) : timeout;
     try {
       const response = await this.fetcher(`https://chatgpt.com/backend-api/${pathArg}`, {
         method: 'GET', redirect: 'error', signal,
@@ -125,7 +126,7 @@ export class CodexAccountStatus {
       catch { throw new StatusRequestError('The service returned invalid status data.'); }
     } catch (errorArg) {
       // Never surface remote bodies, request headers, token strings or arbitrary fetch errors.
-      if (signal.aborted) throw new Error('The status request timed out.');
+      if (signal.aborted) throw new Error(timeout.aborted ? 'The status request timed out.' : 'The status request was cancelled.');
       if (errorArg instanceof StatusRequestError) throw errorArg;
       throw new Error('The status service could not be reached.');
     }

package/ts/classes.fileharness.ts

@@ -1,4 +1,4 @@
-import type { IAuthHarness, IHarnessAccountStatus, IHarnessCredentialDrift, IHarnessOutcome, IHarnessProcessControl, IHarnessState } from './interfaces.harness.js';
+import type { IAuthHarness, IHarnessAccountStatus, IHarnessCredentialDrift, IHarnessOutcome, IHarnessProcessControl, IHarnessState, IHarnessStatusOptions } from './interfaces.harness.js';
 import { credentialHash, CredentialStore, type IStoredCredential, type ISwitchRecord } from './classes.credentialstore.js';
 import { pauseSynchronously } from './helpers.js';
 import { plainText } from './formatting.js';
@@ -28,7 +28,7 @@ export abstract class FileHarness implements IAuthHarness {
   /** Raw bytes of the native files a snapshot's credentials are taken from, in a fixed order. */
   protected abstract nativeSources(): (string | null)[];
   protected abstract inspect(credential: Record<string, unknown>, slotId: string): IFileAccount;
-  public abstract readAccountStatus(id: string): Promise<IHarnessAccountStatus>;
+  public abstract readAccountStatus(id: string, optionsArg?: IHarnessStatusOptions): Promise<IHarnessAccountStatus>;
 
   /**
    * A snapshot proven not to have been taken across a native write.

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,6 +46,12 @@ 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;
 
@@ -76,6 +82,9 @@ const byProviderThenAccount = <TRow extends TCondensedRow>(rowsArg: TRow[]): TRo
 /** 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]);
 
@@ -108,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,
@@ -154,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.`
@@ -171,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.',
@@ -188,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' };
@@ -209,10 +225,13 @@ 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) }) },

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`. */