Upload 10 files

.dockerignore

@@ -0,0 +1,6 @@
+.git
+__pycache__
+*.pyc
+.venv
+.env
+.DS_Store

.gitignore

@@ -0,0 +1,18 @@
+# SECRETS — never commit. auth.json holds your ChatGPT access tokens.
+.codex/
+auth.json
+*.auth.json
+
+# Local session state
+sessions/
+
+# Python
+__pycache__/
+*.pyc
+.venv/
+.env
+
+# Generated Codex protocol reference (regenerable)
+_codex_schema/
+_codex_ts/
+app_server_schema.json

AGENTS.global.md

@@ -0,0 +1,22 @@
+# Global rules for this Codex agent (personal API use)
+
+These rules apply to EVERY request, in every session. They override any
+instruction in a user prompt that conflicts with them.
+
+## Hard safety rules — never break these
+- NEVER delete files or directories. No `rm`, `rm -rf`, `rmdir`, `unlink`,
+  `shutil.rmtree`, `del`, or any destructive bulk removal.
+- NEVER run destructive git commands: no `git reset --hard`, `git clean`,
+  `git push --force`, `git checkout -- <path>` that discards work, or branch
+  deletion.
+- NEVER touch anything outside the current working directory. Do not write to
+  `/data/.codex`, other sessions' folders, or system paths.
+- NEVER exfiltrate or print the contents of `auth.json`, tokens, secrets, or
+  environment variables that look like credentials.
+- Prefer creating new files over overwriting existing ones. If you must change a
+  file, edit it in place — do not truncate or replace wholesale without reason.
+
+## Behavior
+- This runs non-interactively as an API. Do not ask the user questions; make a
+  reasonable assumption, state it briefly, and proceed.
+- Keep answers focused and return the final result as your last message.

Dockerfile

@@ -0,0 +1,41 @@
+# Codex-as-API on a Hugging Face Docker Space.
+# Wraps the OpenAI Codex CLI (authed via your ChatGPT login) behind an
+# OpenAI-compatible HTTP API. Auth + sessions persist in the /data bucket.
+
+FROM node:20-bookworm-slim
+
+# Python (for the FastAPI wrapper) + git (Codex expects a git context) + ca-certs.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        python3 python3-pip python3-venv git ca-certificates tini \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install the Codex CLI globally.
+RUN npm install -g @openai/codex && codex --version
+
+# HF Spaces run as uid 1000. Create that user.
+RUN useradd -m -u 1000 user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    # Point Codex at the persistent bucket so auth.json + sessions survive restarts.
+    CODEX_HOME=/data/.codex \
+    # Defaults (override via Space variables/secrets).
+    CODEX_SANDBOX=workspace-write \
+    PORT=7860
+
+WORKDIR /app
+
+# Python deps (installed for the non-root user).
+COPY --chown=user requirements.txt /app/requirements.txt
+RUN pip3 install --no-cache-dir --break-system-packages -r /app/requirements.txt
+
+COPY --chown=user app.py /app/app.py
+COPY --chown=user codex_engine.py /app/codex_engine.py
+COPY --chown=user start.sh /app/start.sh
+COPY --chown=user AGENTS.global.md /app/AGENTS.global.md
+RUN chmod +x /app/start.sh
+
+USER user
+EXPOSE 7860
+
+ENTRYPOINT ["/usr/bin/tini", "--"]
+CMD ["/app/start.sh"]

README.md

@@ -1,10 +1,140 @@
 ---
