codex-switch-cli 0.1.0__tar.gz → 0.1.2__tar.gz

{codex_switch_cli-0.1.0 → codex_switch_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-switch-cli
-Version: 0.1.0
+Version: 0.1.2
 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
@@ -35,20 +35,30 @@ From PyPI after release:
 
 ```bash
 python3 -m pip install codex-switch-cli
-codex-switch install-shim
+codex-switch init
+```
+
+From Homebrew:
+
+```bash
+brew tap ForeverHYX/tap
+brew install codex-switch-cli
+codex-switch init
 ```
 
 From GitHub before the first PyPI release:
 
 ```bash
 python3 -m pip install git+https://github.com/ForeverHYX/codex-switch.git
-codex-switch install-shim
+codex-switch init
 ```
 
-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.
+`codex-switch init` auto-detects the real `codex` binary, asks how many
+accounts to create, walks you through each upstream login flow, and installs the
+shim so later `codex` commands go through `codex-switch`.
 
 ```bash
+codex-switch init
 codex
 ```
 
@@ -61,9 +71,12 @@ 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.
+The first `codex` run triggers setup if you have already installed the shim.
+`codex-switch init` runs the same interactive flow explicitly and is the
+recommended first step after installation. In both cases, `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.

{codex_switch_cli-0.1.0 → codex_switch_cli-0.1.2}/README.md

@@ -20,20 +20,30 @@ From PyPI after release:
 
 ```bash
 python3 -m pip install codex-switch-cli
-codex-switch install-shim
+codex-switch init
+```
+
+From Homebrew:
+
+```bash
+brew tap ForeverHYX/tap
+brew install codex-switch-cli
+codex-switch init
 ```
 
 From GitHub before the first PyPI release:
 
 ```bash
 python3 -m pip install git+https://github.com/ForeverHYX/codex-switch.git
-codex-switch install-shim
+codex-switch init
 ```
 
-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.
+`codex-switch init` auto-detects the real `codex` binary, asks how many
+accounts to create, walks you through each upstream login flow, and installs the
+shim so later `codex` commands go through `codex-switch`.
 
 ```bash
+codex-switch init
 codex
 ```
 
@@ -46,9 +56,12 @@ 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.
+The first `codex` run triggers setup if you have already installed the shim.
+`codex-switch init` runs the same interactive flow explicitly and is the
+recommended first step after installation. In both cases, `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.

{codex_switch_cli-0.1.0 → codex_switch_cli-0.1.2}/pyproject.toml

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

codex_switch_cli-0.1.2/src/codex_switch/__init__.py

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

{codex_switch_cli-0.1.0 → codex_switch_cli-0.1.2}/src/codex_switch/cli.py

@@ -18,11 +18,11 @@ from codex_switch.config import (
     save_config,
 )
 from codex_switch.doctor import create_doctor_report
-from codex_switch.install import install_shim, uninstall_shim
+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, shim_dir
-from codex_switch.runtime import resolve_real_codex
-from codex_switch.wizard import initialize_app
+from codex_switch.paths import config_path
+from codex_switch.runtime import find_real_codex, resolve_real_codex
+from codex_switch.wizard import bootstrap_from_prompt, clear_existing_state, initialize_app
 
 app = typer.Typer(no_args_is_help=True)
 
@@ -51,7 +51,7 @@ def _load_initialized_config() -> AppConfig:
 
 def _resolve_real_codex_for_management(config: AppConfig) -> str:
     try:
-        resolved = resolve_real_codex(config.real_codex_path, shim_dir())
+        resolved = resolve_real_codex(config.real_codex_path, runtime_wrapper_dir())
     except FileNotFoundError as exc:
         _fail(f"Unable to locate the real Codex binary: {exc}")
 
@@ -75,19 +75,55 @@ def _resolve_instance(config: AppConfig, instance_name: str):
 
 @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()),
+    instance_count: int | None = typer.Option(None, min=1),
+    real_codex_path: Path | None = typer.Option(None, exists=True, dir_okay=False),
+    shared_home: Path | None = typer.Option(None),
+    force: bool = typer.Option(False, "--force", help="Overwrite any existing configuration."),
 ) -> None:
+    selected_shared_home = Path.home() if shared_home is None else shared_home
     try:
