@carjms/codexswitch 0.3.4 → 0.4.0

package/README.ko.md

@@ -203,14 +203,18 @@ cxs list                # 계정별 5h/week 사용량 % 확인
 | `cxs login [이름]` | 새 계정 로그인 후 저장 (기존 로그인 유지, 이름 생략 시 이메일 사용) |
 | `cxs import [이름]` | 현재 `~/.codex`에 로그인된 계정을 저장소로 가져오기 |
 | `cxs add-key <이름> [키]` | OpenAI API 키 계정 등록 (키 생략 시 `$OPENAI_API_KEY` 사용) |
-| `cxs list` | 계정 목록: 활성 표시(`*`), 이메일, 플랜, 우선순위, 한도 상태 |
+| `cxs list` | 계정 목록: 활성 표시, 이메일, 플랜, 우선순위, 한도 상태, 사용량 % |
+| `cxs usage [이름]` | 계정별 사용량 대시보드: 5시간/주간 게이지 바, 리셋 카운트다운, 다음 로테이션 계정 (별칭: `status`) |
+| `cxs watch` | 실시간 대시보드 — 5초마다 자동 갱신 + 최근 활동 표시 (q로 종료) |
+| `cxs probe [이름]` | 계정마다 최소 요청 1회를 보내 사용량 게이지 워밍업 (토큰 소량 소모) |
+| `cxs log [개수]` | 최근 활동 기록: 계정 전환, 한도 도달, 로테이션, 프로브 |
 | `cxs use <이름>` | 활성 계정 전환 |
 | `cxs current` | 현재 활성 계정 확인 |
 | `cxs next` | 설정된 순서의 다음 계정으로 전환 (끝에 오면 처음으로 순환) |
 | `cxs run [이름] [인자...]` | 전환 없이 특정 계정으로 codex 실행 (격리 환경) |
 | `cxs exec [인자...]` | `codex exec` + 한도 도달 시 순서대로 자동 로테이션 — 다음 계정이 같은 세션을 이어받음. git 저장소가 아닌 폴더에서도 동작 |
 | `cxs exec -a <이름> ...` | 특정 계정부터 exec 시작 (`--no-resume`: 이어받기 대신 처음부터 재시도) |
-| `cxs order [이름들...]` | 로테이션 순서를 한 번에 설정 (인자 없으면 현재 순서 표시) |
+| `cxs order [이름들...]` | 로테이션 순서 고정(pin); 나열하지 않은 계정은 **주간 리셋이 빠른 순**으로 자동 소진 (use-or-lose) |
 | `cxs model [모델명]` | `run`/`exec`에 자동 적용할 기본 모델 설정 (`default`로 초기화) |
 | `cxs threshold [5h%] [주간%]` | 사용량이 이 퍼센트에 도달하면 다음 계정으로 전환 (기본 95, 값 하나면 둘 다) |
 | `cxs patterns [add/remove]` | 한도 감지에 쓸 커스텀 정규식 패턴 추가/삭제 |
@@ -221,7 +225,7 @@ cxs list                # 계정별 5h/week 사용량 % 확인
 | `cxs remove <이름>` | 계정 삭제 |
 | `cxs rename <옛이름> <새이름>` | 계정 이름 변경 |
 | `cxs disable / enable <이름>` | 로테이션에서 임시 제외 / 복귀 |
-| `cxs priority <이름> <숫자>` | 계정 하나의 우선순위만 변경 (낮을수록 먼저, 기본 0) |
+| `cxs priority <이름> <숫자\|auto>` | 계정 하나의 순위 고정, `auto`면 고정 해제(리셋 빠른 순 자동 로테이션) |
 | `cxs clear-limit <이름>` | 기록된 한도 상태 수동 해제 |
 | `cxs cooldown [분]` | 한도 감지 시 기본 대기 시간 조회/설정 (기본 60분) |
 | `cxs sync` | codex가 갱신한 토큰을 저장소에 반영 |

package/README.md

@@ -205,14 +205,18 @@ cxs list                # per-account 5h/week usage columns
 | `cxs login [name]` | Log in to a new account and store it (existing login untouched; defaults to the email as the name) |
 | `cxs import [name]` | Import the account currently in `~/.codex` |
 | `cxs add-key <name> [key]` | Register an OpenAI API-key account (falls back to `$OPENAI_API_KEY`) |