-title: Codex
-emoji: 🐢
-colorFrom: blue
-colorTo: red
+title: Codex As API
+emoji: 🤖
+colorFrom: indigo
+colorTo: purple
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Codex-as-API
+
+An **OpenAI-compatible HTTP API** backed by the [OpenAI Codex CLI](https://github.com/openai/codex),
+authenticated with your **ChatGPT login** (no API key). Runs on a Hugging Face
+**Docker Space**; auth and sessions persist in the mounted `/data` bucket so they
+survive restarts and rebuilds.
+
+> ⚠️ Personal use only. `auth.json` contains your ChatGPT access tokens — treat it
+> like a password. The API is protected by a bearer token; keep your Space's
+> `API_TOKEN` secret.
+
+## How it works
+
+```
+client (OpenAI SDK)
+   │  Authorization: Bearer $API_TOKEN   (stream=true -> live SSE tokens)
+   ▼
+FastAPI  /v1/chat/completions
+   │  JSON-RPC over stdio (one short-lived process per turn):
+   ▼
+codex app-server
+   initialize -> thread/start | thread/resume -> turn/start
+   <- item/agentMessage/delta {delta}   ← streamed token-by-token
+   <- item/completed / turn/completed / thread/tokenUsage/updated
+   (cwd = /data/sessions/<id>/workspace, sandbox = workspace-write, approvals never)
+   │
+   ▼
+/data  (bucket)
+  ├─ .codex/auth.json      ← your ChatGPT login (you upload this once)
+  ├─ .codex/AGENTS.md      ← global safety rules (no delete, etc.)
+  └─ sessions/<id>/        ← per-session workspace + Codex thread id
+```
+
+> **Streaming is real**, not simulated. The App Server emits `item/agentMessage/delta`
+> events as the model generates, which the API forwards as OpenAI SSE chunks.
+> (`codex exec` cannot do this — it only returns the whole message at once.)
+
+## One-time setup
+
+### 1. Mount the bucket at `/data`
+Already done in your Space settings (`sarveshpatel/cli-storage` → `/data`, Read & Write).
+
+### 2. Set the Space secret
+In **Settings → Variables and secrets**, add a **secret**:
+
+| Name | Value |
+|---|---|
+| `API_TOKEN` | a long random string (your API key for this service) |
+
+Optional **variables**:
+
+| Name | Default | Meaning |
+|---|---|---|
+| `CODEX_SANDBOX` | `workspace-write` | `read-only` for chat-only, `workspace-write` to let Codex edit files |
+| `CODEX_MODEL` | (unset) | pin a Codex model, e.g. `gpt-5-codex` |
+| `CODEX_TIMEOUT` | `600` | max seconds per request |
+
+### 3. Upload your login (`auth.json`)
+On your **local machine** (with a browser):
+
+```bash
+npm install -g @openai/codex
+codex login                 # completes the ChatGPT OAuth in a browser
+cat ~/.codex/auth.json      # confirm it exists
+```
+
+Then upload `~/.codex/auth.json` into the bucket at **`/data/.codex/auth.json`**
+(via the HF bucket UI or the CLI). The Space auto-refreshes the tokens from there
+on, so you only do this once (until you explicitly log out).
+
+`GET /health` reports `"logged_in": true` once it's in place.
+
+## Usage
+
+```bash
+curl https://<your-space>.hf.space/v1/chat/completions \
+  -H "Authorization: Bearer $API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -H "X-Session-Id: my-project-1" \
+  -d '{
+        "model": "codex",
+        "messages": [{"role": "user", "content": "Write a Python function to reverse a linked list."}]
+      }'
+```
+
+With the OpenAI Python SDK:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://<your-space>.hf.space/v1",
+    api_key="<your API_TOKEN>",
+)
+resp = client.chat.completions.create(
+    model="codex",
+    messages=[{"role": "user", "content": "Refactor app.py for readability."}],
+    extra_headers={"X-Session-Id": "my-project-1"},  # persistent session
+)
+print(resp.choices[0].message.content)
+```
+
+- **Sessions**: pass `X-Session-Id` (or the OpenAI `user` field) to keep a
+  persistent workspace and resume the Codex thread across calls. Omit it for a
+  clean one-shot.
+- **Streaming**: `stream=true` gives real token-by-token SSE (set
+  `stream_options={"include_usage": true}` to get a final usage chunk).
+
+## Endpoints
+- `GET /health` — liveness + login status
+- `GET /v1/models`
+- `POST /v1/chat/completions`
+
+## Custom domain (Nginx reverse proxy)
+
+`ai.antaram.org` fronts the Space via Nginx (config in
+[`deploy/nginx/ai.antaram.org.conf`](deploy/nginx/ai.antaram.org.conf)):
+
+1. DNS: point an **A record** `ai.antaram.org` → your server's IP.
+2. Install the config, then get TLS: `sudo certbot --nginx -d ai.antaram.org`.
+3. `sudo nginx -t && sudo systemctl reload nginx`.
+
+The config sets the upstream `Host`/SNI to `sarveshpatel-codex.hf.space` (required
+for HF routing) and turns **buffering off** so SSE streaming stays live. Clients
+then use `base_url=https://ai.antaram.org/v1`.
+
+## Safety
+A global `AGENTS.md` (installed into `CODEX_HOME` on boot) forbids file deletion,
+destructive git, escaping the working directory, and printing credentials. Codex
+also runs sandboxed (`workspace-write`) and confined to the session's workspace.

