@dst-justin/relay 2.2.6 → 2.2.7

package/README.md

@@ -223,6 +223,13 @@ Sessions live in `~/.claude/projects/` and are shared across all accounts — af
 
 ## Changelog
 
+### v2.2.7 — 2026-07-05
+- `relay lock <name>` / `relay unlock <name>`: lock an account so it won't be cycled back to when over its usage threshold
+- `relay lock` (no args): show locked accounts
+- Autoswitch daemon now auto-enables with default 80% threshold when 2+ accounts exist — no config required
+- Cycling follows `order` sequence; locked+over-threshold accounts are skipped; if all candidates are blocked, stays on current account and notifies
+- Lock badge (🔒) shown in `relay list` and `relay autoswitch status`
+
 ### v2.2.6 — 2026-07-04
 - `relay status -f` / `relay status --follow`: live-refresh current account status, same 30-second interval as `relay list -f`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dst-justin/relay",
-  "version": "2.2.6",
+  "version": "2.2.7",
   "description": "Multi-account switcher for Claude Code — instant credential swap across macOS, Linux, and Windows",
   "bin": {
     "relay": "./relay.js"

package/relay

@@ -136,6 +136,14 @@ mode, creds_dir, meta_dir, current = sys.argv[1], sys.argv[2], sys.argv[3], sys.
 no_usage = '--no-usage' in sys.argv
 relay_dir = os.path.dirname(creds_dir)
 cache_file = os.path.join(relay_dir, 'usage_cache.json')
+
+# Load locks from autoswitch config (best-effort, no error if missing)
+_locks = []
+try:
+    _as_cfg = json.load(open(os.path.join(relay_dir, 'autoswitch.json')))
+    _locks = _as_cfg.get('locks', [])
+except Exception:
+    pass
 CACHE_TTL = 120  # seconds
 
 R='\033[0m'; B='\033[1m'; D='\033[2m'
@@ -316,7 +324,8 @@ if mode == 'quick':
         ncol = GR + B if cur else B
         email = get_email(name)
         u = u5_str(usage.get(name)) if not no_usage else ''
-        print(f'  {marker}  {ncol}{name:<12}{R}  {D}{email:<26}{R}  {u}')
+        lock_badge = f' {YL}🔒{R}' if name in _locks else ''
+        print(f'  {marker}  {ncol}{name:<12}{R}  {D}{email:<26}{R}  {u}{lock_badge}')
     print()
     print(f'  {D}switch:{R} {CY}!relay <index or name>{R}   {D}details:{R} {CY}!relay status{R}')
     print()
@@ -331,8 +340,9 @@ else:
         d = usage.get(name)
         u5 = u5_str(d) if not no_usage else '—'
         u7 = u7_str(d, name) if not no_usage else '—'
+        lock_badge = f' {YL}🔒{R}' if name in _locks else ''
         # ANSI codes don't consume display width — pad manually for alignment
-        print(f'  {marker} {D}{i:<2}{R}{ncol}{name:<12}{R} {email:<28} {u5:<52} {u7}')
+        print(f'  {marker} {D}{i:<2}{R}{ncol}{name:<12}{R} {email:<28} {u5:<52} {u7}{lock_badge}')
     print()
     n_warn = sum(1 for d in usage.values() if isinstance(d, dict) and (d.get('five_hour') or {}).get('utilization', 0) >= 80)
     if n_warn:
@@ -998,6 +1008,14 @@ def get_utilization(usage_data):
     u = fh.get('utilization')
     return int(u) if u is not None else None
 
+def is_blocked(name, thr_map, locks_list, usage_map):
+    """True if account is locked AND at or over its threshold — skip as switch target."""
+    if name not in locks_list:
+        return False
+    util = get_utilization(usage_map.get(name))
+    threshold = thr_map.get(name, 80)
+    return util is not None and util >= threshold
+
 # ── manual switch protection ───────────────────────────────────────
 def get_manual_switch():
     try: return json.load(open(MANUAL_FILE))
@@ -1009,8 +1027,21 @@ def clear_manual_switch():
 
 # ── main loop ─────────────────────────────────────────────────────
 def load_config():
-    try: return json.load(open(CONFIG_FILE))
-    except: return None
+    try:
+        return json.load(open(CONFIG_FILE))
+    except:
+        # Auto-default: 2+ accounts → enable with 80% threshold, no explicit config needed
+        if not os.path.isdir(CREDS_DIR):
+            return None
+        accounts = sorted(f[:-5] for f in os.listdir(CREDS_DIR) if f.endswith('.json'))
+        if len(accounts) < 2:
+            return None
+        return {
+            'order': accounts,
+            'thresholds': {a: 80 for a in accounts},
+            'locks': [],
+            'poll': {'low_minutes': 10, 'high_minutes': 2, 'high_threshold': 50}
+        }
 
 def main():
     check_single_instance()
@@ -1034,6 +1065,7 @@ def main():
 
         order = cfg.get('order', [])
         thresholds = cfg.get('thresholds', {})
+        locks = cfg.get('locks', [])
         poll = cfg.get('poll', {})
         low_min   = int(poll.get('low_minutes', 10))
         high_min  = int(poll.get('high_minutes', 2))
@@ -1061,21 +1093,23 @@ def main():
         if cur_threshold is None or cur_util is None or cur_util < cur_threshold:
             time.sleep(sleep_sec); continue
 
-        candidates = [(n, get_utilization(usage.get(n))) for n in order if n != current]
-        under = [(n, u) for n, u in candidates if u is not None and thresholds.get(n) is not None and u < thresholds[n]]
-
-        if under:
-            target, target_util = under[0]
-        else:
-            measured = [(n, u) for n, u in candidates if u is not None]
-            if not measured:
-                time.sleep(sleep_sec); continue
-            target, target_util = min(measured, key=lambda x: x[1])
-            log_event('all_over_threshold', selected=target, usage=target_util)
-            notify('relay', f'All accounts over threshold — switching to {target} ({target_util}%)')
-            do_switch(target)
-            time.sleep(sleep_sec); continue
-
+        # Ordered cycling: walk order[] from current position, skip blocked accounts
+        idx = order.index(current) if current in order else 0
+        target = None
+        for i in range(1, len(order)):
+            candidate = order[(idx + i) % len(order)]
+            if not is_blocked(candidate, thresholds, locks, usage):
+                target = candidate
+                break
+
+        if target is None:
+            # All candidates are locked + over threshold — stay put
+            log_event('all_blocked', current=current)
+            notify('relay', 'All accounts at limit — staying on current account')
+            time.sleep(sleep_sec)
+            continue
+
+        target_util = get_utilization(usage.get(target))
         log_event('switch', frm=current, to=target, usage=cur_util)
         notify('relay', f'switched {current} → {target} ({current} at {cur_util}%)')
         do_switch(target)
@@ -1314,6 +1348,7 @@ cfg = json.load(open(sys.argv[1]))
 current = sys.argv[2]
 order = cfg.get('order', [])
 thresholds = cfg.get('thresholds', {})
+locks = cfg.get('locks', [])
 relay_dir = os.path.expanduser('~/.claude-relay')
 cache_file = os.path.join(relay_dir, 'usage_cache.json')
 
@@ -1332,8 +1367,8 @@ def get_util(name):
     u = fh.get('utilization')
     return int(u) if u is not None else None
 
-print(f'  {B}{"order":<4} {"account":<14} {"threshold":<12} {"cached usage":<14}{R}')
-print(f'  {D}{"─"*52}{R}')
+print(f'  {B}{"order":<4} {"account":<14} {"threshold":<12} {"cached usage":<14} {"lock":<6}{R}')
+print(f'  {D}{"─"*58}{R}')
 for i, name in enumerate(order, 1):
     cur = name == current
     marker = f'{GR}●{R}' if cur else ' '
@@ -1353,7 +1388,8 @@ for i, name in enumerate(order, 1):
             for j in range(i-1)
         )
         if prev_over: next_s = f' {CY}← next{R}'
