@rikcodes/teamclaude 1.1.20-rik.13 → 1.1.20-rik.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rikcodes/teamclaude",
-  "version": "1.1.20-rik.13",
+  "version": "1.1.20-rik.14",
   "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/account-manager.js

@@ -214,6 +214,13 @@ function makeAccount(acct, index) {
     hasClaudeMax: acct.hasClaudeMax ?? null,
     hasClaudePro: acct.hasClaudePro ?? null,
     priority: acct.priority || 0,
+    // Where this account sits in the list the TUI draws, arranged by the
+    // operator from the settings screen. Presentation only: nothing but
+    // _displayOrder in tui.js reads it, and it is emphatically NOT `priority`
+    // above — that one decides which account rotation spends next, and the two
+    // answer different questions about the same fleet. `null` means never
+    // placed, which sorts after every account that has been.
+    displayOrder: Number.isFinite(acct.displayOrder) ? acct.displayOrder : null,
     disabled: acct.disabled || false,
     maxUsage: acct.maxUsage ?? null,
     upstream: acct.upstream || null,

package/src/sync-accounts.js

@@ -94,6 +94,11 @@ export async function syncAccountsFromDisk(diskConfig, memConfig, accountManager
     }
     if (diskAcct.name && mgr.name !== diskAcct.name) mgr.name = diskAcct.name;
     if (diskAcct.priority != null && mgr.priority !== diskAcct.priority) mgr.priority = diskAcct.priority;
+    // A list position edited on disk applies on reload for the same reason a
+    // priority edit does, and `null` rather than `??` so deleting the field
+    // puts the account back among the unplaced instead of leaving it stuck at
+    // the position it last held. Display only — see makeAccount.
+    mgr.displayOrder = Number.isFinite(diskAcct.displayOrder) ? diskAcct.displayOrder : null;
     // A cap edit applies live for the same reason priority does: it is an
     // operator decision about a running fleet, and waiting for a restart to
     // honour a budget defeats the budget.

package/src/tui.js

@@ -213,15 +213,27 @@ const BAR_MAX = 20;
 // terminal lays the table out exactly as it did before the column could grow.
 const NAME_MIN = 12;
 
-// Clear space the version label needs on each side before it is drawn at all.
-// Below that it reads as a collision with the title or the port block.
-const HEAD_GAP = 2;
-
 // Narrowest label still worth drawing: an ellipsis and three columns of build.
-// Under that the header goes back to naming no build at all, which at those
+// Under that the footer goes back to naming no build at all, which at those
 // widths is the honest answer.
 const HEAD_LABEL_MIN = 4;
 
+// Clear space the footer keeps between the last key hint and the build label.
+// Any closer and the label reads as one more hint, which is the one thing it
+// must not look like — there is no key that does it.
+const FOOT_GAP = 2;
+
+// Where an account sits in the list the operator arranged — the sort key behind
+// _displayOrder, written by _doMoveAccount and by nothing else.
+//
+// An account with no `displayOrder` has never been placed: every account on a
+// config that predates the field, and every account added since the last
+// arrangement. Those sort after every account that has one, which is where a
+// new account already appeared back when this list was raw array order — so
+// the answer to "where does the one I just logged in with go" does not change
+// with the feature, and there is nothing to migrate.
+const listRank = (/** @type {any} */ a) => (Number.isFinite(a?.displayOrder) ? a.displayOrder : Infinity);
+
 // Which pair of bars a row draws: the subscription buckets (Ses/Wk, plus the
 // S7/F7 family bars) when any unified reading exists, else the metered Tok/Req
 // pair an API-key account reports. The account row budget is drawn per
@@ -288,7 +300,7 @@ export function fitLine(s, w) {
 /** The build label at `max` columns, or '' when nothing legible fits.
  *
  *  Build metadata is spent before anything is cut. A checkout labels itself
- *  `<version>+<sha>`, and of the two it is the version the header is read for;
+ *  `<version>+<sha>`, and of the two it is the version the footer is read for;
  *  the sha only says which build of it. Shortening the sha instead would be
  *  worse than losing it — four hex digits name no commit, and are read as if
  *  they did.
@@ -299,7 +311,7 @@ export function fitLine(s, w) {
  *  Sliced by code unit against a display-width budget — a version or a sha is
  *  ASCII, and a label arriving over the wire is measured again by the caller
  *  before it is placed, so a wide glyph costs the label its slot rather than
- *  the header its width.
+ *  the footer its width.
  *  @param {string} label
  *  @param {number} max */
 export function fitHeadLabel(label, max) {
@@ -490,7 +502,7 @@ export class TUI {
     this.mode = 'normal';    // normal | select | add | input | settings | pick
     this.pick = null;        // active list picker (routes editor accounts/bucket/color)
     this.pickReturn = 'routes'; // mode to fall back to when the picker closes
-    this.selAction = null;   // switch | remove | toggle
+    this.selAction = null;   // switch | remove | toggle | reorder
     this.selIdx = 0;
     this.selRoute = null;    // in switch mode: null = global default, else a getRoutes() entry to pin
     this.selReturn = 'normal'; // mode to fall back to when select mode closes
@@ -900,6 +912,18 @@ export class TUI {
       });
     }
 
+    // Two rows is the least that can be arranged. Below that the row would open
+    // a screen on which no key does anything.
+    if (this._displayOrder().length > 1) {
+      fields.push({
+        id: 'orderAccounts',
+        label: 'Reorder accounts',
+        hint: 'Enter to arrange',
+        value: () => dim('—'),
+        enter: () => { this.mode = 'select'; this.selAction = 'reorder'; this.selIdx = this._displayOrder()[0] ?? 0; this.selReturn = 'settings'; },
+      });
+    }
+
     fields.push({
       id: 'upstreamProxy',
       label: 'Upstream proxy',
@@ -1063,11 +1087,22 @@ export class TUI {
     // can only ask for the default account — leaves these keys alone.
     else if ((k === 'tab' || k === 'right') && this.selAction === 'switch' && !this.remote) this._cycleSelRoute(+1);
     else if (k === 'left' && this.selAction === 'switch' && !this.remote) this._cycleSelRoute(-1);
+    // ←→ in reorder mode move the ACCOUNT, not the cursor. ↑↓ already walk the
+    // rows, so this is the pair left over, and ←→ is what "change the thing the
+    // cursor is on" already means on the settings screen this is opened from.
+    // The cursor does not move with the key: `selIdx` names the account being
+    // dragged, and the row it marks travels with it.
+    else if ((k === 'left' || k === 'h') && this.selAction === 'reorder') this._doMoveAccount(-1);
+    else if ((k === 'right' || k === 'l') && this.selAction === 'reorder') this._doMoveAccount(+1);
     else if (k === 'enter') {
       if (this.selAction === 'switch') {
         this._doSwitchSelection();
       } else if (this.selAction === 'toggle') {
         this._doToggleDisabled(this.selIdx);
+      } else if (this.selAction === 'reorder') {
+        // Every move has already been saved, so Enter only means "done" — and
+        // it has to be caught here, ahead of the remove branch below, which is
+        // what an unlisted action falls into.
       } else {
         this._doRemove(this.selIdx);
       }
@@ -1481,6 +1516,50 @@ export class TUI {
     this._addLog(`${next ? 'Disabled' : 'Enabled'} account "${acct.name}"`);
   }
 
+  /** Move the selected account `delta` rows through the list as drawn.
+   *
+   *  The array is NOT permuted. `selIdx` is a manager index, and so are route
+   *  pins, session pins, `currentIndex`, `TC_ACCT` and the disable/switch CLI
+   *  paths — reordering `am.accounts` would silently repoint every one of them
+   *  at a different account. So the rows are sorted by a field instead and each
+   *  account keeps the slot it has held since startup.
+   *
+   *  It is not `priority` either. That field is rotation preference and only
+   *  one account in a fleet usually carries a non-default value — a
+   *  deliberately deprioritised local backend, say. Deriving it from where a
+   *  row sits on screen would re-rank the fleet as a side effect of tidying the
+   *  display, which is a routing change nobody asked for.
+   *
+   *  Every displayed account is renumbered from its new position rather than
+   *  only the two that moved: before the first move there are no numbers to
+   *  insert between, and a dense 0..n-1 is the form that reads in a hand-edited
+   *  config. Local backends are excluded throughout — _displayOrder filters
+   *  them out before this ever sees them, so they hold no position and their
+   *  array slots are simply skipped over.
+   *
+   *  @param {number} delta  rows to travel: -1 up the list, +1 down it
+   */
+  async _doMoveAccount(delta) {
+    const order = this._displayOrder();
+    const from = order.indexOf(this.selIdx);
+    const to = from + delta;
+    if (from < 0 || to < 0 || to >= order.length) return; // already at the end it was pushed against
+    order.splice(to, 0, ...order.splice(from, 1));
+    order.forEach((/** @type {number} */ mgrIdx, /** @type {number} */ pos) => {
+      this.am.accounts[mgrIdx].displayOrder = pos;
+      // Onto this account's own entry: a manager index is not a config index
+      // (account-pairing.js), and an account whose entry the config no longer
+      // holds keeps its position on screen with nothing to persist.
+      const cfgIdx = configIndexFor(this.config.accounts, this.am.accounts, mgrIdx);
+      if (cfgIdx >= 0) this.config.accounts[cfgIdx].displayOrder = pos;
+    });
+    // Nothing is logged on success. The row visibly moves, which is the whole
+    // feedback a drag needs, and a held arrow key would otherwise push the
+    // activity pane out from under the list being arranged.
+    try { await this.saveConfig(this.config); }
+    catch (/** @type {any} */ e) { this._addLog(`Failed to save: ${e.message}`); }
+  }
+
   // ── rendering ──────────────────────────────────────
 
   render({ force = false } = {}) {
@@ -1565,44 +1644,15 @@ export class TUI {
     // mode): what is on screen is the last snapshot, not the current state.
     const live = this.am.connected === false ? red('▼') : green('▲');
     const right = `${sessStr}Port ${port} ${live} `;
-    // In attach mode the dashboard names the server's build, not this process's,
-    // so the account manager's answer wins. It arrives sanitized (applyStatus)
-    // and starts empty, which keeps the label hidden until the first poll rather
-    // than briefly showing the local checkout's version as if it were the
-    // server's. A local AccountManager has neither property.
-    const label = this.am.versionLabel ?? this.versionLabel;
-    const upd = this.am.updateAvailable ?? this.updateAvailable;
-    const lw = vw(left), rw = vw(right);
-    // Columns left between the two blocks, and what the label may take of them.
-    // The marker is budgeted before the label is cut, so a shortened label and
-    // its marker still fit the room they were measured against.
-    const room = W - lw - rw;
-    const markerW = upd ? 2 : 0;
-    const text = label ? fitHeadLabel(label, room - 2 * HEAD_GAP - markerW) : '';
-    const mid = text ? dim(text) + (upd ? ` ${green('▲')}` : '') : '';
-    const mw = vw(mid);
-    // Centred on the line, not in the gap between the two blocks, so the label
-    // holds still as the session segment comes and goes.
-    const start = Math.floor((W - mw) / 2);
-    // Load-bearing, not cosmetic: both padding runs below would be negative
-    // without it, and ' '.repeat(-1) throws. Satisfying it also means the mid
-    // branch can never produce the over-wide line the other branch can, so the
-    // two are not interchangeable.
-    const midFits = mw > 0 && start - lw >= HEAD_GAP && (W - rw) - (start + mw) >= HEAD_GAP;
-    // Line-centring is a position, not a fit. The two blocks are different
-    // widths, so a label small enough for the gap can still be pushed inside
-    // one of them by where the centre of the LINE falls — and that, not width,
-    // is what used to drop the label every time the session segment grew,
-    // leaving a header that silently stopped naming the build it exists to
-    // name. Centre it in the GAP instead, which is exact by construction: the
-    // two runs below sum to `room`. The label moves when sessions come and go,
-    // which is the price; being able to read it is what that buys.
-    const gapPad = mw > 0 && room - mw >= 2 * HEAD_GAP ? Math.floor((room - mw) / 2) : -1;
-    lines.push(midFits
-      ? left + ' '.repeat(start - lw) + mid + ' '.repeat(W - rw - start - mw) + right
-      : gapPad >= 0
-        ? left + ' '.repeat(gapPad) + mid + ' '.repeat(room - mw - gapPad) + right
-        : left + ' '.repeat(Math.max(1, W - lw - rw)) + right);
+    // Title, padding, port block — and nothing between them. The build this
+    // checkout runs is named once, in the corner of the footer.
+    //
+    // That padding run is the whole of the line's arithmetic now, and it is
+    // floored rather than trusted: a wide session segment on a narrow terminal
+    // can leave the two blocks alone wider than the line, and ' '.repeat(-1)
+    // throws. There the header overruns and fitLine takes its tail, as it has
+    // since long before there was a label to lose.
+    lines.push(left + ' '.repeat(Math.max(1, W - vw(left) - vw(right))) + right);
     lines.push(' ' + dim('─'.repeat(W - 2)));
 
     const footerH = 2;
@@ -1798,11 +1848,21 @@ export class TUI {
    *  Display only. `selIdx`, `currentIndex`, session pins and route entries all
    *  stay manager indices, so nothing about selection or routing moves with the
    *  rows — see _keySelect, which walks this order but still stores an index.
+   *
+   *  Which is also why the operator's arrangement is a sort key and not a
+   *  permutation of `am.accounts`: see _doMoveAccount.
    */
   _displayOrder() {
     return this.am.accounts
       .map((/** @type {any} */ _, /** @type {number} */ i) => i)
-      .filter(i => !isLocalUpstream(this.am.accounts[i]));
+      .filter(i => !isLocalUpstream(this.am.accounts[i]))
+      .sort((/** @type {number} */ a, /** @type {number} */ b) => {
+        const ra = listRank(this.am.accounts[a]);
+        const rb = listRank(this.am.accounts[b]);
+        // Infinity !== Infinity is false, so two unplaced accounts fall through
+        // to the index rather than subtracting to NaN.
+        return ra === rb ? a - b : ra - rb;
+      });
   }
 
   /** Manager indices of the local backends, in config order. */
@@ -2052,9 +2112,10 @@ export class TUI {
     lines.push(row(byId('blocklist')));
     lines.push('');
     // ── Accounts
-    lines.push(bold('  Accounts') + dim('  — add (import / API key) or remove an account'));
+    lines.push(bold('  Accounts') + dim('  — add (import / API key), remove, or set the order they list in'));
     lines.push(row(byId('addAccount')));
     if (byId('removeAccount')) lines.push(row(byId('removeAccount')));
+    if (byId('orderAccounts')) lines.push(row(byId('orderAccounts')));
     lines.push('');
     // ── Network
     // Drawn before the sx.org block, which returns early when sx is unavailable:
@@ -2377,12 +2438,26 @@ export class TUI {
     }
   }
 
-  /** @param {number} [W]  columns to compose against; only the drain line uses it */
+  /** The footer line: the mode's key hints from the left, the build label set
+   *  against the right edge.
+   *  @param {number} [W]  columns to compose against */
   _renderFooter(W = process.stdout.columns || 80) {
     // A restart drain outranks every mode: the keys this line would otherwise
     // advertise are all refused while one runs (see _key), and how far the
     // drain has got is the only thing on screen worth the row.
+    //
+    // It is also the one footer drawn without the build label or its update
+    // marker. The line lives for at most the deadline, the build cannot change
+    // under it, and when the restart is an update the label names the build
+    // being replaced and the marker points at the thing already happening — so
+    // those columns go to the escape hatch, which is what the line is read for.
     if (this._restartDrain) return this._restartDrainFooter(this._restartDrain, W);
+    return this._footerWithVersion(this._footerHints(), W);
+  }
+
+  /** What the keyboard does on the screen the operator is looking at. Composed
+   *  without regard to width: fitting it to the line is _renderFooter's job. */
+  _footerHints() {
     switch (this.mode) {
       case 'normal':
         return this.remote
@@ -2408,6 +2483,12 @@ export class TUI {
             : 'default';
           return ` ${dim('↑↓')} select  ${dim('←→')} target: ${target}  ${bold('Enter')} pin  ${bold('Esc')} cancel`;
         }
+        // Both keys leave, because each move has already been saved: there is
+        // no pending change for one to commit and the other to throw away, and
+        // offering "cancel" would promise an undo this screen does not have.
+        if (this.selAction === 'reorder') {
+          return ` ${dim('↑↓')} select  ${dim('←→')} move  ${bold('Enter')}/${bold('Esc')} done`;
+        }
         const act = this.selAction === 'toggle' ? 'enable/disable' : 'remove';
         return ` ${dim('↑↓')} select  ${bold('Enter')} ${act}  ${bold('Esc')} cancel`;
       }
@@ -2420,6 +2501,55 @@ export class TUI {
     }
   }
 
+  /**
+   * `hints` with the build label — and, when one is waiting, an update marker —
+   * set against the right edge of a W-column line. This is the only place the
+   * display names either: the header carries its title and the port block and
+   * nothing else.
+   *
+   * Composed to exactly W, never less. The paint loop pads every short line out
+   * to the terminal width and truncates the tail of every long one (fitLine), so
+   * a label merely appended is pushed out of the corner it was put in, and a
+   * line built past W has that same corner eaten. Both failures are silent, and
+   * both look like the label was never drawn at all.
+   *
+   * The hints are never cut to make room. They are the only thing on this line
+   * that says what the keyboard does: a build the operator cannot read costs
+   * them nothing, a key they cannot read costs them the screen. So the label is
+   * fitted to whatever the hints leave over — fitHeadLabel spends the build sha
+   * first and then the head of the version — and it is dropped whole when what
+   * is left will not carry it.
+   *
+   * @param {string} hints
+   * @param {number} W
+   */
+  _footerWithVersion(hints, W) {
+    // In attach mode the dashboard names the server's build, not this
+    // process's, so the account manager's answer wins for both. It arrives
+    // sanitized (applyStatus) and starts empty, which keeps the corner blank
+    // until the first poll rather than briefly naming the local checkout as if
+    // it were the server's. A local AccountManager has neither property.
+    // `??` on purpose: '' is that deliberate blank, not a miss.
+    const label = this.am.versionLabel ?? this.versionLabel;
+    const upd = this.am.updateAvailable ?? this.updateAvailable;
+    // The marker rides with the label and is never drawn without it. Alone in
+    // the corner a bare glyph names nothing it could be an update TO, and reads
+    // as one more key hint — the one thing this end of the line must not look
+    // like. It would also be the wrong answer for an attached dashboard that
+    // has not polled yet: no server label, but this process's update flag.
+    if (!label) return hints;
+    const hw = vw(hints);
+    // Budgeted before the label is cut, so a shortened label and its marker
+    // still fit the room they were measured against.
+    const markerW = upd ? 2 : 0;
+    // One column of margin at the edge — what the rule under the header and
+    // the header's port block both leave.
+    const text = fitHeadLabel(label, W - hw - FOOT_GAP - markerW - 1);
+    if (!text) return hints;
+    const marker = upd ? ` ${green('▲')}` : '';
+    return `${hints}${' '.repeat(W - hw - vw(text) - markerW - 1)}${dim(text)}${marker} `;
+  }
+
   /**
    * The footer while this process drains to a restart: how long the wait has
    * run against the bound it cannot exceed, what is still holding it, and the