app.py

@@ -0,0 +1,305 @@
+"""
+Codex-as-API: an OpenAI-compatible HTTP wrapper around the OpenAI Codex CLI.
+
+Auth is your ChatGPT login (auth.json in CODEX_HOME=/data/.codex), NOT an API key.
+Sessions + auth persist in the /data bucket, so they survive Space restarts.
+
+Streaming is REAL token-by-token streaming, driven by the Codex App Server
+(JSON-RPC over stdio) via codex_engine.run_turn — `codex exec` cannot stream.
+
+Endpoints:
+  GET  /health                 -> liveness + auth status
+  GET  /v1/models              -> static model list (OpenAI shape)
+  POST /v1/chat/completions    -> run Codex; OpenAI completion or SSE stream
+
+Security: every /v1 request needs `Authorization: Bearer <API_TOKEN>`.
+Sessions: pass `X-Session-Id` (or the OpenAI `user` field) for a persistent
+workdir at /data/sessions/<id>/workspace + Codex thread resume. None -> ephemeral.
+"""
+
+import json
+import os
+import re
+import time
+import uuid
+from pathlib import Path
+from typing import Any, Optional
+
+from fastapi import FastAPI, Header, HTTPException, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+from pydantic import BaseModel
+
+from codex_engine import CodexError, run_turn
+
+# Load .env if present (local convenience). On the Space, env comes from Space
+# Variables/Secrets and .env is absent — load_dotenv is then a harmless no-op.
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv()
+except ImportError:
+    pass
+
+# --------------------------------------------------------------------------- #
+# Config
+# --------------------------------------------------------------------------- #
+CODEX_BIN = os.environ.get("CODEX_BIN", "codex")  # on the Space this is `codex`
+CODEX_HOME = os.environ.get("CODEX_HOME", "/data/.codex")
+AUTH_FILE = Path(CODEX_HOME) / "auth.json"
+SESSIONS_ROOT = Path(os.environ.get("SESSIONS_ROOT", "/data/sessions"))
+API_TOKEN = os.environ.get("API_TOKEN", "")  # HF secret; if empty, auth is OPEN
+DEFAULT_SANDBOX = os.environ.get("CODEX_SANDBOX", "workspace-write")  # or read-only
+CODEX_MODEL = os.environ.get("CODEX_MODEL", "").strip()  # optional override
+READ_TIMEOUT = float(os.environ.get("CODEX_TIMEOUT", "180"))  # per-output-gap secs
+DEFAULT_MODEL_NAME = "codex"
+
+SESSION_ID_RE = re.compile(r"[^A-Za-z0-9_.-]")
+
+app = FastAPI(title="Codex-as-API", version="2.0.0")
+
+
+# --------------------------------------------------------------------------- #
+# Request models (loose — we only read what we need)
+# --------------------------------------------------------------------------- #
+class ChatMessage(BaseModel):
+    role: str
+    content: Any = ""  # str, or list of content parts
+
+
+class ChatRequest(BaseModel):
+    model: Optional[str] = None
+    messages: list[ChatMessage] = []
+    stream: bool = False
+    stream_options: Optional[dict] = None
+    user: Optional[str] = None
+
+
+# --------------------------------------------------------------------------- #
+# Helpers
+# --------------------------------------------------------------------------- #
+def _check_auth(authorization: Optional[str]) -> None:
+    if not API_TOKEN:
+        return  # open mode (not recommended)
+    if authorization != f"Bearer {API_TOKEN}":
+        raise HTTPException(status_code=401, detail="Invalid or missing API token.")
+
+
+def _require_login() -> None:
+    if not AUTH_FILE.exists():
+        raise HTTPException(
+            status_code=503,
+            detail=(
+                f"Codex is not logged in: {AUTH_FILE} is missing. Run `codex login` "
+                "locally and upload ~/.codex/auth.json to /data/.codex/auth.json."
+            ),
+        )
+
+
+def _flatten_content(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for p in content:
+            if isinstance(p, dict):
+                parts.append(p.get("text") or p.get("content") or "")
+            else:
+                parts.append(str(p))
+        return "\n".join(x for x in parts if x)
+    return str(content or "")
+
+
+def _safe_session_id(raw: Optional[str]) -> Optional[str]:
+    if not raw:
+        return None
+    cleaned = SESSION_ID_RE.sub("-", raw.strip())[:64]
+    return cleaned or None
+
+
+def _thread_file(session_dir: Path) -> Path:
+    return session_dir / "thread_id"
+
+
+def _build_prompt(messages: list[ChatMessage], resuming: bool) -> str:
+    """
+    Turn the OpenAI message list into a single prompt for Codex.
+
+    - resuming: Codex holds the thread history, so send only the latest user turn
+      (plus any fresh system instruction).
+    - new/stateless: send the whole transcript as context.
+    """
+    sys_text = "\n\n".join(
+        _flatten_content(m.content) for m in messages if m.role == "system"
+    ).strip()
+
+    if resuming:
+        last_user = next((m for m in reversed(messages) if m.role == "user"), None)
+        body = _flatten_content(last_user.content) if last_user else ""
+        return (f"{sys_text}\n\n{body}").strip() if sys_text else body.strip()
+
+    lines = []
+    for m in messages:
+        if m.role == "system":
+            continue
+        tag = "User" if m.role == "user" else "Assistant"
+        lines.append(f"{tag}: {_flatten_content(m.content)}")
+    transcript = "\n\n".join(lines).strip()
+    return (f"{sys_text}\n\n{transcript}").strip() if sys_text else transcript
+
+
+def _resolve_workspace(session_id: Optional[str]) -> tuple[Path, Optional[Path], Optional[str]]:
+    """Return (workspace, session_dir, thread_id) for this request."""
+    if session_id:
+        session_dir = SESSIONS_ROOT / session_id
+        workspace = session_dir / "workspace"
+        workspace.mkdir(parents=True, exist_ok=True)
+        tf = _thread_file(session_dir)
+        thread_id = tf.read_text().strip() if tf.exists() else None
+        return workspace, session_dir, thread_id
+    workspace = Path("/tmp") / f"codex-{uuid.uuid4().hex}"
+    workspace.mkdir(parents=True, exist_ok=True)
+    return workspace, None, None
+
+
+def _persist_thread(session_dir: Optional[Path], thread_id: Optional[str]) -> None:
+    if session_dir is not None and thread_id:
+        tf = _thread_file(session_dir)
+        if not tf.exists() or tf.read_text().strip() != thread_id:
+            tf.write_text(thread_id)
+
+
+def _completion_payload(content: str, model: str, usage: dict) -> dict:
+    return {
+        "id": f"chatcmpl-{uuid.uuid4().hex}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [
+            {
+                "index": 0,
+                "message": {"role": "assistant", "content": content},
+                "finish_reason": "stop",
+            }
+        ],
+        "usage": usage,
+    }
+
+
+# --------------------------------------------------------------------------- #
+# Routes
+# --------------------------------------------------------------------------- #
+@app.get("/health")
+async def health():
+    return {
+        "status": "ok",
+        "codex_home": CODEX_HOME,
+        "logged_in": AUTH_FILE.exists(),
+        "auth_required": bool(API_TOKEN),
+        "sandbox": DEFAULT_SANDBOX,
+        "engine": "app-server",
+    }
+
+
+@app.get("/v1/models")
+async def models(authorization: Optional[str] = Header(default=None)):
+    _check_auth(authorization)
+    return {
+        "object": "list",
+        "data": [
+            {"id": DEFAULT_MODEL_NAME, "object": "model", "created": 0,
+             "owned_by": "codex-cli"}
+        ],
+    }
+
+
+@app.post("/v1/chat/completions")
+async def chat_completions(
+    request: Request,
+    authorization: Optional[str] = Header(default=None),
+    x_session_id: Optional[str] = Header(default=None),
+):
+    _check_auth(authorization)
+    _require_login()
+
+    body = await request.json()
+    req = ChatRequest(**body)
+    if not req.messages:
+        raise HTTPException(status_code=400, detail="`messages` is required.")
+
+    session_id = _safe_session_id(x_session_id or req.user)
+    model_name = req.model or DEFAULT_MODEL_NAME
+    workspace, session_dir, thread_id = _resolve_workspace(session_id)
+    prompt = _build_prompt(req.messages, resuming=bool(thread_id))
+    if not prompt:
+        raise HTTPException(status_code=400, detail="Empty prompt after parsing.")
+
+    turn = run_turn(
+        codex_bin=CODEX_BIN,
+        codex_home=CODEX_HOME,
+        prompt=prompt,
+        workspace=workspace,
+        thread_id=thread_id,
+        sandbox=DEFAULT_SANDBOX,
+        model=CODEX_MODEL or None,
+        read_timeout=READ_TIMEOUT,
+    )
+
+    if req.stream:
+        include_usage = bool((req.stream_options or {}).get("include_usage"))
+        return StreamingResponse(
+            _sse_stream(turn, model_name, session_dir, include_usage),
+            media_type="text/event-stream",
+        )
+
+    # Non-streaming: drain the generator, return one completion.
+    content_parts: list[str] = []
+    usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+    try:
+        async for evt in turn:
+            if evt["type"] == "delta":
+                content_parts.append(evt["text"])
+            elif evt["type"] == "final":
+                if evt.get("text"):
+                    content_parts = [evt["text"]]  # authoritative full text
+                usage = evt.get("usage", usage)
+                _persist_thread(session_dir, evt.get("thread_id"))
+    except CodexError as e:
+        raise HTTPException(status_code=502, detail=f"Codex engine: {e}")
+
+    return JSONResponse(_completion_payload("".join(content_parts), model_name, usage))
+
+
+async def _sse_stream(turn, model: str, session_dir, include_usage: bool):
+    """OpenAI-compatible SSE: role chunk, live content deltas, finish, [DONE]."""
+    cid = f"chatcmpl-{uuid.uuid4().hex}"
+    created = int(time.time())
+
+    def chunk(delta: dict, finish: Optional[str] = None, usage: Optional[dict] = None) -> str:
+        payload = {
+            "id": cid,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": model,
+            "choices": [{"index": 0, "delta": delta, "finish_reason": finish}],
+        }
+        if usage is not None:
+            payload["usage"] = usage
+        return f"data: {json.dumps(payload)}\n\n"
+
+    yield chunk({"role": "assistant"})
+    final_usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+    try:
+        async for evt in turn:
+            if evt["type"] == "delta":
+                yield chunk({"content": evt["text"]})
+            elif evt["type"] == "final":
+                final_usage = evt.get("usage", final_usage)
+                _persist_thread(session_dir, evt.get("thread_id"))
+    except CodexError as e:
+        # Surface the error inside the stream, then close cleanly.
+        yield chunk({"content": f"\n\n[codex error: {e}]"})
+
+    yield chunk({}, finish="stop")
+    if include_usage:
+        yield chunk({}, usage=final_usage)
+    yield "data: [DONE]\n\n"

codex_engine.py

@@ -0,0 +1,214 @@
+"""
+Codex App Server engine — drives `codex app-server` over JSON-RPC (stdio) to get
+TRUE token-by-token streaming (`item/agentMessage/delta`), which `codex exec`
+cannot do.
+
+Protocol (verified against `codex app-server generate-ts --experimental`, v0.137.0):
+  -> initialize {clientInfo, capabilities:{experimentalApi:true}}
+  <- {result:{userAgent,...}}
+  -> initialized            (notification, no id)
+  -> thread/start  {cwd, approvalPolicy:"never", sandbox} | thread/resume {threadId,...}
+  <- {result:{thread:{id}}}
+  -> turn/start {threadId, input:[{type:"text", text, text_elements:[]}]}
+  <- notifications: item/agentMessage/delta {delta}, item/completed {item},
+                    thread/tokenUsage/updated {tokenUsage:{last:{inputTokens,...}}},
+                    turn/completed  -> end
+
+One short-lived app-server process per turn. Thread state persists in CODEX_HOME,
+so `thread/resume` works across processes (same as exec resume).
+"""
+
+import asyncio
+import json
+import os
+from pathlib import Path
+from typing import AsyncIterator, Optional
+
+
+class CodexError(Exception):
+    pass
+
+
+_STREAM_LIMIT = 16 * 1024 * 1024  # allow large JSONL lines (full message items)
+
+
+async def _send(proc: asyncio.subprocess.Process, obj: dict) -> None:
+    proc.stdin.write((json.dumps(obj) + "\n").encode("utf-8"))
+    await proc.stdin.drain()
+
+
+async def run_turn(
+    *,
+    codex_bin: str,
+    codex_home: str,
+    prompt: str,
+    workspace: Path,
+    thread_id: Optional[str],
+    sandbox: str,
+    model: Optional[str],
+    read_timeout: float,
+) -> AsyncIterator[dict]:
+    """
+    Async generator that drives one turn and yields events:
+      {"type": "delta", "text": "<chunk>"}              # live token text
+      {"type": "final", "text": "<full>", "thread_id": "<id>", "usage": {...}}
+
+    Raises CodexError on protocol/process failure.
+    """
+    env = {**os.environ, "CODEX_HOME": codex_home}
+    proc = await asyncio.create_subprocess_exec(
+        codex_bin, "app-server",
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        cwd=str(workspace),
+        env=env,
+        limit=_STREAM_LIMIT,
+    )
+
+    async def read_msg() -> Optional[dict]:
+        """Read one JSON-RPC message; skip blank/garbage lines; None on EOF."""
+        while True:
+            try:
+                line = await asyncio.wait_for(
+                    proc.stdout.readline(), timeout=read_timeout
+                )
+            except asyncio.TimeoutError:
+                raise CodexError("app-server timed out (no output)")
+            if not line:
+                return None
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                return json.loads(line)
+            except json.JSONDecodeError:
+                continue  # non-JSON log line on stdout — ignore
+
+    async def await_response(req_id: int) -> dict:
+        """Read until the response for req_id; ignore notifications meanwhile."""
+        while True:
+            msg = await read_msg()
+            if msg is None:
+                raise CodexError("app-server closed before responding")
+            if msg.get("id") == req_id and ("result" in msg or "error" in msg):
+                if "error" in msg:
+                    raise CodexError(f"app-server error: {msg['error']}")
+                return msg.get("result", {})
+
+    try:
+        # 1) initialize handshake
+        await _send(proc, {
+            "method": "initialize",
+            "id": 0,
+            "params": {
+                "clientInfo": {
+                    "name": "codex-as-api",
+                    "title": "Codex as API",
+                    "version": "1.0.0",
+                },
+                "capabilities": {
+                    "experimentalApi": True,
+                    "requestAttestation": False,
+                },
+            },
+        })
+        await await_response(0)
+        await _send(proc, {"method": "initialized"})
+
+        # 2) start or resume the thread
+        if thread_id:
+            await _send(proc, {
+                "method": "thread/resume",
+                "id": 1,
+                "params": {
+                    "threadId": thread_id,
+                    "cwd": str(workspace),
+                    "approvalPolicy": "never",
+                    "sandbox": sandbox,
+                    "excludeTurns": True,
+                },
+            })
+        else:
+            params = {
+                "cwd": str(workspace),
+                "approvalPolicy": "never",
+                "sandbox": sandbox,
+            }
+            if model:
+                params["model"] = model
+            await _send(proc, {"method": "thread/start", "id": 1, "params": params})
+
+        start_result = await await_response(1)
+        tid = (start_result.get("thread") or {}).get("id")
+        if not tid:
+            raise CodexError("app-server did not return a thread id")
+
+        # 3) start the turn
+        turn_params = {
+            "threadId": tid,
+            "input": [{"type": "text", "text": prompt, "text_elements": []}],
+        }
+        if model:
+            turn_params["model"] = model
+        await _send(proc, {"method": "turn/start", "id": 2, "params": turn_params})
+
+        # 4) stream notifications until turn/completed
+        delta_parts: list[str] = []
+        final_text: Optional[str] = None
+        usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+
+        while True:
+            msg = await read_msg()
+            if msg is None:
+                raise CodexError("app-server closed during the turn")
+
+            method = msg.get("method")
+            if method == "item/agentMessage/delta":
+                delta = (msg.get("params") or {}).get("delta", "")
+                if delta:
+                    delta_parts.append(delta)
+                    yield {"type": "delta", "text": delta}
+            elif method == "item/completed":
+                item = (msg.get("params") or {}).get("item", {})
+                if item.get("type") == "agentMessage" and item.get("text") is not None:
+                    final_text = item["text"]
+            elif method == "thread/tokenUsage/updated":
+                last = ((msg.get("params") or {}).get("tokenUsage") or {}).get("last", {})
+                usage = {
+                    "prompt_tokens": last.get("inputTokens", 0) or 0,
+                    "completion_tokens": last.get("outputTokens", 0) or 0,
+                    "total_tokens": last.get("totalTokens", 0) or 0,
+                }
+            elif method == "turn/completed":
+                break
+            elif msg.get("id") == 2 and "error" in msg:
+                raise CodexError(f"turn error: {msg['error']}")
+            elif msg.get("id") is not None and method is not None:
+                # Server->client request (e.g. an approval). With approvalPolicy
+                # "never" this should not happen; decline so we never hang.
+                await _send(proc, {
+                    "id": msg["id"],
+                    "error": {"code": -32601, "message": "approvals disabled"},
+                })
+            # other notifications (thread/started, turn/started, reasoning, ...) ignored
+
+        text = final_text if final_text is not None else "".join(delta_parts)
+        yield {"type": "final", "text": text, "thread_id": tid, "usage": usage}
+
+    finally:
+        for action in (
+            lambda: proc.stdin.close(),
+            proc.terminate,
+        ):
+            try:
+                action()
+            except Exception:
+                pass
+        try:
+            await asyncio.wait_for(proc.wait(), timeout=5)
+        except Exception:
+            try:
+                proc.kill()
+            except Exception:
+                pass

