codex-switch-cli 0.1.0__py3-none-any.whl

codex_switch/__init__.py

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

codex_switch/auth.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable
+
+from codex_switch.models import InstanceConfig
+from codex_switch.runtime import build_instance_env
+
+
+@dataclass(slots=True)
+class LoginStatus:
+    logged_in: bool
+    output: str
+    returncode: int
+
+
+class LoginBootstrapAbortedError(RuntimeError):
+    pass
+
+
+class CodexCommandError(RuntimeError):
+    pass
+
+
+def _run_codex(
+    real_codex_path: str | Path,
+    instance: InstanceConfig,
+    argv: list[str],
+    *,
+    capture_output: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    try:
+        return subprocess.run(
+            [str(real_codex_path), *argv],
+            env=build_instance_env(instance.name, Path(instance.home_dir)),
+            text=True,
+            capture_output=capture_output,
+            check=False,
+        )
+    except FileNotFoundError as exc:
+        raise CodexCommandError(f"Unable to launch the real Codex binary: {exc}") from exc
+
+
+def login_status(real_codex_path: str | Path, instance: InstanceConfig) -> LoginStatus:
+    completed = _run_codex(real_codex_path, instance, ["login", "status"], capture_output=True)
+    output = "\n".join(
+        part for part in (completed.stdout, completed.stderr) if part
+    ).strip()
+    return LoginStatus(
+        logged_in=completed.returncode == 0 and "Logged in" in output,
+        output=output,
+        returncode=completed.returncode,
+    )
+
+
+def login(real_codex_path: str | Path, instance: InstanceConfig) -> subprocess.CompletedProcess[str]:
+    return _run_codex(real_codex_path, instance, ["login"])
+
+
+def logout(
+    real_codex_path: str | Path, instance: InstanceConfig
+) -> subprocess.CompletedProcess[str]:
+    return _run_codex(real_codex_path, instance, ["logout"])
+
+
+def _prompt_failure_resolution(
+    instance_name: str,
+    *,
+    allow_skip: bool,
+    input_fn: Callable[[str], str],
+) -> str:
+    choices = "retry, skip, or abort" if allow_skip else "retry or abort"
+    while True:
+        response = input_fn(
+            f"{instance_name} login failed. Type {choices}: "
+        ).strip().lower()
+        if response in {"r", "retry"}:
+            return "retry"
+        if allow_skip and response in {"s", "skip"}:
+            return "skip"
+        if response in {"a", "abort"}:
+            return "abort"
+
+
+def ensure_instance_logged_in(
+    real_codex_path: str | Path,
+    instance: InstanceConfig,
+    *,
+    allow_skip: bool,
+    input_fn: Callable[[str], str],
+    output_fn: Callable[[str], None],
+) -> bool:
+    current_status = login_status(real_codex_path, instance)
+    if current_status.logged_in:
+        return True
+
+    while True:
+        login(real_codex_path, instance)
+        current_status = login_status(real_codex_path, instance)
+        if current_status.logged_in:
+            return True
+
+        if current_status.output:
+            output_fn(current_status.output)
+
+        choice = _prompt_failure_resolution(
+            instance.name,
+            allow_skip=allow_skip,
+            input_fn=input_fn,
+        )
+        if choice == "retry":
+            continue
+        if choice == "skip":
+            return False
+        raise LoginBootstrapAbortedError(
+            f"Login aborted for instance {instance.name}"
+        )

codex_switch/cli.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from codex_switch.auth import (
+    CodexCommandError,
+    LoginBootstrapAbortedError,
+    ensure_instance_logged_in,
+    login_status,
+    logout as run_logout,
+)
+from codex_switch.config import (
+    ConfigCorruptError,
+    ConfigNotInitializedError,
+    load_config,
+    save_config,
+)
+from codex_switch.doctor import create_doctor_report
+from codex_switch.install import install_shim, uninstall_shim
+from codex_switch.models import AppConfig
+from codex_switch.paths import config_path, shim_dir
+from codex_switch.runtime import resolve_real_codex
+from codex_switch.wizard import initialize_app
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.callback()
+def main() -> None:
+    """Codex Switch CLI."""
+
+
+def _fail(message: str) -> None:
+    typer.secho(f"Error: {message}", err=True)
+    raise typer.Exit(code=1)
+
+
+def _load_initialized_config() -> AppConfig:
+    try:
+        return load_config()
+    except ConfigNotInitializedError:
+        _fail("Codex Switch is not initialized. Run `codex-switch init` first.")
+    except ConfigCorruptError:
+        _fail(
+            f"Codex Switch config at {config_path()} is corrupt. "
+            "Remove it and run `codex-switch init` again."
+        )
+
+
+def _resolve_real_codex_for_management(config: AppConfig) -> str:
+    try:
+        resolved = resolve_real_codex(config.real_codex_path, shim_dir())
+    except FileNotFoundError as exc:
+        _fail(f"Unable to locate the real Codex binary: {exc}")
+
+    resolved_str = str(resolved)
+    if resolved_str != config.real_codex_path:
+        save_config(
+            AppConfig(
+                real_codex_path=resolved_str,
+                instances=config.instances,
+            )
+        )
+    return resolved_str
+
+
+def _resolve_instance(config: AppConfig, instance_name: str):
+    instance = next((item for item in config.instances if item.name == instance_name), None)
+    if instance is None:
+        _fail(f"Instance {instance_name!r} is not present in the config")
+    return instance
+
+
+@app.command()
+def init(
+    instance_count: int = typer.Option(..., min=1),
+    real_codex_path: Path = typer.Option(..., exists=True, dir_okay=False),
+    shared_home: Path = typer.Option(Path.home()),
+) -> None:
+    try:
+        initialize_app(
+            real_codex_path=real_codex_path,
+            instance_count=instance_count,
+            shared_home=shared_home,
+        )
+    except (CodexCommandError, FileExistsError, LoginBootstrapAbortedError, ValueError) as exc:
+        _fail(str(exc))
+    typer.echo(f"Initialized {instance_count} account instances")
+
+
+@app.command("list")
+def list_instances() -> None:
+    config = _load_initialized_config()
+    for instance in config.instances:
+        typer.echo(f"{instance.name}\t{instance.home_dir}")
+
+
+@app.command()
+def login(instance_name: str) -> None:
+    config = _load_initialized_config()
+    instance = _resolve_instance(config, instance_name)
+    real_codex_path = _resolve_real_codex_for_management(config)
+
+    try:
+        authenticated = ensure_instance_logged_in(
+            real_codex_path,
+            instance,
+            allow_skip=False,
+            input_fn=input,
+            output_fn=typer.echo,
+        )
+    except (CodexCommandError, LoginBootstrapAbortedError) as exc:
+        _fail(str(exc))
+
+    if not authenticated:
+        _fail(f"Instance {instance_name!r} did not complete login")
+    typer.echo(f"Logged in {instance_name}")
+
+
+@app.command()
+def logout(instance_name: str) -> None:
+    config = _load_initialized_config()
+    instance = _resolve_instance(config, instance_name)
+    real_codex_path = _resolve_real_codex_for_management(config)
+
+    try:
+        run_logout(real_codex_path, instance)
+        status = login_status(real_codex_path, instance)
+    except CodexCommandError as exc:
+        _fail(str(exc))
+    if status.logged_in:
+        _fail(f"Instance {instance_name!r} is still logged in after logout")
+    typer.echo(f"Logged out {instance_name}")
+
+
+@app.command()
+def doctor() -> None:
+    report = create_doctor_report()
+    typer.echo(report.summary())
+
+
+@app.command("install-shim")
+def install_shim_command() -> None:
+    target = install_shim()
+    typer.echo(f"Installed codex shim at {target}")
+
+
+@app.command()
+def uninstall() -> None:
+    target = uninstall_shim()
+    typer.echo(f"Removed codex shim at {target}")
+
+
+if __name__ == "__main__":
+    app()

codex_switch/config.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import json
+
+from codex_switch.models import AppConfig
+from codex_switch.paths import config_path
+
+
+class ConfigError(RuntimeError):
+    pass
+
+
+class ConfigNotInitializedError(ConfigError):
+    pass
+
+
+class ConfigCorruptError(ConfigError):
+    pass
+
+
+def load_config() -> AppConfig:
+    path = config_path()
+    try:
+        payload = json.loads(path.read_text())
+    except FileNotFoundError as exc:
+        raise ConfigNotInitializedError(str(path)) from exc
+    except (json.JSONDecodeError, OSError) as exc:
+        raise ConfigCorruptError(str(path)) from exc
+
+    try:
+        return AppConfig.from_dict(payload)
+    except (TypeError, ValueError, KeyError) as exc:
+        raise ConfigCorruptError(str(path)) from exc
+
+
+def save_config(config: AppConfig) -> None:
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(config.to_dict(), indent=2, sort_keys=True) + "\n")

