@modelprofile.com/authswitch 6.1.0 → 6.3.0

package/ts/classes.codexpreuse.ts

@@ -70,7 +70,7 @@ export class CodexPreuse {
     } catch {
       throw new PreuseError(requestStarted
         ? 'Preuse did not complete. Tokens may already have been consumed; no automatic retry was made. Check the account status before trying again.'
-        : 'Preuse was cancelled before the prompt was sent.');
+        : 'Preuse was cancelled before the prompt was sent.', requestStarted);
     }
   }
 }

package/ts/classes.stashstore.ts

@@ -6,6 +6,7 @@ import type {
   THarnessName,
 } from './interfaces.js';
 import { writeSecretFileAtomically } from './helpers.js';
+import { codexIdentityFromRaw } from './classes.codexauth.js';
 
 const AUTH_FILE_NAME = 'auth.json';
 const META_FILE_NAME = 'stash.json';
@@ -105,6 +106,27 @@ export class StashStore {
     return entry;
   }
 
+  /**
+   * Replaces the credential of an existing stash and leaves its metadata exactly as it is.
+   *
+   * Codex refreshes the login it is running on its own schedule, so a saved copy of that login holds older
+   * tokens until something writes the rotation back. Doing so is an update of one account's credential, not a
+   * new save: the record keeps its account, its enrollments and the moment it was saved, which `write()` would
+   * stamp anew. The credential must belong to the account the metadata names -- the same guard `write()`
+   * applies -- so a mirror can never move one account's login into another account's record.
+   */
+  public replaceAuth(emailArg: string, rawAuthArg: string): void {
+    const meta = this.readMeta(emailArg);
+    if (!meta) {
+      throw new Error(`no stash for "${emailArg}" whose credential could be replaced`);
+    }
+    const identity = codexIdentityFromRaw(rawAuthArg);
+    if (!identity || identity.email !== meta.email || identity.accountId !== meta.accountId || identity.kind !== meta.kind) {
+      throw new Error('the credential does not belong to the account this stash holds; refusing to replace it');
+    }
+    writeSecretFileAtomically(plugins.path.join(this.entryDir(emailArg), AUTH_FILE_NAME), rawAuthArg);
+  }
+
   /**
    * Reads a stash back and confirms it matches what was meant to be written.
    * Callers use this before clearing the active credential, so a stash is only

package/ts/classes.tui.ts

@@ -1,10 +1,16 @@
 import * as plugins from './plugins.js';
-import type { IAuthHarness, IHarnessOutcome, IHarnessProcess, IHarnessState, IHarnessStopOutcome } from './interfaces.harness.js';
+import type { IAuthHarness, IHarnessAccount, IHarnessOutcome, IHarnessProcess, IHarnessState, IHarnessStopOutcome } from './interfaces.harness.js';
 import { accountBadge, accountDetails, accountPlan, accountQuotaSummary, accountResets, accountState, accountUsageWindows, usageWindowName, until, readAccountRows, type IAccountRow } from './accounts.js';
+import { defaultPreusePrompt, preuseAccounts, preuseCountsText, preuseTargets, type TPreuseAccountResult } from './preuse.js';
 import { plainText } from './formatting.js';
 import { AuthSwitchOperations, authSwitchMutationReplacesLogin, type TAuthSwitchMutation } from './classes.operations.js';
 import { describeHarnessProcesses, describeStopOutcome } from './classes.harnessprocesses.js';
 
+/** One account's preuse result, as the dashboard's activity log and footer report it. */
+const preuseResultLine = (resultArg: TPreuseAccountResult): string => resultArg.outcome === 'completed'
+  ? `${plainText(resultArg.account.label)}: completed with ${plainText(resultArg.result.model)}, ${resultArg.result.totalTokens ?? 'unreported'} tokens.`
+  : `${plainText(resultArg.account.label)}: ${resultArg.reason}`;
+
 /** Owns account-management actions; terminal rendering and interaction belong to smartconsole. */
 export class AuthSwitchTui {
   constructor(private readonly harnesses: readonly IAuthHarness[], private readonly out: plugins.smartconsole.SmartConsole, private readonly operations = new AuthSwitchOperations()) {}
@@ -126,6 +132,30 @@ export class AuthSwitchTui {
       await refresh(screen);
       if (showOutcome(outcome)) ui.logs.append(`Now active: ${plainText(target.label)}${badge}`);
     };
+    /**
+     * Send one preuse prompt through each of these accounts, after one confirmation that names the cost.
+     *
+     * The prompt consumes the account's own quota, so nothing is sent before consent, the accounts run
+     * one at a time through the shared runner, and the footer follows the run account by account. Closing
+     * the dashboard aborts it before the next account starts. Nothing is switched, saved or written.
+     */
+    const preuse = async (screen: plugins.smartconsole.ITuiContext, accountsArg: readonly IHarnessAccount[]): Promise<void> => {
+      if (!harness.preuseAccount) { footer.setText(`${plainText(harness.label)} does not support preuse.`); return; }
+      if (!accountsArg.length) { footer.setText('Select an account to preuse.'); return; }
+      const message = accountsArg.length === 1
+        ? `Send one preuse prompt through ${plainText(accountsArg[0].label)}? This consumes its quota.`
+        : `Send one preuse prompt through each of these ${accountsArg.length} ${plainText(harness.label)} accounts? This consumes quota on every one of them.`;
+      if (!await screen.confirm(message, { confirmLabel: 'Preuse' })) return;
+      if (screen.signal.aborted) return;
+      const summary = await preuseAccounts(harness, accountsArg, { prompt: defaultPreusePrompt, signal: screen.signal }, event => {
+        if (event.kind === 'started') footer.setText(`Preusing ${plainText(event.account.label)} (${event.index + 1}/${event.total})…`);
+        else { const line = preuseResultLine(event.result); ui.logs.append(line); footer.setText(line); }
+        void screen.invalidate();
+      });
+      // The prompts moved usage and reset deadlines, so the table is read again before the counts are shown.
+      await refresh(screen);
+      footer.setText(`Preuse: ${preuseCountsText(summary)}.`);
+    };
     const remove = async (screen: plugins.smartconsole.ITuiContext): Promise<void> => {
       const selected = table.selected;
       if (!selected || (!selected.account.isStashed && selected.account.savedAt === null)) { footer.setText('Select an account with a saved copy.'); return; }
@@ -156,7 +186,7 @@ export class AuthSwitchTui {
         return ui.column([
           ui.text('authswitch · account management', { height: 1 }),
           this.harnesses.length > 1 ? ui.row([ui.panel('Harnesses', harnessTable, { width: 23 }), accountView]) : accountView,
-          ui.text('Enter switch · a save · c save+clear · d remove · r refresh · g diagnose · Tab focus · q quit', { height: 2 }),
+          ui.text(`Enter switch · a save · c save+clear · d remove${harness.preuseAccount ? ' · p preuse · P preuse all' : ''} · r refresh · g diagnose · Tab focus · q quit`, { height: 2 }),
           footer,
         ]);
       },
@@ -167,6 +197,13 @@ export class AuthSwitchTui {
         a: screen => perform(screen, () => save(screen, true)),
         c: screen => perform(screen, () => save(screen, false)),
         d: screen => perform(screen, () => remove(screen)),
+        // The key map is fixed for the session while the harness selector can change the harness, so both
+        // preuse keys are always bound and the action itself reports a harness that does not support it.
+        p: screen => perform(screen, async () => {
+          const selected = table.selected?.account.id;
+          await preuse(screen, preuseTargets((await harness.readState()).accounts).filter(account => account.id === selected));
+        }),
+        P: screen => perform(screen, async () => { await preuse(screen, preuseTargets((await harness.readState()).accounts)); }),
         g: screen => perform(screen, async () => { showOutcome(await harness.diagnose()); }),
       },
     });

package/ts/preuse.ts

@@ -1,9 +1,19 @@
-import type { IHarnessPreuseOptions } from './interfaces.harness.js';
+import { orderedUsageWindows } from './accounts.js';
+import type { IAuthHarness, IHarnessAccount, IHarnessPreuseOptions, IHarnessPreuseResult, IHarnessUsageWindow } from './interfaces.harness.js';
 
 export const defaultPreusePrompt = 'Write 2000 words about strawberries.';
 
-/** Only fixed local messages may cross the inference error boundary. */
-export class PreuseError extends Error {}
+/**
+ * Only fixed local messages may cross the inference error boundary.
+ *
+ * `requestStarted` says whether the prompt may already have reached the provider. False is a refusal that
+ * sent nothing -- an unsupported login, a missing credential, a model catalog that could not be read before
+ * the prompt -- so the account's quota is untouched. True, and any error that is not a `PreuseError` at all,
+ * means tokens may have been consumed, and such a request is never repeated automatically.
+ */
+export class PreuseError extends Error {
+  constructor(messageArg: string, public readonly requestStarted = false) { super(messageArg); }
+}
 
 export const validatePreuseOptions = (optionsArg: IHarnessPreuseOptions): void => {
   if (typeof optionsArg.prompt !== 'string' || !optionsArg.prompt.trim() || Buffer.byteLength(optionsArg.prompt, 'utf8') > 16_384) {
@@ -13,3 +23,131 @@ export const validatePreuseOptions = (optionsArg: IHarnessPreuseOptions): void =
     throw new PreuseError('The preuse model must be a valid model identifier of at most 128 characters.');
   }
 };