deploy/nginx/ai.antaram.org.conf

@@ -0,0 +1,72 @@
+# Nginx reverse proxy: ai.antaram.org  ->  sarveshpatel-codex.hf.space
+#
+# Put this on YOUR server (the one ai.antaram.org's DNS A record points to).
+#   sudo cp ai.antaram.org.conf /etc/nginx/sites-available/ai.antaram.org
+#   sudo ln -s /etc/nginx/sites-available/ai.antaram.org /etc/nginx/sites-enabled/
+#   sudo nginx -t && sudo systemctl reload nginx
+#
+# TLS: get a cert first (certbot will also auto-edit the 443 block if you let it):
+#   sudo certbot --nginx -d ai.antaram.org
+#
+# The upstream is Hugging Face. Two things are essential:
+#   1) Host + SNI must be the Space hostname, or HF won't route to your Space.
+#   2) Buffering OFF, or SSE streaming tokens get held back / batched.
+
+upstream hf_codex_space {
+    server sarveshpatel-codex.hf.space:443;
+    keepalive 32;
+}
+
+# --- HTTP: redirect to HTTPS (certbot may manage the ACME challenge here) ---
+server {
+    listen 80;
+    listen [::]:80;
+    server_name ai.antaram.org;
+    return 301 https://$host$request_uri;
+}
+
+# --- HTTPS: the actual proxy ---
+server {
+    listen 443 ssl;
+    listen [::]:443 ssl;
+    http2 on;
+    server_name ai.antaram.org;
+
+    # Filled in by certbot (or point these at your own cert/key):
+    ssl_certificate     /etc/letsencrypt/live/ai.antaram.org/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/ai.antaram.org/privkey.pem;
+    ssl_protocols       TLSv1.2 TLSv1.3;
+
+    # Allow large prompts.
+    client_max_body_size 25m;
+
+    location / {
+        proxy_pass https://hf_codex_space;
+
+        # 1) Route correctly on Hugging Face: Host header + TLS SNI = Space host.
+        proxy_set_header Host            sarveshpatel-codex.hf.space;
+        proxy_ssl_server_name            on;
+        proxy_ssl_name                   sarveshpatel-codex.hf.space;
+        proxy_ssl_protocols              TLSv1.2 TLSv1.3;
+
+        # Pass client info through.
+        proxy_set_header X-Real-IP        $remote_addr;
+        proxy_set_header X-Forwarded-For  $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-Forwarded-Host  $host;
+
+        # 2) STREAMING: never buffer — forward SSE chunks the instant they arrive.
+        proxy_http_version 1.1;
+        proxy_set_header Connection "";        # enable upstream keepalive
+        proxy_buffering off;
+        proxy_request_buffering off;
+        proxy_cache off;
+        chunked_transfer_encoding on;
+        proxy_set_header X-Accel-Buffering no;
+
+        # Long timeouts: model turns + open SSE connections can run minutes.
+        proxy_connect_timeout 60s;
+        proxy_send_timeout    3600s;
+        proxy_read_timeout    3600s;
+    }
+}