codex_switch/doctor.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from codex_switch.config import ConfigCorruptError, ConfigNotInitializedError, load_config
+from codex_switch.paths import shim_dir
+from codex_switch.probe import probe_instance
+from codex_switch.runtime import resolve_real_codex
+
+
+@dataclass(slots=True)
+class DoctorReport:
+    real_codex_found: bool
+    shim_precedes_path: bool
+    unhealthy_instances: list[str] = field(default_factory=list)
+
+    def summary(self) -> str:
+        unhealthy = ",".join(self.unhealthy_instances) if self.unhealthy_instances else "none"
+        shim = "ok" if self.shim_precedes_path else "missing"
+        real = "ok" if self.real_codex_found else "missing"
+        return f"real-codex={real} shim={shim} unhealthy={unhealthy}"
+
+
+def shim_precedes_path(wrapper_dir: Path | None = None) -> bool:
+    expected = (wrapper_dir or shim_dir()).resolve()
+    for entry in os.environ.get("PATH", "").split(os.pathsep):
+        if not entry:
+            continue
+        return Path(entry).expanduser().resolve() == expected
+    return False
+
+
+def create_doctor_report(wrapper_dir: Path | None = None) -> DoctorReport:
+    actual_wrapper_dir = wrapper_dir or shim_dir()
+    shim_ok = shim_precedes_path(actual_wrapper_dir)
+
+    try:
+        config = load_config()
+    except (ConfigNotInitializedError, ConfigCorruptError):
+        return DoctorReport(real_codex_found=False, shim_precedes_path=shim_ok)
+
+    try:
+        real_codex_path = resolve_real_codex(config.real_codex_path, actual_wrapper_dir)
+    except FileNotFoundError:
+        unhealthy_instances = [instance.name for instance in config.instances if instance.enabled]
+        return DoctorReport(
+            real_codex_found=False,
+            shim_precedes_path=shim_ok,
+            unhealthy_instances=unhealthy_instances,
+        )
+
+    unhealthy_instances = [
+        result.instance_name
+        for result in (
+            probe_instance(str(real_codex_path), instance)
+            for instance in config.instances
+            if instance.enabled
+        )
+        if not result.ok
+    ]
+    return DoctorReport(
+        real_codex_found=True,
+        shim_precedes_path=shim_ok,
+        unhealthy_instances=unhealthy_instances,
+    )

