@rikcodes/teamclaude 1.1.22-rik.4 → 1.1.22-rik.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rikcodes/teamclaude",
-  "version": "1.1.22-rik.4",
+  "version": "1.1.22-rik.6",
   "description": "Multi-account proxy for Claude Code and Codex: pools Claude Max, ChatGPT/Codex, API-key and third-party backend accounts, and rotates on quota",
   "type": "module",
   "main": "src/index.js",

package/src/config.js

@@ -111,6 +111,7 @@ export function createDefaultConfig() {
     // the proxy does no throughput work at all (see OutputTracker).
     throughputMeter: false,
     projection: { enabled: true, windowMinutes: 90, wasteFloor: 0.1 },
+    accountSort: 'arranged',
     eventLogging: 'hide',
     defaultClientMode: 'mitm',
     // Written out rather than left absent, so a fresh config states the one

package/src/index.js

@@ -37,7 +37,7 @@ import { ResetCreditRedeemer } from './codex-reset-credits.js';
 import { Warmer } from './warmer.js';
 import { formatWarmupScheduleConfirmation, resolveWarmupConfig } from './warmup-schedule.js';
 import { Sidecar, SIDECAR_DRAIN_GRACE_MS, SIDECAR_SHUTDOWN_GRACE_MS } from './sidecar.js';
-import { TUI } from './tui.js';
+import { TUI, ACCOUNT_SORTS } from './tui.js';
 import { SessionTitles } from './session-titles.js';
 import { captureEarlyConsole } from './early-log.js';
 import { RemoteControl, createAttachSession } from './tui-remote.js';
@@ -535,6 +535,7 @@ async function serverCommand() {
     // Read by the server per request and by the TUI per frame, so the reload
     // is the whole application: the next request is timed, or is not.
     config.throughputMeter = diskConfig.throughputMeter === true;
+    config.accountSort = ACCOUNT_SORTS.includes(diskConfig.accountSort) ? diskConfig.accountSort : 'arranged';
     // Read by `run`/`env` from disk, but the TUI settings screen shows it live.
     config.defaultClientMode = diskConfig.defaultClientMode === 'base-url' ? 'base-url' : 'mitm';
     // The fleet switch for spending Codex reset credits. The redeemer reads it
@@ -636,6 +637,7 @@ async function serverCommand() {
         if (config.eventLogging != null) diskConfig.eventLogging = config.eventLogging;
         if (config.quotaBarPercent != null) diskConfig.quotaBarPercent = config.quotaBarPercent;
         if (config.throughputMeter != null) diskConfig.throughputMeter = config.throughputMeter;
+        if (config.accountSort != null) diskConfig.accountSort = config.accountSort;
         if (config.defaultClientMode != null) diskConfig.defaultClientMode = config.defaultClientMode;
         if (config.autoRedeemResets != null) diskConfig.autoRedeemResets = config.autoRedeemResets;
         if (config.blockedModels != null) diskConfig.blockedModels = config.blockedModels;

package/src/tui.js

@@ -286,6 +286,38 @@ const PANE_MIN = 62;
 // the feature, and there is nothing to migrate.
 const listRank = (/** @type {any} */ a) => (Number.isFinite(a?.displayOrder) ? a.displayOrder : Infinity);
 
+// How the account list is ordered inside each provider group (`accountSort`).
+// `arranged` is the operator's own order (listRank). Each of the others puts
+// the account whose window ends soonest first, so quota that is about to
+// expire unspent is at the top of the list.
+//
+// The window each sort reads. S7 and F7 are the family's own weekly bucket
+// where the account has one, else the all-models weekly, which is what governs
+// that family on such an account — the rule quota-summary.js resolves a
+// family's window by.
+/** @type {Record<string, (q: any) => any>} */
+const SORT_RESET = {
+  'session-reset': q => q.unified5hReset,
+  'weekly-reset': q => q.unified7dReset,
+  'sonnet-reset': q => (q.unified7dSonnet != null ? q.unified7dSonnetReset : q.unified7dReset),
+  'fable-reset': q => (q.unified7dFable != null ? q.unified7dFableReset : q.unified7dReset),
+};
+export const ACCOUNT_SORTS = ['arranged', ...Object.keys(SORT_RESET)];
+/** @type {Record<string, string>} */
+const ACCOUNT_SORT_LABELS = {
+  arranged: 'arranged',
+  'session-reset': 'session reset',
+  'weekly-reset': 'weekly reset',
+  'sonnet-reset': 'S7 reset',
+  'fable-reset': 'F7 reset',
+};
+
+// The sort key: when the window resets. No reading (an API-key account, one
+// that has not reported, a five-hour window nothing has opened) and a reset
+// that has already passed both sort last: the second is a window that has just
+// started over, so its next reset is the one furthest away.
+const resetRank = (/** @type {any} */ t, /** @type {number} */ now) => (Number.isFinite(t) && t > now ? t : Infinity);
+
 // How long a reorder waits after the last move before it is written. Longer
 // than a terminal's key-repeat interval, so a held arrow is one write; short
 // enough that the file is current by the time anyone looks at it.
@@ -1468,6 +1500,21 @@ export class TUI {
       });
     }
 
+    if (this.am.accounts.length > 1) {
+      fields.push({
+        id: 'accountSort',
+        label: 'Sort accounts',
+        hint: '←→ cycle',
+        value: () => {
+          const s = this._accountSort();
+          return s === 'arranged' ? gray(ACCOUNT_SORT_LABELS[s]) : green(ACCOUNT_SORT_LABELS[s]);
+        },
+        left: () => this._cycleAccountSort(-1),
+        right: () => this._cycleAccountSort(+1),
+        enter: () => this._cycleAccountSort(+1),
+      });
+    }
+
     fields.push({
       id: 'upstreamProxy',
       label: 'Upstream proxy',
@@ -2093,6 +2140,24 @@ export class TUI {
     if (this.running) this.render();
   }
 
+  /** The configured account sort; anything unknown reads as `arranged`. */
+  _accountSort() {
+    const s = this.config?.accountSort;
+    return ACCOUNT_SORTS.includes(s) ? s : 'arranged';
+  }
+
+  async _cycleAccountSort(dir = 1) {
+    // Read by _displayOrder on every frame, so the assignment is the whole
+    // application and the save is only what survives a restart.
+    const prev = this.config.accountSort;
+    const cur = this._accountSort();
+    const next = ACCOUNT_SORTS[(ACCOUNT_SORTS.indexOf(cur) + dir + ACCOUNT_SORTS.length) % ACCOUNT_SORTS.length];
+    this.config.accountSort = next;
+    if (!await this._saveSetting('account sort', () => { this.config.accountSort = prev; })) return;
+    this._addLog(`Account sort: ${ACCOUNT_SORT_LABELS[next]}`);
+    if (this.running) this.render();
+  }
+
   async _cycleEventLogging(dir = 1) {
     // Claude Code telemetry display/handling: show → hide → block → show.
     const order = ['show', 'hide', 'block'];
@@ -2983,17 +3048,32 @@ export class TUI {
    *  rows — see _keySelect, which walks this order but still stores an index.
    *  Which is also why the arrangement is a sort key rather than a permutation
    *  of `am.accounts`: see _doMoveAccount.
+   *
+   *  With a reset sort (`accountSort`) the soonest reset goes before the
+   *  arrangement, which then only breaks ties. Not on the reorder screen, and
+   *  not when `arranged` is asked for: the arrangement is what that screen
+   *  edits, so it must see that order.
+   *
+   *  @param {{ arranged?: boolean }} [opts]
    */
-  _displayOrder() {
+  _displayOrder({ arranged = false } = {}) {
+    const resetOf = arranged || (this.mode === 'select' && this.selAction === 'reorder')
+      ? null : SORT_RESET[this._accountSort()];
+    const now = Date.now();
     return this.am.accounts
       .map((/** @type {any} */ _, /** @type {number} */ i) => i)
       .filter(i => !isLocalUpstream(this.am.accounts[i]))
       .sort((/** @type {number} */ x, /** @type {number} */ y) => {
         const px = PROVIDER_ORDER.indexOf(providerOf(this.am.accounts[x]));
         const py = PROVIDER_ORDER.indexOf(providerOf(this.am.accounts[y]));
-        // Provider, then the arrangement: the provider is what a row IS, so a
-        // number the operator set never crosses it.
+        // Provider, then the sort, then the arrangement: the provider is what a
+        // row IS, so no sort and no number the operator set crosses it.
         if (px !== py) return px - py;
+        if (resetOf) {
+          const tx = resetRank(resetOf(this.am.accounts[x].quota || {}), now);
+          const ty = resetRank(resetOf(this.am.accounts[y].quota || {}), now);
+          if (tx !== ty) return tx < ty ? -1 : 1; // Infinity - Infinity is NaN, so compare
+        }
         const rx = listRank(this.am.accounts[x]);
         const ry = listRank(this.am.accounts[y]);
         // Infinity !== Infinity is false, so two unplaced accounts fall through
@@ -3281,9 +3361,13 @@ export class TUI {
    *  Every account except the locally-served ones. _displayOrder already leaves
    *  those out (they draw as conduit lines, not rows), so they hold no position
    *  and their array slots are simply stepped over.
+   *
+   *  Always in the arranged order, whatever `accountSort` says: a move
+   *  renumbers every account from this list, so a sorted list here would
+   *  write the sort into `displayOrder`.
    */
   _arrangeable() {
-    return this._displayOrder();
+    return this._displayOrder({ arranged: true });
   }
 
   /** The rows that carry ►: the cursor, or in a mixed pool each provider's current
@@ -3624,6 +3708,12 @@ export class TUI {
     lines.push(row(byId('addAccount')));
     if (byId('removeAccount')) lines.push(row(byId('removeAccount')));
     if (byId('orderAccounts')) lines.push(row(byId('orderAccounts')));
+    if (byId('accountSort')) {
+      lines.push(row(byId('accountSort')));
+      lines.push(dim('  A reset sort lists the account whose window ends soonest first;'));
+      lines.push(dim('  S7/F7 read the weekly window on an account without one. The'));
+      lines.push(dim('  arranged order breaks ties.'));
+    }
     lines.push('');
     // ── Network
     // Drawn before the sx.org block, which returns early when sx is unavailable: