@rikcodes/teamclaude 1.1.22-rik.3 → 1.1.22-rik.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rikcodes/teamclaude",
-  "version": "1.1.22-rik.3",
+  "version": "1.1.22-rik.5",
   "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

@@ -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 = diskConfig.accountSort === 'weekly-reset' ? 'weekly-reset' : '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/throughput.js

@@ -259,7 +259,7 @@ export function niceCeil(v) {
 
 const mod = (/** @type {number} */ x, /** @type {number} */ n) => ((x % n) + n) % n;
 
-/** @typedef {{ chars: number, firstAt: number, lastAt: number, model: string|null }} Stream */
+/** @typedef {{ chars: number, firstAt: number, lastAt: number, model: string|null, counted: boolean }} Stream */
 
 /**
  * The fleet's output rate: tokens generated across every request in the last
@@ -282,6 +282,11 @@ const mod = (/** @type {number} */ x, /** @type {number} */ n) => ((x % n) + n)
  *
  * Generating time runs from the stream's first output event to now, not to its
  * latest one: hidden thinking sends nothing while it thinks.
+ *
+ * A stream can be followed without being counted (`counted` false): its own
+ * live estimate is kept, but it adds nothing to the fleet's reading, books
+ * nothing when it ends and teaches its model nothing. The TUI uses that for
+ * the second leg of one generation (see TUI._markLeg).
  */
 export class ThroughputMeter {
   /** @param {{ now?: () => number, windowSec?: number, ringSec?: number }} [opts] */
@@ -305,22 +310,24 @@ export class ThroughputMeter {
 
   /**
    * Output streamed for request `id`: `chars` of text at `at`, from `model`.
-   * The first call starts the stream's generating time.
-   * @param {unknown} id @param {number} chars @param {number} at @param {string|null} [model]
+   * The first call starts the stream's generating time. `counted` false follows
+   * the stream for its own estimate only (see the class comment).
+   * @param {unknown} id @param {number} chars @param {number} at @param {string|null} [model] @param {boolean} [counted]
    */
-  progress(id, chars, at, model = null) {
+  progress(id, chars, at, model = null, counted = true) {
     const t = time(at);
     if (t === null) return;
     const n = typeof chars === 'number' && Number.isFinite(chars) && chars > 0 ? chars : 0;
     let s = this.streams.get(id);
     if (!s) {
       if (this.streams.size >= MAX_STREAMS) this.streams.delete(this.streams.keys().next().value);
-      s = { chars: 0, firstAt: t, lastAt: t, model: null };
+      s = { chars: 0, firstAt: t, lastAt: t, model: null, counted: true };
       this.streams.set(id, s);
     }
     s.chars += n;
     if (t > s.lastAt) s.lastAt = t;
     if (model) s.model = model;
+    s.counted = counted !== false;
   }
 
   /**
@@ -333,12 +340,16 @@ export class ThroughputMeter {
    * part of its estimate it can vouch for, its visible text, and not the part
    * that was a guess from its model's pace.
    *
+   * A request that is not counted (`counted` false, here or on its stream)
+   * books nothing and teaches nothing: it is only forgotten.
+   *
    * @param {unknown} id
-   * @param {{ outputTokens?: number|null, firstAt?: number|null, lastAt?: number|null, dispatchedAt?: number|null, endedAt?: number|null, model?: string|null }} [r]
+   * @param {{ outputTokens?: number|null, firstAt?: number|null, lastAt?: number|null, dispatchedAt?: number|null, endedAt?: number|null, model?: string|null, counted?: boolean }} [r]
    */
-  finish(id, { outputTokens = null, firstAt = null, lastAt = null, dispatchedAt = null, endedAt = null, model = null } = {}) {
+  finish(id, { outputTokens = null, firstAt = null, lastAt = null, dispatchedAt = null, endedAt = null, model = null, counted = true } = {}) {
     const s = this.streams.get(id);
     this.streams.delete(id);
+    if (counted === false || s?.counted === false) return;
     const end = time(endedAt);
     if (end !== null) this._observe(end);
     const n = tokens(outputTokens);
@@ -402,6 +413,7 @@ export class ThroughputMeter {
     sum += this.ring[mod(sec - w, n)] * (1 - into);
     const from = t - w * 1000;
     for (const s of this.streams.values()) {
+      if (!s.counted) continue;
       const { est, genMs } = this._estimate(s, t);
       if (!est) continue;
       sum += genMs > 0 ? est * (Math.min(genMs, t - from) / genMs) : est;
@@ -410,11 +422,13 @@ export class ThroughputMeter {
     return Number.isFinite(r) && r > 0 ? r : 0;
   }
 
-  /** Whether the reading is anything but a settled zero: a stream in flight, or
-   *  tokens still in the window. The TUI keeps its fast tick for exactly as long.
+  /** Whether the reading is anything but a settled zero: a counted stream in
+   *  flight, or tokens still in the window. The TUI keeps its fast tick for
+   *  exactly as long.
    *  @param {number} [at] */
   recent(at = this.now()) {
-    return this.streams.size > 0 || this.rate(at) > 0;
+    for (const s of this.streams.values()) if (s.counted) return true;
+    return this.rate(at) > 0;
   }
 
   /**

package/src/tui.js

@@ -22,7 +22,7 @@ import { sanitizeText, safeLine } from './safe-text.js';
 // The setting rules live in one module; the CLI, the MCP tools and this screen
 // all read them from there, so they cannot drift apart (#426).
 import { MAX_PROBE_SECONDS, ROUTE_COLORS } from './config-ops.js';
-import { isLocalUpstream } from './provider.js';
+import { isLocalUpstream, providerForPath } from './provider.js';
 import { ThroughputMeter, requestRate, formatRate } from './throughput.js';
 import { renderSpeedo, speedoWidth, SPEEDO_MIN_H, SPEEDO_MAX_H } from './speedo.js';
 
@@ -286,6 +286,23 @@ 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); `weekly-reset` puts the
+// account whose weekly window ends soonest first, so quota that is about to
+// expire unspent is at the top of the list.
+const ACCOUNT_SORTS = ['arranged', 'weekly-reset'];
+/** @type {Record<string, string>} */
+const ACCOUNT_SORT_LABELS = { arranged: 'arranged', 'weekly-reset': 'weekly reset' };
+
+// When the account's weekly window resets — the sort key behind `weekly-reset`.
+// No reading (an API-key account, or one that has not reported) 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 weeklyResetRank = (/** @type {any} */ a, /** @type {number} */ now) => {
+  const t = a?.quota?.unified7dReset;
+  return 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.
@@ -1099,7 +1116,48 @@ export class TUI {
 
   onRequestRouted(id, info) {
     const r = this.active.get(id);
-    if (r) r.account = info.account == null ? info.account : safeLine(info.account, 64);
+    if (!r) return;
+    r.account = info.account == null ? info.account : safeLine(info.account, 64);
+    if (this._throughputOn()) this._markLeg(r, info.account);
+  }
+
+  /**
+   * Whether this request is the second leg of a generation the fleet meter
+   * already counts, decided once, when the request is first routed.
+   *
+   * A translating sidecar (the Codex one in docs/openai.md) is a local-upstream
+   * account that calls back through this proxy: Claude Code's request goes to
+   * the sidecar, and the sidecar's translation of it comes back in and is served
+   * by a real account. Both legs stream the same generation and both report its
+   * tokens, so counting both doubles it. The outer leg is the one counted: it is
+   * what the client asked for, and the sidecar hands it the translated count.
+   *
+   * The inner leg is recognised by what the sidecar forwards and nothing else
+   * does: the SAME session as a request the proxy is currently serving on a
+   * local upstream, in a DIFFERENT dialect from it (the path says which), since
+   * the leg is that request translated. The session alone is not enough, because
+   * one session runs unrelated requests side by side; those are in the client's
+   * own dialect. A request that is itself on a local upstream is an outer leg,
+   * never an inner one. With no session on either leg nothing can be paired, and
+   * a local backend that does not call back never sends an inner leg, so in both
+   * cases everything is counted, as before.
+   *
+   * O(active) once per routing, never per delta. A nested request still keeps
+   * its own estimate and its own finished rate; it is only left out of the sum.
+   *
+   * @param {Record<string, any>} r the active entry
+   * @param {string|null|undefined} name the account it was routed to
+   */
+  _markLeg(r, name) {
+    const acct = name == null ? null : this.am.accounts.find((/** @type {any} */ a) => a.name === name);
+    r.local = isLocalUpstream(acct);
+    r.dialect ??= providerForPath(r.path || '');
+    if (r.nested !== undefined) return;
+    r.nested = false;
+    if (r.local || !r.sessionId) return;
+    for (const o of this.active.values()) {
+      if (o !== r && o.local && o.sessionId === r.sessionId && o.dialect !== r.dialect) { r.nested = true; return; }
+    }
   }
 
   /**
@@ -1113,7 +1171,7 @@ export class TUI {
    */
   onRequestProgress(id, { chars, at }) {
     const r = this.active.get(id);
-    if (r) this.throughput.progress(id, chars, at, r.model || null);
+    if (r) this.throughput.progress(id, chars, at, r.model || null, !r.nested);
   }
 
   onRequestEnd(id, info) {
@@ -1134,7 +1192,7 @@ export class TUI {
       outputTokens: info.outputTokens, firstAt: info.firstTokenAt, lastAt: info.lastTokenAt,
       dispatchedAt: info.dispatchedAt ?? r?.started ?? null, endedAt: now, model: info.model || r?.model || null,
     };
-    this.throughput.finish(id, timing);
+    this.throughput.finish(id, { ...timing, counted: !r?.nested });
     const tps = r ? requestRate({ ...timing, startedAt: timing.dispatchedAt }) : null;
     const tag = this._sessionTag(sid);
     // The line as it has always read. The rate is kept beside it rather than in
@@ -1427,6 +1485,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',
@@ -2052,6 +2125,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'];
@@ -2942,17 +3033,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 `accountSort: "weekly-reset"` the soonest weekly 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 byReset = !arranged && this.config?.accountSort === 'weekly-reset'
+      && !(this.mode === 'select' && this.selAction === 'reorder');
+    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 (byReset) {
+          const tx = weeklyResetRank(this.am.accounts[x], now);
+          const ty = weeklyResetRank(this.am.accounts[y], 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
@@ -3240,9 +3346,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
@@ -3583,6 +3693,11 @@ 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('  Weekly reset lists the account whose week ends soonest first;'));
+      lines.push(dim('  the arranged order breaks ties.'));
+    }
     lines.push('');
     // ── Network
     // Drawn before the sx.org block, which returns early when sx is unavailable: