portacode 1.5.17.dev0__tar.gz → 1.5.17.dev1__tar.gz

{portacode-1.5.17.dev0 → portacode-1.5.17.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.17.dev0
+Version: 1.5.17.dev1
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-1.5.17.dev0 → portacode-1.5.17.dev1}/portacode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.17.dev0'
-__version_tuple__ = version_tuple = (1, 5, 17, 'dev0')
+__version__ = version = '1.5.17.dev1'
+__version_tuple__ = version_tuple = (1, 5, 17, 'dev1')
 
 __commit_id__ = commit_id = None

portacode-1.5.17.dev1/portacode/codex_loopback_proxy.py

@@ -0,0 +1,468 @@
+"""Loopback-only Codex Responses proxy authenticated by the device key.
+
+Runs on a dedicated thread + event loop so long-lived SSE streams and crypto
+never starve the Portacode websocket / terminal asyncio loop.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import hashlib
+import json
+import logging
+import os
+import secrets
+import threading
+import time
+import uuid
+from concurrent.futures import Future
+from typing import Dict, Optional, Tuple
+
+import httpx
+
+from .codex_usage_limit import note_usage_limit_resets_at
+from .keypair import KeyPair
+
+LOGGER = logging.getLogger(__name__)
+
+CODEX_LOOPBACK_HOST = "127.0.0.1"
+CODEX_LOOPBACK_PORT = 61789
+DEFAULT_GATEWAY_URL = "https://codexapi.portacode.com/v1"
+MAX_REQUEST_BYTES = 10 * 1024 * 1024
+ALLOWED_PATHS = {"/health", "/v1/models", "/v1/responses"}
+MAX_CONCURRENT_UPSTREAM = 8
+
+# Streaming read can idle between SSE chunks; connect/write stay bounded.
+_UPSTREAM_TIMEOUT = httpx.Timeout(connect=20.0, read=600.0, write=60.0, pool=20.0)
+
+FORWARD_RESPONSE_HEADERS = frozenset(
+    {
+        "content-type",
+        "cache-control",
+        "x-codex-active-limit",
+        "x-codex-primary-reset-at",
+        "x-codex-secondary-reset-at",
+        "x-codex-primary-used-percent",
+        "x-codex-secondary-used-percent",
+        "x-codex-primary-window-minutes",
+        "x-codex-secondary-window-minutes",
+        "x-codex-promo-message",
+        "x-codex-credits-available",
+        "x-codex-credits-balance",
+        "x-portacode-resets-at",
+        "x-request-id",
+        "cf-ray",
+    }
+)
+
+
+class CodexLoopbackProxy:
+    """Expose the narrow OpenAI-compatible surface that Codex CLI needs locally."""
+
+    def __init__(self, keypair: KeyPair, gateway_url: Optional[str] = None) -> None:
+        self.keypair = keypair
+        self.gateway_url = (
+            gateway_url
+            or os.getenv("PORTACODE_CODEX_DEVICE_GATEWAY_URL")
+            or DEFAULT_GATEWAY_URL
+        ).rstrip("/")
+        self._server: Optional[asyncio.AbstractServer] = None
+        self._client: Optional[httpx.AsyncClient] = None
+        self._upstream_sem: Optional[asyncio.Semaphore] = None
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event: Optional[threading.Event] = None
+        self._active_requests = 0
+        self._active_lock = threading.Lock()
+
+    async def start(self) -> None:
+        """Start the proxy thread (idempotent). Awaitable from the agent loop."""
+        if self._thread is not None and self._thread.is_alive() and self._server is not None:
+            return
+
+        ready: Future = Future()
+        stop_event = threading.Event()
+        self._stop_event = stop_event
+
+        def _thread_main() -> None:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            self._loop = loop
+            try:
+                loop.run_until_complete(self._async_start())
+                ready.set_result(True)
+                while not stop_event.is_set():
+                    loop.run_forever()
+                    if stop_event.is_set():
+                        break
+            except Exception as exc:
+                if not ready.done():
+                    ready.set_exception(exc)
+                else:
+                    LOGGER.exception("Codex loopback proxy thread crashed")
+            finally:
+                try:
+                    loop.run_until_complete(self._async_stop())
+                except Exception:
+                    LOGGER.exception("Codex loopback proxy cleanup failed")
+                try:
+                    loop.close()
+                except Exception:
+                    pass
+                self._loop = None
+
+        self._thread = threading.Thread(
+            target=_thread_main,
+            name="portacode-codex-loopback",
+            daemon=True,
+        )
+        self._thread.start()
+        await asyncio.wrap_future(ready)
+
+    async def stop(self) -> None:
+        thread = self._thread
+        loop = self._loop
+        stop_event = self._stop_event
+        if thread is None:
+            return
+        if stop_event is not None:
+            stop_event.set()
+        if loop is not None and loop.is_running():
+            loop.call_soon_threadsafe(loop.stop)
+        # Prefer to_thread when available; keep a 3.8-safe fallback.
+        try:
+            await asyncio.to_thread(thread.join, 5.0)
+        except AttributeError:
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, thread.join, 5.0)
+        self._thread = None
+        self._stop_event = None
+
+    async def _async_start(self) -> None:
+        if self._server is not None:
+            return
+        self._upstream_sem = asyncio.Semaphore(MAX_CONCURRENT_UPSTREAM)
+        self._client = httpx.AsyncClient(
+            timeout=_UPSTREAM_TIMEOUT,
+            follow_redirects=False,
+            http2=False,
+        )
+        try:
+            self._server = await asyncio.start_server(
+                self._handle_client,
+                host=CODEX_LOOPBACK_HOST,
+                port=CODEX_LOOPBACK_PORT,
+                limit=MAX_REQUEST_BYTES + 16 * 1024,
+                reuse_address=True,
+            )
+        except OSError:
+            LOGGER.exception(
+                "Failed to bind Codex loopback proxy on %s:%s",
+                CODEX_LOOPBACK_HOST,
+                CODEX_LOOPBACK_PORT,
+            )
+            await self._async_stop()
+            raise
+        LOGGER.info(
+            "Codex loopback proxy listening on http://%s:%s/v1 (isolated thread, gateway=%s)",
+            CODEX_LOOPBACK_HOST,
+            CODEX_LOOPBACK_PORT,
+            self.gateway_url,
+        )
+
+    async def _async_stop(self) -> None:
+        server = self._server
+        self._server = None
+        if server is not None:
+            server.close()
+            try:
+                await server.wait_closed()
+            except Exception:
+                LOGGER.debug("wait_closed for loopback server failed", exc_info=True)
+        client = self._client
+        self._client = None
+        if client is not None:
+            try:
+                await client.aclose()
+            except Exception:
+                LOGGER.debug("Closing upstream httpx client failed", exc_info=True)
+
+    def _signature_headers(self, method: str, path: str, body: bytes) -> Dict[str, str]:
+        timestamp = str(int(time.time()))
+        nonce = secrets.token_urlsafe(24)
+        body_hash = hashlib.sha256(body).hexdigest()
+        canonical = f"{method}\n{path}\n{timestamp}\n{nonce}\n{body_hash}".encode("ascii")
+        signature = base64.b64encode(self.keypair.sign_bytes(canonical)).decode("ascii")
+        return {
+            "X-Portacode-Device-Key": self.keypair.public_key_der_b64(),
+            "X-Portacode-Timestamp": timestamp,
+            "X-Portacode-Nonce": nonce,
+            "X-Portacode-Signature": signature,
+        }
+
+    def _bump_active(self, delta: int) -> int:
+        with self._active_lock:
+            self._active_requests = max(0, self._active_requests + delta)
+            return self._active_requests
+
+    async def _handle_client(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        req_id = uuid.uuid4().hex[:10]
+        peer = writer.get_extra_info("peername")
+        started = time.monotonic()
+        active = self._bump_active(1)
+        method = path = "-"
+        try:
+            method, path, headers, body = await self._read_request(reader)
+            LOGGER.info(
+                "codex-proxy[%s] %s %s bytes=%s peer=%s active=%s",
+                req_id,
+                method,
+                path,
+                len(body),
+                peer,
+                active,
+            )
+            if method == "GET" and path == "/health":
+                payload = {
+                    "ok": True,
+                    "service": "portacode-codex-loopback",
+                    "active_requests": active,
+                    "gateway": self.gateway_url,
+                }
+                await self._write_json(
+                    writer, 200, json.dumps(payload, separators=(",", ":")).encode("utf-8")
+                )
+                return
+            if method not in {"GET", "POST"} or path not in ALLOWED_PATHS:
+                await self._write_error(writer, 404, "Unsupported local Codex endpoint")
+                return
+            if method == "GET" and path != "/v1/models":
+                await self._write_error(writer, 405, "Method not allowed")
+                return
+            if method == "POST" and path != "/v1/responses":
+                await self._write_error(writer, 405, "Method not allowed")
+                return
+            await self._forward(writer, method, path, headers, body, req_id=req_id)
+        except asyncio.TimeoutError:
+            LOGGER.error(
+                "codex-proxy[%s] timed out after %.1fs method=%s path=%s",
+                req_id,
+                time.monotonic() - started,
+                method,
+                path,
+            )
+            try:
+                await self._write_error(writer, 504, "Portacode Codex proxy timed out talking to gateway")
+            except Exception:
+                pass
+        except ValueError as exc:
+            LOGGER.warning("codex-proxy[%s] bad request: %s", req_id, exc)
+            try:
+                await self._write_error(writer, 400, str(exc))
+            except Exception:
+                pass
+        except Exception:
+            LOGGER.exception(
+                "codex-proxy[%s] request failed after %.1fs method=%s path=%s",
+                req_id,
+                time.monotonic() - started,
+                method,
+                path,
+            )
+            try:
+                await self._write_error(writer, 502, "Portacode Codex proxy request failed")
+            except Exception:
+                pass
+        finally:
+            remaining = self._bump_active(-1)
+            LOGGER.info(
+                "codex-proxy[%s] done in %.1fs active=%s",
+                req_id,
+                time.monotonic() - started,
+                remaining,
+            )
+            try:
+                writer.close()
+                await asyncio.wait_for(writer.wait_closed(), timeout=2.0)
+            except Exception:
+                pass
+
+    async def _read_request(
+        self, reader: asyncio.StreamReader
+    ) -> Tuple[str, str, Dict[str, str], bytes]:
+        request_line = (await asyncio.wait_for(reader.readline(), timeout=30.0)).decode("latin-1").strip()
+        parts = request_line.split(" ")
+        if len(parts) != 3:
+            raise ValueError("Malformed HTTP request")
+        method, target, _version = parts
+        path = target.split("?", 1)[0]
+        headers: Dict[str, str] = {}
+        while True:
+            line = await asyncio.wait_for(reader.readline(), timeout=30.0)
+            if line in {b"\r\n", b"\n", b""}:
+                break
+            name, separator, value = line.decode("latin-1").partition(":")
+            if not separator:
+                raise ValueError("Malformed HTTP header")
+            headers[name.strip().lower()] = value.strip()
+        if headers.get("transfer-encoding", "").lower() == "chunked":
+            raise ValueError("Chunked request bodies are not supported")
+        length = int(headers.get("content-length", "0"))
+        if length < 0 or length > MAX_REQUEST_BYTES:
+            raise ValueError("Request body exceeds the local Codex proxy limit")
+        body = (
+            await asyncio.wait_for(reader.readexactly(length), timeout=60.0) if length else b""
+        )
+        return method.upper(), path, headers, body
+
+    def _collect_response_headers(self, response: httpx.Response) -> Dict[str, str]:
+        out: Dict[str, str] = {
+            "Content-Type": response.headers.get("content-type", "application/json"),
+            "Cache-Control": "no-store",
+            "Connection": "close",
+        }
+        for name, value in response.headers.items():
+            key = name.lower()
+            if key in FORWARD_RESPONSE_HEADERS and key not in {"content-type", "cache-control"}:
+                out[name] = value
+        return out
+
+    def _note_resets_from_error(self, response: httpx.Response, body: bytes) -> None:
+        resets_at = None
+        header_val = response.headers.get("x-portacode-resets-at") or response.headers.get(
+            "x-codex-primary-reset-at"
+        )
+        if header_val:
+            try:
+                resets_at = int(header_val)
+            except ValueError:
+                resets_at = None
+        if resets_at is None and body:
+            try:
+                payload = json.loads(body.decode("utf-8", errors="replace"))
+            except json.JSONDecodeError:
+                payload = None
+            if isinstance(payload, dict):
+                err = payload.get("error") if isinstance(payload.get("error"), dict) else {}
+                for key in ("resets_at", "resetsAt"):
+                    if key in err:
+                        try:
+                            resets_at = int(err[key])
+                            break
+                        except (TypeError, ValueError):
+                            pass
+        note_usage_limit_resets_at(resets_at)
+
+    async def _forward(
+        self,
+        writer: asyncio.StreamWriter,
+        method: str,
+        path: str,
+        request_headers: Dict[str, str],
+        body: bytes,
+        *,
+        req_id: str,
+    ) -> None:
+        headers = self._signature_headers(method, path, body)
+        content_type = request_headers.get("content-type")
+        if content_type:
+            headers["Content-Type"] = content_type
+        gateway_path = path[3:] if path.startswith("/v1") else path
+        upstream_url = f"{self.gateway_url}/device{gateway_path}"
+        client = self._client
+        if client is None:
+            raise RuntimeError("Upstream HTTP client is not started")
+        sem = self._upstream_sem
+        if sem is None:
+            raise RuntimeError("Upstream semaphore is not started")
+
+        async with sem:
+            LOGGER.info(
+                "codex-proxy[%s] upstream %s %s",
+                req_id,
+                method,
+                upstream_url,
+            )
+            try:
+                async with client.stream(
+                    method,
+                    upstream_url,
+                    content=body,
+                    headers=headers,
+                ) as response:
+                    response_headers = self._collect_response_headers(response)
+                    status_text = response.reason_phrase or "OK"
+                    LOGGER.info(
+                        "codex-proxy[%s] upstream status=%s content-type=%s",
+                        req_id,
+                        response.status_code,
+                        response.headers.get("content-type", ""),
+                    )
+
+                    if response.status_code >= 400:
+                        err_body = await response.aread()
+                        self._note_resets_from_error(response, err_body)
+                        LOGGER.warning(
+                            "codex-proxy[%s] upstream error status=%s body_prefix=%r",
+                            req_id,
+                            response.status_code,
+                            err_body[:300],
+                        )
+                        response_headers["Content-Length"] = str(len(err_body))
+                        writer.write(
+                            f"HTTP/1.1 {response.status_code} {status_text}\r\n".encode("ascii")
+                        )
+                        for name, value in response_headers.items():
+                            writer.write(f"{name}: {value}\r\n".encode("latin-1"))
+                        writer.write(b"\r\n")
+                        writer.write(err_body)
+                        await writer.drain()
+                        return
+
+                    if response.headers.get("content-length"):
+                        response_headers["Content-Length"] = response.headers["content-length"]
+                    writer.write(
+                        f"HTTP/1.1 {response.status_code} {status_text}\r\n".encode("ascii")
+                    )
+                    for name, value in response_headers.items():
+                        writer.write(f"{name}: {value}\r\n".encode("latin-1"))
+                    writer.write(b"\r\n")
+                    bytes_out = 0
+                    async for chunk in response.aiter_raw():
+                        if not chunk:
+                            continue
+                        bytes_out += len(chunk)
+                        writer.write(chunk)
+                        await writer.drain()
+                    LOGGER.info(
+                        "codex-proxy[%s] streamed %s bytes to client",
+                        req_id,
+                        bytes_out,
+                    )
+            except httpx.TimeoutException as exc:
+                LOGGER.error("codex-proxy[%s] upstream timeout: %s", req_id, exc)
+                raise asyncio.TimeoutError(str(exc)) from exc
+            except httpx.HTTPError as exc:
+                LOGGER.error("codex-proxy[%s] upstream http error: %s", req_id, exc)
+                raise
+
+    async def _write_error(self, writer: asyncio.StreamWriter, status: int, message: str) -> None:
+        body = ('{"error":{"message":"' + message.replace('"', "'") + '"}}').encode("utf-8")
+        await self._write_json(writer, status, body)
+
+    async def _write_json(self, writer: asyncio.StreamWriter, status: int, body: bytes) -> None:
+        reason = "OK" if 200 <= status < 300 else "Error"
+        writer.write(
+            (
+                f"HTTP/1.1 {status} {reason}\r\n"
+                "Content-Type: application/json\r\n"
+                "Cache-Control: no-store\r\n"
+                f"Content-Length: {len(body)}\r\n"
+                "Connection: close\r\n\r\n"
+            ).encode("ascii")
+            + body
+        )
+        await writer.drain()

{portacode-1.5.17.dev0 → portacode-1.5.17.dev1}/portacode/codex_prepare.py

@@ -170,6 +170,148 @@ def read_codex_env_file(path: Optional[Path] = None) -> Dict[str, str]:
     return values
 
 
+def _runtime_user_home() -> Path:
+    try:
+        from portacode.connection.handlers.runtime_user import get_runtime_user_home
+
+        return Path(get_runtime_user_home())
+    except Exception:
+        return Path.home()
+
+
+def resolve_codex_home() -> Path:
+    """Return the Codex state directory shared by app-server and interactive CLI.
+
+    Web chat and ``codex resume`` must use the same store. When the Portacode
+    agent runs as root it previously defaulted to ``/root/.codex`` while IDE
+    terminals (as the workspace user) used ``$HOME/.codex`` — so the CLI could
+    not see web-created chats.
+    """
+    preferred = _runtime_user_home() / ".codex"
+    explicit = (os.environ.get("CODEX_HOME") or "").strip()
+    if not explicit:
+        return preferred
+
+    path = Path(explicit).expanduser()
+    # Remap stale root homes so CLI (runtime user) and app-server stay aligned.
+    try:
+        from portacode.connection.handlers.runtime_user import get_default_runtime_user
+
+        runtime_user = get_default_runtime_user()
+    except Exception:
+        runtime_user = ""
+    if (
+        hasattr(os, "geteuid")
+        and os.geteuid() == 0
+        and runtime_user
+        and runtime_user != "root"
+        and (str(path) == "/root/.codex" or str(path).startswith("/root/.codex/"))
+    ):
+        return preferred
+    return path
+
+
+def _persist_codex_home_env(codex_home: Path) -> None:
+    """Ensure interactive shells (profile.d) pick up the shared CODEX_HOME."""
+    if platform.system().lower() != "linux":
+        return
+    path = Path(CODEX_ENV_PATH)
+    desired = f"CODEX_HOME={codex_home}"
+    try:
+        existing = path.read_text(encoding="utf-8") if path.is_file() else ""
+    except OSError:
+        return
+    lines = existing.splitlines()
+    out: list[str] = []
+    found = False
+    for line in lines:
+        if line.startswith("CODEX_HOME="):
+            if not found:
+                out.append(desired)
+                found = True
+            continue
+        out.append(line)
+    if not found:
+        if out and out[-1] != "":
+            out.append("")
+        out.append(desired)
+    body = "\n".join(out).rstrip() + "\n"
+    if body == existing:
+        return
+    script = (
+        f"install -d -m 755 /etc/portacode && "
+        f"printf '%s' {shlex.quote(body)} > {shlex.quote(str(path))} && "
+        f"chmod 644 {shlex.quote(str(path))}"
+    )
+    try:
+        _run([*_sudo_prefix(), "sh", "-c", script])
+    except Exception:
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(body, encoding="utf-8")
+            path.chmod(0o644)
+        except OSError:
+            pass
+
+
+def ensure_codex_home() -> Path:
+    """Create CODEX_HOME and seed it from /root/.codex sessions when needed."""
+    import pwd
+    import shutil
+
+    codex_home = resolve_codex_home()
+    codex_home.mkdir(parents=True, exist_ok=True)
+    sessions_dir = codex_home / "sessions"
+    sessions_dir.mkdir(parents=True, exist_ok=True)
+
+    root_codex = Path("/root/.codex")
+    root_sessions = root_codex / "sessions"
+    if (
+        hasattr(os, "geteuid")
+        and os.geteuid() == 0
+        and root_sessions.is_dir()
+        and codex_home.resolve() != root_codex.resolve()
+    ):
+        for src in root_sessions.rglob("*.jsonl"):
+            try:
+                rel = src.relative_to(root_sessions)
+            except ValueError:
+                continue
+            dest = sessions_dir / rel
+            if dest.exists():
+                continue
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                shutil.copy2(src, dest)
+            except OSError:
+                continue
+        for name in ("config.toml", "auth.json"):
+            src = root_codex / name
+            dest = codex_home / name
+            if src.is_file() and not dest.exists():
+                try:
+                    shutil.copy2(src, dest)
+                except OSError:
+                    pass
+        try:
+            from portacode.connection.handlers.runtime_user import get_default_runtime_user
+
+            user = get_default_runtime_user()
+            pw_entry = pwd.getpwnam(user)
+            for path in [codex_home, *codex_home.rglob("*")]:
+                try:
+                    os.chown(path, pw_entry.pw_uid, pw_entry.pw_gid)
+                except OSError:
+                    pass
+        except Exception:
+            pass
+    try:
+        _persist_codex_home_env(codex_home)
+    except Exception:
+        pass
+    return codex_home
+
+
 def apply_codex_env_to_mapping(
     env: MutableMapping[str, str],
     path: Optional[Path] = None,
@@ -187,6 +329,9 @@ def apply_codex_env_to_mapping(
     # Always guarantee the local proxy sentinel unless a non-empty value exists.
     if not (env.get(OPENAI_API_KEY_ENV) or "").strip():
         env[OPENAI_API_KEY_ENV] = file_values.get(OPENAI_API_KEY_ENV) or LOCAL_SENTINEL
+    # Keep interactive CLI and app-server on the same session store.
+    if not (env.get("CODEX_HOME") or "").strip():
+        env["CODEX_HOME"] = str(resolve_codex_home())
 
 
 def build_codex_subprocess_env(
@@ -196,6 +341,10 @@ def build_codex_subprocess_env(
     """Environment for Codex CLI / app-server subprocesses."""
     env = dict(base or os.environ)
     apply_codex_env_to_mapping(env, path=path)
+    try:
+        env["CODEX_HOME"] = str(ensure_codex_home())
+    except Exception:
+        env.setdefault("CODEX_HOME", str(resolve_codex_home()))
     return env
 
 
@@ -241,9 +390,13 @@ def _set_local_sentinel() -> None:
     if system == "linux":
         # Portacode terminals load this directly, including sessions started by
         # a long-running agent that pre-dates the prepare command.
+        codex_home = str(resolve_codex_home())
         managed_setup = (
             "install -d -m 755 /etc/portacode && "
-            f"printf '%s\\n' '{OPENAI_API_KEY_ENV}={LOCAL_SENTINEL}' > {CODEX_ENV_PATH} && "
+            f"printf '%s\\n' "
+            f"'{OPENAI_API_KEY_ENV}={LOCAL_SENTINEL}' "
+            f"'CODEX_HOME={codex_home}' "
+            f"> {CODEX_ENV_PATH} && "
             f"chmod 644 {CODEX_ENV_PATH} && "
             "printf '%s\\n' '# Managed by portacode prepare codex.' "
             f"'if [ -r {CODEX_ENV_PATH} ]; then' '  set -a' "