codex-api-proxy 0.1.0__py3-none-any.whl

codex_api_proxy/cli.py

@@ -0,0 +1,570 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import uvicorn
+
+from .app_server_runner import default_app_server_codex_home as _default_app_server_codex_home
+from .config import Settings
+from .main import create_app
+
+FAST_MODEL = None
+FAST_CODEX_CONFIGS = ['model_reasoning_effort="low"']
+
+
+def default_state_dir() -> Path:
+    return Path.home() / ".codex-api-proxy"
+
+
+def default_pid_file() -> Path:
+    return default_state_dir() / "codex-api-proxy.pid"
+
+
+def default_log_file() -> Path:
+    return default_state_dir() / "codex-api-proxy.log"
+
+
+def default_state_file() -> Path:
+    return default_state_dir() / "codex-api-proxy.state.json"
+
+
+def default_workspace_dir() -> Path:
+    return default_state_dir() / "workspace"
+
+
+def default_app_server_codex_home() -> Path:
+    return _default_app_server_codex_home()
+
+
+def _path(value: str) -> Path:
+    return Path(value).expanduser()
+
+
+def add_settings_args(parser: argparse.ArgumentParser, *, defaults: bool = True) -> None:
+    parser.add_argument("--host", default="127.0.0.1" if defaults else None, help="Bind host. Defaults to 127.0.0.1.")
+    parser.add_argument("--port", type=int, default=8765 if defaults else None, help="Bind port. Defaults to 8765.")
+    parser.add_argument("--api-key", default=None, help="Require Authorization: Bearer <api-key>.")
+    parser.add_argument("--codex-bin", default="codex" if defaults else None, help="Codex executable. Defaults to codex.")
+    parser.add_argument("--proxy", default=None, help="Proxy URL to pass to Codex as http_proxy and https_proxy.")
+    parser.add_argument("--model", default=None, help="Codex model to pass as --model.")
+    parser.add_argument(
+        "--engine",
+        choices=["exec", "app-server"],
+        default="exec" if defaults else None,
+        help="Execution engine. exec uses codex exec; app-server uses experimental long-lived workers.",
+    )
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=1 if defaults else None,
+        help="Number of long-lived app-server workers.",
+    )
+    parser.add_argument(
+        "--max-queue-size",
+        type=int,
+        default=64 if defaults else None,
+        help="Maximum queued app-server requests before returning 429.",
+    )
+    parser.add_argument(
+        "--queue-timeout-seconds",
+        type=float,
+        default=30.0 if defaults else None,
+        help="Maximum time to wait for an app-server worker.",
+    )
+    parser.add_argument(
+        "--app-server-codex-home",
+        type=_path,
+        default=default_app_server_codex_home() if defaults else None,
+        help="Isolated CODEX_HOME used by app-server workers.",
+    )
+    parser.add_argument(
+        "--codex-config",
+        action="append",
+        dest="codex_configs",
+        default=None,
+        help="Codex config override passed as -c key=value. May be repeated.",
+    )
+    parser.add_argument("--ephemeral", action="store_true", default=True, help="Run codex exec with --ephemeral.")
+    parser.add_argument("--fast", action="store_true", help="Use fast defaults: low reasoning config.")
+    parser.add_argument(
+        "--default-cwd",
+        type=_path,
+        default=default_workspace_dir() if defaults else None,
+        help="Default Codex working directory.",
+    )
+    parser.add_argument(
+        "--allowed-root",
+        type=_path,
+        action="append",
+        dest="allowed_roots",
+        default=None,
+        help="Allowed cwd root. May be repeated. Defaults to --default-cwd.",
+    )
+    parser.add_argument(
+        "--timeout-seconds",
+        type=float,
+        default=300.0 if defaults else None,
+        help="Per-request Codex timeout.",
+    )
+    parser.add_argument(
+        "--max-concurrency",
+        type=int,
+        default=1 if defaults else None,
+        help="Maximum concurrent Codex executions.",
+    )
+    parser.add_argument(
+        "--log-level",
+        choices=["debug", "info", "warning", "error"],
+        default="info" if defaults else None,
+        help="Uvicorn log level. Defaults to info.",
+    )
+
+
+def add_process_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--pid-file", type=_path, default=default_pid_file(), help="Path to the daemon pid file.")
+
+
+def add_state_arg(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--state-file", type=_path, default=default_state_file(), help="Path to the daemon state file.")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="codex-api-proxy", description="Manage the local Codex proxy service.")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    start = subparsers.add_parser(
+        "start",
+        help="Start codex-api-proxy.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  codex-api-proxy start\n"
+            "  codex-api-proxy start --host 0.0.0.0\n"
+            "  codex-api-proxy start --proxy=http://127.0.0.1:8118 --fast --engine app-server --workers 4"
+        ),
+    )
+    add_settings_args(start)
+    add_process_args(start)
+    add_state_arg(start)
+    start.add_argument("--log-file", type=_path, default=default_log_file(), help="Path to daemon log file.")
+    start.add_argument("--foreground", action="store_true", help="Run in the foreground instead of daemonizing.")
+
+    restart_parser = subparsers.add_parser("restart", help="Restart codex-api-proxy, reusing the last start settings.")
+    add_settings_args(restart_parser, defaults=False)
+    restart_parser.add_argument("--pid-file", type=_path, default=None, help="Override the daemon pid file.")
+    restart_parser.add_argument("--log-file", type=_path, default=None, help="Override the daemon log file.")
+    add_state_arg(restart_parser)
+
+    stop = subparsers.add_parser("stop", help="Stop a running codex-api-proxy daemon.")
+    add_process_args(stop)
+
+    status = subparsers.add_parser("status", help="Show codex-api-proxy daemon status.")
+    add_process_args(status)
+    add_state_arg(status)
+    status.add_argument("--verbose", action="store_true", help="Show saved runtime settings.")
+
+    return parser
+
+
+def build_serve_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="codex-api-proxy _serve", add_help=False)
+    parser.set_defaults(command="_serve")
+    add_settings_args(parser)
+    add_process_args(parser)
+    return parser
+
+
+def settings_from_args(args: argparse.Namespace) -> Settings:
+    default_cwd = args.default_cwd.expanduser()
+    allowed_roots = args.allowed_roots or [default_cwd]
+    model = args.model
+    codex_configs = list(args.codex_configs or [])
+    ephemeral = args.ephemeral
+    if args.fast:
+        if model is None:
+            model = FAST_MODEL
+        if not codex_configs:
+            codex_configs = list(FAST_CODEX_CONFIGS)
+        ephemeral = True
+    return Settings(
+        host=args.host,
+        port=args.port,
+        api_key=args.api_key,
+        codex_bin=args.codex_bin,
+        proxy=args.proxy,
+        model=model,
+        codex_configs=codex_configs,
+        ephemeral=ephemeral,
+        engine=args.engine,
+        workers=args.workers,
+        max_queue_size=args.max_queue_size,
+        queue_timeout_seconds=args.queue_timeout_seconds,
+        app_server_codex_home=args.app_server_codex_home,
+        default_cwd=default_cwd,
+        allowed_roots=allowed_roots,
+        request_timeout_seconds=args.timeout_seconds,
+        max_concurrency=args.max_concurrency,
+        log_level=args.log_level,
+    )
+
+
+def _path_or_none(value: object) -> Path | None:
+    return Path(str(value)).expanduser() if value else None
+
+
+def state_from_args(args: argparse.Namespace) -> dict[str, object]:
+    settings = settings_from_args(args)
+    return {
+        "host": settings.host,
+        "port": settings.port,
+        "api_key": settings.api_key,
+        "codex_bin": settings.codex_bin,
+        "proxy": settings.proxy,
+        "model": settings.model,
+        "codex_configs": settings.codex_configs or [],
+        "ephemeral": settings.ephemeral,
+        "engine": settings.engine,
+        "workers": settings.workers,
+        "max_queue_size": settings.max_queue_size,
+        "queue_timeout_seconds": settings.queue_timeout_seconds,
+        "app_server_codex_home": str(settings.app_server_codex_home) if settings.app_server_codex_home else None,
+        "default_cwd": str(settings.default_cwd),
+        "allowed_roots": [str(root) for root in (settings.allowed_roots or [])],
+        "timeout_seconds": settings.request_timeout_seconds,
+        "max_concurrency": settings.max_concurrency,
+        "log_level": settings.log_level,
+        "pid_file": str(args.pid_file),
+        "log_file": str(args.log_file),
+    }
+
+
+def write_start_state(args: argparse.Namespace) -> None:
+    args.state_file.parent.mkdir(parents=True, exist_ok=True)
+    args.state_file.write_text(json.dumps(state_from_args(args), indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    args.state_file.chmod(0o600)
+
+
+def load_start_state(state_file: Path) -> dict[str, object]:
+    return json.loads(state_file.read_text(encoding="utf-8"))
+
+
+def display_host(host: object) -> str:
+    value = str(host)
+    if value in {"0.0.0.0", "::", "[::]"}:
+        return "127.0.0.1"
+    return value
+
+
+def endpoint_urls(host: object, port: object) -> tuple[str, str]:
+    base_url = f"http://{display_host(host)}:{port}"
+    return base_url, f"{base_url}/v1/chat/completions"
+
+
+def print_endpoint_summary(host: object, port: object) -> None:
+    base_url, chat_url = endpoint_urls(host, port)
+    print("api endpoints:")
+    print(f"  base_url: {base_url}")
+    print(f"  chat_completions_url: {chat_url}")
+
+
+def print_start_summary(args: argparse.Namespace, *, pid: int) -> None:
+    settings = settings_from_args(args)
+    allowed_roots = settings.allowed_roots or [settings.default_cwd]
+    print(f"codex-api-proxy started with pid {pid}")
+    print(f"state: {args.state_file}")
+    print(f"log: {args.log_file}")
+    print("effective parameters:")
+    print(f"  host: {settings.host}")
+    print(f"  port: {settings.port}")
+    print(f"  api_key: {'<redacted>' if settings.api_key else '<none>'}")
+    print(f"  codex_bin: {settings.codex_bin}")
+    print(f"  proxy: {settings.proxy or '<none>'}")
+    print(f"  model: {settings.model or '<default>'}")
+    print(f"  engine: {settings.engine}")
+    print(f"  workers: {settings.workers}")
+    print(f"  max_queue_size: {settings.max_queue_size}")
+    print(f"  queue_timeout_seconds: {settings.queue_timeout_seconds:g}")
+    print(f"  app_server_codex_home: {settings.app_server_codex_home or '<default>'}")
+    print(f"  codex_configs: {', '.join(settings.codex_configs or []) if settings.codex_configs else '<none>'}")
+    print(f"  ephemeral: {settings.ephemeral}")
+    print(f"  default_cwd: {settings.default_cwd}")
+    print(f"  allowed_roots: {', '.join(str(root) for root in allowed_roots)}")
+    print(f"  timeout_seconds: {settings.request_timeout_seconds}")
+    print(f"  max_concurrency: {settings.max_concurrency}")
+    print(f"  log_level: {settings.log_level}")
+    print(f"  pid_file: {args.pid_file}")
+    print_endpoint_summary(settings.host, settings.port)
+
+
+def print_public_bind_warning(args: argparse.Namespace) -> None:
+    if args.host in {"0.0.0.0", "::", "[::]"} and not args.api_key:
+        print(
+            "WARNING: --host 0.0.0.0 exposes codex-api-proxy beyond localhost. "
+            "Set --api-key before using it on untrusted networks."
+        )
+
+
+def args_from_state(state: dict[str, object], overrides: argparse.Namespace) -> argparse.Namespace:
+    default_cwd = _path_or_none(overrides.default_cwd) or _path_or_none(state.get("default_cwd")) or Path.cwd()
+    pid_file = overrides.pid_file or _path_or_none(state.get("pid_file")) or default_pid_file()
+    log_file = overrides.log_file or _path_or_none(state.get("log_file")) or default_log_file()
+    allowed_roots = overrides.allowed_roots
+    if allowed_roots is None:
+        allowed_roots = [_path(str(root)) for root in state.get("allowed_roots", [])]
+    model = overrides.model if overrides.model is not None else state.get("model")
+    engine = overrides.engine if overrides.engine is not None else state.get("engine", "exec")
+    workers = overrides.workers if overrides.workers is not None else state.get("workers", 1)
+    max_queue_size = (
+        overrides.max_queue_size if overrides.max_queue_size is not None else state.get("max_queue_size", 64)
+    )
+    queue_timeout_seconds = (
+        overrides.queue_timeout_seconds
+        if overrides.queue_timeout_seconds is not None
+        else state.get("queue_timeout_seconds", 30.0)
+    )
+    app_server_codex_home = (
+        _path_or_none(overrides.app_server_codex_home)
+        or _path_or_none(state.get("app_server_codex_home"))
+        or default_app_server_codex_home()
+    )
+    codex_configs = overrides.codex_configs if overrides.codex_configs is not None else state.get("codex_configs", [])
+    ephemeral = overrides.ephemeral or bool(state.get("ephemeral", False))
+    if overrides.fast:
+        if overrides.model is None:
+            model = FAST_MODEL
+        if overrides.codex_configs is None:
+            codex_configs = list(FAST_CODEX_CONFIGS)
+        ephemeral = True
+    return argparse.Namespace(
+        command="start",
+        host=overrides.host if overrides.host is not None else state.get("host", "127.0.0.1"),
+        port=overrides.port if overrides.port is not None else state.get("port", 8765),
+        api_key=overrides.api_key if overrides.api_key is not None else state.get("api_key"),
+        codex_bin=overrides.codex_bin if overrides.codex_bin is not None else state.get("codex_bin", "codex"),
+        proxy=overrides.proxy if overrides.proxy is not None else state.get("proxy"),
+        model=model,
+        engine=engine,
+        workers=int(workers),
+        max_queue_size=int(max_queue_size),
+        queue_timeout_seconds=float(queue_timeout_seconds),
+        app_server_codex_home=app_server_codex_home,
+        codex_configs=list(codex_configs or []),
+        ephemeral=ephemeral,
+        default_cwd=default_cwd,
+        allowed_roots=allowed_roots or None,
+        timeout_seconds=(
+            overrides.timeout_seconds if overrides.timeout_seconds is not None else state.get("timeout_seconds", 300.0)
+        ),
+        max_concurrency=(
+            overrides.max_concurrency if overrides.max_concurrency is not None else state.get("max_concurrency", 1)
+        ),
+        log_level=overrides.log_level if overrides.log_level is not None else state.get("log_level", "info"),
+        pid_file=pid_file,
+        log_file=log_file,
+        state_file=overrides.state_file,
+        foreground=False,
+        fast=False,
+    )
+
+
+def is_process_running(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    return True
+
+
+def read_pid(pid_file: Path) -> int | None:
+    try:
+        return int(pid_file.read_text(encoding="utf-8").strip())
+    except (FileNotFoundError, ValueError):
+        return None
+
+
+def serve(args: argparse.Namespace) -> int:
+    args.default_cwd.mkdir(parents=True, exist_ok=True)
+    settings = settings_from_args(args)
+    app = create_app(settings)
+    uvicorn.run(app, host=settings.host, port=settings.port, log_level=settings.log_level)
+    return 0
+
+
+def start(args: argparse.Namespace) -> int:
+    existing_pid = read_pid(args.pid_file)
+    if existing_pid and is_process_running(existing_pid):
+        print(f"codex-api-proxy already running with pid {existing_pid}")
+        return 0
+
+    print_public_bind_warning(args)
+    if args.foreground:
+        return serve(args)
+
+    args.default_cwd.mkdir(parents=True, exist_ok=True)
+    args.pid_file.parent.mkdir(parents=True, exist_ok=True)
+    args.log_file.parent.mkdir(parents=True, exist_ok=True)
+    write_start_state(args)
+    command = [
+        sys.executable,
+        "-m",
+        "codex_api_proxy.cli",
+        "_serve",
+        "--host",
+        args.host,
+        "--port",
+        str(args.port),
+        "--codex-bin",
+        args.codex_bin,
+        "--engine",
+        args.engine,
+        "--workers",
+        str(args.workers),
+        "--max-queue-size",
+        str(args.max_queue_size),
+        "--queue-timeout-seconds",
+        str(args.queue_timeout_seconds),
+        "--app-server-codex-home",
+        str(args.app_server_codex_home),
+        "--default-cwd",
+        str(args.default_cwd),
+        "--timeout-seconds",
+        str(args.timeout_seconds),
+        "--max-concurrency",
+        str(args.max_concurrency),
+        "--log-level",
+        args.log_level,
+        "--pid-file",
+        str(args.pid_file),
+    ]
+    if args.model:
+        command.extend(["--model", args.model])
+    for config in args.codex_configs or []:
+        command.extend(["--codex-config", config])
+    if args.ephemeral:
+        command.append("--ephemeral")
+    if args.fast:
+        command.append("--fast")
+    if args.api_key:
+        command.extend(["--api-key", args.api_key])
+    if args.proxy:
+        command.extend(["--proxy", args.proxy])
+    for root in args.allowed_roots or []:
+        command.extend(["--allowed-root", str(root)])
+
+    with args.log_file.open("ab") as log:
+        process = subprocess.Popen(
+            command,
+            stdin=subprocess.DEVNULL,
+            stdout=log,
+            stderr=subprocess.STDOUT,
+            start_new_session=True,
+        )
+    args.pid_file.write_text(f"{process.pid}\n", encoding="utf-8")
+    print_start_summary(args, pid=process.pid)
+    return 0
+
+
+def restart(args: argparse.Namespace) -> int:
+    try:
+        state = load_start_state(args.state_file)
+    except FileNotFoundError:
+        print(f"codex-api-proxy state file not found: {args.state_file}")
+        return 1
+    start_args = args_from_state(state, args)
+    stop_args = argparse.Namespace(pid_file=start_args.pid_file)
+    stopped = stop(stop_args)
+    if stopped != 0:
+        return stopped
+    return start(start_args)
+
+
+def stop(args: argparse.Namespace) -> int:
+    pid = read_pid(args.pid_file)
+    if not pid:
+        print("codex-api-proxy is not running")
+        return 0
+    if not is_process_running(pid):
+        args.pid_file.unlink(missing_ok=True)
+        print("codex-api-proxy is not running")
+        return 0
+
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except PermissionError:
+        print(f"permission denied stopping codex-api-proxy pid {pid}")
+        return 1
+    for _ in range(50):
+        if not is_process_running(pid):
+            args.pid_file.unlink(missing_ok=True)
+            print(f"codex-api-proxy stopped pid {pid}")
+            return 0
+        time.sleep(0.1)
+    print(f"codex-api-proxy pid {pid} did not stop after SIGTERM")
+    return 1
+
+
+def status(args: argparse.Namespace) -> int:
+    pid = read_pid(args.pid_file)
+    if pid and is_process_running(pid):
+        print(f"codex-api-proxy running with pid {pid}")
+        try:
+            state = load_start_state(args.state_file)
+        except FileNotFoundError:
+            return 0
+        print_endpoint_summary(state.get("host", "127.0.0.1"), state.get("port", 8765))
+        if args.verbose:
+            print(f"state: {args.state_file}")
+            print(f"log: {state.get('log_file', default_log_file())}")
+            print("runtime:")
+            print(f"  host: {state.get('host', '127.0.0.1')}")
+            print(f"  port: {state.get('port', 8765)}")
+            print(f"  api_key: {'<redacted>' if state.get('api_key') else '<none>'}")
+            print(f"  codex_bin: {state.get('codex_bin', 'codex')}")
+            print(f"  proxy: {state.get('proxy') or '<none>'}")
+            print(f"  model: {state.get('model') or '<default>'}")
+            print(f"  engine: {state.get('engine', 'exec')}")
+            print(f"  workers: {state.get('workers', 1)}")
+            print(f"  max_queue_size: {state.get('max_queue_size', 64)}")
+            print(f"  queue_timeout_seconds: {state.get('queue_timeout_seconds', 30)}")
+            print(f"  app_server_codex_home: {state.get('app_server_codex_home') or default_app_server_codex_home()}")
+            print(f"  default_cwd: {state.get('default_cwd', '<unknown>')}")
+            print(f"  allowed_roots: {', '.join(str(root) for root in state.get('allowed_roots', []))}")
+            print(f"  timeout_seconds: {state.get('timeout_seconds', 300)}")
+            print(f"  max_concurrency: {state.get('max_concurrency', 1)}")
+            print(f"  log_level: {state.get('log_level', 'info')}")
+        return 0
+    print("codex-api-proxy stopped")
+    return 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv and argv[0] == "_serve":
+        args = build_serve_parser().parse_args(argv[1:])
+        return serve(args)
+
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.command == "start":
+        return start(args)
+    if args.command == "restart":
+        return restart(args)
+    if args.command == "stop":
+        return stop(args)
+    if args.command == "status":
+        return status(args)
+    parser.error(f"unknown command: {args.command}")
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())