codex-manager 1.0.1__tar.gz → 2.0.0__tar.gz

{codex_manager-1.0.1 → codex_manager-2.0.0}/PKG-INFO

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

{codex_manager-1.0.1 → codex_manager-2.0.0}/pyproject.toml

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

{codex_manager-1.0.1 → codex_manager-2.0.0}/src/codex_manager/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "1.0.1"
+__version__ = "2.0.0"

{codex_manager-1.0.1 → codex_manager-2.0.0}/src/codex_manager/args.py

@@ -4,11 +4,7 @@ import argparse
 from .config import (
     DEFAULT_BACKUP_DIR,
     DEFAULT_COOLDOWN_DISPLAY_LIMIT,
-    DEFAULT_INVENTORY_PATH,
     DEFAULT_CODEX_HOME,
-    DEFAULT_REFERENCE_YEAR,
-    DEFAULT_SAMPLE_HOME,
-    DEFAULT_SESSION_DURATION_HOURS,
     load_config,
 )
 
@@ -22,69 +18,14 @@ def get_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="codex-manager")
     subparsers = parser.add_subparsers(dest="command")
 
-    normalize_parser = subparsers.add_parser(
-        "normalize",
-        help="Normalize legacy Codex auth snapshot names into a machine-readable inventory.",
-    )
-    normalize_parser.add_argument(
-        "--source-dir",
-        default=str(DEFAULT_SAMPLE_HOME),
-        help="Directory containing legacy *_auth.json files.",
-    )
-    normalize_parser.add_argument(
-        "--session-duration-hours",
-        type=float,
-        default=DEFAULT_SESSION_DURATION_HOURS,
-        help="Hours to subtract from auth file mtime to infer session start.",
-    )
-    normalize_parser.add_argument(
-        "--reference-year",
-        type=int,
-        default=DEFAULT_REFERENCE_YEAR,
-        help="Year used when expanding legacy day-month tokens such as 21apr.",
-    )
-    normalize_parser.add_argument(
-        "--write-inventory",
-        action="store_true",
-        help="Write the normalized inventory to disk.",
-    )
-    normalize_parser.add_argument(
-        "--inventory-path",
-        default=str(DEFAULT_INVENTORY_PATH),
-        help="Path to write the normalized inventory JSON.",
-    )
-    normalize_parser.set_defaults(write_inventory=True)
-
     cooldown_parser = subparsers.add_parser(
         "cooldown",
-        help="Show weekly availability from normalized inventory records.",
-    )
-    cooldown_parser.add_argument(
-        "--inventory-path",
-        default=str(DEFAULT_INVENTORY_PATH),
-        help="Path to the normalized inventory JSON.",
-    )
-    cooldown_parser.add_argument(
-        "--source-dir",
-        default=str(DEFAULT_SAMPLE_HOME),
-        help="Directory containing legacy *_auth.json files when refreshing inventory.",
-    )
-    cooldown_parser.add_argument(
-        "--session-duration-hours",
-        type=float,
-        default=DEFAULT_SESSION_DURATION_HOURS,
-        help="Hours to subtract from auth file mtime to infer session start.",
+        help="Show weekly availability from backup metadata, optionally merged with live Codex status.",
     )
     cooldown_parser.add_argument(
-        "--reference-year",
-        type=int,
-        default=DEFAULT_REFERENCE_YEAR,
-        help="Year used when expanding legacy day-month tokens such as 21apr.",
-    )
-    cooldown_parser.add_argument(
-        "--refresh",
-        action="store_true",
-        help="Regenerate inventory from source-dir before showing cooldowns.",
+        "--backup-dir",
+        default=str(DEFAULT_BACKUP_DIR),
+        help="Directory containing backup archives and metadata.",
     )
     cooldown_parser.add_argument(
         "--live",
@@ -138,34 +79,60 @@ def get_parser() -> argparse.ArgumentParser:
 
     recommend_parser = subparsers.add_parser(
         "recommend",
-        help="Recommend the best account to use next from normalized inventory records.",
+        help="Recommend the best account to use next from backup metadata, optionally merged with live Codex status.",
     )
     recommend_parser.add_argument(
-        "--inventory-path",
-        default=str(DEFAULT_INVENTORY_PATH),
-        help="Path to the normalized inventory JSON.",
+        "--backup-dir",
+        default=str(DEFAULT_BACKUP_DIR),
+        help="Directory containing backup archives and metadata.",
     )
     recommend_parser.add_argument(
-        "--source-dir",
-        default=str(DEFAULT_SAMPLE_HOME),
-        help="Directory containing legacy *_auth.json files when refreshing inventory.",
+        "--live",
+        action="store_true",
+        help="Query current live account via /status and merge with stored backups.",
     )
     recommend_parser.add_argument(
-        "--session-duration-hours",
-        type=float,
-        default=DEFAULT_SESSION_DURATION_HOURS,
-        help="Hours to subtract from auth file mtime to infer session start.",
+        "--status-command",
+        help="Shell command that prints parseable Codex status text for --live mode.",
     )
     recommend_parser.add_argument(
         "--reference-year",
         type=int,
-        default=DEFAULT_REFERENCE_YEAR,
-        help="Year used when expanding legacy day-month tokens such as 21apr.",
+        help="Year used when the status text omits the year in reset time.",
     )
     recommend_parser.add_argument(
-        "--refresh",
-        action="store_true",
-        help="Regenerate inventory from source-dir before recommending an account.",
+        "--codex-command",
+        default="codex --no-alt-screen",
+        help="Command used to launch Codex for live tmux capture in --live mode.",
+    )
+    recommend_parser.add_argument(
+        "--tmux-session-name",
+        default="codexmgr_capture",
+        help="Temporary tmux session name used for live status capture in --live mode.",
+    )
+    recommend_parser.add_argument(
+        "--tmux-cols",
+        type=int,
+        default=120,
+        help="tmux capture width for live status capture in --live mode.",
+    )
+    recommend_parser.add_argument(
+        "--tmux-rows",
+        type=int,
+        default=40,
+        help="tmux capture height for live status capture in --live mode.",
+    )
+    recommend_parser.add_argument(
+        "--startup-timeout-seconds",
+        type=float,
+        default=20.0,
+        help="Seconds to wait for the Codex prompt in --live mode.",
+    )
+    recommend_parser.add_argument(
+        "--status-timeout-seconds",
+        type=float,
+        default=20.0,
+        help="Seconds to wait for the status panel in --live mode.",
     )
 
     status_parser = subparsers.add_parser(

{codex_manager-1.0.1 → codex_manager-2.0.0}/src/codex_manager/backup.py

@@ -5,14 +5,13 @@ import shutil
 import subprocess
 import tarfile
 import tempfile
-from dataclasses import asdict
 from datetime import datetime
 from pathlib import Path
 
 from .config import DEFAULT_BACKUP_DIR, DEFAULT_CODEX_HOME
-from .normalize import isoformat_local
 from .prune import perform_prune
 from .status import LiveStatus, capture_tmux_status_text, parse_live_status_text
+from .utils import isoformat_local
 
 EXCLUDED_TOP_LEVEL_NAMES = {".tmp", "tmp"}
 AUTH_ONLY_INCLUDES = {"auth.json", "config.toml", "installation_id"}

{codex_manager-1.0.1 → codex_manager-2.0.0}/src/codex_manager/cli.py

@@ -7,9 +7,7 @@ from .args import get_parser
 from .backup import backup_result_to_text, perform_backup
 from .cooldown import CooldownStatus, evaluate_records, statuses_to_table
 from .doctor import run_doctor
-from .inventory import load_inventory, write_inventory
 from .list_backups import entries_to_table, list_backups
-from .normalize import normalize_directory, records_to_json
 from .profile import export_profile, import_profile
 from .prune import perform_prune, prune_result_to_text
 from .prune_backups import perform_prune_backups
@@ -27,68 +25,41 @@ def main() -> None:
     parser = get_parser()
     args = parser.parse_args()
 
-    if args.command == "normalize":
-        records = normalize_directory(
-            Path(args.source_dir),
-            session_duration_hours=args.session_duration_hours,
-            reference_year=args.reference_year,
+    def build_live_status(args) -> CooldownStatus | None:
+        if not getattr(args, "live", False):
+            return None
+
+        from .backup import read_status_text_from_args
+        from datetime import datetime
+
+        status_text = read_status_text_from_args(args)
+        ls = parse_live_status_text(status_text, reference_year=getattr(args, "reference_year", None))
+
+        now = datetime.now().astimezone()
+        remaining_seconds = int((ls.reset_at - now).total_seconds())
+        status = "ready" if remaining_seconds <= 0 else "cooldown"
+
+        return CooldownStatus(
+            email=ls.email,
+            status=status,
+            session_start_at=ls.session_start_at,
+            next_available_at=ls.reset_at,
+            quota_end_detected_at=now,
+            validation_status="live",
+            proposed_archive_name=ls.proposed_archive_name,
+            remaining_seconds=max(0, remaining_seconds),
         )
-        if args.write_inventory:
-            write_inventory(records, Path(args.inventory_path))
-        print(records_to_json(records))
-        return
 
     if args.command == "cooldown":
-        inventory_path = Path(args.inventory_path)
-        if args.refresh or not inventory_path.exists():
-            records = normalize_directory(
-                Path(args.source_dir),
-                session_duration_hours=args.session_duration_hours,
-                reference_year=args.reference_year,
-            )
-            write_inventory(records, inventory_path)
-        else:
-            records = load_inventory(inventory_path)
-
-        live_status = None
-        if args.live:
-            from .backup import read_status_text_from_args
-            from datetime import datetime
-            status_text = read_status_text_from_args(args)
-            ls = parse_live_status_text(status_text)
-
-            now = datetime.now().astimezone()
-            remaining_seconds = int((ls.reset_at - now).total_seconds())
-            s = "ready" if remaining_seconds <= 0 else "cooldown"
-
-            live_status = CooldownStatus(
-                email=ls.email,
-                status=s,
-                session_start_at=ls.session_start_at,
-                next_available_at=ls.reset_at,
-                quota_end_detected_at=now,
-                validation_status="live",
-                proposed_archive_name=ls.proposed_archive_name,
-                remaining_seconds=max(0, remaining_seconds),
-            )
-
-        statuses = evaluate_records(records, live_status=live_status)[: args.limit]
+        entries = list_backups(Path(args.backup_dir).expanduser(), latest_per_email=True)
+        live_status = build_live_status(args)
+        statuses = evaluate_records(entries, live_status=live_status)[: args.limit]
         print(statuses_to_table(statuses, live_email=live_status.email if live_status else None))
         return
 
     if args.command == "recommend":
-        inventory_path = Path(args.inventory_path)
-        if args.refresh or not inventory_path.exists():
-            records = normalize_directory(
-                Path(args.source_dir),
-                session_duration_hours=args.session_duration_hours,
-                reference_year=args.reference_year,
-            )
-            write_inventory(records, inventory_path)
-        else:
-            records = load_inventory(inventory_path)
-
-        recommendation = choose_best_account(evaluate_records(records))
+        entries = list_backups(Path(args.backup_dir).expanduser(), latest_per_email=True)
+        recommendation = choose_best_account(evaluate_records(entries, live_status=build_live_status(args)))
         print(recommendation_to_text(recommendation))
         return
 

{codex_manager-1.0.1 → codex_manager-2.0.0}/src/codex_manager/config.py

@@ -1,43 +1,14 @@
 from __future__ import annotations
 
 import os
-import re
 from pathlib import Path
 
 CODEX_MANAGER_HOME = Path(
     os.path.expanduser(os.environ.get("CODEXMGR_HOME", "~/.codexmgr"))
 )
 DEFAULT_CODEX_HOME = Path(os.path.expanduser("~/.codex"))
-DEFAULT_SAMPLE_HOME = Path(".codex_sample")
-DEFAULT_INVENTORY_PATH = CODEX_MANAGER_HOME / "inventory.json"
 DEFAULT_BACKUP_DIR = CODEX_MANAGER_HOME / "backups"
 DEFAULT_COOLDOWN_DISPLAY_LIMIT = 200
-DEFAULT_SESSION_DURATION_HOURS = 2.0
-DEFAULT_REFERENCE_YEAR = 2026
-
-LEGACY_AUTH_FILENAME_RE = re.compile(
-    r"^(?P<day>\d{1,2})(?P<month>[a-z]{3})_(?P<email>.+)_auth\.json$",
-    re.IGNORECASE,
-)
-
-NORMALIZED_ARCHIVE_RE = re.compile(
-    r"^\d{4}-\d{2}-\d{2}-\d{6}-.+-codex\.tar\.gz$"
-)
-
-MONTH_LOOKUP = {
-    "jan": 1,
-    "feb": 2,
-    "mar": 3,
-    "apr": 4,
-    "may": 5,
-    "jun": 6,
-    "jul": 7,
-    "aug": 8,
-    "sep": 9,
-    "oct": 10,
-    "nov": 11,
-    "dec": 12,
-}
 
 def load_config() -> dict[str, str | int | float | bool]:
     import json

{codex_manager-1.0.1 → codex_manager-2.0.0}/src/codex_manager/cooldown.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import datetime
 
-from .normalize import NormalizedRecord
+from .list_backups import BackupEntry
 
 
 @dataclass(frozen=True)
@@ -22,32 +22,32 @@ def parse_iso_datetime(value: str) -> datetime:
     return datetime.fromisoformat(value)
 
 
-def evaluate_record(record: NormalizedRecord, now: datetime | None = None) -> CooldownStatus:
+def evaluate_entry(entry: BackupEntry, now: datetime | None = None) -> CooldownStatus:
     current = now.astimezone() if now is not None else datetime.now().astimezone()
-    session_start_at = parse_iso_datetime(record.session_start_at)
-    next_available_at = parse_iso_datetime(record.next_available_at)
-    quota_end_detected_at = parse_iso_datetime(record.quota_end_detected_at)
+    session_start_at = parse_iso_datetime(entry.session_start_at)
+    next_available_at = parse_iso_datetime(entry.reset_at)
+    quota_end_detected_at = parse_iso_datetime(entry.created_at)
     remaining_seconds = int((next_available_at - current).total_seconds())
     status = "ready" if remaining_seconds <= 0 else "cooldown"
 
     return CooldownStatus(
-        email=record.email,
+        email=entry.email,
         status=status,
         session_start_at=session_start_at,
         next_available_at=next_available_at,
         quota_end_detected_at=quota_end_detected_at,
-        validation_status=record.validation_status,
-        proposed_archive_name=record.proposed_archive_name,
+        validation_status="backup",
+        proposed_archive_name=entry.archive_path.name,
         remaining_seconds=max(0, remaining_seconds),
     )
 
 
 def evaluate_records(
-    records: list[NormalizedRecord],
+    entries: list[BackupEntry],
     now: datetime | None = None,
     live_status: CooldownStatus | None = None,
 ) -> list[CooldownStatus]:
-    statuses = [evaluate_record(record, now=now) for record in records]
+    statuses = [evaluate_entry(entry, now=now) for entry in entries]
 
     if live_status is not None:
         # replace any historical status for the live account
@@ -83,8 +83,8 @@ def statuses_to_table(statuses: list[CooldownStatus], live_email: str | None = N
         "Status",
         "Available",
         "Session Start",
-        "Quota End",
-        "Valid",
+        "Reset At",
+        "Source",
     ]
     rows = []
     for status in statuses:

{codex_manager-1.0.1 → codex_manager-2.0.0}/src/codex_manager/list_backups.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from pathlib import Path
 
-from .config import DEFAULT_BACKUP_DIR
 from .restore import load_metadata_for_archive
 
 

{codex_manager-1.0.1 → codex_manager-2.0.0}/src/codex_manager/recommend.py

@@ -19,17 +19,17 @@ def choose_best_account(statuses: list[CooldownStatus]) -> Recommendation:
         statuses,
         key=lambda item: (
             item.status != "ready",
-            item.validation_status != "ok",
+            item.validation_status != "live",
             item.next_available_at if item.status != "ready" else item.session_start_at,
             item.email,
         ),
     )
 
     if selected.status == "ready":
-        if selected.validation_status == "ok":
-            reason = "Ready now with validated timing metadata."
+        if selected.validation_status == "live":
+            reason = "Ready now from live Codex status."
         else:
-            reason = "Ready now, but timing metadata did not validate against the legacy quota token."
+            reason = "Ready now from backup metadata."
     else:
         reason = (
             "No account is ready. This account becomes available first in "

{codex_manager-1.0.1 → codex_manager-2.0.0}/src/codex_manager/restore.py

@@ -8,7 +8,6 @@ from datetime import datetime
 from pathlib import Path
 
 from .config import DEFAULT_BACKUP_DIR, DEFAULT_CODEX_HOME
-from .normalize import isoformat_local
 
 
 def resolve_archive_path(args) -> Path:

{codex_manager-1.0.1 → codex_manager-2.0.0}/src/codex_manager/status.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta
 from typing import Sequence
 
-from .normalize import build_archive_name, isoformat_local
+from .utils import build_archive_name, isoformat_local
 
 STATUS_PANEL_ACCOUNT_RE = re.compile(r"Account:\s+(\S+@\S+)")
 STATUS_PANEL_WEEKLY_RE = re.compile(r"Weekly limit:\s+(.*?)(?:\n|$)", re.DOTALL)

codex_manager-2.0.0/src/codex_manager/utils.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+
+def isoformat_local(dt: datetime) -> str:
+    return dt.astimezone().isoformat(timespec="seconds")
+
+
+def build_archive_name(session_start_at: datetime, email: str) -> str:
+    return f"{session_start_at.strftime('%Y-%m-%d-%H%M%S')}-{email}-codex.tar.gz"

{codex_manager-1.0.1 → codex_manager-2.0.0}/src/codex_manager.egg-info/PKG-INFO

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

{codex_manager-1.0.1 → codex_manager-2.0.0}/src/codex_manager.egg-info/SOURCES.txt

@@ -8,9 +8,7 @@ src/codex_manager/cli.py
 src/codex_manager/config.py
 src/codex_manager/cooldown.py
 src/codex_manager/doctor.py
-src/codex_manager/inventory.py
 src/codex_manager/list_backups.py
-src/codex_manager/normalize.py
 src/codex_manager/profile.py
 src/codex_manager/prune.py
 src/codex_manager/prune_backups.py
@@ -19,6 +17,7 @@ src/codex_manager/restore.py
 src/codex_manager/status.py
 src/codex_manager/sync.py
 src/codex_manager/use_account.py
+src/codex_manager/utils.py
 src/codex_manager.egg-info/PKG-INFO
 src/codex_manager.egg-info/SOURCES.txt
 src/codex_manager.egg-info/dependency_links.txt
@@ -29,9 +28,7 @@ tests/test_backup.py
 tests/test_config.py
 tests/test_cooldown.py
 tests/test_doctor.py
-tests/test_inventory.py
 tests/test_list_backups.py
-tests/test_normalize.py
 tests/test_profile.py
 tests/test_prune.py
 tests/test_prune_backups.py

codex_manager-2.0.0/tests/test_cooldown.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+
+from codex_manager.cooldown import CooldownStatus, evaluate_entry, evaluate_records, format_remaining
+from codex_manager.list_backups import BackupEntry
+
+
+def make_entry(reset_at: str, email: str = "a@example.com") -> BackupEntry:
+    return BackupEntry(
+        archive_path=Path(f"/tmp/{email}.tar.gz"),
+        email=email,
+        session_start_at="2026-04-14T15:55:00+00:00",
+        reset_at=reset_at,
+        created_at="2026-04-14T17:55:00+00:00",
+        quota_percent_left=0,
+        quota_text="[####] 0% left",
+    )
+
+
+def test_evaluate_record_ready() -> None:
+    entry = make_entry("2026-04-20T15:55:00+00:00")
+    status = evaluate_entry(entry, now=datetime(2026, 4, 21, 16, 0, tzinfo=timezone.utc))
+    assert status.status == "ready"
+    assert status.remaining_seconds == 0
+
+
+def test_evaluate_record_cooldown() -> None:
+    entry = make_entry("2026-04-21T18:00:00+00:00")
+    status = evaluate_entry(entry, now=datetime(2026, 4, 21, 16, 0, tzinfo=timezone.utc))
+    assert status.status == "cooldown"
+    assert status.remaining_seconds == 7200
+
+
+def test_evaluate_records_sorts_ready_first() -> None:
+    ready = make_entry("2026-04-20T15:55:00+00:00", email="ready@example.com")
+    locked = make_entry("2026-04-22T15:55:00+00:00", email="locked@example.com")
+    statuses = evaluate_records(
+        [locked, ready],
+        now=datetime(2026, 4, 21, 16, 0, tzinfo=timezone.utc),
+    )
+    assert statuses[0].email == "ready@example.com"
+    assert statuses[1].email == "locked@example.com"
+
+
+def test_evaluate_records_merges_live_status() -> None:
+    now = datetime(2026, 4, 18, 12, 0, 0, tzinfo=timezone.utc)
+    entry1 = BackupEntry(
+        archive_path=Path("/tmp/a@example.com.tar.gz"),
+        email="a@example.com",
+        session_start_at="2026-04-12T10:00:00+00:00",
+        reset_at="2026-04-19T10:00:00+00:00",
+        created_at="2026-04-12T12:00:00+00:00",
+        quota_percent_left=0,
+        quota_text="[####] 0% left",
+    )
+
+    live_status = CooldownStatus(
+        email="a@example.com",
+        status="cooldown",
+        session_start_at=datetime(2026, 4, 13, 10, 0, 0, tzinfo=timezone.utc),
+        next_available_at=datetime(2026, 4, 20, 10, 0, 0, tzinfo=timezone.utc),
+        quota_end_detected_at=datetime(2026, 4, 13, 12, 0, 0, tzinfo=timezone.utc),
+        validation_status="live",
+        proposed_archive_name="2026-04-13-100000-a@example.com-codex.tar.gz",
+        remaining_seconds=1000,
+    )
+
+    statuses = evaluate_records([entry1], now=now, live_status=live_status)
+    assert len(statuses) == 1
+    assert statuses[0].validation_status == "live"
+    assert statuses[0].next_available_at.day == 20
+
+
+def test_format_remaining() -> None:
+    assert format_remaining(0) == "now"
+    assert format_remaining(5400) == "1h 30m"

{codex_manager-1.0.1 → codex_manager-2.0.0}/tests/test_recommend.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 from datetime import datetime, timezone
+from pathlib import Path
 
-from codex_manager.cooldown import evaluate_records
-from codex_manager.normalize import NormalizedRecord
+from codex_manager.cooldown import CooldownStatus, evaluate_records
+from codex_manager.list_backups import BackupEntry
 from codex_manager.recommend import choose_best_account
 
 
@@ -12,44 +13,44 @@ def make_record(
     email: str,
     session_start_at: str,
     next_available_at: str,
-    validation_status: str = "ok",
-) -> NormalizedRecord:
-    return NormalizedRecord(
+    ) -> BackupEntry:
+    return BackupEntry(
+        archive_path=Path(f"/tmp/{email}.tar.gz"),
         email=email,
-        legacy_auth_filename=f"21apr_{email}_auth.json",
-        legacy_quota_day_token="21apr",
-        quota_end_detected_at="2026-04-14T17:55:00+00:00",
         session_start_at=session_start_at,
-        next_available_at=next_available_at,
-        inferred_session_duration_seconds=7200,
-        proposed_archive_name=f"2026-04-14-155500-{email}-codex.tar.gz",
-        validation_status=validation_status,
-        validation_details="x",
-        source_path=f".codex_sample/21apr_{email}_auth.json",
+        reset_at=next_available_at,
+        created_at="2026-04-14T17:55:00+00:00",
+        quota_percent_left=0,
+        quota_text="[####] 0% left",
     )
 
 
-def test_choose_best_account_prefers_ready_and_validated() -> None:
+def test_choose_best_account_prefers_ready_and_live_first() -> None:
     statuses = evaluate_records(
         [
             make_record(
-                email="mismatch@example.com",
+                email="backup@example.com",
                 session_start_at="2026-04-10T10:00:00+00:00",
                 next_available_at="2026-04-17T10:00:00+00:00",
-                validation_status="mismatch",
-            ),
-            make_record(
-                email="ok@example.com",
-                session_start_at="2026-04-11T10:00:00+00:00",
-                next_available_at="2026-04-18T10:00:00+00:00",
-                validation_status="ok",
             ),
         ],
         now=datetime(2026, 4, 19, 10, 0, tzinfo=timezone.utc),
     )
+    statuses.append(
+        CooldownStatus(
+            email="live@example.com",
+            status="ready",
+            session_start_at=datetime(2026, 4, 11, 10, 0, tzinfo=timezone.utc),
+            next_available_at=datetime(2026, 4, 18, 10, 0, tzinfo=timezone.utc),
+            quota_end_detected_at=datetime(2026, 4, 11, 12, 0, tzinfo=timezone.utc),
+            validation_status="live",
+            proposed_archive_name="2026-04-11-100000-live@example.com-codex.tar.gz",
+            remaining_seconds=0,
+        )
+    )
 
     recommendation = choose_best_account(statuses)
-    assert recommendation.selected.email == "ok@example.com"
+    assert recommendation.selected.email == "live@example.com"
 
 
 def test_choose_best_account_uses_earliest_unlock_when_none_ready() -> None:

codex_manager-1.0.1/src/codex_manager/inventory.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-import json
-from dataclasses import asdict
-from datetime import datetime
-from pathlib import Path
-
-from .normalize import NormalizedRecord, isoformat_local
-
-
-def build_inventory_payload(records: list[NormalizedRecord]) -> dict:
-    return {
-        "generated_at": isoformat_local(datetime.now().astimezone()),
-        "record_count": len(records),
-        "records": [asdict(record) for record in records],
-    }
-
-
-def write_inventory(records: list[NormalizedRecord], inventory_path: Path) -> None:
-    inventory_path.parent.mkdir(parents=True, exist_ok=True)
-    inventory_path.write_text(
-        json.dumps(build_inventory_payload(records), indent=2),
-        encoding="utf-8",
-    )
-
-
-def load_inventory(inventory_path: Path) -> list[NormalizedRecord]:
-    payload = json.loads(inventory_path.read_text(encoding="utf-8"))
-    raw_records = payload.get("records", [])
-    if not isinstance(raw_records, list):
-        raise ValueError(f"Invalid inventory payload in {inventory_path}")
-    return [NormalizedRecord(**record) for record in raw_records]

codex_manager-1.0.1/src/codex_manager/normalize.py

@@ -1,119 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass
-from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Iterable
-
-from .config import LEGACY_AUTH_FILENAME_RE, MONTH_LOOKUP, NORMALIZED_ARCHIVE_RE
-
-
-@dataclass(frozen=True)
-class NormalizedRecord:
-    email: str
-    legacy_auth_filename: str
-    legacy_quota_day_token: str
-    quota_end_detected_at: str
-    session_start_at: str
-    next_available_at: str
-    inferred_session_duration_seconds: int
-    proposed_archive_name: str
-    validation_status: str
-    validation_details: str
-    source_path: str
-
-
-def parse_legacy_auth_filename(filename: str) -> tuple[int, int, str, str]:
-    match = LEGACY_AUTH_FILENAME_RE.match(filename)
-    if not match:
-        raise ValueError(f"Unsupported legacy auth filename: {filename}")
-
-    day = int(match.group("day"))
-    month_token = match.group("month").lower()
-    email = match.group("email")
-    month = MONTH_LOOKUP.get(month_token)
-    if month is None:
-        raise ValueError(f"Unsupported month token in filename: {filename}")
-
-    return day, month, month_token, email
-
-
-def isoformat_local(dt: datetime) -> str:
-    return dt.astimezone().isoformat(timespec="seconds")
-
-
-def build_archive_name(session_start_at: datetime, email: str) -> str:
-    name = f"{session_start_at.strftime('%Y-%m-%d-%H%M%S')}-{email}-codex.tar.gz"
-    if not NORMALIZED_ARCHIVE_RE.match(name):
-        raise ValueError(f"Generated invalid archive name: {name}")
-    return name
-
-
-def normalize_auth_file(
-    auth_path: Path,
-    *,
-    session_duration_hours: float,
-    reference_year: int,
-) -> NormalizedRecord:
-    day, month, month_token, email = parse_legacy_auth_filename(auth_path.name)
-    quota_end_detected_at = datetime.fromtimestamp(auth_path.stat().st_mtime).astimezone()
-    session_start_at = quota_end_detected_at - timedelta(hours=session_duration_hours)
-    next_available_at = session_start_at + timedelta(days=7)
-    target_date = datetime(reference_year, month, day).date()
-
-    if next_available_at.date() == target_date:
-        validation_status = "ok"
-        validation_details = "Legacy quota-day token matches computed next availability date."
-    else:
-        validation_status = "mismatch"
-        validation_details = (
-            "Legacy quota-day token does not match computed next availability date: "
-            f"expected {target_date.isoformat()}, got {next_available_at.date().isoformat()}."
-        )
-
-    return NormalizedRecord(
-        email=email,
-        legacy_auth_filename=auth_path.name,
-        legacy_quota_day_token=f"{day:02d}{month_token}",
-        quota_end_detected_at=isoformat_local(quota_end_detected_at),
-        session_start_at=isoformat_local(session_start_at),
-        next_available_at=isoformat_local(next_available_at),
-        inferred_session_duration_seconds=int(session_duration_hours * 3600),
-        proposed_archive_name=build_archive_name(session_start_at, email),
-        validation_status=validation_status,
-        validation_details=validation_details,
-        source_path=str(auth_path),
-    )
-
-
-def iter_legacy_auth_files(source_dir: Path) -> Iterable[Path]:
-    if not source_dir.exists():
-        raise FileNotFoundError(f"Source directory does not exist: {source_dir}")
-    if not source_dir.is_dir():
-        raise NotADirectoryError(f"Source path is not a directory: {source_dir}")
-
-    for path in sorted(source_dir.iterdir(), key=lambda item: item.name):
-        if path.is_file() and LEGACY_AUTH_FILENAME_RE.match(path.name):
-            yield path
-
-
-def normalize_directory(
-    source_dir: Path,
-    *,
-    session_duration_hours: float,
-    reference_year: int,
-) -> list[NormalizedRecord]:
-    return [
-        normalize_auth_file(
-            path,
-            session_duration_hours=session_duration_hours,
-            reference_year=reference_year,
-        )
-        for path in iter_legacy_auth_files(source_dir)
-    ]
-
-
-def records_to_json(records: list[NormalizedRecord]) -> str:
-    import json
-
-    return json.dumps([asdict(record) for record in records], indent=2)

codex_manager-1.0.1/tests/test_cooldown.py

@@ -1,85 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timezone
-
-from codex_manager.cooldown import evaluate_record, evaluate_records, format_remaining, CooldownStatus
-from codex_manager.normalize import NormalizedRecord
-
-
-def make_record(next_available_at: str, email: str = "a@example.com") -> NormalizedRecord:
-    return NormalizedRecord(
-        email=email,
-        legacy_auth_filename="21apr_a@example.com_auth.json",
-        legacy_quota_day_token="21apr",
-        quota_end_detected_at="2026-04-14T17:55:00+00:00",
-        session_start_at="2026-04-14T15:55:00+00:00",
-        next_available_at=next_available_at,
-        inferred_session_duration_seconds=7200,
-        proposed_archive_name=f"2026-04-14-155500-{email}-codex.tar.gz",
-        validation_status="ok",
-        validation_details="ok",
-        source_path=".codex_sample/21apr_a@example.com_auth.json",
-    )
-
-
-def test_evaluate_record_ready() -> None:
-    record = make_record("2026-04-20T15:55:00+00:00")
-    status = evaluate_record(record, now=datetime(2026, 4, 21, 16, 0, tzinfo=timezone.utc))
-    assert status.status == "ready"
-    assert status.remaining_seconds == 0
-
-
-def test_evaluate_record_cooldown() -> None:
-    record = make_record("2026-04-21T18:00:00+00:00")
-    status = evaluate_record(record, now=datetime(2026, 4, 21, 16, 0, tzinfo=timezone.utc))
-    assert status.status == "cooldown"
-    assert status.remaining_seconds == 7200
-
-
-def test_evaluate_records_sorts_ready_first() -> None:
-    ready = make_record("2026-04-20T15:55:00+00:00", email="ready@example.com")
-    locked = make_record("2026-04-22T15:55:00+00:00", email="locked@example.com")
-    statuses = evaluate_records(
-        [locked, ready],
-        now=datetime(2026, 4, 21, 16, 0, tzinfo=timezone.utc),
-    )
-    assert statuses[0].email == "ready@example.com"
-    assert statuses[1].email == "locked@example.com"
-
-
-def test_evaluate_records_merges_live_status() -> None:
-    now = datetime(2026, 4, 18, 12, 0, 0, tzinfo=timezone.utc)
-    record1 = NormalizedRecord(
-        email="a@example.com",
-        legacy_auth_filename="test.json",
-        legacy_quota_day_token="19apr",
-        quota_end_detected_at="2026-04-12T12:00:00+00:00",
-        session_start_at="2026-04-12T10:00:00+00:00",
-        next_available_at="2026-04-19T10:00:00+00:00",
-        inferred_session_duration_seconds=7200,
-        proposed_archive_name="2026-04-12-100000-a@example.com-codex.tar.gz",
-        validation_status="ok",
-        validation_details="ok",
-        source_path=".codex_sample/19apr_a@example.com_auth.json",
-    )
-
-    live_status = CooldownStatus(
-        email="a@example.com",
-        status="cooldown",
-        session_start_at=datetime(2026, 4, 13, 10, 0, 0, tzinfo=timezone.utc),
-        next_available_at=datetime(2026, 4, 20, 10, 0, 0, tzinfo=timezone.utc),
-        quota_end_detected_at=datetime(2026, 4, 13, 12, 0, 0, tzinfo=timezone.utc),
-        validation_status="live",
-        proposed_archive_name="2026-04-13-100000-a@example.com-codex.tar.gz",
-        remaining_seconds=1000,
-    )
-
-    statuses = evaluate_records([record1], now=now, live_status=live_status)
-    assert len(statuses) == 1
-    assert statuses[0].validation_status == "live"
-    assert statuses[0].next_available_at.day == 20
-
-
-def test_format_remaining() -> None:
-    assert format_remaining(0) == "now"
-    assert format_remaining(5400) == "1h 30m"

codex_manager-1.0.1/tests/test_inventory.py

@@ -1,30 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from codex_manager.inventory import load_inventory, write_inventory
-from codex_manager.normalize import NormalizedRecord
-
-
-def test_inventory_roundtrip(tmp_path: Path) -> None:
-    inventory_path = tmp_path / "inventory.json"
-    records = [
-        NormalizedRecord(
-            email="a@example.com",
-            legacy_auth_filename="21apr_a@example.com_auth.json",
-            legacy_quota_day_token="21apr",
-            quota_end_detected_at="2026-04-14T17:55:00+05:30",
-            session_start_at="2026-04-14T15:55:00+05:30",
-            next_available_at="2026-04-21T15:55:00+05:30",
-            inferred_session_duration_seconds=7200,
-            proposed_archive_name="2026-04-14-155500-a@example.com-codex.tar.gz",
-            validation_status="ok",
-            validation_details="ok",
-            source_path=".codex_sample/21apr_a@example.com_auth.json",
-        )
-    ]
-
-    write_inventory(records, inventory_path)
-    loaded = load_inventory(inventory_path)
-
-    assert loaded == records

codex_manager-1.0.1/tests/test_normalize.py

@@ -1,92 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-
-from codex_manager.normalize import (
-    build_archive_name,
-    normalize_auth_file,
-    normalize_directory,
-    parse_legacy_auth_filename,
-)
-
-
-def test_parse_legacy_auth_filename() -> None:
-    day, month, month_token, email = parse_legacy_auth_filename(
-        "21apr_drdpsbose023@gmail.com_auth.json"
-    )
-    assert day == 21
-    assert month == 4
-    assert month_token == "apr"
-    assert email == "drdpsbose023@gmail.com"
-
-
-def test_build_archive_name() -> None:
-    session_start = datetime(2026, 4, 14, 15, 55, 0, tzinfo=timezone.utc)
-    assert (
-        build_archive_name(session_start, "drdpsbose023@gmail.com")
-        == "2026-04-14-155500-drdpsbose023@gmail.com-codex.tar.gz"
-    )
-
-
-def test_normalize_auth_file_matches_example(tmp_path: Path, mocker) -> None:
-    auth_file = tmp_path / "21apr_drdpsbose023@gmail.com_auth.json"
-    auth_file.write_text("{}", encoding="utf-8")
-    ist = timezone(timedelta(hours=5, minutes=30))
-    quota_end = datetime(2026, 4, 14, 17, 55, 0, tzinfo=ist)
-    epoch = quota_end.timestamp()
-    auth_file.touch()
-    auth_file.chmod(0o600)
-    import os
-    os.utime(auth_file, (epoch, epoch))
-
-    # Avoid patching datetime which causes issues.
-    # Just calculate what the name should be based on the actual mtime
-    mtime = auth_file.stat().st_mtime
-    actual_quota_end = datetime.fromtimestamp(mtime).astimezone()
-    actual_session_start = actual_quota_end - timedelta(hours=2)
-    expected_name = f"{actual_session_start.strftime('%Y-%m-%d-%H%M%S')}-drdpsbose023@gmail.com-codex.tar.gz"
-
-    record = normalize_auth_file(
-        auth_file,
-        session_duration_hours=2,
-        reference_year=2026,
-    )
-
-    assert record.email == "drdpsbose023@gmail.com"
-    assert record.legacy_quota_day_token == "21apr"
-    assert record.proposed_archive_name == expected_name
-    assert record.validation_status == "ok"
-
-
-def test_normalize_auth_file_detects_mismatch(tmp_path: Path) -> None:
-    auth_file = tmp_path / "21apr_drdpsbose023@gmail.com_auth.json"
-    auth_file.write_text("{}", encoding="utf-8")
-    ist = timezone(timedelta(hours=5, minutes=30))
-    quota_end = datetime(2026, 4, 14, 17, 55, 0, tzinfo=ist) + timedelta(days=1)
-    epoch = quota_end.timestamp()
-    import os
-    os.utime(auth_file, (epoch, epoch))
-
-    record = normalize_auth_file(
-        auth_file,
-        session_duration_hours=2,
-        reference_year=2026,
-    )
-
-    assert record.validation_status == "mismatch"
-    assert "expected 2026-04-21" in record.validation_details
-
-
-def test_normalize_directory_filters_non_matching_files(tmp_path: Path) -> None:
-    (tmp_path / "21apr_a@gmail.com_auth.json").write_text("{}", encoding="utf-8")
-    (tmp_path / "README.txt").write_text("x", encoding="utf-8")
-
-    records = normalize_directory(
-        tmp_path,
-        session_duration_hours=2,
-        reference_year=2026,
-    )
-
-    assert len(records) == 1
-    assert records[0].email == "a@gmail.com"