-    print(f'  {marker} {D}{i:<2}{R}{ncol}{name:<14}{R} {thr_s:<12} {util_s}{next_s}')
+    lock_s = f' {YL}🔒{R}' if name in locks else ''
+    print(f'  {marker} {D}{i:<2}{R}{ncol}{name:<14}{R} {thr_s:<12} {util_s}{next_s}{lock_s}')
 
 log_file = os.path.join(os.path.dirname(sys.argv[1]), 'autoswitch.log')
 try:
@@ -1372,6 +1408,8 @@ EOF
   printf "  %-34s %s\n" "  ${CY}relay autoswitch stop${R}"   "stop daemon"
   printf "  %-34s %s\n" "  ${CY}relay autoswitch config${R}" "edit settings"
   printf "  %-34s %s\n" "  ${CY}relay autoswitch log${R}"    "switch history"
+  printf "  %-34s %s\n" "  ${CY}relay lock <name>${R}"       "lock account (skip when over threshold)"
+  printf "  %-34s %s\n" "  ${CY}relay unlock <name>${R}"     "remove lock"
   _show_update_notice
 }
 
@@ -1422,6 +1460,87 @@ cmd_autoswitch() {
   esac
 }
 
+cmd_lock() {
+  local name="${1:-}"
+  local cfg="${RELAY_DIR}/autoswitch.json"
+
+  # No argument: show lock status
+  if [[ -z "${name}" ]]; then
+    hdr "Account locks"
+    if [[ ! -f "${cfg}" ]]; then
+      warn "No autoswitch config. Run: relay autoswitch config"
+      return 0
+    fi
+    "${PY}" - "${cfg}" <<'PYEOF'
+import json, sys
+cfg = json.load(open(sys.argv[1]))
+locks = cfg.get('locks', [])
+R='\033[0m'; B='\033[1m'; D='\033[2m'; YL='\033[33m'
+if not locks:
+    print(f'  {D}No accounts locked.{R}')
+else:
+    for name in locks:
+        print(f'  {YL}🔒{R}  {B}{name}{R}')
+print()
+PYEOF
+    return 0
+  fi
+
+  account_exists "${name}" || { err "Account '${name}' not found"; exit 1; }
+
+  # Ensure config file exists (create auto-default if missing)
+  if [[ ! -f "${cfg}" ]]; then
+    "${PY}" - "${CREDS_STORE}" "${cfg}" <<'PYEOF'
+import json, sys, os
+creds_dir, cfg_path = sys.argv[1], sys.argv[2]
+accounts = sorted(f[:-5] for f in os.listdir(creds_dir) if f.endswith('.json'))
+config = {
+    'order': accounts,
+    'thresholds': {a: 80 for a in accounts},
+    'locks': [],
+    'poll': {'low_minutes': 10, 'high_minutes': 2, 'high_threshold': 50}
+}
+json.dump(config, open(cfg_path, 'w'), indent=2)
+PYEOF
+    ok "Created default autoswitch config: ${cfg}"
+  fi
+
+  "${PY}" - "${cfg}" "${name}" <<'PYEOF'
+import json, sys
+cfg_path, name = sys.argv[1], sys.argv[2]
+cfg = json.load(open(cfg_path))
+locks = cfg.get('locks', [])
+if name in locks:
+    print(f'  already locked: {name}')
+    sys.exit(0)
+locks.append(name)
+cfg['locks'] = locks
+json.dump(cfg, open(cfg_path, 'w'), indent=2)
+PYEOF
+  ok "Locked '${B}${name}${R}' — won't be switched back to when over threshold"
+}
+
+cmd_unlock() {
+  local name="${1:-}"
+  [[ -z "${name}" ]] && { err "usage: relay unlock <name>"; exit 1; }
+  local cfg="${RELAY_DIR}/autoswitch.json"
+  [[ ! -f "${cfg}" ]] && { warn "No autoswitch config — nothing to unlock"; return 0; }
+
+  "${PY}" - "${cfg}" "${name}" <<'PYEOF'
+import json, sys
+cfg_path, name = sys.argv[1], sys.argv[2]
+cfg = json.load(open(cfg_path))
+locks = cfg.get('locks', [])
+if name not in locks:
+    print(f'  not locked: {name}')
+    sys.exit(0)
+locks.remove(name)
+cfg['locks'] = locks
+json.dump(cfg, open(cfg_path, 'w'), indent=2)
+PYEOF
+  ok "Unlocked '${B}${name}${R}'"
+}
+
 _script_dir() {
   # Resolve symlinks so we find package.json even when installed via npm/symlink
   local src="$0"
@@ -1639,6 +1758,9 @@ cmd_help() {
   printf "  %-32s %s\n" "  relay autoswitch config"   "set up auto-switching"
   printf "  %-32s %s\n" "  relay autoswitch start/stop" "manage background daemon"
   printf "  %-32s %s\n" "  relay autoswitch status"   "daemon state + thresholds"
+  printf "  %-32s %s\n" "  relay lock <name>"         "prevent account from cycling back when over limit"
+  printf "  %-32s %s\n" "  relay unlock <name>"       "remove lock"
+  printf "  %-32s %s\n" "  relay lock"                "show locked accounts"
   echo ""
   printf "  ${D}switches the OAuth credential (macOS Keychain / Linux ~/.claude/.credentials.json); sessions are shared${R}\n"
   printf "  ${D}after switching: claude -c to resume, claude --resume <id> for a specific session${R}\n\n"
@@ -1676,6 +1798,8 @@ case "${CMD}" in
   rename|mv)        cmd_rename "$@" ;;
   sessions|sess)    cmd_sessions ;;
   autoswitch|as)    cmd_autoswitch "$@" ;;
+  lock)             cmd_lock "$@" ;;
+  unlock)           cmd_unlock "$@" ;;
   version|--version|-V) cmd_version ;;
   update)           cmd_update ;;
   install)          cmd_install ;;