-        initialize_app(
-            real_codex_path=real_codex_path,
-            instance_count=instance_count,
-            shared_home=shared_home,
+        resolved_real_codex = (
+            real_codex_path
+            if real_codex_path is not None
+            else find_real_codex(runtime_wrapper_dir())
         )
-    except (CodexCommandError, FileExistsError, LoginBootstrapAbortedError, ValueError) as exc:
+    except FileNotFoundError as exc:
+        _fail(f"Unable to locate the real Codex binary: {exc}")
+
+    if config_path().exists():
+        should_rebuild = force or typer.confirm(
+            f"{config_path()} already exists. Overwrite it and rebuild all account instances?"
+        )
+        if not should_rebuild:
+            _fail("Initialization aborted.")
+        clear_existing_state()
+
+    try:
+        if instance_count is None:
+            config = bootstrap_from_prompt(
+                real_codex_path=resolved_real_codex,
+                shared_home=selected_shared_home,
+                input_fn=input,
+                output_fn=typer.echo,
+            )
+        else:
+            config = initialize_app(
+                real_codex_path=resolved_real_codex,
+                instance_count=instance_count,
+                shared_home=selected_shared_home,
+                input_fn=input,
+                output_fn=typer.echo,
+            )
+        shim_target = install_shim()
+    except (
+        CodexCommandError,
+        FileExistsError,
+        LoginBootstrapAbortedError,
+        ValueError,
+    ) as exc:
         _fail(str(exc))
-    typer.echo(f"Initialized {instance_count} account instances")
+    typer.echo(f"Initialized {len(config.instances)} account instances")
+    typer.echo(f"Installed codex shim at {shim_target}")
 
 
 @app.command("list")
@@ -143,7 +179,10 @@ def doctor() -> None:
 
 @app.command("install-shim")
 def install_shim_command() -> None:
-    target = install_shim()
+    try:
+        target = install_shim()
+    except FileExistsError as exc:
+        _fail(str(exc))
     typer.echo(f"Installed codex shim at {target}")
 
 

{codex_switch_cli-0.1.0 → codex_switch_cli-0.1.2}/src/codex_switch/doctor.py

@@ -5,7 +5,7 @@ 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.install import active_shim_path, runtime_wrapper_dir
 from codex_switch.probe import probe_instance
 from codex_switch.runtime import resolve_real_codex
 
@@ -24,16 +24,16 @@ class DoctorReport:
 
 
 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
+    active = active_shim_path(os.environ.get("PATH", ""))
+    if active is None:
+        return False
+    if wrapper_dir is None:
+        return True
+    return active.parent.resolve() == wrapper_dir.resolve()
 
 
 def create_doctor_report(wrapper_dir: Path | None = None) -> DoctorReport:
-    actual_wrapper_dir = wrapper_dir or shim_dir()
+    actual_wrapper_dir = wrapper_dir or runtime_wrapper_dir()
     shim_ok = shim_precedes_path(actual_wrapper_dir)
 
     try:

codex_switch_cli-0.1.2/src/codex_switch/install.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from pathlib import Path
+
+from codex_switch.paths import shim_dir
+
+ENV_SHIM_DIR = "CODEX_SWITCH_SHIM_DIR"
+
+
+def _path_entries(path_env: str | None = None) -> list[Path]:
+    return [
+        Path(entry).expanduser().resolve()
+        for entry in (os.environ.get("PATH", "") if path_env is None else path_env).split(os.pathsep)
+        if entry
+    ]
+
+
+def _is_user_python_bin(path: Path, home_dir: Path) -> bool:
+    try:
+        relative = path.relative_to(home_dir)
+    except ValueError:
+        return False
+    return (
+        len(relative.parts) == 4
+        and relative.parts[0] == "Library"
+        and relative.parts[1] == "Python"
+        and relative.parts[3] == "bin"
+    )
+
+
+def _is_preferred_install_dir(path: Path, home_dir: Path) -> bool:
+    return path in {
+        (home_dir / ".local" / "bin").resolve(),
+        (home_dir / "bin").resolve(),
+    } or _is_user_python_bin(path, home_dir)
+
+
+def preferred_shim_dir(path_env: str | None = None) -> Path:
+    home_dir = Path.home().expanduser().resolve()
+    for entry in _path_entries(path_env):
+        if _is_preferred_install_dir(entry, home_dir):
+            return entry
+    return shim_dir()
+
+
+def shim_path(install_dir: Path | None = None) -> Path:
+    return (preferred_shim_dir() if install_dir is None else install_dir) / "codex"
+
+
+def legacy_shim_path() -> Path:
+    return shim_dir() / "codex"
+
+
+def is_codex_switch_shim(path: Path) -> bool:
+    try:
+        return "codex_switch.wrapper" in path.read_text()
+    except OSError:
+        return False
+
+
+def active_shim_path(path_env: str | None = None) -> Path | None:
+    resolved = shutil.which("codex", path=path_env)
+    if resolved is None:
+        return None
+    candidate = Path(resolved).expanduser().resolve()
+    if not is_codex_switch_shim(candidate):
+        return None
+    return candidate
+
+
+def runtime_wrapper_dir() -> Path:
+    override = os.environ.get(ENV_SHIM_DIR)
+    if override:
+        return Path(override).expanduser().resolve()
+    active = active_shim_path()
+    if active is not None:
+        return active.parent
+    return preferred_shim_dir()
+
+
+def _write_shim(target: Path) -> None:
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(
+        "#!/bin/sh\n"
+        f'CODEX_SWITCH_SHIM_DIR="{target.parent}" '
+        f'exec "{sys.executable}" -m codex_switch.wrapper "$@"\n'
+    )
+    os.chmod(target, 0o755)
+
+
+def install_shim() -> Path:
+    target = shim_path()
+    if target.exists() and not is_codex_switch_shim(target):
+        raise FileExistsError(f"{target} already exists and is not a codex-switch shim")
+    _write_shim(target)
+
+    legacy = legacy_shim_path()
+    if legacy != target and legacy.exists() and is_codex_switch_shim(legacy):
+        legacy.unlink()
+    return target
+
+
+def uninstall_shim() -> Path:
+    target = shim_path()
+    candidates = [target, legacy_shim_path(), active_shim_path()]
+    seen: set[Path] = set()
+    for candidate in candidates:
+        if candidate is None:
+            continue
+        resolved = candidate.resolve()
+        if resolved in seen:
+            continue
+        seen.add(resolved)
+        if candidate.exists() and is_codex_switch_shim(candidate):
+            candidate.unlink()
+    return target

codex_switch_cli-0.1.2/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.0 → codex_switch_cli-0.1.2}/src/codex_switch/wizard.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import shutil
 from typing import Callable
 from pathlib import Path
 