codex_switch/install.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+from codex_switch.paths import shim_dir
+
+
+def shim_path() -> Path:
+    return shim_dir() / "codex"
+
+
+def install_shim() -> Path:
+    target = shim_path()
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(
+        "#!/bin/sh\n"
+        f'exec "{sys.executable}" -m codex_switch.wrapper "$@"\n'
+    )
+    os.chmod(target, 0o755)
+    return target
+
+
+def uninstall_shim() -> Path:
+    target = shim_path()
+    if target.exists():
+        target.unlink()
+    return target

codex_switch/instances.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from codex_switch.models import InstanceConfig
+from codex_switch.paths import instances_dir
+
+
+def ensure_shared_codex_paths(instance_home: Path, shared_home: Path) -> None:
+    for relative in (
+        Path(".codex") / "skills",
+        Path(".codex") / "superpowers",
+    ):
+        source = shared_home / relative
+        if not source.exists():
+            continue
+        target = instance_home / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if target.is_symlink() or target.exists():
+            if target.is_dir() and not target.is_symlink():
+                shutil.rmtree(target)
+            else:
+                target.unlink()
+        target.symlink_to(source)
+
+
+def create_instances(instance_count: int, shared_home: Path) -> list[InstanceConfig]:
+    instances: list[InstanceConfig] = []
+    for index in range(1, instance_count + 1):
+        name = f"acct-{index:03d}"
+        home_dir = instances_dir() / name / "home"
+        home_dir.mkdir(parents=True, exist_ok=True)
+        ensure_shared_codex_paths(home_dir, shared_home)
+        instances.append(
+            InstanceConfig(
+                name=name,
+                order=index,
+                home_dir=str(home_dir),
+            )
+        )
+    return instances

