@carjms/codexswitch 0.1.0 → 0.3.1

package/src/store.js

@@ -30,6 +30,9 @@ function loadMeta() {
   if (!meta.accounts) meta.accounts = {};
   if (!('active' in meta)) meta.active = null;
   if (!meta.cooldownMinutes) meta.cooldownMinutes = 60;
+  if (!meta.threshold5h) meta.threshold5h = 95;
+  if (!meta.thresholdWeekly) meta.thresholdWeekly = 95;
+  if (!Array.isArray(meta.limitPatterns)) meta.limitPatterns = [];
   return meta;
 }
 
@@ -83,6 +86,7 @@ function listAccounts() {
         priority: m.priority ?? 0,
         disabled: !!m.disabled,
         limitedUntil: m.limitedUntil || null,
+        usage: m.usage || null,
         active: meta.active === name,
       };
     })
@@ -91,14 +95,19 @@ function listAccounts() {
 
 // Copy refreshed tokens from a live auth.json back into the store, so a
 // token refresh done by codex itself is never lost when we switch accounts.
-// Matches by account_id; prefers the account we believe deployed the file.
+// Matches by email first: team-plan accounts share one chatgpt_account_id
+// per workspace, so matching by account_id alone would let two teammates'
+// tokens overwrite each other. Falls back to account_id for tokens without
+// an email claim. Prefers the account we believe deployed the file.
 function syncBackFrom(authFile) {
   const cur = readJSONSafe(authFile);
   if (!cur) return null;
   const curInfo = authInfo(cur);
   if (!curInfo.accountId) return null;
   const meta = loadMeta();
-  const candidates = listAccounts().filter((a) => a.accountId === curInfo.accountId);
+  const all = listAccounts();
+  const byEmail = curInfo.email ? all.filter((a) => a.email === curInfo.email) : [];
+  const candidates = byEmail.length > 0 ? byEmail : all.filter((a) => a.accountId === curInfo.accountId);
   if (candidates.length === 0) return null;
   const target = candidates.find((a) => a.name === meta.active) || candidates[0];
   const stored = readAccountAuth(target.name);
@@ -122,24 +131,78 @@ function markLimited(name, untilTs) {
   saveMeta(meta);
 }
 
-function clearLimited(name) {
+function clearLimited(name, { includeUsage = false } = {}) {
   const meta = loadMeta();
-  if (meta.accounts[name] && meta.accounts[name].limitedUntil) {
-    delete meta.accounts[name].limitedUntil;
+  const m = meta.accounts[name];
+  if (m && (m.limitedUntil || (includeUsage && m.usage))) {
+    delete m.limitedUntil;
+    if (includeUsage) delete m.usage;
     saveMeta(meta);
   }
 }
 
+function saveUsage(name, usage) {
+  const meta = loadMeta();
+  if (!meta.accounts[name]) meta.accounts[name] = {};
+  meta.accounts[name].usage = usage;
+  saveMeta(meta);
+}
+
+// An account is "over threshold" when its last recorded 5h/weekly usage
+// exceeds the configured percentage and the window has not reset yet.
+// Returns the blocking window ('5h' | 'weekly') or null.
+function overThreshold(account, meta, now = Date.now()) {
+  const u = account.usage;
+  if (!u) return null;
+  const checks = [
+    ['5h', u.p5h, meta.threshold5h],
+    ['weekly', u.weekly, meta.thresholdWeekly],
+  ];
+  for (const [label, win, threshold] of checks) {
+    if (!win || typeof win.pct !== 'number') continue;
+    if (win.pct < threshold) continue;
+    // Trust the snapshot only while its window can still be in effect.
+    if (win.resetAt) {
+      if (win.resetAt > now) return label;
+    } else if (win.windowMinutes && u.at + win.windowMinutes * 60000 > now) {
+      return label;
+    }
+  }
+  return null;
+}
+
+function isUsable(account, meta, now = Date.now()) {
+  if (account.disabled) return false;
+  if (account.limitedUntil && account.limitedUntil > now) return false;
+  if (overThreshold(account, meta, now)) return false;
+  return true;
+}
+
 // Pick the best usable account: enabled, not currently rate-limited,
-// lowest priority number first. `exclude` skips accounts already tried.
+// lowest priority number first (the order set by "order"/"priority").
+// The active account only wins ties within the same priority, so an
+// explicit order is always respected. `exclude` skips accounts already tried.
 function pickAccount(exclude = []) {
   const now = Date.now();
-  const usable = listAccounts().filter(
-    (a) => !a.disabled && !exclude.includes(a.name) && (!a.limitedUntil || a.limitedUntil <= now)
-  );
+  const meta = loadMeta();
+  const usable = listAccounts().filter((a) => !exclude.includes(a.name) && isUsable(a, meta, now));
   if (usable.length === 0) return null;
-  const active = usable.find((a) => a.active);
-  return active || usable[0];
+  const group = usable.filter((a) => a.priority === usable[0].priority);
+  return group.find((a) => a.active) || group[0];
+}
+
+// Next usable account after the active one, following priority order and
+// wrapping around — so repeated "next" cycles through the configured order.
+function nextAccount() {
+  const all = listAccounts();
+  const now = Date.now();
+  const meta = loadMeta();
+  const start = all.findIndex((a) => a.active);
+  for (let i = 1; i <= all.length; i++) {
+    const cand = all[(start + i) % all.length];
+    if (!cand.active && isUsable(cand, meta, now)) return cand;
+  }
+  return null;
 }
 
 module.exports = {
@@ -155,7 +218,11 @@ module.exports = {
   syncBackFrom,
   markLimited,
   clearLimited,
+  saveUsage,
+  overThreshold,
+  isUsable,
   pickAccount,
+  nextAccount,
   ensureDirs() {
     const p = paths();
     ensureDir(p.home);