-| `cxs list` | List accounts: active marker (`*`), email, plan, priority, limit status |
+| `cxs list` | List accounts: active marker, email, plan, priority, limit status, usage % |
+| `cxs usage [name]` | Per-account usage dashboard: 5h/weekly gauge bars, reset countdowns, next rotation pick (alias: `status`) |
+| `cxs watch` | Live dashboard — auto-refreshes every 5s with recent activity (q to quit) |
+| `cxs probe [name]` | Warm up the usage gauges with one minimal request per account (costs a few tokens) |
+| `cxs log [count]` | Recent activity: account switches, limits hit, rotations, probes |
 | `cxs use <name>` | Switch the active account |
 | `cxs current` | Show the active account |
 | `cxs next` | Switch to the next account in rotation order (wraps around) |
 | `cxs run [name] [args...]` | Run codex as a specific account without switching (isolated env) |
 | `cxs exec [args...]` | `codex exec` + automatic rotation on usage limits — the next account resumes the same session; works outside git repos |
 | `cxs exec -a <name> ...` | Start exec with a specific account (`--no-resume`: restart instead of resuming) |
-| `cxs order [names...]` | Set the rotation order in one command (no args: show it) |
+| `cxs order [names...]` | Pin the rotation order; unlisted accounts rotate by **soonest weekly reset** (use-or-lose) |
 | `cxs model [name]` | Set the default model injected into `run`/`exec` (`default` to reset) |
 | `cxs threshold [5h%] [wk%]` | Rotate to the next account when usage reaches these percents (default 95; one value sets both) |
 | `cxs patterns [add/remove]` | Custom regex patterns treated as rate-limit errors |
@@ -223,7 +227,7 @@ cxs list                # per-account 5h/week usage columns
 | `cxs remove <name>` | Delete an account |
 | `cxs rename <old> <new>` | Rename an account |
 | `cxs disable / enable <name>` | Temporarily exclude from / restore to rotation |