codex_switch/models.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+
+
+@dataclass(slots=True)
+class InstanceConfig:
+    name: str
+    order: int
+    home_dir: str
+    enabled: bool = True
+
+    def to_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+
+@dataclass(slots=True)
+class ProbeResult:
+    instance_name: str
+    order: int
+    quota_remaining: int | None
+    ok: bool
+    reason: str | None = None
+
+
+@dataclass(slots=True)
+class AppConfig:
+    real_codex_path: str
+    instances: list[InstanceConfig] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "real_codex_path": self.real_codex_path,
+            "instances": [instance.to_dict() for instance in self.instances],
+        }
+
+    @classmethod
+    def from_dict(cls, payload: dict[str, object]) -> "AppConfig":
+        if not isinstance(payload, dict):
+            raise ValueError("config payload must be a mapping")
+
+        real_codex_path = payload.get("real_codex_path")
+        if not isinstance(real_codex_path, str) or not real_codex_path:
+            raise ValueError("real_codex_path must be a non-empty string")
+
+        raw_instances = payload.get("instances", [])
+        if not isinstance(raw_instances, list):
+            raise ValueError("instances must be a list")
+
+        instances = []
+        for item in raw_instances:
+            if not isinstance(item, dict):
+                raise ValueError("each instance must be a mapping")
+
+            name = item.get("name")
+            order = item.get("order")
+            home_dir = item.get("home_dir")
+            enabled = item.get("enabled", True)
+
+            if not isinstance(name, str) or not name:
+                raise ValueError("instance name must be a non-empty string")
+            if not isinstance(order, int) or isinstance(order, bool):
+                raise ValueError("instance order must be an integer")
+            if not isinstance(home_dir, str) or not home_dir:
+                raise ValueError("instance home_dir must be a non-empty string")
+            if not isinstance(enabled, bool):
+                raise ValueError("instance enabled must be a boolean")
+
+            instances.append(
+                InstanceConfig(
+                    name=name,
+                    order=order,
+                    home_dir=home_dir,
+                    enabled=enabled,
+                )
+            )
+
+        return cls(
+            real_codex_path=real_codex_path,
+            instances=instances,
+        )

codex_switch/paths.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+ENV_ROOT = "CODEX_SWITCH_HOME"
+
+
+def state_root() -> Path:
+    override = os.environ.get(ENV_ROOT)
+    if override:
+        return Path(override).expanduser().resolve()
+    return Path.home() / ".codex-switch"
+
+
+def config_path() -> Path:
+    return state_root() / "config.json"
+
+
+def instances_dir() -> Path:
+    return state_root() / "instances"
+
+
+def logs_dir() -> Path:
+    return state_root() / "logs"
+
+
+def shim_dir() -> Path:
+    return state_root() / "bin"

codex_switch/probe.py

@@ -0,0 +1,69 @@
+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/routing.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from codex_switch.models import ProbeResult
+
+
+def select_best_instance(results: list[ProbeResult]) -> ProbeResult:
+    candidates = [
+        result for result in results if result.ok and result.quota_remaining is not None
+    ]
+    if not candidates:
+        raise RuntimeError("No usable Codex account instances are available")
+
+    return sorted(
+        candidates,
+        key=lambda item: (-int(item.quota_remaining), item.order),
+    )[0]

codex_switch/runtime.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def _is_executable_file(path: Path) -> bool:
+    return path.exists() and os.access(path, os.X_OK)
+
+
+def find_real_codex(wrapper_dir: Path) -> Path:
+    path_entries = []
+    for entry in os.environ.get("PATH", "").split(os.pathsep):
+        if not entry:
+            continue
+        if Path(entry).resolve() == wrapper_dir.resolve():
+            continue
+        path_entries.append(entry)
+
+    for entry in path_entries:
+        candidate = Path(entry) / "codex"
+        if candidate.exists() and os.access(candidate, os.X_OK):
+            return candidate.resolve()
+
+    raise FileNotFoundError("Unable to locate the real codex binary outside the shim directory")
+
+
+def resolve_real_codex(stored_path: str, wrapper_dir: Path) -> Path:
+    candidate = Path(stored_path).expanduser()
+    if _is_executable_file(candidate):
+        return candidate.resolve()
+    return find_real_codex(wrapper_dir)
+
+
+def build_instance_env(
+    instance_name: str,
+    instance_home: Path,
+    parent_env: dict[str, str] | None = None,
+) -> dict[str, str]:
+    env = dict(os.environ if parent_env is None else parent_env)
+    env["HOME"] = str(instance_home)
+    env["XDG_CONFIG_HOME"] = str(instance_home / ".config")
+    env["XDG_CACHE_HOME"] = str(instance_home / ".cache")
+    env["XDG_STATE_HOME"] = str(instance_home / ".local" / "state")
+    env["CODEX_SWITCH_ACTIVE_INSTANCE"] = instance_name
+    return env