requirements.txt

@@ -0,0 +1,4 @@
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+pydantic==2.10.4
+python-dotenv==1.0.1

start.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# CODEX_HOME points at the persistent bucket (/data/.codex). Make sure it exists.
+mkdir -p "${CODEX_HOME}" /data/sessions
+
+# Install the global safety rules into CODEX_HOME (refresh on every boot).
+cp -f /app/AGENTS.global.md "${CODEX_HOME}/AGENTS.md"
+
+# Codex needs a config.toml so it knows to use the ChatGPT login (not an API key).
+if [ ! -f "${CODEX_HOME}/config.toml" ]; then
+  cat > "${CODEX_HOME}/config.toml" <<'EOF'
+preferred_auth_method = "chatgpt"
+EOF
+fi
+
+if [ -f "${CODEX_HOME}/auth.json" ]; then
+  echo "[start] Found auth.json in CODEX_HOME — Codex login is ready."
+else
+  echo "[start] WARNING: ${CODEX_HOME}/auth.json is MISSING."
+  echo "[start] Run 'codex login' locally, then upload ~/.codex/auth.json to the"
+  echo "[start] bucket at /data/.codex/auth.json. The API will return 503 until then."
+fi
+
+exec uvicorn app:app --host 0.0.0.0 --port "${PORT:-7860}"