-| `cxs priority <name> <n>` | Change one account's priority (lower = preferred, default 0) |
+| `cxs priority <name> <n\|auto>` | Pin one account's priority, or `auto` to unpin (use-or-lose rotation) |
 | `cxs clear-limit <name>` | Manually clear a recorded rate-limit |
 | `cxs cooldown [minutes]` | Show/set the default cooldown after a limit is detected (default 60) |
 | `cxs sync` | Save tokens refreshed by codex back into the store |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carjms/codexswitch",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "Multi-account manager for OpenAI Codex CLI with quota-based rotation (inspired by KarpelesLab/teamclaude)",
   "license": "MIT",
   "repository": {

package/src/cli.js

@@ -14,7 +14,13 @@ Accounts
   login [name]            log in to a new account (isolated "codex login") and store it
   import [name]           import the account currently in ~/.codex/auth.json
   add-key <name> [key]    register an OpenAI API-key account (or read $OPENAI_API_KEY)
-  list                    list stored accounts (alias: accounts, status)
+  list                    list stored accounts (alias: accounts)
+  usage [name]            per-account 5h/weekly usage gauges with reset times
+                          (alias: status)
+  watch                   live usage dashboard, refreshes every 5s (q to quit)
+  probe [name]            warm up quota gauges with a minimal request per
+                          account (costs a few tokens; alias: warmup)
+  log [count]             recent activity: switches, limits, rotations
   use <name>              make <name> the active account in ~/.codex
   current                 show the active account
   next                    switch to the next account in rotation order (wraps around)
@@ -22,8 +28,9 @@ Accounts
   rename <old> <new>      rename a stored account
   enable <name>           re-enable a disabled account
   disable <name>          temporarily exclude an account from rotation
-  order [name...]         show or set the rotation order in one command
-  priority <name> <n>     set one account's priority (lower = preferred, default 0)
+  order [name...]         pin the rotation order in one command; accounts not
+                          listed rotate by soonest weekly reset (use-or-lose)
+  priority <name> <n|auto>  pin one account's priority, or "auto" to unpin
   clear-limit <name>      forget a recorded rate-limit for an account
 
 Running codex
@@ -84,7 +91,7 @@ function storeAccount(name, auth) {
   const existed = store.accountExists(name);
   store.writeAccountAuth(name, auth);
   const meta = store.loadMeta();
-  if (!meta.accounts[name]) meta.accounts[name] = { priority: 0, addedAt: Date.now() };
+  if (!meta.accounts[name]) meta.accounts[name] = { addedAt: Date.now() };
   // fresh credentials fix whatever got the account disabled or limited
   delete meta.accounts[name].disabled;
   delete meta.accounts[name].limitedUntil;
@@ -160,7 +167,7 @@ function cmdList() {
       a.active ? ui.bold(a.name) : a.name,
       ui.dim(a.email || '-'),
       a.plan,
-      a.priority,
+      a.priority == null ? ui.dim('auto') : a.priority,
       status,
       pct(a.usage && a.usage.p5h, meta.threshold5h),
       pct(a.usage && a.usage.weekly, meta.thresholdWeekly),
@@ -180,9 +187,10 @@ function cmdUse(args) {
   writeJSONAtomic(p.authPath, auth, 0o600);
   const meta = store.loadMeta();
   meta.active = name;
-  if (!meta.accounts[name]) meta.accounts[name] = { priority: 0 };
+  if (!meta.accounts[name]) meta.accounts[name] = {};
   meta.accounts[name].lastUsed = Date.now();
   store.saveMeta(meta);
+  store.logEvent('switch', `now using "${name}"`);
   const info = authInfo(auth);
   out(ui.ok(`now using ${ui.bold(`"${name}"`)}${info.email ? ui.dim(` (${info.email}, ${info.plan || 'unknown plan'})`) : ''}`));
 }
@@ -269,10 +277,18 @@ function setFlag(name, patch) {
 
 function cmdPriority(args) {
   const name = requireArg(args, 0, 'account name');
-  const n = parseInt(requireArg(args, 1, 'priority number'), 10);
-  if (Number.isNaN(n)) throw new Error('priority must be a number');
+  const value = requireArg(args, 1, 'priority number or "auto"');
+  if (value === 'auto') {
+    const meta = store.loadMeta();
+    if (meta.accounts[name]) delete meta.accounts[name].priority;
+    store.saveMeta(meta);
+    out(ui.ok(`"${name}" unpinned — rotates by soonest weekly reset (use-or-lose)`));
+    return;
+  }
+  const n = parseInt(value, 10);
+  if (Number.isNaN(n)) throw new Error('priority must be a number or "auto"');
   setFlag(name, { priority: n });
-  out(`priority of "${name}" set to ${n}`);
+  out(ui.ok(`priority of "${name}" pinned to ${n}`));
 }
 
 function cmdCooldown(args) {
@@ -315,13 +331,16 @@ function cmdOrder(args) {
   for (const name of args) {
     meta.accounts[name] = { ...(meta.accounts[name] || {}), priority: prio++ };
   }
+  // accounts not listed become "auto" and rotate by soonest weekly reset
   for (const a of accounts) {
     if (args.includes(a.name)) continue;
-    meta.accounts[a.name] = { ...(meta.accounts[a.name] || {}), priority: prio++ };
+    if (meta.accounts[a.name]) delete meta.accounts[a.name].priority;
   }
   store.saveMeta(meta);
-  out('rotation order set:');
-  store.listAccounts().forEach((a, i) => out(`${i + 1}. ${a.name}`));
+  out(ui.ok('rotation order set:'));
+  store.listAccounts().forEach((a, i) =>
+    out(`${i + 1}. ${a.name}${a.priority == null ? ui.dim(' (auto)') : ''}`)
+  );
 }
 
 function cmdModel(args) {
@@ -341,6 +360,138 @@ function cmdModel(args) {
   out(`default model set to "${meta.model}" (applied to run/exec)`);
 }
 
+// Per-account usage dashboard: gauge bars for the 5h / weekly windows with
+// reset countdowns, based on what codex recorded in its session files.
+function cmdUsage(args) {
+  const meta = store.loadMeta();
+  let accounts = store.listAccounts();
+  if (args[0]) {
+    accounts = accounts.filter((a) => a.name === args[0]);
+    if (accounts.length === 0) throw new Error(`no such account: ${args[0]}`);
+  }
+  if (accounts.length === 0) {
+    out('no accounts yet — add one with "codexswitch login" or "codexswitch import"');
+    return;
+  }
+  const now = Date.now();
+  const bar = (pct, threshold) => {
+    const width = 20;
+    const filled = Math.max(0, Math.min(width, Math.round((pct / 100) * width)));
+    const paint = pct >= threshold ? ui.red : pct >= 70 ? ui.yellow : ui.green;
+    return `[${paint('█'.repeat(filled))}${ui.dim('░'.repeat(width - filled))}]`;
+  };
+  const line = (label, win, threshold) => {
+    if (!win || typeof win.pct !== 'number') return `  ${label} ${ui.dim('no data')}`;
+    const pct = Math.round(win.pct);
+    const reset = win.resetAt && win.resetAt > now ? ` resets in ${fmtRemaining(win.resetAt)}` : '';
+    const overMark = win.pct >= threshold ? ` ${ui.red(`≥ threshold ${threshold}%`)}` : '';
+    return `  ${label} ${bar(win.pct, threshold)} ${String(pct).padStart(3)}%${ui.dim(reset)}${overMark}`;
+  };
+  for (const a of accounts) {
+    const mark = a.active ? ui.green('●') : ' ';
+    const state = a.disabled ? ui.red(' [disabled]') : a.limitedUntil && a.limitedUntil > now ? ui.yellow(` [limited ${fmtRemaining(a.limitedUntil)}]`) : '';
+    out(`${mark} ${ui.bold(a.name)}${ui.dim(` (${a.plan || a.email || '-'})`)}${state}`);
+    if (!a.usage) {
+      out(ui.dim('  no usage data yet — codex records it during runs (try "codexswitch run" once)'));
+    } else {
+      out(line('5h    ', a.usage.p5h, meta.threshold5h));
+      out(line('weekly', a.usage.weekly, meta.thresholdWeekly));
+      if (a.usage.at) out(ui.dim(`  measured ${fmtDate(a.usage.at)}`));
+    }
+  }
+  const next = store.pickAccount();
+  out(ui.dim(`\nrotation would pick: ${next ? next.name : '(none usable)'} · threshold 5h ${meta.threshold5h}% / weekly ${meta.thresholdWeekly}%`));
+}
+
+// Warm up quota measurements: send a minimal request per account so the
+// usage gauges (and use-or-lose ordering) have data. Costs a few tokens.
+async function cmdProbe(args) {
+  runner.assertCodexAvailable();
+  const meta = store.loadMeta();
+  let accounts = store.listAccounts().filter((a) => !a.disabled);
+  if (args[0]) {
+    accounts = accounts.filter((a) => a.name === args[0]);
+    if (accounts.length === 0) throw new Error(`no such account: ${args[0]}`);
+  }
+  if (accounts.length === 0) throw new Error('no enabled accounts to probe');
+  out(ui.info(ui.dim(`probing ${accounts.length} account(s) with a minimal request...`)));
+  let failures = 0;
+  for (const a of accounts) {
+    const startTs = Date.now();
+    const res = await runner.runCodex(
+      a.name,
+      ['exec', ...buildExecArgs(['Reply with exactly: ok'], meta)],
+      { capture: true, silent: true }
+    );
+    const usage = runner.recordUsage(a.name, res.profile, startTs);
+    if (res.code !== 0) {
+      failures++;
+      const why = runner.looksAuthFailed(res.output)
+        ? `login revoked — fix with "codexswitch login ${a.name}"`
+        : runner.looksRateLimited(res.output, meta.limitPatterns)
+          ? 'rate limited'
+          : `exit ${res.code}`;
+      out(ui.fail(`${a.name}: ${why}`));
+      store.logEvent('probe', `${a.name} failed: ${why}`);
+    } else if (usage && usage.p5h) {
+      out(ui.ok(`${a.name}: 5h ${Math.round(usage.p5h.pct)}%${usage.weekly ? ` / weekly ${Math.round(usage.weekly.pct)}%` : ''}`));
+      store.logEvent('probe', `${a.name} measured`);
+    } else {
+      out(ui.warn(`${a.name}: reachable, but codex reported no usage data`));
+    }
+  }
+  return failures > 0 ? 1 : 0;
+}
+
+function cmdLog(args) {
+  const count = args[0] ? parseInt(args[0], 10) : 20;
+  if (Number.isNaN(count) || count < 1) throw new Error('usage: codexswitch log [count]');
+  const events = store.readEvents(count);
+  if (events.length === 0) {
+    out('no activity yet');
+    return;
+  }
+  const color = { limit: ui.yellow, auth: ui.red, probe: ui.cyan, switch: ui.green, exec: ui.green };
+  for (const e of events) {
+    const paint = color[e.type] || ((s) => s);
+    out(`${ui.dim(e.at.replace('T', ' ').slice(0, 19))}  ${paint(e.type.padEnd(6))} ${e.message}`);
+  }
+}
+
+// Live dashboard: re-renders the usage view every few seconds until "q".
+async function cmdWatch() {
+  if (!process.stdout.isTTY) {
+    cmdUsage([]);
+    return 0;
+  }
+  const render = () => {
+    process.stdout.write('\x1b[2J\x1b[H');
+    out(`${ui.bold('codexswitch watch')}${ui.dim(`  ${new Date().toLocaleTimeString()} · refreshes every 5s · q to quit`)}\n`);
+    cmdUsage([]);
+    const events = store.readEvents(5);
+    if (events.length > 0) {
+      out(ui.dim('\nrecent activity:'));
+      for (const e of events) out(ui.dim(`  ${e.at.replace('T', ' ').slice(11, 19)}  ${e.type}: ${e.message}`));
+    }
+  };
+  render();
+  const timer = setInterval(render, 5000);
+  await new Promise((resolve) => {
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('data', (b) => {
+      const s = b.toString();
+      if (s === 'q' || s === '\u0003') {
+        clearInterval(timer);
+        if (process.stdin.isTTY) process.stdin.setRawMode(false);
+        process.stdin.pause();
+        resolve();
+      }
+    });
+  });
+  return 0;
+}
+
 // Rotate-early thresholds: how full the 5h / weekly window may get before
 // the account is skipped in rotation.
 function cmdThreshold(args) {
@@ -424,7 +575,7 @@ function cmdNames() {
 }
 
 const COMMANDS =
-  'login import add-key list use current next run exec order model remove rename ' +
+  'login import add-key list usage watch probe log use current next run exec order model remove rename ' +
   'enable disable priority clear-limit cooldown threshold patterns export restore sync completion help';
 
 function cmdCompletion(args) {
@@ -533,6 +684,7 @@ async function cmdExec(args) {
     if (res.code === 0) {
       store.clearLimited(name);
       console.error(ui.ok(`done as ${ui.bold(`"${name}"`)}`));
+      store.logEvent('exec', `done as "${name}"${useResume ? ' (resumed session)' : ''}`);
       warnIfOverThreshold(name);
       return 0;
     }
@@ -545,6 +697,7 @@ async function cmdExec(args) {
       console.error(
         ui.warn(`"${name}" hit a usage/rate limit (paused until ${fmtDate(until)}) — rotating${useResume ? ' and resuming the session' : ''}`)
       );
+      store.logEvent('limit', `"${name}" paused until ${fmtDate(until)}`);
       continue;
     }
     if (runner.looksAuthFailed(res.output)) {
@@ -554,6 +707,7 @@ async function cmdExec(args) {
       console.error(
         ui.fail(`"${name}" has a revoked/invalid login — disabled. Fix it with: ${ui.bold(`codexswitch login ${name}`)}`)
       );
+      store.logEvent('auth', `"${name}" disabled (revoked login)`);
       continue;
     }
     return res.code; // real failure, don't burn other accounts on it
@@ -595,8 +749,19 @@ async function main(argv) {
       return cmdImport(args), 0;
     case 'list':
     case 'accounts':
-    case 'status':
       return cmdList(), 0;
+    case 'usage':
+    case 'status':
+      return cmdUsage(args), 0;
+    case 'watch':
+    case 'dashboard':
+      return cmdWatch();
+    case 'probe':
+    case 'warmup':
+      return cmdProbe(args);
+    case 'log':
+    case 'activity':
+      return cmdLog(args), 0;
     case 'use':
       return cmdUse(args), 0;
     case 'current':

package/src/runner.js

@@ -164,7 +164,8 @@ function refreshCopy(target, dest) {
 // Run codex for one account inside its overlay profile.
 // capture=false: interactive, stdio inherited. capture=true: stream output
 // through while also collecting it so the caller can detect limit errors.
-function runCodex(name, args, { capture = false } = {}) {
+// silent=true (with capture): collect without echoing (used by probe).
+function runCodex(name, args, { capture = false, silent = false } = {}) {
   assertCodexAvailable();
   const profile = buildProfile(name);
   const env = { ...process.env, CODEX_HOME: profile };
@@ -182,7 +183,7 @@ function runCodex(name, args, { capture = false } = {}) {
         stream.on('data', (chunk) => {
           out += chunk.toString('utf8');
           if (out.length > 262144) out = out.slice(-131072);
-          dest.write(chunk);
+          if (!silent) dest.write(chunk);
         });
       };
       collect(child.stdout, process.stdout);

package/src/store.js

@@ -36,6 +36,34 @@ function loadMeta() {
   return meta;
 }
 
+// Append an event to the activity log (rotations, limits, auth failures...).
+function logEvent(type, message) {
+  try {
+    ensureDir(paths().home);
+    fs.appendFileSync(
+      path.join(paths().home, 'activity.log'),
+      JSON.stringify({ at: new Date().toISOString(), type, message }) + '\n'
+    );
+  } catch {
+    /* logging must never break the tool */
+  }
+}
+
+function readEvents(count = 20) {
+  try {
+    const lines = fs.readFileSync(path.join(paths().home, 'activity.log'), 'utf8').trim().split('\n');
+    return lines.slice(-count).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
 function saveMeta(meta) {
   writeJSONAtomic(paths().metaPath, meta);
 }
@@ -83,14 +111,27 @@ function listAccounts() {
       return {
         name,
         ...authInfo(auth),
-        priority: m.priority ?? 0,
+        priority: m.priority ?? null, // null = auto (use-or-lose ordering)
         disabled: !!m.disabled,
         limitedUntil: m.limitedUntil || null,
         usage: m.usage || null,
         active: meta.active === name,
       };
     })
-    .sort((a, b) => a.priority - b.priority || a.name.localeCompare(b.name));
+    .sort(rotationCompare);
+}
+
+// Rotation order: pinned accounts (explicit priority) come first in pin
+// order; auto accounts follow, spending the one whose weekly quota resets
+// soonest first (use-or-lose — quota about to refresh anyway gets burned
+// first). Ties prefer the active account to avoid needless switching.
+function rotationCompare(a, b) {
+  const aPinned = a.priority != null;
+  const bPinned = b.priority != null;
+  if (aPinned !== bPinned) return aPinned ? -1 : 1;
+  if (aPinned && a.priority !== b.priority) return a.priority - b.priority;
+  const reset = (x) => (x.usage && x.usage.weekly && x.usage.weekly.resetAt) || Infinity;
+  return reset(a) - reset(b) || Number(b.active) - Number(a.active) || a.name.localeCompare(b.name);
 }
 
 // Copy refreshed tokens from a live auth.json back into the store, so a
@@ -187,8 +228,10 @@ function pickAccount(exclude = []) {
   const meta = loadMeta();
   const usable = listAccounts().filter((a) => !exclude.includes(a.name) && isUsable(a, meta, now));
   if (usable.length === 0) return null;
-  const group = usable.filter((a) => a.priority === usable[0].priority);
-  return group.find((a) => a.active) || group[0];
+  // listAccounts is already in rotation order (pins first, then use-or-lose,
+  // active as tiebreaker) — but a pinned tie should still stick to active.
+  const top = usable.filter((a) => a.priority != null && a.priority === usable[0].priority);
+  return top.find((a) => a.active) || usable[0];
 }
 
 // Next usable account after the active one, following priority order and
@@ -223,6 +266,8 @@ module.exports = {
   isUsable,
   pickAccount,
   nextAccount,
+  logEvent,
+  readEvents,
   ensureDirs() {
     const p = paths();
     ensureDir(p.home);

package/src/util.js

@@ -85,6 +85,7 @@ function fmtRemaining(untilTs) {
   if (ms <= 0) return 'now';
   const h = Math.floor(ms / 3600000);
   const m = Math.round((ms % 3600000) / 60000);
+  if (h >= 48) return `${Math.floor(h / 24)}d${h % 24}h`;
   return h > 0 ? `${h}h${m}m` : `${m}m`;
 }