+
+/**
+ * What one account's turn in a run did.
+ *
+ * `skipped` is a refusal that sent nothing and consumed nothing, with the reason the adapter stated.
+ * `failed` and `interrupted` may both have consumed tokens, so neither is ever retried by the runner.
+ */
+export type TPreuseOutcome = 'completed' | 'skipped' | 'failed' | 'interrupted';
+
+/**
+ * The reset schedule read after a prompt completed.
+ *
+ * `reported` carries what the provider answered, which may be no window at all; `unavailable` is a lookup
+ * that failed, and `notRead` is a run the user interrupted before it asked. None of them says anything
+ * about the completed prompt, which is never repeated because its schedule could not be confirmed.
+ */
+export type TPreuseSchedule =
+  | { kind: 'reported'; windows: readonly IHarnessUsageWindow[] }
+  | { kind: 'unavailable' }
+  | { kind: 'notRead' };
+
+export type TPreuseAccountResult =
+  | { account: IHarnessAccount; outcome: 'completed'; result: IHarnessPreuseResult; schedule: TPreuseSchedule }
+  | { account: IHarnessAccount; outcome: Exclude<TPreuseOutcome, 'completed'>; reason: string };
+
+/** One account starting, and that account's result. A run reports nothing else, and never the generated prose. */
+export type TPreuseRunEvent =
+  | { kind: 'started'; index: number; total: number; account: IHarnessAccount }
+  | { kind: 'finished'; index: number; total: number; result: TPreuseAccountResult };
+
+export interface IPreuseRunSummary {
+  results: readonly TPreuseAccountResult[];
+  counts: Readonly<Record<TPreuseOutcome, number>>;
+  /** Accounts an abort kept the run from reaching. Nothing was sent for them. */
+  notRun: readonly IHarnessAccount[];
+}
+
+/**
+ * Every account a run may preuse, in the order the harness lists them, each at most once.
+ *
+ * A harness reports an active login and that login's saved record as one account -- Codex keys both by
+ * email, the file harness merges the active login into its saved record by account id -- so the walk is
+ * the account list itself. The seen set keeps a repeated id from being charged twice regardless.
+ */
+export const preuseTargets = (accountsArg: readonly IHarnessAccount[]): IHarnessAccount[] => {
+  const seen = new Set<string>();
+  const targets: IHarnessAccount[] = [];
+  for (const account of accountsArg) {
+    if (seen.has(account.id)) continue;
+    seen.add(account.id);
+    targets.push(account);
+  }
+  return targets;
+};
+
+/**
+ * A run's counts in one line, for a command's closing line and for the dashboard footer.
+ *
+ * Completed accounts are always named, including none of them; every other count appears only when it
+ * happened, so a clean run reads as one fact rather than as four.
+ */
+export const preuseCountsText = (summaryArg: IPreuseRunSummary): string => [
+  `${summaryArg.counts.completed} completed`,
+  ...(summaryArg.counts.skipped ? [`${summaryArg.counts.skipped} skipped`] : []),
+  ...(summaryArg.counts.failed ? [`${summaryArg.counts.failed} failed`] : []),
+  ...(summaryArg.counts.interrupted ? [`${summaryArg.counts.interrupted} interrupted`] : []),
+  ...(summaryArg.notRun.length ? [`${summaryArg.notRun.length} not run`] : []),
+].join(', ');
+
+/** An adapter's own fixed message, or the fixed local text for an error that crossed the boundary unnamed. */
+const preuseReason = (errorArg: unknown): string => errorArg instanceof PreuseError
+  ? errorArg.message
+  : 'Preuse failed. Tokens may already have been consumed; check account status before trying again.';
+
+/**
+ * The account's reset schedule, read after its prompt completed, exactly as the single-account command reads it.
+ *
+ * The read never activates or writes a login, and its failure never turns a completed prompt into a failed
+ * one: there is nothing to undo and nothing worth repeating. An interrupted run does not ask at all.
+ */
+const readPreuseSchedule = async (harnessArg: IAuthHarness, accountArg: IHarnessAccount, signalArg: AbortSignal): Promise<TPreuseSchedule> => {
+  if (signalArg.aborted) return { kind: 'notRead' };
+  try {
+    const status = await harnessArg.readAccountStatus(accountArg.id, { signal: signalArg });
+    return { kind: 'reported', windows: orderedUsageWindows(status.summary?.usageWindows) };
+  } catch { return { kind: 'unavailable' }; }
+};
+
+/**
+ * Send one preuse prompt through each account in turn, and report what each one did.
+ *
+ * Accounts run strictly one after another, each with exactly one inference request and no retry, because
+ * every request costs the account's own quota. An aborted signal stops the run before the next account
+ * starts, and an account already in flight is reported as interrupted: its tokens may be gone either way,
+ * which is why nothing is repeated. Nothing is switched, refreshed, stopped or written anywhere.
+ */
+export const preuseAccounts = async (
+  harnessArg: IAuthHarness,
+  accountsArg: readonly IHarnessAccount[],
+  optionsArg: { prompt: string; model?: string; signal: AbortSignal },
+  reportArg: (eventArg: TPreuseRunEvent) => void,
+): Promise<IPreuseRunSummary> => {
+  const preuseAccount = harnessArg.preuseAccount?.bind(harnessArg);
+  if (!preuseAccount) throw new PreuseError('This harness does not support preuse.');
+  validatePreuseOptions(optionsArg);
+  const results: TPreuseAccountResult[] = [];
+  const counts: Record<TPreuseOutcome, number> = { completed: 0, skipped: 0, failed: 0, interrupted: 0 };
+  const notRun: IHarnessAccount[] = [];
+  const total = accountsArg.length;
+  for (const [index, account] of accountsArg.entries()) {
+    if (optionsArg.signal.aborted) { notRun.push(account); continue; }
+    reportArg({ kind: 'started', index, total, account });
+    let result: TPreuseAccountResult;
+    try {
+      const completed = await preuseAccount(account.id, { prompt: optionsArg.prompt, model: optionsArg.model, signal: optionsArg.signal });
+      result = { account, outcome: 'completed', result: completed, schedule: await readPreuseSchedule(harnessArg, account, optionsArg.signal) };
+    } catch (error) {
+      // A cancelled account is interrupted whether or not its prompt went out; its reason says which.
+      const outcome = optionsArg.signal.aborted ? 'interrupted'
+        : error instanceof PreuseError && !error.requestStarted ? 'skipped' : 'failed';
+      result = { account, outcome, reason: preuseReason(error) };
+    }
+    results.push(result);
+    counts[result.outcome]++;
+    reportArg({ kind: 'finished', index, total, result });
+  }
+  return { results, counts, notRun };
+};