codex-switch-cli 0.1.0__tar.gz

codex_switch_cli-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,74 @@
+# 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/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "codex-switch-cli"
+version = "0.1.0"
+description = "Transparent account-aware wrapper for the Codex CLI"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = ["typer>=0.12,<1.0"]
+
+[project.urls]
+Homepage = "https://github.com/ForeverHYX/codex-switch"
+Repository = "https://github.com/ForeverHYX/codex-switch"
+Issues = "https://github.com/ForeverHYX/codex-switch/issues"
+
+[project.optional-dependencies]
+dev = ["build>=1.2,<2.0", "pytest>=8.0,<9.0", "twine>=6.0,<7.0"]
+
+[project.scripts]
+codex-switch = "codex_switch.cli:app"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]

codex_switch_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

codex_switch_cli-0.1.0/src/codex_switch/__init__.py

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

codex_switch_cli-0.1.0/src/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-0.1.0/src/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_cli-0.1.0/src/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_cli-0.1.0/src/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_cli-0.1.0/src/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_cli-0.1.0/src/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