@@ -8,7 +9,7 @@ from codex_switch.auth import LoginBootstrapAbortedError, ensure_instance_logged
 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
+from codex_switch.paths import config_path, instances_dir
 
 
 def _validate_real_codex_path(real_codex_path: Path) -> None:
@@ -77,6 +78,15 @@ def initialize_app(
     return config
 
 
+def clear_existing_state() -> None:
+    path = config_path()
+    if path.exists():
+        path.unlink()
+    target_instances_dir = instances_dir()
+    if target_instances_dir.exists():
+        shutil.rmtree(target_instances_dir)
+
+
 def bootstrap_from_prompt(
     real_codex_path: Path,
     shared_home: Path,

{codex_switch_cli-0.1.0 → codex_switch_cli-0.1.2}/src/codex_switch/wrapper.py

@@ -12,11 +12,12 @@ from codex_switch.config import (
     load_config,
     save_config,
 )
+from codex_switch.install import runtime_wrapper_dir
 from codex_switch.models import AppConfig
 from codex_switch.models import ProbeResult
+from codex_switch.paths import shim_dir
 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
 
@@ -73,7 +74,7 @@ def main(argv: list[str] | None = None) -> int:
         config = load_config()
     except ConfigNotInitializedError:
         try:
-            real_codex_path = find_real_codex(shim_dir())
+            real_codex_path = find_real_codex(runtime_wrapper_dir())
             bootstrap_from_prompt(real_codex_path=real_codex_path, shared_home=Path.home())
             config = load_config()
         except (CodexCommandError, LoginBootstrapAbortedError) as exc:
@@ -86,7 +87,7 @@ def main(argv: list[str] | None = None) -> int:
         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())
+        resolved_real_codex = resolve_real_codex(config.real_codex_path, runtime_wrapper_dir())
     except FileNotFoundError as exc:
         return _fail(f"Unable to locate the real Codex binary: {exc}")
     _refresh_real_codex_path(config, resolved_real_codex)