codex-manager 7.0.0__tar.gz → 9.0.0__tar.gz

{codex_manager-7.0.0 → codex_manager-9.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-manager
-Version: 7.0.0
+Version: 9.0.0
 Summary: Codex account snapshot manager
 Author-email: Dhruv <dhruv13x@gmail.com>
 License: MIT

{codex_manager-7.0.0 → codex_manager-9.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codex-manager"
-version = "7.0.0"
+version = "9.0.0"
 description = "Codex account snapshot manager"
 readme = "README.md"
 requires-python = ">=3.10"

{codex_manager-7.0.0 → codex_manager-9.0.0}/src/codex_manager/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "7.0.0"
+__version__ = "9.0.0"

{codex_manager-7.0.0 → codex_manager-9.0.0}/src/codex_manager/account_status.py

@@ -30,6 +30,10 @@ def patch_metadata(
     # We will compute the final reset_at and session_start_at to save to registry
     final_reset_at = reset_at
     final_session_start_at = session_start_at
+    if is_expired and final_reset_at is None:
+        final_reset_at = datetime.now().astimezone()
+    if is_expired and final_session_start_at is None and final_reset_at is not None:
+        final_session_start_at = final_reset_at - timedelta(days=7)
 
     if backup_dir.exists():
         # Find any metadata file containing this email
@@ -151,15 +155,16 @@ def patch_metadata(
                     try:
                         cp.download_file(metadata_name, local_metadata)
                         data = json.loads(local_metadata.read_text(encoding="utf-8"))
-                        data["reset_at"] = (
-                            reset_at.isoformat() if hasattr(reset_at, "isoformat") else str(reset_at)
-                        )
-                        data["next_available_at"] = data["reset_at"]
-                        if session_start_at:
+                        if final_reset_at is not None:
+                            data["reset_at"] = (
+                                final_reset_at.isoformat() if hasattr(final_reset_at, "isoformat") else str(final_reset_at)
+                            )
+                            data["next_available_at"] = data["reset_at"]
+                        if final_session_start_at:
                             data["session_start_at"] = (
-                                session_start_at.isoformat()
-                                if hasattr(session_start_at, "isoformat")
-                                else str(session_start_at)
+                                final_session_start_at.isoformat()
+                                if hasattr(final_session_start_at, "isoformat")
+                                else str(final_session_start_at)
                             )
                         data["quota_text"] = quota_text
                         if quota_percent_left is not None:

{codex_manager-7.0.0 → codex_manager-9.0.0}/src/codex_manager/cli.py

@@ -47,12 +47,11 @@ def list_entries_from_args(args: Any) -> list[BackupEntry]:
             )
         )
 
-    if getattr(args, "cloud", False) or force_latest:
+    if getattr(args, "cloud", False):
         cp = get_cloud_provider(args)
         if cp:
             # Sync registry (cooldown.json) when cloud is enabled
-            if getattr(args, "cloud", False):
-                sync_registry_with_cloud(cp)
+            sync_registry_with_cloud(cp)
 
             all_entries.extend(
                 list_cloud_backups(
@@ -72,7 +71,8 @@ def list_entries_from_args(args: Any) -> list[BackupEntry]:
             sys.exit(1)
 
     if latest_per_email:
-        all_entries.sort(key=lambda entry: entry.created_at, reverse=True)
+        # Sort by reset_at descending so the newest state is picked
+        all_entries.sort(key=lambda entry: entry.reset_at, reverse=True)
         seen_emails: dict[str, BackupEntry] = {}
         for entry in all_entries:
             if entry.email not in seen_emails:
@@ -166,6 +166,8 @@ def build_live_status(args: Any) -> CooldownStatus | None:
         validation_status="live",
         proposed_archive_name=live_status.proposed_archive_name,
         remaining_seconds=max(0, remaining_seconds),
+        quota_text=live_status.quota_text,
+        quota_percent_left=live_status.quota_percent_left,
         is_expired=live_status.is_expired,
     )
 

{codex_manager-7.0.0 → codex_manager-9.0.0}/src/codex_manager/cooldown.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import datetime, timedelta
 
 from .list_backups import BackupEntry
 
@@ -16,6 +16,8 @@ class CooldownStatus:
     validation_status: str
     proposed_archive_name: str
     remaining_seconds: int
+    quota_text: str | None = None
+    quota_percent_left: int | None = None
     is_expired: bool = False
 
 
@@ -34,9 +36,6 @@ def evaluate_entry(entry: BackupEntry, now: datetime | None = None) -> CooldownS
     remaining_seconds = int((next_available_at - current).total_seconds())
     status = "ready" if remaining_seconds <= 0 else "cooldown"
 
-    # metadata for entry might have is_expired
-    # we need to load it if not already there, but BackupEntry doesn't have it.
-    # However, list_backups.py build_backup_entry could be updated to include it.
     is_expired = getattr(entry, "is_expired", False)
 
     return CooldownStatus(
@@ -48,6 +47,8 @@ def evaluate_entry(entry: BackupEntry, now: datetime | None = None) -> CooldownS
         validation_status="backup",
         proposed_archive_name=entry.archive_path.name,
         remaining_seconds=max(0, remaining_seconds),
+        quota_text=getattr(entry, "quota_text", None),
+        quota_percent_left=getattr(entry, "quota_percent_left", None),
         is_expired=is_expired,
     )
 
@@ -66,10 +67,12 @@ def evaluate_records(
     current = now.astimezone() if now is not None else datetime.now().astimezone()
     
     for email, reg_entry in registry_data.items():
-        if "reset_at" not in reg_entry or "updated_at" not in reg_entry:
+        if "updated_at" not in reg_entry:
             continue
             
         reg_updated_at = parse_iso_datetime(reg_entry["updated_at"])
+        reg_reset_at = reg_entry.get("reset_at")
+        reg_is_expired = reg_entry.get("is_expired", False)
         
         # Check if we already have a status for this email from backups
         existing_idx = next((i for i, s in enumerate(statuses) if s.email == email), None)
@@ -78,8 +81,14 @@ def evaluate_records(
             existing_status = statuses[existing_idx]
             # If registry is newer, update the status
             if reg_updated_at > existing_status.quota_end_detected_at:
-                next_available_at = parse_iso_datetime(reg_entry["reset_at"])
-                session_start_at = parse_iso_datetime(reg_entry.get("session_start_at", reg_entry["reset_at"]))
+                if reg_reset_at is not None:
+                    next_available_at = parse_iso_datetime(reg_reset_at)
+                    session_start_at = parse_iso_datetime(reg_entry.get("session_start_at", reg_reset_at))
+                elif reg_is_expired:
+                    next_available_at = existing_status.next_available_at
+                    session_start_at = existing_status.session_start_at
+                else:
+                    continue
                 remaining_seconds = int((next_available_at - current).total_seconds())
                 statuses[existing_idx] = CooldownStatus(
                     email=email,
@@ -90,12 +99,20 @@ def evaluate_records(
                     validation_status="registry",
                     proposed_archive_name=existing_status.proposed_archive_name,
                     remaining_seconds=max(0, remaining_seconds),
-                    is_expired=reg_entry.get("is_expired", False)
+                    quota_text=reg_entry.get("quota_text"),
+                    quota_percent_left=reg_entry.get("quota_percent_left"),
+                    is_expired=reg_is_expired
                 )
         else:
             # Create a new status from registry
-            next_available_at = parse_iso_datetime(reg_entry["reset_at"])
-            session_start_at = parse_iso_datetime(reg_entry.get("session_start_at", reg_entry["reset_at"]))
+            if reg_reset_at is not None:
+                next_available_at = parse_iso_datetime(reg_reset_at)
+                session_start_at = parse_iso_datetime(reg_entry.get("session_start_at", reg_reset_at))
+            elif reg_is_expired:
+                next_available_at = reg_updated_at
+                session_start_at = reg_updated_at - timedelta(days=7)
+            else:
+                continue
             remaining_seconds = int((next_available_at - current).total_seconds())
             statuses.append(
                 CooldownStatus(
@@ -107,7 +124,9 @@ def evaluate_records(
                     validation_status="registry",
                     proposed_archive_name="none",
                     remaining_seconds=max(0, remaining_seconds),
-                    is_expired=reg_entry.get("is_expired", False)
+                    quota_text=reg_entry.get("quota_text"),
+                    quota_percent_left=reg_entry.get("quota_percent_left"),
+                    is_expired=reg_is_expired
                 )
             )
 
@@ -145,6 +164,7 @@ def print_statuses_table(statuses: list[CooldownStatus], live_email: str | None
     table = Table(show_header=True, header_style="bold bright_magenta")
     table.add_column("Account", style="bright_cyan")
     table.add_column("Status", justify="center", no_wrap=True)
+    table.add_column("Quota", justify="right", style="bright_yellow")
     table.add_column("Available", justify="right", style="bright_yellow")
     table.add_column("Session Start", justify="right", style="dim")
     table.add_column("Reset At", justify="right", style="dim")
@@ -161,9 +181,16 @@ def print_statuses_table(statuses: list[CooldownStatus], live_email: str | None
         else:
             status_display = f"[bold bright_green]{status.status.upper()}[/]" if status.status == "ready" else f"[bold bright_yellow]{status.status.upper()}[/]"
 
+        quota_display = (
+            f"{status.quota_percent_left}%"
+            if status.quota_percent_left is not None
+            else "unknown"
+        )
+
         table.add_row(
             account_display,
             status_display,
+            quota_display,
             format_remaining(status.remaining_seconds),
             status.session_start_at.strftime("%Y-%m-%d %H:%M:%S"),
             status.next_available_at.strftime("%Y-%m-%d %H:%M:%S"),

{codex_manager-7.0.0 → codex_manager-9.0.0}/src/codex_manager/status.py

@@ -109,11 +109,14 @@ def capture_tmux_status_text(
     if has_session:
         run_command(["tmux", "kill-session", "-t", session_name], check=False)
 
-    run_command(
+    session = run_command(
         [
             "tmux",
             "new-session",
             "-d",
+            "-P",
+            "-F",
+            "#{pane_id}",
             "-s",
             session_name,
             "-x",
@@ -123,12 +126,16 @@ def capture_tmux_status_text(
             codex_command,
         ]
     )
+    pane_id = session.stdout.strip()
+    if not pane_id:
+        raise RuntimeError("tmux did not return a pane id for the temporary capture session.")
+    run_command(["tmux", "set-option", "-t", session_name, "remain-on-exit", "on"])
 
     try:
         start = time.time()
         with console.status("[cyan]Waiting for Codex prompt...[/cyan]", spinner="dots"):
             while True:
-                output = run_command(["tmux", "capture-pane", "-t", session_name, "-p"]).stdout
+                output = run_command(["tmux", "capture-pane", "-t", pane_id, "-p"]).stdout
                 if "›" in output:
                     break
                 
@@ -136,13 +143,13 @@ def capture_tmux_status_text(
                     raise RuntimeError("Timed out waiting for Codex prompt.")
                 time.sleep(0.5)
 
-        run_command(["tmux", "send-keys", "-t", session_name, "/status", "Enter"])
+        run_command(["tmux", "send-keys", "-t", pane_id, "/status", "Enter"])
 
         start = time.time()
         last_retry = start
         with console.status("[cyan]Checking Codex status...[/cyan]", spinner="dots"):
             while True:
-                output = run_command(["tmux", "capture-pane", "-t", session_name, "-p"]).stdout
+                output = run_command(["tmux", "capture-pane", "-t", pane_id, "-p"]).stdout
                 
                 # If we have the full panel, return it
                 if "Account:" in output and "Weekly limit:" in output:
@@ -163,7 +170,7 @@ def capture_tmux_status_text(
 
                 # Periodic retry of /status if it seems stuck or refreshing
                 if time.time() - last_retry > 5.0:
-                    run_command(["tmux", "send-keys", "-t", session_name, "/status", "Enter"])
+                    run_command(["tmux", "send-keys", "-t", pane_id, "/status", "Enter"])
                     last_retry = time.time()
                 
                 time.sleep(0.5)

{codex_manager-7.0.0 → codex_manager-9.0.0}/src/codex_manager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-manager
-Version: 7.0.0
+Version: 9.0.0
 Summary: Codex account snapshot manager
 Author-email: Dhruv <dhruv13x@gmail.com>
 License: MIT

{codex_manager-7.0.0 → codex_manager-9.0.0}/tests/test_account_status_coverage.py

@@ -55,6 +55,28 @@ def test_patch_metadata_fallback_datetime_parsing(mocker, tmp_path) -> None:
     mock_update.assert_called_once()
 
 
+def test_patch_metadata_expired_without_existing_metadata_sets_registry_times(mocker, tmp_path) -> None:
+    class Args:
+        pass
+
+    args = Args()
+    args.backup_dir = str(tmp_path / "missing-backups")
+
+    mock_update = mocker.patch("codex_manager.account_status.update_registry_entry")
+
+    patch_metadata(
+        "expired@example.com",
+        quota_text="TOKEN EXPIRED: Re-login required.",
+        args=args,
+        is_expired=True,
+    )
+
+    call = mock_update.call_args.kwargs
+    assert call["is_expired"] is True
+    assert call["reset_at"] is not None
+    assert call["session_start_at"] is not None
+
+
 
 def test_sync_current_account_status_no_email(tmp_path, capsys):
     class Args:

{codex_manager-7.0.0 → codex_manager-9.0.0}/tests/test_cli_coverage_more.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
 import pytest
+from unittest.mock import MagicMock
 
 from codex_manager.cli import (
     _ensure_cloud_archive,
     _read_status_command_input,
     handle_status,
+    handle_recommend,
     list_entries_from_args,
 )
 from codex_manager.status import TokenExpiredError
@@ -67,3 +69,27 @@ def test_handle_status_token_expired(mocker, capsys):
 
     with pytest.raises(SystemExit):
         handle_status(args)
+
+
+def test_handle_recommend_without_cloud_does_not_fetch_cloud(mocker, tmp_path):
+    class Args:
+        command = "recommend"
+        backup_dir = str(tmp_path)
+        cloud = False
+        live = False
+
+    args = Args()
+    mocker.patch("codex_manager.cli.list_backups", return_value=[])
+    mock_cloud = mocker.patch("codex_manager.cli.list_cloud_backups")
+    recommendation = MagicMock()
+    recommendation.selected.email = "test@example.com"
+    recommendation.selected.status = "ready"
+    recommendation.selected.remaining_seconds = 0
+    recommendation.selected.next_available_at.strftime.return_value = "2026-04-29 00:00:00 +0000"
+    recommendation.selected.validation_status = "backup"
+    recommendation.reason = "ready now"
+    mocker.patch("codex_manager.cli.choose_best_account", return_value=recommendation)
+
+    handle_recommend(args)
+
+    mock_cloud.assert_not_called()

{codex_manager-7.0.0 → codex_manager-9.0.0}/tests/test_cooldown.py

@@ -83,6 +83,25 @@ def test_evaluate_records_merges_live_status(mock_reg) -> None:
     assert statuses[0].next_available_at.day == 20
 
 
+@patch(
+    "codex_manager.registry.load_registry",
+    return_value={
+        "expired@example.com": {
+            "updated_at": "2026-04-21T16:00:00+00:00",
+            "is_expired": True,
+            "quota_text": "TOKEN EXPIRED: Re-login required.",
+        }
+    },
+)
+def test_evaluate_records_includes_expired_registry_entries_without_reset_at(mock_reg) -> None:
+    statuses = evaluate_records([], now=datetime(2026, 4, 21, 16, 0, tzinfo=timezone.utc))
+    assert len(statuses) == 1
+    assert statuses[0].email == "expired@example.com"
+    assert statuses[0].validation_status == "registry"
+    assert statuses[0].is_expired is True
+    assert statuses[0].status == "ready"
+
+
 def test_format_remaining() -> None:
     assert format_remaining(0) == "now"
     assert format_remaining(5400) == "1h 30m"

{codex_manager-7.0.0 → codex_manager-9.0.0}/tests/test_status2.py

@@ -56,6 +56,8 @@ def test_capture_tmux_status_text_timeout(mock_sleep, mock_run):
 @patch("codex_manager.status.time.sleep")
 def test_capture_tmux_status_text_success(mock_sleep, mock_run):
     def mock_run_side_effect(args, **kwargs):
+        if args[:3] == ["tmux", "new-session", "-d"]:
+            return MagicMock(stdout="%42")
         if "capture-pane" in args:
             # We need to simulate the prompt '›' appearing, then the status appearing.
             # Let's count how many times capture-pane is called
@@ -72,11 +74,16 @@ def test_capture_tmux_status_text_success(mock_sleep, mock_run):
     mock_run.side_effect = mock_run_side_effect
     res = capture_tmux_status_text(startup_timeout_seconds=1.0, status_timeout_seconds=1.0)
     assert "Account: a@b.com" in res
+    capture_targets = [call.args[0] for call in mock_run.call_args_list if "capture-pane" in call.args[0]]
+    assert capture_targets
+    assert all("%42" in args for args in capture_targets)
 
 @patch("codex_manager.status.run_command")
 @patch("codex_manager.status.time.sleep")
 def test_capture_tmux_status_text_retry_and_timeout(mock_sleep, mock_run):
     def mock_run_side_effect(args, **kwargs):
+        if args[:3] == ["tmux", "new-session", "-d"]:
+            return MagicMock(stdout="%42")
         if "capture-pane" in args:
             # First phase: '›'
             # Second phase: status timeout
@@ -98,6 +105,19 @@ def test_capture_tmux_status_text_retry_and_timeout(mock_sleep, mock_run):
         with pytest.raises(RuntimeError):
             capture_tmux_status_text(startup_timeout_seconds=10.0, status_timeout_seconds=5.0)
 
+
+@patch("codex_manager.status.run_command")
+@patch("codex_manager.status.time.sleep")
+def test_capture_tmux_status_text_requires_pane_id(mock_sleep, mock_run):
+    def mock_run_side_effect(args, **kwargs):
+        if args[:3] == ["tmux", "new-session", "-d"]:
+            return MagicMock(stdout="")
+        return MagicMock()
+
+    mock_run.side_effect = mock_run_side_effect
+    with pytest.raises(RuntimeError, match="pane id"):
+        capture_tmux_status_text(startup_timeout_seconds=1.0, status_timeout_seconds=1.0)
+
 @patch("codex_manager.status.subprocess.run")
 def test_run_command_fail(mock_run):
     mock_run.return_value = MagicMock(returncode=1)