codex_switch/wizard.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import os
+from typing import Callable
+from pathlib import Path
+
+from codex_switch.auth import LoginBootstrapAbortedError, ensure_instance_logged_in
+from codex_switch.config import save_config
+from codex_switch.instances import create_instances
+from codex_switch.models import AppConfig
+from codex_switch.paths import config_path
+
+
+def _validate_real_codex_path(real_codex_path: Path) -> None:
+    if not real_codex_path.is_file() or not os.access(real_codex_path, os.X_OK):
+        raise ValueError(f"{real_codex_path} must point to an executable file")
+
+
+def prompt_instance_count(
+    *,
+    input_fn: Callable[[str], str] | None = None,
+    output_fn: Callable[[str], None],
+) -> int:
+    if input_fn is None:
+        input_fn = input
+    while True:
+        raw_value = input_fn("How many Codex account instances should be created? ").strip()
+        try:
+            instance_count = int(raw_value)
+        except ValueError:
+            output_fn("Please enter a whole number.")
+            continue
+        if instance_count < 1:
+            output_fn("Please enter at least 1 account instance.")
+            continue
+        return instance_count
+
+
+def initialize_app(
+    real_codex_path: Path,
+    instance_count: int,
+    shared_home: Path,
+    *,
+    allow_skip: bool = True,
+    input_fn: Callable[[str], str] | None = None,
+    output_fn: Callable[[str], None] = print,
+) -> AppConfig:
+    if input_fn is None:
+        input_fn = input
+    path = config_path()
+    if path.exists():
+        raise FileExistsError(f"{path} already exists")
+
+    _validate_real_codex_path(real_codex_path)
+    if instance_count < 1:
+        raise ValueError("instance_count must be at least 1")
+
+    instances = create_instances(instance_count=instance_count, shared_home=shared_home)
+    for instance in instances:
+        authenticated = ensure_instance_logged_in(
+            real_codex_path,
+            instance,
+            allow_skip=allow_skip,
+            input_fn=input_fn,
+            output_fn=output_fn,
+        )
+        if not authenticated and not allow_skip:
+            raise LoginBootstrapAbortedError(
+                f"Login aborted for instance {instance.name}"
+            )
+
+    config = AppConfig(
+        real_codex_path=str(real_codex_path),
+        instances=instances,
+    )
+    save_config(config)
+    return config
+
+
+def bootstrap_from_prompt(
+    real_codex_path: Path,
+    shared_home: Path,
+    *,
+    input_fn: Callable[[str], str] | None = None,
+    output_fn: Callable[[str], None] = print,
+) -> AppConfig:
+    if input_fn is None:
+        input_fn = input
+    instance_count = prompt_instance_count(
+        input_fn=input_fn,
+        output_fn=output_fn,
+    )
+    return initialize_app(
+        real_codex_path=real_codex_path,
+        instance_count=instance_count,
+        shared_home=shared_home,
+        allow_skip=True,
+        input_fn=input_fn,
+        output_fn=output_fn,
+    )

