codex-switch-cli 0.1.1__tar.gz → 0.1.3__tar.gz

{codex_switch_cli-0.1.1 → codex_switch_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-switch-cli
-Version: 0.1.1
+Version: 0.1.3
 Summary: Transparent account-aware wrapper for the Codex CLI
 Project-URL: Homepage, https://github.com/ForeverHYX/codex-switch
 Project-URL: Repository, https://github.com/ForeverHYX/codex-switch
@@ -67,6 +67,7 @@ Once setup is done, day-to-day usage stays the same:
 ```bash
 codex "review this branch"
 codex exec "make test"
+codex-switch list
 ```
 
 ## How it works

{codex_switch_cli-0.1.1 → codex_switch_cli-0.1.3}/README.md

@@ -52,6 +52,7 @@ Once setup is done, day-to-day usage stays the same:
 ```bash
 codex "review this branch"
 codex exec "make test"
+codex-switch list
 ```
 
 ## How it works

{codex_switch_cli-0.1.1 → codex_switch_cli-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codex-switch-cli"
-version = "0.1.1"
+version = "0.1.3"
 description = "Transparent account-aware wrapper for the Codex CLI"
 readme = "README.md"
 requires-python = ">=3.11"

codex_switch_cli-0.1.3/src/codex_switch/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.3"

{codex_switch_cli-0.1.1 → codex_switch_cli-0.1.3}/src/codex_switch/cli.py

@@ -21,6 +21,13 @@ from codex_switch.doctor import create_doctor_report
 from codex_switch.install import install_shim, runtime_wrapper_dir, uninstall_shim
 from codex_switch.models import AppConfig
 from codex_switch.paths import config_path
+from codex_switch.rate_limits import (
+    FIVE_HOUR_WINDOW_MINS,
+    SEVEN_DAY_WINDOW_MINS,
+    format_reset_timestamp,
+    read_instance_rate_limits,
+    select_window_for_duration,
+)
 from codex_switch.runtime import find_real_codex, resolve_real_codex
 from codex_switch.wizard import bootstrap_from_prompt, clear_existing_state, initialize_app
 
@@ -73,6 +80,22 @@ def _resolve_instance(config: AppConfig, instance_name: str):
     return instance
 
 
+def _render_table(headers: list[str], rows: list[list[str]]) -> list[str]:
+    widths = [len(header) for header in headers]
+    for row in rows:
+        for index, cell in enumerate(row):
+            widths[index] = max(widths[index], len(cell))
+
+    rendered = [
+        "  ".join(header.ljust(widths[index]) for index, header in enumerate(headers))
+    ]
+    for row in rows:
+        rendered.append(
+            "  ".join(cell.ljust(widths[index]) for index, cell in enumerate(row))
+        )
+    return rendered
+
+
 @app.command()
 def init(
     instance_count: int | None = typer.Option(None, min=1),
@@ -129,8 +152,51 @@ def init(
 @app.command("list")
 def list_instances() -> None:
     config = _load_initialized_config()
+    real_codex_path = _resolve_real_codex_for_management(config)
+
+    rows: list[list[str]] = []
     for instance in config.instances:
-        typer.echo(f"{instance.name}\t{instance.home_dir}")
+        result = read_instance_rate_limits(real_codex_path, instance)
+        if not result.ok or result.snapshot is None:
+            rows.append(
+                [
+                    instance.name,
+                    "unavailable",
+                    "-",
+                    "unavailable",
+                    "-",
+                    result.reason or "Unavailable",
+                ]
+            )
+            continue
+
+        five_hour = select_window_for_duration(
+            result.snapshot,
+            FIVE_HOUR_WINDOW_MINS,
+            fallback="primary",
+        )
+        seven_day = select_window_for_duration(
+            result.snapshot,
+            SEVEN_DAY_WINDOW_MINS,
+            fallback="secondary",
+        )
+
+        rows.append(
+            [
+                instance.name,
+                f"{five_hour.remaining_percent}%" if five_hour is not None else "-",
+                format_reset_timestamp(five_hour.resets_at) if five_hour is not None else "-",
+                f"{seven_day.remaining_percent}%" if seven_day is not None else "-",
+                format_reset_timestamp(seven_day.resets_at) if seven_day is not None else "-",
+                result.snapshot.plan_type or "ok",
+            ]
+        )
+
+    for line in _render_table(
+        ["INSTANCE", "5H REMAINING", "5H RESET", "7D REMAINING", "7D RESET", "STATUS"],
+        rows,
+    ):
+        typer.echo(line)
 
 
 @app.command()

codex_switch_cli-0.1.3/src/codex_switch/probe.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import os
+import pty
+import re
+import select
+import subprocess
+import time
+from pathlib import Path
+
+from codex_switch.auth import CodexCommandError, login_status
+from codex_switch.models import InstanceConfig, ProbeResult
+from codex_switch.runtime import build_instance_env
+
+
+QUOTA_PATTERNS = (
+    re.compile(r"remaining[^0-9]*(\d+)", re.IGNORECASE),
+    re.compile(r"(\d+)[^0-9]*remaining", re.IGNORECASE),
+)
+READY_PATTERNS = (
+    "OpenAI Codex",
+    "tab to queue message",
+    "context left",
+    "Codex ready",
+    "BOOTED",
+)
+ANSI_ESCAPE_RE = re.compile(
+    r"\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07]*(?:\x07|\x1b\\)|\x1b[@-_]"
+)
+
+
+def parse_remaining_quota(output: str) -> int:
+    for pattern in QUOTA_PATTERNS:
+        match = pattern.search(output)
+        if match:
+            return int(match.group(1))
+    raise ValueError("Unable to parse remaining quota from /status output")
+
+
+def _failure(instance: InstanceConfig, reason: str) -> ProbeResult:
+    return ProbeResult(
+        instance_name=instance.name,
+        order=instance.order,
+        quota_remaining=None,
+        ok=False,
+        reason=reason,
+    )
+
+
+def _sanitize_terminal_output(raw_output: bytes) -> str:
+    text = raw_output.decode("utf-8", errors="ignore").replace("\r", "\n")
+    text = ANSI_ESCAPE_RE.sub("", text)
+    text = text.replace("\b", "")
+    return text
+
+
+def _trusted_project_override(path: Path) -> str:
+    escaped = str(path).replace("\\", "\\\\").replace('"', '\\"')
+    return f'projects."{escaped}".trust_level="trusted"'
+
+
+def _looks_ready(output: str) -> bool:
+    return any(pattern in output for pattern in READY_PATTERNS)
+
+
+def _fallback_logged_in_result(
+    real_codex_path: str,
+    instance: InstanceConfig,
+    reason: str,
+) -> ProbeResult | None:
+    try:
+        status = login_status(real_codex_path, instance)
+    except CodexCommandError:
+        return None
+    if not status.logged_in:
+        return None
+    return ProbeResult(
+        instance_name=instance.name,
+        order=instance.order,
+        quota_remaining=0,
+        ok=True,
+        reason=f"{reason}. Falling back to login-only availability.",
+    )
+
+
+def _run_status_probe(
+    real_codex_path: str,
+    instance: InstanceConfig,
+    *,
+    timeout: int = 6,
+) -> tuple[int, str]:
+    instance_home = Path(instance.home_dir)
+    instance_home.mkdir(parents=True, exist_ok=True)
+    env = build_instance_env(instance.name, instance_home)
+    command = [
+        real_codex_path,
+        "-C",
+        str(instance_home),
+        "-c",
+        _trusted_project_override(instance_home),
+        "--no-alt-screen",
+    ]
+
+    master_fd, slave_fd = pty.openpty()
+    process: subprocess.Popen[bytes] | None = None
+    sent_status = False
+    sent_exit = False
+    sent_trust = False
+    status_sent_at: float | None = None
+    exit_sent_at: float | None = None
+    output = bytearray()
+    deadline = time.monotonic() + timeout
+    startup_deadline = time.monotonic() + min(3.0, timeout / 2)
+
+    try:
+        process = subprocess.Popen(
+            command,
+            stdin=slave_fd,
+            stdout=slave_fd,
+            stderr=slave_fd,
+            env=env,
+            cwd=instance_home,
+            close_fds=True,
+        )
+    finally:
+        os.close(slave_fd)
+
+    try:
+        while True:
+            now = time.monotonic()
+            if now >= deadline:
+                raise subprocess.TimeoutExpired(cmd=command, timeout=timeout)
+
+            wait_for = min(0.2, deadline - now)
+            ready, _, _ = select.select([master_fd], [], [], wait_for)
+            if ready:
+                try:
+                    chunk = os.read(master_fd, 4096)
+                except OSError:
+                    chunk = b""
+                if chunk:
+                    output.extend(chunk)
+
+            cleaned_output = _sanitize_terminal_output(output)
+
+            if (
+                not sent_trust
+                and "Do you trust the contents of this directory?" in cleaned_output
+            ):
+                os.write(master_fd, b"1\n")
+                sent_trust = True
+
+            if not sent_status and (
+                _looks_ready(cleaned_output) or time.monotonic() >= startup_deadline
+            ):
+                os.write(master_fd, b"/status\n")
+                sent_status = True
+                status_sent_at = time.monotonic()
+
+            if sent_status and not sent_exit:
+                try:
+                    parse_remaining_quota(cleaned_output)
+                except ValueError:
+                    if status_sent_at is not None and time.monotonic() - status_sent_at > 2:
+                        os.write(master_fd, b"/exit\n")
+                        sent_exit = True
+                        exit_sent_at = time.monotonic()
+                else:
+                    os.write(master_fd, b"/exit\n")
+                    sent_exit = True
+                    exit_sent_at = time.monotonic()
+
+            if (
+                sent_exit
+                and exit_sent_at is not None
+                and time.monotonic() - exit_sent_at > 1
+                and process.poll() is None
+            ):
+                process.terminate()
+
+            poll_result = process.poll()
+            if poll_result is not None:
+                while True:
+                    ready, _, _ = select.select([master_fd], [], [], 0)
+                    if not ready:
+                        break
+                    try:
+                        chunk = os.read(master_fd, 4096)
+                    except OSError:
+                        break
+                    if not chunk:
+                        break
+                    output.extend(chunk)
+                return poll_result, _sanitize_terminal_output(output)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        process.wait(timeout=1)
+        raise
+    finally:
+        os.close(master_fd)
+
+
+def probe_instance(real_codex_path: str, instance: InstanceConfig) -> ProbeResult:
+    try:
+        returncode, output = _run_status_probe(real_codex_path, instance)
+    except FileNotFoundError as exc:
+        return _failure(instance, f"Probe could not launch the real Codex binary: {exc}")
+    except subprocess.TimeoutExpired:
+        fallback = _fallback_logged_in_result(
+            real_codex_path,
+            instance,
+            "Probe timed out",
+        )
+        if fallback is not None:
+            return fallback
+        return _failure(instance, "Probe timed out")
+
+    if returncode != 0:
+        fallback = _fallback_logged_in_result(
+            real_codex_path,
+            instance,
+            f"Probe exited with exit code {returncode}",
+        )
+        if fallback is not None:
+            return fallback
+        return _failure(instance, f"Probe exited with exit code {returncode}")
+
+    try:
+        remaining = parse_remaining_quota(output)
+    except ValueError as exc:
+        fallback = _fallback_logged_in_result(real_codex_path, instance, str(exc))
+        if fallback is not None:
+            return fallback
+        return _failure(instance, str(exc))
+
+    return ProbeResult(
+        instance_name=instance.name,
+        order=instance.order,
+        quota_remaining=remaining,
+        ok=True,
+    )

codex_switch_cli-0.1.3/src/codex_switch/rate_limits.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import json
+import select
+import subprocess
+import time
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+from codex_switch.auth import CodexCommandError
+from codex_switch.models import InstanceConfig
+from codex_switch.runtime import build_instance_env
+
+
+INITIALIZE_REQUEST_ID = 1
+RATE_LIMITS_REQUEST_ID = 2
+FIVE_HOUR_WINDOW_MINS = 300
+SEVEN_DAY_WINDOW_MINS = 10080
+
+
+@dataclass(slots=True)
+class RateLimitWindow:
+    used_percent: int
+    window_duration_mins: int | None = None
+    resets_at: int | None = None
+
+    @property
+    def remaining_percent(self) -> int:
+        return max(0, 100 - self.used_percent)
+
+
+@dataclass(slots=True)
+class RateLimitSnapshot:
+    limit_id: str | None
+    limit_name: str | None
+    plan_type: str | None
+    primary: RateLimitWindow | None = None
+    secondary: RateLimitWindow | None = None
+
+
+@dataclass(slots=True)
+class InstanceRateLimitResult:
+    instance_name: str
+    ok: bool
+    snapshot: RateLimitSnapshot | None = None
+    reason: str | None = None
+
+
+def _start_app_server(
+    real_codex_path: str | Path,
+    instance: InstanceConfig,
+) -> subprocess.Popen[str]:
+    instance_home = Path(instance.home_dir)
+    instance_home.mkdir(parents=True, exist_ok=True)
+    try:
+        return subprocess.Popen(
+            [str(real_codex_path), "app-server"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            env=build_instance_env(instance.name, instance_home),
+            cwd=instance_home,
+        )
+    except FileNotFoundError as exc:
+        raise CodexCommandError(f"Unable to launch the real Codex binary: {exc}") from exc
+
+
+def _write_request(
+    process: subprocess.Popen[str],
+    request_id: int,
+    method: str,
+    params: object,
+) -> None:
+    if process.stdin is None:
+        raise CodexCommandError("Codex app-server stdin is unavailable")
+    process.stdin.write(
+        json.dumps(
+            {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "method": method,
+                "params": params,
+            }
+        )
+        + "\n"
+    )
+    process.stdin.flush()
+
+
+def _read_response(
+    process: subprocess.Popen[str],
+    request_id: int,
+    *,
+    timeout: float,
+) -> dict[str, object]:
+    if process.stdout is None:
+        raise CodexCommandError("Codex app-server stdout is unavailable")
+
+    deadline = time.monotonic() + timeout
+    stdout_fd = process.stdout.fileno()
+
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            raise subprocess.TimeoutExpired(cmd=process.args, timeout=timeout)
+
+        ready, _, _ = select.select([stdout_fd], [], [], remaining)
+        if not ready:
+            raise subprocess.TimeoutExpired(cmd=process.args, timeout=timeout)
+
+        line = process.stdout.readline()
+        if not line:
+            stderr_output = ""
+            if process.stderr is not None:
+                stderr_output = process.stderr.read().strip()
+            message = "Codex app-server exited before returning a response"
+            if stderr_output:
+                message = f"{message}: {stderr_output}"
+            raise CodexCommandError(message)
+
+        payload = json.loads(line)
+        if payload.get("id") != request_id:
+            continue
+        return payload
+
+
+def _extract_result(payload: dict[str, object], method: str) -> dict[str, object]:
+    error = payload.get("error")
+    if isinstance(error, dict):
+        message = error.get("message")
+        if isinstance(message, str) and message:
+            raise CodexCommandError(f"{method} failed: {message}")
+        raise CodexCommandError(f"{method} failed")
+
+    result = payload.get("result")
+    if not isinstance(result, dict):
+        raise CodexCommandError(f"{method} returned an invalid payload")
+    return result
+
+
+def _parse_window(payload: object) -> RateLimitWindow | None:
+    if payload is None:
+        return None
+    if not isinstance(payload, dict):
+        raise CodexCommandError("Rate limit window payload is malformed")
+
+    used_percent = payload.get("usedPercent")
+    if not isinstance(used_percent, int) or isinstance(used_percent, bool):
+        raise CodexCommandError("Rate limit window is missing usedPercent")
+
+    window_duration_mins = payload.get("windowDurationMins")
+    if window_duration_mins is not None and (
+        not isinstance(window_duration_mins, int) or isinstance(window_duration_mins, bool)
+    ):
+        raise CodexCommandError("Rate limit window has an invalid windowDurationMins")
+
+    resets_at = payload.get("resetsAt")
+    if resets_at is not None and (not isinstance(resets_at, int) or isinstance(resets_at, bool)):
+        raise CodexCommandError("Rate limit window has an invalid resetsAt")
+
+    return RateLimitWindow(
+        used_percent=used_percent,
+        window_duration_mins=window_duration_mins,
+        resets_at=resets_at,
+    )
+
+
+def _parse_snapshot(payload: dict[str, object]) -> RateLimitSnapshot:
+    return RateLimitSnapshot(
+        limit_id=payload.get("limitId") if isinstance(payload.get("limitId"), str) else None,
+        limit_name=payload.get("limitName") if isinstance(payload.get("limitName"), str) else None,
+        plan_type=payload.get("planType") if isinstance(payload.get("planType"), str) else None,
+        primary=_parse_window(payload.get("primary")),
+        secondary=_parse_window(payload.get("secondary")),
+    )
+
+
+def _select_snapshot(result_payload: dict[str, object]) -> dict[str, object]:
+    by_limit = result_payload.get("rateLimitsByLimitId")
+    if isinstance(by_limit, dict):
+        codex_snapshot = by_limit.get("codex")
+        if isinstance(codex_snapshot, dict):
+            return codex_snapshot
+
+    rate_limits = result_payload.get("rateLimits")
+    if isinstance(rate_limits, dict):
+        return rate_limits
+
+    raise CodexCommandError("account/rateLimits/read returned no rate limit snapshot")
+
+
+def read_rate_limits(
+    real_codex_path: str | Path,
+    instance: InstanceConfig,
+    *,
+    timeout: float = 8,
+) -> RateLimitSnapshot:
+    process = _start_app_server(real_codex_path, instance)
+    try:
+        _write_request(
+            process,
+            INITIALIZE_REQUEST_ID,
+            "initialize",
+            {
+                "clientInfo": {
+                    "name": "codex-switch",
+                    "version": "0.1.3",
+                },
+                "capabilities": {
+                    "experimentalApi": True,
+                },
+            },
+        )
+        init_payload = _read_response(
+            process, INITIALIZE_REQUEST_ID, timeout=max(1.0, timeout / 2)
+        )
+        _extract_result(init_payload, "initialize")
+
+        _write_request(process, RATE_LIMITS_REQUEST_ID, "account/rateLimits/read", None)
+        rate_limit_payload = _read_response(
+            process, RATE_LIMITS_REQUEST_ID, timeout=max(1.0, timeout / 2)
+        )
+        result = _extract_result(rate_limit_payload, "account/rateLimits/read")
+        return _parse_snapshot(_select_snapshot(result))
+    except subprocess.TimeoutExpired as exc:
+        raise CodexCommandError("Timed out while reading account rate limits") from exc
+    finally:
+        if process.stdin is not None and not process.stdin.closed:
+            process.stdin.close()
+        try:
+            process.terminate()
+            process.wait(timeout=1)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait(timeout=1)
+
+
+def read_instance_rate_limits(
+    real_codex_path: str | Path,
+    instance: InstanceConfig,
+) -> InstanceRateLimitResult:
+    try:
+        snapshot = read_rate_limits(real_codex_path, instance)
+    except CodexCommandError as exc:
+        return InstanceRateLimitResult(
+            instance_name=instance.name,
+            ok=False,
+            reason=str(exc),
+        )
+    return InstanceRateLimitResult(
+        instance_name=instance.name,
+        ok=True,
+        snapshot=snapshot,
+    )
+
+
+def select_window_for_duration(
+    snapshot: RateLimitSnapshot,
+    duration_mins: int,
+    *,
+    fallback: str | None = None,
+) -> RateLimitWindow | None:
+    candidates = [snapshot.primary, snapshot.secondary]
+    for window in candidates:
+        if window is not None and window.window_duration_mins == duration_mins:
+            return window
+
+    if fallback == "primary":
+        return snapshot.primary
+    if fallback == "secondary":
+        return snapshot.secondary
+    return None
+
+
+def format_reset_timestamp(timestamp: int | None) -> str:
+    if timestamp is None:
+        return "-"
+    return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M")

{codex_switch_cli-0.1.1 → codex_switch_cli-0.1.3}/src/codex_switch_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-switch-cli
-Version: 0.1.1
+Version: 0.1.3
 Summary: Transparent account-aware wrapper for the Codex CLI
 Project-URL: Homepage, https://github.com/ForeverHYX/codex-switch
 Project-URL: Repository, https://github.com/ForeverHYX/codex-switch
@@ -67,6 +67,7 @@ Once setup is done, day-to-day usage stays the same:
 ```bash
 codex "review this branch"
 codex exec "make test"
+codex-switch list
 ```
 
 ## How it works

{codex_switch_cli-0.1.1 → codex_switch_cli-0.1.3}/src/codex_switch_cli.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/codex_switch/instances.py
 src/codex_switch/models.py
 src/codex_switch/paths.py
 src/codex_switch/probe.py
+src/codex_switch/rate_limits.py
 src/codex_switch/routing.py
 src/codex_switch/runtime.py
 src/codex_switch/wizard.py
@@ -26,6 +27,7 @@ tests/test_doctor.py
 tests/test_instances.py
 tests/test_integration_wrapper.py
 tests/test_probe.py
+tests/test_rate_limits.py
 tests/test_routing.py
 tests/test_runtime.py
 tests/test_smoke.py

codex_switch_cli-0.1.3/tests/test_probe.py

@@ -0,0 +1,160 @@
+import subprocess
+import os
+import sys
+from pathlib import Path
+
+from codex_switch.models import InstanceConfig
+from codex_switch.auth import LoginStatus
+from codex_switch.probe import parse_remaining_quota
+from codex_switch.probe import probe_instance
+
+
+def test_parse_remaining_quota_from_status_output() -> None:
+    output = """
+    Account: acct-001
+    Requests remaining: 42
+    """
+
+    assert parse_remaining_quota(output) == 42
+
+
+def test_probe_instance_returns_failure_for_malformed_output(
+    tmp_path, monkeypatch
+) -> None:
+    instance = InstanceConfig(
+        name="acct-001",
+        order=1,
+        home_dir=str(tmp_path / "home"),
+    )
+
+    monkeypatch.setattr(
+        "codex_switch.probe._run_status_probe",
+        lambda *args, **kwargs: (0, "Account: acct-001\n"),
+    )
+    monkeypatch.setattr(
+        "codex_switch.probe.login_status",
+        lambda *args, **kwargs: LoginStatus(logged_in=False, output="", returncode=1),
+    )
+
+    result = probe_instance("/usr/local/bin/codex", instance)
+
+    assert result.ok is False
+    assert result.quota_remaining is None
+    assert "Unable to parse remaining quota" in result.reason
+
+
+def test_probe_instance_returns_failure_for_nonzero_exit(
+    tmp_path, monkeypatch
+) -> None:
+    instance = InstanceConfig(
+        name="acct-001",
+        order=1,
+        home_dir=str(tmp_path / "home"),
+    )
+
+    monkeypatch.setattr(
+        "codex_switch.probe._run_status_probe",
+        lambda *args, **kwargs: (1, "Requests remaining: 42\npermission denied"),
+    )
+
+    result = probe_instance("/usr/local/bin/codex", instance)
+
+    assert result.ok is False
+    assert result.quota_remaining is None
+    assert "exit code 1" in result.reason
+
+
+def test_probe_instance_returns_failure_for_timeout(tmp_path, monkeypatch) -> None:
+    instance = InstanceConfig(
+        name="acct-001",
+        order=1,
+        home_dir=str(tmp_path / "home"),
+    )
+
+    def raise_timeout(*args, **kwargs):
+        raise subprocess.TimeoutExpired(cmd=["codex"], timeout=15)
+
+    monkeypatch.setattr("codex_switch.probe._run_status_probe", raise_timeout)
+
+    result = probe_instance("/usr/local/bin/codex", instance)
+
+    assert result.ok is False
+    assert result.quota_remaining is None
+    assert result.reason == "Probe timed out"
+
+
+def test_probe_instance_handles_tty_only_codex_process(tmp_path) -> None:
+    home_dir = tmp_path / "acct-home"
+    home_dir.mkdir()
+    instance = InstanceConfig(
+        name="acct-001",
+        order=1,
+        home_dir=str(home_dir),
+    )
+    script_path = tmp_path / "fake_tty_codex.py"
+    launcher_path = tmp_path / "fake-codex"
+    script_path.write_text(
+        "import os\n"
+        "import sys\n"
+        "print('OpenAI Codex ready', flush=True)\n"
+        "if not sys.stdin.isatty():\n"
+        "    print('stdin is not a terminal', file=sys.stderr, flush=True)\n"
+        "    raise SystemExit(1)\n"
+        "expected_cwd = os.environ.get('EXPECTED_CWD')\n"
+        "if expected_cwd and os.getcwd() != expected_cwd:\n"
+        "    print(f'bad cwd: {os.getcwd()}', file=sys.stderr, flush=True)\n"
+        "    raise SystemExit(2)\n"
+        "for raw_line in sys.stdin:\n"
+        "    line = raw_line.strip()\n"
+        "    if line == '/status':\n"
+        "        print('Requests remaining: 42', flush=True)\n"
+        "    elif line == '/exit':\n"
+        "        raise SystemExit(0)\n"
+    )
+    launcher_path.write_text(
+        "#!/bin/sh\n"
+        f'exec "{sys.executable}" "{script_path}" "$@"\n'
+    )
+    os.chmod(launcher_path, 0o755)
+
+    previous_expected_cwd = os.environ.get("EXPECTED_CWD")
+    os.environ["EXPECTED_CWD"] = str(home_dir)
+    try:
+        result = probe_instance(str(launcher_path), instance)
+    finally:
+        if previous_expected_cwd is None:
+            os.environ.pop("EXPECTED_CWD", None)
+        else:
+            os.environ["EXPECTED_CWD"] = previous_expected_cwd
+
+    assert result.ok is True
+    assert result.quota_remaining == 42
+
+
+def test_probe_instance_falls_back_to_logged_in_account_when_quota_parse_fails(
+    tmp_path, monkeypatch
+) -> None:
+    instance = InstanceConfig(
+        name="acct-001",
+        order=1,
+        home_dir=str(tmp_path / "home"),
+    )
+
+    monkeypatch.setattr(
+        "codex_switch.probe._run_status_probe",
+        lambda *args, **kwargs: (0, "Account status unavailable\n"),
+    )
+    monkeypatch.setattr(
+        "codex_switch.probe.login_status",
+        lambda *args, **kwargs: LoginStatus(
+            logged_in=True,
+            output="Logged in using ChatGPT",
+            returncode=0,
+        ),
+    )
+
+    result = probe_instance("/usr/local/bin/codex", instance)
+
+    assert result.ok is True
+    assert result.quota_remaining == 0
+    assert "falling back" in (result.reason or "").lower()

codex_switch_cli-0.1.3/tests/test_rate_limits.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from codex_switch.cli import app
+from codex_switch.models import AppConfig, InstanceConfig
+
+
+def _make_launcher(tmp_path: Path, fake_codex: Path) -> Path:
+    launcher = tmp_path / "codex"
+    launcher.write_text(
+        "#!/bin/sh\n"
+        f'exec "{sys.executable}" "{fake_codex}" "$@"\n'
+    )
+    os.chmod(launcher, 0o755)
+    return launcher
+
+
+def test_read_rate_limits_returns_structured_windows(tmp_path, fake_codex_path: Path) -> None:
+    from codex_switch.rate_limits import read_rate_limits
+
+    launcher = _make_launcher(tmp_path, fake_codex_path)
+    home = tmp_path / "acct-001"
+    home.mkdir()
+    (home / "rate-limits.json").write_text(
+        json.dumps(
+            {
+                "rateLimits": {
+                    "limitId": "codex",
+                    "limitName": None,
+                    "planType": "plus",
+                    "primary": {
+                        "usedPercent": 64,
+                        "windowDurationMins": 300,
+                        "resetsAt": 1_775_461_397,
+                    },
+                    "secondary": {
+                        "usedPercent": 29,
+                        "windowDurationMins": 10080,
+                        "resetsAt": 1_776_001_304,
+                    },
+                }
+            }
+        )
+    )
+    instance = InstanceConfig(name="acct-001", order=1, home_dir=str(home))
+
+    snapshot = read_rate_limits(str(launcher), instance)
+
+    assert snapshot.plan_type == "plus"
+    assert snapshot.primary is not None
+    assert snapshot.primary.used_percent == 64
+    assert snapshot.primary.window_duration_mins == 300
+    assert snapshot.secondary is not None
+    assert snapshot.secondary.used_percent == 29
+    assert snapshot.secondary.window_duration_mins == 10080
+
+
+def test_list_command_displays_live_rate_limits(tmp_path, monkeypatch) -> None:
+    from codex_switch.rate_limits import (
+        InstanceRateLimitResult,
+        RateLimitSnapshot,
+        RateLimitWindow,
+    )
+
+    config = AppConfig(
+        real_codex_path="/usr/local/bin/codex",
+        instances=[
+            InstanceConfig(name="acct-001", order=1, home_dir=str(tmp_path / "acct-001")),
+            InstanceConfig(name="acct-002", order=2, home_dir=str(tmp_path / "acct-002")),
+        ],
+    )
+
+    def fake_read(real_codex_path: str, instance: InstanceConfig) -> InstanceRateLimitResult:
+        if instance.name == "acct-001":
+            return InstanceRateLimitResult(
+                instance_name=instance.name,
+                ok=True,
+                snapshot=RateLimitSnapshot(
+                    limit_id="codex",
+                    limit_name=None,
+                    plan_type="plus",
+                    primary=RateLimitWindow(
+                        used_percent=64,
+                        window_duration_mins=300,
+                        resets_at=1_775_461_397,
+                    ),
+                    secondary=RateLimitWindow(
+                        used_percent=29,
+                        window_duration_mins=10080,
+                        resets_at=1_776_001_304,
+                    ),
+                ),
+            )
+        return InstanceRateLimitResult(
+            instance_name=instance.name,
+            ok=False,
+            reason="Not logged in",
+        )
+
+    monkeypatch.setattr("codex_switch.cli._load_initialized_config", lambda: config)
+    monkeypatch.setattr(
+        "codex_switch.cli._resolve_real_codex_for_management",
+        lambda config: config.real_codex_path,
+    )
+    monkeypatch.setattr("codex_switch.cli.read_instance_rate_limits", fake_read)
+
+    result = CliRunner().invoke(app, ["list"])
+
+    assert result.exit_code == 0
+    assert "INSTANCE" in result.stdout
+    assert "5H REMAINING" in result.stdout
+    assert "7D REMAINING" in result.stdout
+    assert "acct-001" in result.stdout
+    assert "36%" in result.stdout
+    assert "71%" in result.stdout
+    assert "acct-002" in result.stdout
+    assert "unavailable" in result.stdout
+

{codex_switch_cli-0.1.1 → codex_switch_cli-0.1.3}/tests/test_smoke.py

@@ -5,7 +5,7 @@ from codex_switch.cli import app
 
 
 def test_package_exposes_version() -> None:
-    assert __version__ == "0.1.1"
+    assert __version__ == "0.1.3"
 
 
 def test_cli_app_displays_help() -> None:

codex_switch_cli-0.1.1/src/codex_switch/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.1"

codex_switch_cli-0.1.1/src/codex_switch/probe.py

@@ -1,69 +0,0 @@
-from __future__ import annotations
-
-import re
-import subprocess
-from pathlib import Path
-
-from codex_switch.models import InstanceConfig, ProbeResult
-from codex_switch.runtime import build_instance_env
-
-
-QUOTA_PATTERNS = (
-    re.compile(r"remaining[^0-9]*(\d+)", re.IGNORECASE),
-    re.compile(r"(\d+)[^0-9]*remaining", re.IGNORECASE),
-)
-
-
-def parse_remaining_quota(output: str) -> int:
-    for pattern in QUOTA_PATTERNS:
-        match = pattern.search(output)
-        if match:
-            return int(match.group(1))
-    raise ValueError("Unable to parse remaining quota from /status output")
-
-
-def _failure(instance: InstanceConfig, reason: str) -> ProbeResult:
-    return ProbeResult(
-        instance_name=instance.name,
-        order=instance.order,
-        quota_remaining=None,
-        ok=False,
-        reason=reason,
-    )
-
-
-def probe_instance(real_codex_path: str, instance: InstanceConfig) -> ProbeResult:
-    env = build_instance_env(instance.name, Path(instance.home_dir))
-    try:
-        completed = subprocess.run(
-            [real_codex_path, "--no-alt-screen"],
-            input="/status\n/exit\n",
-            text=True,
-            capture_output=True,
-            env=env,
-            check=False,
-            timeout=15,
-        )
-    except FileNotFoundError as exc:
-        return _failure(instance, f"Probe could not launch the real Codex binary: {exc}")
-    except subprocess.TimeoutExpired:
-        return _failure(instance, "Probe timed out")
-
-    output = f"{completed.stdout}\n{completed.stderr}"
-    if completed.returncode != 0:
-        return _failure(
-            instance,
-            f"Probe exited with exit code {completed.returncode}",
-        )
-
-    try:
-        remaining = parse_remaining_quota(output)
-    except ValueError as exc:
-        return _failure(instance, str(exc))
-
-    return ProbeResult(
-        instance_name=instance.name,
-        order=instance.order,
-        quota_remaining=remaining,
-        ok=True,
-    )

codex_switch_cli-0.1.1/tests/test_probe.py

@@ -1,85 +0,0 @@
-import subprocess
-
-from codex_switch.models import InstanceConfig
-from codex_switch.probe import parse_remaining_quota
-from codex_switch.probe import probe_instance
-
-
-def test_parse_remaining_quota_from_status_output() -> None:
-    output = """
-    Account: acct-001
-    Requests remaining: 42
-    """
-
-    assert parse_remaining_quota(output) == 42
-
-
-def test_probe_instance_returns_failure_for_malformed_output(
-    tmp_path, monkeypatch
-) -> None:
-    instance = InstanceConfig(
-        name="acct-001",
-        order=1,
-        home_dir=str(tmp_path / "home"),
-    )
-
-    monkeypatch.setattr(
-        "codex_switch.probe.subprocess.run",
-        lambda *args, **kwargs: subprocess.CompletedProcess(
-            args=["codex"],
-            returncode=0,
-            stdout="Account: acct-001\n",
-            stderr="",
-        ),
-    )
-
-    result = probe_instance("/usr/local/bin/codex", instance)
-
-    assert result.ok is False
-    assert result.quota_remaining is None
-    assert "Unable to parse remaining quota" in result.reason
-
-
-def test_probe_instance_returns_failure_for_nonzero_exit(
-    tmp_path, monkeypatch
-) -> None:
-    instance = InstanceConfig(
-        name="acct-001",
-        order=1,
-        home_dir=str(tmp_path / "home"),
-    )
-
-    monkeypatch.setattr(
-        "codex_switch.probe.subprocess.run",
-        lambda *args, **kwargs: subprocess.CompletedProcess(
-            args=["codex"],
-            returncode=1,
-            stdout="Requests remaining: 42\n",
-            stderr="permission denied",
-        ),
-    )
-
-    result = probe_instance("/usr/local/bin/codex", instance)
-
-    assert result.ok is False
-    assert result.quota_remaining is None
-    assert "exit code 1" in result.reason
-
-
-def test_probe_instance_returns_failure_for_timeout(tmp_path, monkeypatch) -> None:
-    instance = InstanceConfig(
-        name="acct-001",
-        order=1,
-        home_dir=str(tmp_path / "home"),
-    )
-
-    def raise_timeout(*args, **kwargs):
-        raise subprocess.TimeoutExpired(cmd=["codex"], timeout=15)
-
-    monkeypatch.setattr("codex_switch.probe.subprocess.run", raise_timeout)
-
-    result = probe_instance("/usr/local/bin/codex", instance)
-
-    assert result.ok is False
-    assert result.quota_remaining is None
-    assert result.reason == "Probe timed out"