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

package/package.json

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

@@ -775,11 +775,27 @@ async function serverCommand() {
   // instead of re-running teardown, which would re-arm server.close() and leak a
   // 'close' listener on the server each time (MaxListenersExceededWarning).
   let shuttingDown = false;
-  async function shutdown() {
-    if (shuttingDown) process.exit(0); // second ctrl-c: stop waiting, just go
-    shuttingDown = true;
+  // Everything this process borrowed from the terminal, given back: at most
+  // once, never throwing, and on every path that leaves. shutdown() does it
+  // first, as it always has. A restart drain now keeps the display up to the
+  // last moment and does it last — which makes the guard below, the "stop
+  // waiting, just go" path, the one that would otherwise walk out of a drain
+  // leaving the operator on the alternate screen with raw mode still on and a
+  // terminal they cannot type into.
+  const restoreTerminal = () => {
     try { tui?.stop(); } catch { /* terminal already restored */ }
+    // Stopping the title belongs here rather than at the top of a drain: while
+    // one runs the title still names the build that is running, which is the
+    // whole reason it carries the build at all.
     stopTitle();
+  };
+  async function shutdown() {
+    // Second ctrl-c, or a signal arriving during a restart drain: stop waiting,
+    // just go — but hand the terminal back first, because nothing after this
+    // line runs and on the drain path the display is still up.
+    if (shuttingDown) { restoreTerminal(); process.exit(0); }
+    shuttingDown = true;
+    restoreTerminal();
     if (!tui) console.log('\n[TeamClaude] Shutting down...');
     prober?.stop();
     warmer?.stop();
@@ -810,6 +826,12 @@ async function serverCommand() {
   // stops accepting while the connections already open keep serving; then the
   // bounded wait; then the sidecar, whose replacement the next process spawns;
   // then quota state, exactly as shutdown() persists it. Exit 75 is the ask.
+  //
+  // The display is the other difference. shutdown() tears it down first; this
+  // keeps it to the end. A drain is up to thirty seconds of waiting the
+  // operator asked for, and taking the dashboard away at the start of it left
+  // them watching plain console lines with no way to tell how far it had got or
+  // what was holding it.
   let draining = false;
   hooks.isDraining = () => draining;
   /** @param {string} why  what put the restart in motion, for the line on the way out */
@@ -817,12 +839,19 @@ async function serverCommand() {
     if (shuttingDown) return; // ctrl-c beat us here, or a second trigger did
     shuttingDown = true;
     draining = true;
-    try { tui?.stop(); } catch { /* terminal already restored */ }
-    stopTitle();
+    tui?.restartDrainStarted({
+      deadlineMs: DRAIN_DEADLINE_MS,
+      inFlight: () => accountManager.inFlightRequests(),
+    });
+    // Under the TUI console.log IS the log pane (tui.js), so this line and the
+    // two the drain ends with report themselves on screen beside the live
+    // counter, and nothing extra has to be written for them.
     console.log(`\n[TeamClaude] ${why} — draining, up to ${Math.round(DRAIN_DEADLINE_MS / 1000)}s for requests in flight.`);
     prober?.stop();
     warmer?.stop();
     eventLoopMonitor.stop();
+    /** @type {string|null} */
+    let failure = null;
     // Nothing below may throw its way out. Neither caller awaits this — the TUI
     // key returns to its handler and the watcher fires from a timer — so an
     // escaping rejection would be an unhandled one, and crash-log.js turns that
@@ -840,11 +869,21 @@ async function serverCommand() {
       if (quotaSaveInterval) clearInterval(quotaSaveInterval);
       await persistQuotaState();
     } catch (err) {
-      // Committed from the moment the display came down and the listener
-      // closed: there is no serving state left to return to, so say what broke
-      // and let the relaunch be the recovery.
-      console.error(`[TeamClaude] Drain failed: ${err.message}`);
+      // Committed from the moment the listener closed: there is no serving
+      // state left to return to, so record what broke and let the relaunch be
+      // the recovery. Read off `err` defensively because throwing HERE is the
+      // one thing the try above cannot absorb, and an unhandled rejection out
+      // of this function is exit 1 — a crash, on the path whose whole purpose
+      // is to come back.
+      failure = /** @type {any} */ (err)?.message || String(err);
+    } finally {
+      // The last thing before the exit, and in a finally because the catch is
+      // not the only way out of the block above.
+      restoreTerminal();
     }
+    // After the restore, so it lands on the screen the relaunch comes back to
+    // rather than in a log pane that goes with the alternate screen.
+    if (failure) console.error(`[TeamClaude] Drain failed: ${failure}`);
     process.exit(RESTART_EXIT_CODE);
   }
 

package/src/terminal-title.js

@@ -1,5 +1,5 @@
 // Reflect the active account and the running build in the terminal title (e.g.
-// "teamclaude 2/4 work 1.1.20-rik.11"), so a backgrounded or tabbed
+// "teamclaude 2/4 work 1.1.20-rik.12+acc19b3"), so a backgrounded or tabbed
 // `teamclaude server` is glanceable without switching to it. Pure/side-effect-
 // free here so it can be unit-tested; the caller owns the TTY gate and the
 // interval.
@@ -32,9 +32,13 @@ function truncate(s, max) {
 export function formatTerminalTitle({ index = 0, total = 0, name = null, version = null } = {}) {
   const pos = total > 0 ? `${index + 1}/${total}` : '0/0';
   const who = name ? ` ${truncate(name, 24)}` : '';
-  // Bounded like the account name, for the same reason: a tab strip gives a
-  // title a few dozen columns at best, and neither string was chosen here.
-  const build = version ? ` ${truncate(version, 20)}` : '';
+  // Bounded like the account name, at the same width and for the same reason: a
+  // tab strip gives a title a few dozen columns at best, and neither string was
+  // chosen here. 24 rather than 20 because a checkout names both halves of what
+  // it runs — `1.1.20-rik.12+acc19b3`, 21 columns — and cutting that at 20 ends
+  // the title in half a sha, which names no commit while reading like it does.
+  // A label still long enough to be cut at 24 was never one of ours.
+  const build = version ? ` ${truncate(version, 24)}` : '';
   return `teamclaude ${pos}${who}${build}`;
 }
 

package/src/tui.js

@@ -287,19 +287,31 @@ export function fitLine(s, w) {
 
 /** The build label at `max` columns, or '' when nothing legible fits.
  *
- *  Cut from the LEFT, unlike every other truncation here, because what tells
- *  one build from the next is its tail: `…rik.11` still identifies the build,
- *  `1.1.2…` identifies the three before it just as well. 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.
+ *  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;
+ *  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.
+ *
+ *  What is left is cut from the LEFT, unlike every other truncation here,
+ *  because what tells one build from the next is its tail: `…rik.11` still
+ *  identifies the build, `1.1.2…` identifies the three before it just as well.
+ *  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.
  *  @param {string} label
  *  @param {number} max */
 export function fitHeadLabel(label, max) {
-  const w = vw(label);
-  if (max >= w) return label;
+  if (max >= vw(label)) return label;
+  // Everything after the last `+` is semver build metadata, which is by
+  // definition not the identity — so it is what gets spent first. `> 0` keeps a
+  // label that is nothing but metadata from being spent down to nothing.
+  const plus = label.lastIndexOf('+');
+  const bare = plus > 0 ? label.slice(0, plus) : label;
+  if (max >= vw(bare)) return bare;
   if (max < HEAD_LABEL_MIN) return '';
-  return `…${label.slice(label.length - (max - 1))}`;
+  return `…${bare.slice(bare.length - (max - 1))}`;
 }
 
 function formatReset(resetTs) {
@@ -492,6 +504,15 @@ export class TUI {
     this.frame = 0;
     this.running = false;
     this.timer = null;
+    // Set while THIS PROCESS is draining to be relaunched: when the wait
+    // started, what bounds it, and how to ask how much is still running.
+    // Deliberately not named `draining`: the header's `drain N` marker and the
+    // account manager's drainingCount() are SESSION draining — sessions being
+    // moved off an account during a rotation — and the two have nothing to do
+    // with each other. One is a request finishing somewhere else; this one is
+    // the process going away.
+    /** @type {{ startedAt: number, deadlineMs: number, inFlight: () => number }|null} */
+    this._restartDrain = null;
     // Injectable so a test can drive the repaint tick by hand instead of
     // sleeping through real 500ms/5s intervals.
     this._setTimeout = setTimeout;
@@ -570,8 +591,11 @@ export class TUI {
     this._scheduleTick();
   }
 
-  /** Fast while something is animating, slow when there is nothing to animate. */
-  _tickDelay() { return this.active.size > 0 ? SPIN_MS : IDLE_TICK_MS; }
+  /** Fast while something is animating, slow when there is nothing to animate.
+   *  A restart drain counts as animating: an idle tick is five seconds, and an
+   *  elapsed counter that moves once every five of them reads as a frozen
+   *  screen — which is the complaint keeping the display up exists to answer. */
+  _tickDelay() { return (this.active.size > 0 || this._restartDrain) ? SPIN_MS : IDLE_TICK_MS; }
 
   _scheduleTick() {
     if (!this.running) return;
@@ -626,6 +650,28 @@ export class TUI {
     process.stdin.pause();
   }
 
+  /**
+   * The server has begun draining to be relaunched: its listener is closed and
+   * it is waiting out the requests still running before it exits on 75.
+   *
+   * The display stays up for all of it, and this is what puts the drain on it.
+   * The wait is up to 30 seconds the operator asked for by pressing `u`, and
+   * the two things they want from it — how long it has run, and what is still
+   * holding it — are already here. The dashboard used to come down first, so
+   * the answer to both was a blank console for the duration.
+   *
+   * There is no matching "ended": the process exits at the end of the drain,
+   * and stop() is what takes the screen back (index.js, immediately before the
+   * exit and on every abrupt way out of one).
+   *
+   * @param {{ deadlineMs: number, inFlight: () => number }} drain
+   */
+  restartDrainStarted({ deadlineMs, inFlight }) {
+    this._restartDrain = { startedAt: Date.now(), deadlineMs, inFlight };
+    this._retick();   // idle cadence → something to animate again
+    if (this.running) this.render();
+  }
+
   // A title lookup costs a directory scan and a file read, so it stays off the
   // render path: this returns what is cached and schedules the rest.
   _sessionTag(sid) {
@@ -702,6 +748,17 @@ export class TUI {
   _key(k) {
     if (k === 'ctrl-c') { this.stop(); this.onQuit?.(); return; }
 
+    // Draining to a restart: the listener is closed and this process is on its
+    // way out, so switching, disabling, probing, syncing or editing anything
+    // would act on state that is about to be discarded, and `u` is already
+    // running. Ctrl-c above stays the one key that means something — the escape
+    // from the wait — and the footer says so, which is why nothing is logged
+    // for the rest: a line per keypress would push the drain's own progress out
+    // of the pane. `q` is not an exception on purpose. An unattended restart
+    // can begin while the operator is typing into a prompt, and a letter key
+    // that quietly became "quit" is a poor way to find that out.
+    if (this._restartDrain) return;
+
     switch (this.mode) {
       case 'normal': this._keyNormal(k); break;
       case 'select': this._keySelect(k); break;
@@ -1157,12 +1214,15 @@ export class TUI {
 
   // `u`: pick up a new build now instead of waiting for the next lull. The
   // server owns what happens next — it drains, then exits asking to be
-  // relaunched — and it stops this TUI first, so the line below is on screen
-  // only for the instant before the display goes and the drain reports itself
-  // in plain text.
+  // relaunched — and it now keeps this TUI up for the whole drain, which is
+  // where the progress goes (restartDrainStarted, and the footer). Its own
+  // "draining, up to 30s" line lands in the pane beside the counter, so there
+  // is nothing left for this to announce.
+  //
+  // A second `u` is not a second restart: the server guards on its own flag and
+  // would do nothing at all, so a log line here would be a claim that it had.
   _doRestart() {
-    if (!this.onRestart) return;
-    this._addLog('Draining before restart...');
+    if (!this.onRestart || this._restartDrain) return;
     this.onRestart();
   }
 
@@ -1712,7 +1772,7 @@ export class TUI {
 
     // ── Footer
     lines.push(' ' + dim('─'.repeat(W - 2)));
-    lines.push(this._renderFooter());
+    lines.push(this._renderFooter(W));
 
     // Write buffer
     let buf = `${ESC}H`;
@@ -2317,7 +2377,12 @@ export class TUI {
     }
   }
 
-  _renderFooter() {
+  /** @param {number} [W]  columns to compose against; only the drain line uses it */
+  _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.
+    if (this._restartDrain) return this._restartDrainFooter(this._restartDrain, W);
     switch (this.mode) {
       case 'normal':
         return this.remote
@@ -2354,4 +2419,30 @@ export class TUI {
         return '';
     }
   }
+
+  /**
+   * 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
+   * way out of it.
+   *
+   * Elapsed against the deadline, not a countdown. The drain ends when the last
+   * request does, which is usually long before 30s, so a number counting down
+   * to a moment that will not arrive would be the wrong kind of wrong — worse
+   * than one counting up to a bound that may never be reached.
+   *
+   * Whole seconds: the frame is composed twice a second while a drain runs, and
+   * tenths would buy a full repaint every time for a digit nobody reads.
+   *
+   * Cut by dropping a whole clause rather than by leaving it to fitLine, which
+   * truncates the tail — and at 40 columns the tail is the escape hatch.
+   *
+   * @param {{ startedAt: number, deadlineMs: number, inFlight: () => number }} drain
+   * @param {number} W
+   */
+  _restartDrainFooter(drain, W) {
+    const secs = Math.max(0, Math.round((Date.now() - drain.startedAt) / 1000));
+    const state = `${yellow('Restarting')}  ${secs}s/${Math.round(drain.deadlineMs / 1000)}s  ${drain.inFlight()} in flight`;
+    const lines = [` ${state}  ${dim('ctrl-c to go now')}`, ` ${state}`];
+    return lines.find(line => vw(line) <= W) ?? lines[lines.length - 1];
+  }
 }

package/src/updater.js

@@ -44,9 +44,22 @@ export function currentVersion(root = packageRoot()) {
 
 /**
  * How the running copy identifies itself, for display: the exact tag when the
- * checkout sits on one, else the short sha, else the shipped package.json
- * version, else the literal `local`. `git` reports a checkout — npm cannot
- * update one, so nothing should offer to.
+ * checkout sits on one, else the package.json version joined to the short sha,
+ * else whichever of those two is readable, else the literal `local`. `git`
+ * reports a checkout — npm cannot update one, so nothing should offer to.
+ *
+ * A checkout needs both halves. The sha is here because package.json alone
+ * cannot tell a published release from a local tarball built out of it, so the
+ * sha is what marks a checkout at a glance. But it answers "which commit", and
+ * the question asked after a restart is "which build" — which a sha never
+ * answers, and which is the whole reason this label exists. The two are joined
+ * with `+`, semver's build metadata, because that is precisely what the sha is:
+ * the same version, pinned to the build that produced it. It also tells a
+ * caller short of columns which end to spend, build metadata being by
+ * definition the part that is not the identity.
+ *
+ * A tag still wins outright, and alone: it names a release and a commit at
+ * once, so appending the sha to it would say the same thing twice.
  *
  * The git calls are pinned to the package root. `teamclaude server` is started
  * from the operator's own project directory, and resolving against the process
@@ -59,18 +72,22 @@ export function currentVersion(root = packageRoot()) {
  */
 export async function resolveVersionLabel({ root = packageRoot(), exec = pexec } = {}) {
   const git = existsSync(join(root, '.git'));
+  const version = currentVersion(root);
   if (git) {
     /** @type {{ cwd: string, encoding: 'utf8', timeout: number }} */
     const opts = { cwd: root, encoding: 'utf8', timeout: 2000 };
-    const probes = [['describe', '--tags', '--exact-match', 'HEAD'], ['rev-parse', '--short', 'HEAD']];
-    for (const args of probes) {
+    /** @param {string[]} args */
+    const ask = async (args) => {
       try {
-        const label = safeLine((await exec('git', args, opts)).stdout, LABEL_MAX);
-        if (label) return { label, git };
-      } catch { /* not on a tag, a shallow or broken checkout, or no git binary */ }
-    }
+        return safeLine((await exec('git', args, opts)).stdout, LABEL_MAX);
+      } catch { return ''; /* not on a tag, a shallow or broken checkout, or no git binary */ }
+    };
+    const tag = await ask(['describe', '--tags', '--exact-match', 'HEAD']);
+    if (tag) return { label: tag, git };
+    const sha = await ask(['rev-parse', '--short', 'HEAD']);
+    if (sha) return { label: safeLine(version ? `${version}+${sha}` : sha, LABEL_MAX), git };
   }
-  return { label: safeLine(currentVersion(root) || 'local', LABEL_MAX), git };
+  return { label: safeLine(version || 'local', LABEL_MAX), git };
 }
 
 /** Numeric compare of x.y.z, then the pre-release tail. >0 if a is newer.