cdx-manager 0.5.5 → 0.5.6

package/README.md

@@ -1,6 +1,6 @@
 # CDX Manager
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.5.5-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.5.6-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Run multiple Codex and Claude sessions from one terminal. Switch between accounts instantly.**
 
@@ -126,7 +126,7 @@ For a specific version:
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
-CDX_VERSION=v0.5.5 sh install.sh
+CDX_VERSION=v0.5.6 sh install.sh
 ```
 
 From source:
@@ -258,8 +258,8 @@ cdx status
 | `cdx doctor [--json]` | Inspect CLI dependencies, CDX_HOME permissions, missing state, orphan profiles, and pending quarantines |
 | `cdx repair [--dry-run] [--force] [--json]` | Plan or apply safe repairs for missing state files, quarantines, and orphan profiles |
 | `cdx update [--check] [--yes] [--json] [--version TAG]` | Update cdx-manager using the installer that matches how it was installed |
-| `cdx notify <name> --at-reset [--poll seconds] [--once] [--json]` | Wait for a session reset time and send a desktop notification when due |
-| `cdx notify --next-ready [--poll seconds] [--once] [--json]` | Wait until the recommended session is usable or needs a refresh after reset |
+| `cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh] [--json]` | Wait for a session reset time and send a desktop notification when due |
+| `cdx notify --next-ready [--poll seconds] [--once] [--refresh] [--json]` | Wait until the recommended session is usable or needs a refresh after reset |
 | `cdx status [--json] [--refresh]` | Show token usage table for all sessions; JSON returns a versioned payload with structured warnings |
 | `cdx status --small [--refresh]` / `cdx status -s [--refresh]` | Show compact token usage table without provider, blocking quota, credits, and updated columns |
 | `cdx status <name> [--json] [--refresh]` | Show detailed usage breakdown for one session |

package/changelogs/CHANGELOGS_0_5_6.md

@@ -0,0 +1,42 @@
+# Changelog (`0.5.5 -> 0.5.6`)
+
+Release date: 2026-05-24
+
+## Major Highlights
+
+- Reduced noisy `cdx status` progress output by respecting fresh cached status rows.
+- Stopped probing disabled sessions during status resolution and hid stale quota metrics for disabled rows.
+- Refined `cdx notify --next-ready` so it waits for the next blocked account reset instead of notifying for an account that is already usable.
+
+## Status Output
+
+- Added status-row cache handling so recently resolved rows do not print redundant `Checking ...` progress lines.
+- Kept Claude status cache behavior aligned with the Claude refresh TTL, avoiding unnecessary Claude checks while cached usage is still fresh.
+- Treated disabled sessions as display-only in `cdx status`; disabled sessions remain visible but are not refreshed or re-read from status artifacts.
+- Rendered disabled-session quota columns as `-` for `OK`, `5H`, `WEEK`, `BLOCK`, `CR`, `RESET 5H`, and `RESET WEEK`.
+- Preserved the stored last status internally so re-enabled sessions can resume normal status behavior.
+
+## Notifications
+
+- Added `--refresh` support to `cdx notify` so notification checks can force status refreshes when requested.
+- Added text-mode progress output for notification checks while keeping `--json` output clean.
+- Made `cdx notify --next-ready` ignore disabled sessions.
+- Made `cdx notify --next-ready` ignore sessions that are already usable and instead target the next currently blocked session with a known reset.
+- Returned `No upcoming session reset available` when there is no blocked session with a reset to wait for.
+
+## Documentation
+
+- Updated package metadata, CLI version output, README badge, and pinned installer example to `v0.5.6`.
+- Documented `--refresh` for `cdx notify` command examples.
+
+## Validation and Regression Coverage
+
+- Added regression coverage for cached Codex status rows suppressing redundant checking progress.
+- Added regression coverage for Claude cache TTL behavior.
+- Added regression coverage for disabled sessions skipping refresh and hiding public status metrics.
+- Added regression coverage for `notify --next-ready` ignoring already-available and disabled sessions.
+
+## Validation and Regression Evidence
+
+- `npm run test:py`
+- `./bin/cdx status`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",
@@ -25,6 +25,8 @@
   },
   "files": [
     "bin",
+    "!bin/__pycache__",
+    "!bin/**/*.pyc",
     "checksums",
     "changelogs",
     "src",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdx-manager"
-version = "0.5.5"
+version = "0.5.6"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/cli.py

@@ -49,7 +49,7 @@ from .status_view import (
 )
 from .update_check import check_for_update
 
-VERSION = "0.5.5"
+VERSION = "0.5.6"
 
 
 # ---------------------------------------------------------------------------
@@ -83,8 +83,8 @@ def _print_help(use_color=False):
         f"  {_style('cdx doctor [--json]', '36', use_color)}",
         f"  {_style('cdx repair [--dry-run] [--force] [--json]', '36', use_color)}",
         f"  {_style('cdx update [--check] [--yes] [--json] [--version TAG]', '36', use_color)}",
-        f"  {_style('cdx notify <name> --at-reset [--json]', '36', use_color)}",
-        f"  {_style('cdx notify --next-ready [--json]', '36', use_color)}",
+        f"  {_style('cdx notify <name> --at-reset [--refresh] [--json]', '36', use_color)}",
+        f"  {_style('cdx notify --next-ready [--refresh] [--json]', '36', use_color)}",
         f"  {_style('cdx <name> [--json]', '36', use_color)}",
         f"  {_style('cdx --help', '36', use_color)}",
         f"  {_style('cdx --version', '36', use_color)}",

package/src/cli_commands.py

@@ -139,6 +139,25 @@ def _make_status_progress(ctx):
     return progress
 
 
+def _make_notify_progress(ctx):
+    def progress(event):
+        kind = event.get("event")
+        if kind == "notify_check_started":
+            target = event.get("session_name") or "next ready session"
+            ctx["out"](f"{_info(f'Checking notification target: {target}...', ctx['use_color'])}\n")
+        elif kind == "status_started":
+            message = f"Loading status for {event.get('session_count', 0)} session(s)..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "session_started":
+            provider = event.get("provider") or "session"
+            message = f"Checking {event.get('session_name')} ({provider})..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "notify_waiting":
+            message = f"{event.get('message')}; checking again in {event.get('poll')}s..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+    return progress
+
+
 def _latest_launch_transcript_path(session):
     paths = _list_launch_transcript_paths(session)
     if not paths:
@@ -626,6 +645,7 @@ def handle_notify(rest, ctx):
         notifier=notifier,
         sleep_fn=ctx["options"].get("sleep"),
         now_fn=ctx["options"].get("now"),
+        progress_callback=None if parsed["json"] else _make_notify_progress(ctx),
     )
     if parsed["json"]:
         _write_json(ctx, _json_success("notify", "Resolved notification event", event=event))
@@ -767,7 +787,10 @@ def handle_status(rest, ctx):
     ]
 
     status_progress = None if parsed["json"] else _make_status_progress(ctx)
-    rows = ctx["service"]["get_status_rows"](progress_callback=status_progress)
+    rows = ctx["service"]["get_status_rows"](
+        progress_callback=status_progress,
+        force_refresh=parsed["refresh"],
+    )
     if len(args) == 0:
         if parsed["json"]:
             _write_json(ctx, _json_success("status", "Collected session status rows", warnings=warnings, rows=rows))

package/src/notify.py

@@ -4,7 +4,12 @@ import subprocess
 import time
 
 from .errors import CdxError
-from .status_view import _parse_reset_timestamp, _recommend_priority_sessions
+from .status_view import (
+    PRIORITY_EMPTY_AVAILABLE_THRESHOLD,
+    _parse_reset_timestamp,
+    _priority_reset_timestamp,
+    _recommend_priority_sessions,
+)
 
 
 def parse_notify_args(args):
@@ -12,17 +17,18 @@ def parse_notify_args(args):
     once = "--once" in args
     at_reset = "--at-reset" in args
     next_ready = "--next-ready" in args
+    refresh = "--refresh" in args
     poll = 60
     cleaned = []
     i = 0
     while i < len(args):
         arg = args[i]
-        if arg in ("--json", "--once", "--at-reset", "--next-ready"):
+        if arg in ("--json", "--once", "--at-reset", "--next-ready", "--refresh"):
             i += 1
             continue
         if arg == "--poll":
             if i + 1 >= len(args):
-                raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] | cdx notify --next-ready [--poll seconds] [--once]")
+                raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
             try:
                 poll = max(1, int(args[i + 1]))
             except ValueError as error:
@@ -37,48 +43,68 @@ def parse_notify_args(args):
             i += 1
             continue
         if arg.startswith("-"):
-            raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] | cdx notify --next-ready [--poll seconds] [--once]")
+            raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
         cleaned.append(arg)
         i += 1
     if at_reset == next_ready:
-        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] | cdx notify --next-ready [--poll seconds] [--once]")
+        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
     if at_reset and len(cleaned) != 1:
-        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once]")
+        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh]")
     if next_ready and cleaned:
-        raise CdxError("Usage: cdx notify --next-ready [--poll seconds] [--once]")
+        raise CdxError("Usage: cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
     return {
         "name": cleaned[0] if cleaned else None,
         "mode": "at-reset" if at_reset else "next-ready",
         "poll": poll,
         "once": once,
         "json": json_flag,
+        "refresh": refresh,
     }
 
 
-def wait_for_notification_event(service, parsed, notifier=None, sleep_fn=None, now_fn=None):
+def wait_for_notification_event(service, parsed, notifier=None, sleep_fn=None, now_fn=None, progress_callback=None):
     notifier = notifier or send_desktop_notification
     sleep_fn = sleep_fn or time.sleep
     now_fn = now_fn or time.time
     while True:
-        event = resolve_notify_event(service["get_status_rows"](), parsed, now_fn())
+        if progress_callback:
+            progress_callback({"event": "notify_check_started", "mode": parsed["mode"], "session_name": parsed["name"]})
+        event = resolve_notify_event(
+            service["get_status_rows"](
+                progress_callback=progress_callback,
+                force_refresh=parsed.get("refresh", False),
+            ),
+            parsed,
+            now_fn(),
+        )
         if event["ready"] or parsed["once"]:
             if event["ready"]:
                 notifier(event["title"], event["message"])
             return event
+        if progress_callback:
+            progress_callback({
+                "event": "notify_waiting",
+                "message": event["message"],
+                "poll": parsed["poll"],
+                "session_name": event.get("session"),
+                "target_timestamp": event.get("target_timestamp"),
+            })
         sleep_fn(parsed["poll"])
 
 
 def resolve_notify_event(rows, parsed, now_ts=None):
     now_ts = time.time() if now_ts is None else now_ts
     if parsed["mode"] == "next-ready":
-        priority = _recommend_priority_sessions(rows)
+        active_rows = [row for row in rows if row.get("enabled", True) is not False]
+        priority = _recommend_priority_sessions([
+            row for row in active_rows
+            if not _is_usable_now(row) and _priority_reset_timestamp(row) is not None
+        ])
         if not priority:
-            return _event(False, "cdx", "No session status available", None)
+            return _event(False, "cdx", "No upcoming session reset available", None)
         first = priority[0]
-        if _is_available(first):
-            return _event(True, "cdx", f"{first['session_name']} is ready", first["session_name"])
-        timestamp = _next_reset_timestamp(first)
-        if timestamp is not None and timestamp <= now_ts:
+        timestamp = _priority_reset_timestamp(first)
+        if _needs_refresh(first, timestamp, now_ts):
             return _event(True, "cdx", f"{first['session_name']} reset is due; refresh status", first["session_name"])
         return _event(False, "cdx", f"Waiting for {first['session_name']}", first["session_name"], timestamp)
 
@@ -93,9 +119,16 @@ def resolve_notify_event(rows, parsed, now_ts=None):
     return _event(False, "cdx", f"Waiting for {row['session_name']} reset", row["session_name"], timestamp)
 
 
-def _is_available(row):
+def _is_usable_now(row):
+    value = row.get("available_pct")
+    return value is not None and value > PRIORITY_EMPTY_AVAILABLE_THRESHOLD
+
+
+def _needs_refresh(row, reset_timestamp, now_ts):
     value = row.get("available_pct")
-    return value is not None and value > 0
+    if value is None or value > PRIORITY_EMPTY_AVAILABLE_THRESHOLD:
+        return False
+    return reset_timestamp is not None and reset_timestamp < now_ts
 
 
 def _next_reset_timestamp(row):

package/src/session_service.py

@@ -45,6 +45,8 @@ RESERVED_SESSION_NAMES = {
     "--version",
     "-v",
 }
+STATUS_CACHE_TTL_SECONDS = 60
+CLAUDE_STATUS_CACHE_TTL_SECONDS = 10 * 60
 
 
 def _encode(name):
@@ -133,6 +135,24 @@ def _parse_status_timestamp(value):
         return None
 
 
+def _status_cache_ttl_seconds(session, ttl_seconds=STATUS_CACHE_TTL_SECONDS):
+    if session.get("provider") == PROVIDER_CLAUDE and ttl_seconds == STATUS_CACHE_TTL_SECONDS:
+        return CLAUDE_STATUS_CACHE_TTL_SECONDS
+    return ttl_seconds
+
+
+def _is_status_cache_fresh(session, ttl_seconds=STATUS_CACHE_TTL_SECONDS):
+    status = session.get("lastStatus") or {}
+    if _is_low_confidence_status_source(status):
+        return False
+    updated_at = _parse_status_timestamp(status.get("updated_at") or session.get("lastStatusAt"))
+    if not updated_at:
+        return False
+    now = datetime.now(timezone.utc).astimezone()
+    ttl_seconds = _status_cache_ttl_seconds(session, ttl_seconds)
+    return (now - updated_at.astimezone(now.tzinfo)).total_seconds() < ttl_seconds
+
+
 def _is_status_newer(candidate, current):
     if not candidate:
         return False
@@ -572,8 +592,12 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return updated
 
-    def _resolve_session_status(session):
+    def _resolve_session_status(session, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
         current_status = session.get("lastStatus")
+        if session.get("enabled", True) is False:
+            return current_status
+        if current_status and not force_refresh and _is_status_cache_fresh(session, ttl_seconds=cache_ttl_seconds):
+            return current_status
         source_root = session.get("authHome") or _get_session_auth_home(
             session["name"], session["provider"]
         )
@@ -644,7 +668,7 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return updated
 
-    def get_status_rows(progress_callback=None):
+    def get_status_rows(progress_callback=None, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
         sessions = list_sessions()
         if progress_callback:
             progress_callback({
@@ -653,13 +677,25 @@ def create_session_service(options=None):
             })
         resolved = []
         for s in sessions:
-            if progress_callback:
+            cache_hit = (
+                s.get("enabled", True) is False
+                or (
+                    s.get("lastStatus")
+                    and not force_refresh
+                    and _is_status_cache_fresh(s, ttl_seconds=cache_ttl_seconds)
+                )
+            )
+            if progress_callback and not cache_hit:
                 progress_callback({
                     "event": "session_started",
                     "session_name": s["name"],
                     "provider": s["provider"],
                 })
-            status = _resolve_session_status(s)
+            status = _resolve_session_status(
+                s,
+                force_refresh=force_refresh,
+                cache_ttl_seconds=cache_ttl_seconds,
+            )
             if progress_callback:
                 progress_callback({
                     "event": "session_finished",
@@ -687,18 +723,20 @@ def create_session_service(options=None):
         rows = []
         for s in resolved:
             status = s.get("lastStatus")
+            enabled = s.get("enabled", True) is not False
+            row_status = status if enabled else None
             rows.append({
                 "session_name": s["name"],
                 "provider": s["provider"],
-                "enabled": s.get("enabled", True) is not False,
-                "status": "disabled" if s.get("enabled", True) is False else "enabled",
-                "remaining_5h_pct": status.get("remaining_5h_pct") if status else None,
-                "remaining_week_pct": status.get("remaining_week_pct") if status else None,
-                "credits": status.get("credits") if status else None,
-                "available_pct": _compute_available_pct(status),
-                "reset_5h_at": status.get("reset_5h_at") if status else None,
-                "reset_week_at": status.get("reset_week_at") if status else None,
-                "reset_at": status.get("reset_at") if status else None,
+                "enabled": enabled,
+                "status": "enabled" if enabled else "disabled",
+                "remaining_5h_pct": row_status.get("remaining_5h_pct") if row_status else None,
+                "remaining_week_pct": row_status.get("remaining_week_pct") if row_status else None,
+                "credits": row_status.get("credits") if row_status else None,
+                "available_pct": _compute_available_pct(row_status),
+                "reset_5h_at": row_status.get("reset_5h_at") if row_status else None,
+                "reset_week_at": row_status.get("reset_week_at") if row_status else None,
+                "reset_at": row_status.get("reset_at") if row_status else None,
                 "updated_at": _to_local_iso(s.get("lastStatusAt")),
                 "last_launched_at": _to_local_iso(s.get("lastLaunchedAt")),
             })

package/src/status_view.py

@@ -82,17 +82,20 @@ def _format_status_rows(rows, use_color=False, small=False):
             base.append(r.get("provider") or "n/a")
         status = r.get("status") or ("enabled" if r.get("enabled", True) else "disabled")
         base.append(_style(status, "2" if status == "disabled" else "32", use_color))
-        usage_columns = [
-            _style_pct(r.get("available_pct"), use_color),
-            _style_pct(r.get("remaining_5h_pct"), use_color),
-            _style_pct(r.get("remaining_week_pct"), use_color),
-            _style_reset_time(r.get("reset_5h_at"), use_color),
-            _style_reset_time(r.get("reset_week_at"), use_color),
-        ]
+        if r.get("enabled", True) is False:
+            usage_columns = [_style("-", "2", use_color)] * 5
+        else:
+            usage_columns = [
+                _style_pct(r.get("available_pct"), use_color),
+                _style_pct(r.get("remaining_5h_pct"), use_color),
+                _style_pct(r.get("remaining_week_pct"), use_color),
+                _style_reset_time(r.get("reset_5h_at"), use_color),
+                _style_reset_time(r.get("reset_week_at"), use_color),
+            ]
         if small:
             base += usage_columns
         else:
-            block = _format_blocking_quota(r)
+            block = "-" if r.get("enabled", True) is False else _format_blocking_quota(r)
             credits = str(r["credits"]) if r.get("credits") is not None else "-"
             base += usage_columns[:3] + [
                 _style(block, "33" if block not in ("?", "-") else "2", use_color),