codex_switch/wrapper.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+from codex_switch.auth import CodexCommandError, LoginBootstrapAbortedError
+from codex_switch.config import (
+    ConfigCorruptError,
+    ConfigNotInitializedError,
+    load_config,
+    save_config,
+)
+from codex_switch.models import AppConfig
+from codex_switch.models import ProbeResult
+from codex_switch.probe import probe_instance
+from codex_switch.routing import select_best_instance
+from codex_switch.paths import shim_dir
+from codex_switch.runtime import build_instance_env, find_real_codex, resolve_real_codex
+from codex_switch.wizard import bootstrap_from_prompt
+
+MANAGED_COMMANDS = {"login", "logout"}
+REAL_CODEX_ARGV: list[str] | None = None
+
+
+def probe_all_instances(config) -> list[ProbeResult]:
+    instances = [instance for instance in config.instances if instance.enabled]
+    with ThreadPoolExecutor(max_workers=max(1, len(instances))) as executor:
+        return list(
+            executor.map(
+                lambda instance: probe_instance(config.real_codex_path, instance),
+                instances,
+            )
+        )
+
+
+def _fail(message: str) -> int:
+    print(f"Error: {message}", file=sys.stderr)
+    return 1
+
+
+def _resolve_instance(config, selected_instance_name: str):
+    instance = next(
+        (item for item in config.instances if item.name == selected_instance_name),
+        None,
+    )
+    if instance is None:
+        raise LookupError(
+            f"Selected instance {selected_instance_name!r} is not present in the config"
+        )
+    return instance
+
+
+def _refresh_real_codex_path(config: AppConfig, resolved_real_codex: Path) -> None:
+    resolved_real_codex_str = str(resolved_real_codex)
+    if resolved_real_codex_str == config.real_codex_path:
+        return
+    save_config(
+        AppConfig(
+            real_codex_path=resolved_real_codex_str,
+            instances=config.instances,
+        )
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if args and args[0] in MANAGED_COMMANDS:
+        return _fail("Use `codex-switch login` or `codex-switch logout` for account management")
+
+    try:
+        config = load_config()
+    except ConfigNotInitializedError:
+        try:
+            real_codex_path = find_real_codex(shim_dir())
+            bootstrap_from_prompt(real_codex_path=real_codex_path, shared_home=Path.home())
+            config = load_config()
+        except (CodexCommandError, LoginBootstrapAbortedError) as exc:
+            return _fail(str(exc))
+        except FileNotFoundError as exc:
+            return _fail(f"Unable to locate the real Codex binary: {exc}")
+        except ConfigNotInitializedError:
+            return _fail("Codex Switch is not initialized. Run `codex-switch init` first.")
+    except ConfigCorruptError:
+        return _fail("Codex Switch config is corrupt. Remove it and run `codex-switch init` again.")
+
+    try:
+        resolved_real_codex = resolve_real_codex(config.real_codex_path, shim_dir())
+    except FileNotFoundError as exc:
+        return _fail(f"Unable to locate the real Codex binary: {exc}")
+    _refresh_real_codex_path(config, resolved_real_codex)
+
+    probe_config = AppConfig(
+        real_codex_path=str(resolved_real_codex),
+        instances=config.instances,
+    )
+
+    try:
+        selected = select_best_instance(probe_all_instances(probe_config))
+    except FileNotFoundError as exc:
+        return _fail(f"Unable to locate the real Codex binary: {exc}")
+    except (RuntimeError, StopIteration) as exc:
+        return _fail(str(exc))
+
+    try:
+        instance = _resolve_instance(config, selected.instance_name)
+    except LookupError as exc:
+        return _fail(str(exc))
+
+    env = build_instance_env(
+        instance_name=instance.name,
+        instance_home=Path(instance.home_dir),
+    )
+
+    command = REAL_CODEX_ARGV or [str(resolved_real_codex)]
+    try:
+        completed = subprocess.run(
+            [*command, *args],
+            env=env,
+            check=False,
+        )
+    except FileNotFoundError as exc:
+        return _fail(f"Unable to launch the real Codex binary: {exc}")
+    return completed.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codex_switch_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: codex-switch-cli
+Version: 0.1.0
+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
+Project-URL: Issues, https://github.com/ForeverHYX/codex-switch/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: typer<1.0,>=0.12
+Provides-Extra: dev
+Requires-Dist: build<2.0,>=1.2; extra == "dev"
+Requires-Dist: pytest<9.0,>=8.0; extra == "dev"
+Requires-Dist: twine<7.0,>=6.0; extra == "dev"
+
+# codex-switch
+
+`codex-switch` is a local wrapper for the Codex CLI. It keeps the normal
+`codex` command, but chooses the logged-in account instance with the most
+remaining quota before launching the real CLI.
+
+## What it does
+
+- installs a PATH-first `codex` shim
+- stores one isolated runtime home per account
+- checks account login state with `codex login status`
+- probes each account's remaining quota with `/status` before launch
+- forwards the original user command unchanged to the selected account
+- keeps repository files, project instructions, and shared skills visible to
+  every instance
+
+## Install
+
+From PyPI after release:
+
+```bash
+python3 -m pip install codex-switch-cli
+codex-switch install-shim
+```
+
+From GitHub before the first PyPI release:
+
+```bash
+python3 -m pip install git+https://github.com/ForeverHYX/codex-switch.git
+codex-switch install-shim
+```
+
+After that, just run `codex`. The first launch asks how many accounts to set up
+and walks you through logging each one in with the upstream Codex CLI.
+
+```bash
+codex
+```
+
+Once setup is done, day-to-day usage stays the same:
+
+```bash
+codex "review this branch"
+codex exec "make test"
+```
+
+## How it works
+
+The first `codex` run triggers setup. `codex-switch` creates one isolated
+runtime home per account, runs the upstream login flow for each account in
+turn, then stores the real Codex binary path for later launches.
+
+When you later run `codex`, the shim probes each configured account, skips
+unhealthy or unlogged ones, and picks the one with the most remaining quota.
+
+## Caveats
+
+- it does not switch accounts in the middle of a running Codex session
+- it does not manage upstream Codex upgrades for you
+- it depends on the upstream CLI's login/status output staying readable
+- all accounts still share the same project working directory
+
+## Public repository rules
+
+- commit source files, tests, and public docs only
+- keep local planning docs out of public pushes
+- keep local-only agent and skill metadata out of public pushes
+
+## Publishing
+
+This repository is set up to publish the `codex-switch-cli` package to PyPI
+through GitHub Actions trusted publishing. After PyPI trusted publishing is
+configured for this repository, creating a GitHub release tag can build and
+upload the package automatically.

codex_switch_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+codex_switch/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+codex_switch/auth.py,sha256=kjbFwQeSSRGqDq1jL_mk118MV5Y_pJ4nO9o6G4INPtA,3318
+codex_switch/cli.py,sha256=G3jdcTzpsGXg6AzCWykGvIzDTX9WH81AdC2sc6hxbFQ,4449
+codex_switch/config.py,sha256=IHDrZ73uY9F4AgPwwIzC_j6Y5ENmDN-LrriTn46eGkw,966
+codex_switch/doctor.py,sha256=bAW0UXREXvuEZIIkZf9RIOYQ0qVwVraF6R38T2MvjBk,2295
+codex_switch/install.py,sha256=ATCQc_3amlYeHujiqbVTwobFOEqmYA073Poritw2etU,576
+codex_switch/instances.py,sha256=YmUU3B8CVgR4Vr6CoO1-Sbz94KvUojdCm0Wg7ft6qfA,1344
+codex_switch/models.py,sha256=VM00LBiNQjLgJHIEGwEvWETEXk16qWzd2Gc6AxKzn2k,2539
+codex_switch/paths.py,sha256=0Skqf2sgfrRj3IqVAdV5nId-3K5D78XMF2TiZU2YOVg,538
+codex_switch/probe.py,sha256=bkQ_RXjINjM4OKtdVhZF7dkT0Tgl_rBUXScVvnrlVC8,1972
+codex_switch/routing.py,sha256=MigACRYbUVTY0jftjX7k-T3GqrRXxfgz_fk3VtvS1Gg,482
+codex_switch/runtime.py,sha256=oJOwwI53OJ2NvmaLFganeK_2bbayo8EzfuwkOjuunTg,1474
+codex_switch/wizard.py,sha256=QbQ2Fj7YNB1yBWDPudb26VpbL42DLBMNmEv_0Dv7H7g,2958
+codex_switch/wrapper.py,sha256=tOihDTV2S3UQx3mDPAJLB-cJgPYuVo-ezq4CVfL4kog,4321
+codex_switch_cli-0.1.0.dist-info/METADATA,sha256=Jx0uI_sLYhlL7GxKu3p1cSMH81b7nhRwKIsnqh9RURE,2874
+codex_switch_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+codex_switch_cli-0.1.0.dist-info/entry_points.txt,sha256=V2iL0Gdubr3dckiIypFYbPim6xb2v_ZWX9ZrzTAKaEY,54
+codex_switch_cli-0.1.0.dist-info/top_level.txt,sha256=uDKtbENNcLFp7wVNex8fabvPco79t9d3UlymrQoLkN0,13
+codex_switch_cli-0.1.0.dist-info/RECORD,,

codex_switch_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codex_switch_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codex-switch = codex_switch.cli:app

codex_switch_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+codex_switch