@agentsdock/server 1.0.7-beta.5 → 1.0.7

package/server/codex_app_server.py

@@ -562,6 +562,7 @@ class CodexAppServerClient:
         process_factory: ProcessFactory | None = None,
         before_start: Callable[[], Awaitable[Any]] | None = None,
         server_request_handler: ServerRequestHandler | None = None,
+        notification_guard: Callable[[dict[str, Any]], bool] | None = None,
         initialize_params: dict[str, Any] | None = None,
         on_process_started: ProcessLifecycleHook | None = None,
         on_process_exited: ProcessLifecycleHook | None = None,
@@ -599,6 +600,7 @@ class CodexAppServerClient:
         # arbitrary/recycled PIDs, so never derive a signal target from them.
         self._owns_spawned_process_groups = process_factory is None and os.name == "posix"
         self._server_request_handler = server_request_handler or decline_server_request
+        self._notification_guard = notification_guard
         self._initialize_params = initialize_params or {
             "clientInfo": {
                 "name": "agents_server",
@@ -635,6 +637,8 @@ class CodexAppServerClient:
         self._thread_names: dict[str, str] = {}
         self._subscriptions: set[CodexAppServerSubscription] = set()
         self._notification_handlers: set[NotificationHandler] = set()
+        self._account_usage_handlers: set[NotificationHandler] = set()
+        self._account_epoch = 0
         self._callback_tasks: set[asyncio.Task[Any]] = set()
         self._callback_tails: dict[
             tuple[NotificationHandler, str],
@@ -1401,10 +1405,19 @@ class CodexAppServerClient:
         # Authentication notifications are not chat events. Do not expose
         # account metadata or upstream login errors to event subscribers.
         if method in {"account/login/completed", "account/updated"}:
+            self._account_epoch += 1
+            self._dispatch_notification_handlers(
+                {"method": "account/changed", "params": {}},
+                tuple(self._account_usage_handlers), ordered=False,
+            )
             return
         params = notification.get("params")
         if not isinstance(params, dict):
             return
+        if method == "account/rateLimits/updated":
+            self._dispatch_notification_handlers(
+                notification, tuple(self._account_usage_handlers), ordered=False,
+            )
 
         if method == "serverRequest/resolved":
             request_id = params.get("requestId")
@@ -1457,35 +1470,14 @@ class CodexAppServerClient:
                 "at": time.time(),
             })
 
-        for handler in tuple(self._notification_handlers):
-            owner = (handler, thread_id or "")
-            previous = self._callback_tails.get(owner)
-            if previous is None:
-                try:
-                    result = handler(notification)
-                except Exception:
-                    continue
-                if not inspect.isawaitable(result):
-                    # Preserve the original inline contract for synchronous
-                    # caches consumed by immediately following server requests.
-                    continue
-                task = asyncio.ensure_future(result)
-            else:
-                task = asyncio.create_task(
-                    self._invoke_notification_handler(
-                        handler,
-                        notification,
-                        previous,
-                    )
-                )
-            self._callback_tails[owner] = task
-            self._callback_tasks.add(task)
-            task.add_done_callback(
-                lambda completed, owner=owner: self._finish_callback_task(
-                    owner,
-                    completed,
-                )
-            )
+        handlers = tuple(self._notification_handlers)
+        try:
+            allowed = self._notification_guard is None or self._notification_guard(notification)
+        except Exception:
+            allowed = False
+        if not allowed:
+            handlers = ()
+        self._dispatch_notification_handlers(notification, handlers)
 
         # Synchronous handlers (including the scoped fork watcher) must see
         # whether this identity was known *before* this notification. Record a
@@ -1516,6 +1508,54 @@ class CodexAppServerClient:
                 include_thread_subscription=True,
             )
 
+    @property
+    def account_epoch(self) -> int:
+        return self._account_epoch
+
+    def add_account_usage_handler(self, handler: NotificationHandler) -> None:
+        """Observe rate limits/auth invalidation in native receive order.
+
+        Synchronous observers update their cache inline; any returned async
+        invalidation broadcast is tracked without postponing later cache edits.
+        Authentication payloads are never passed to these handlers.
+        """
+        self._account_usage_handlers.add(handler)
+
+    def _dispatch_notification_handlers(
+        self, notification: dict[str, Any], handlers: tuple[NotificationHandler, ...],
+        *, ordered: bool = True,
+    ) -> None:
+        thread_id, _turn_id = _notification_scope(notification)
+        for handler in handlers:
+            owner = (handler, thread_id or "")
+            previous = self._callback_tails.get(owner) if ordered else None
+            if previous is None:
+                try:
+                    result = handler(notification)
+                except Exception:
+                    continue
+                if not inspect.isawaitable(result):
+                    # Preserve the original inline contract for synchronous
+                    # caches consumed by immediately following server requests.
+                    continue
+                task = asyncio.ensure_future(result)
+            else:
+                task = asyncio.create_task(
+                    self._invoke_notification_handler(
+                        handler,
+                        notification,
+                        previous,
+                    )
+                )
+            self._callback_tails[owner] = task
+            self._callback_tasks.add(task)
+            task.add_done_callback(
+                lambda completed, owner=owner: self._finish_callback_task(
+                    owner,
+                    completed,
+                )
+            )
+
     async def _invoke_notification_handler(
         self,
         handler: NotificationHandler,
@@ -1530,6 +1570,8 @@ class CodexAppServerClient:
                 # notification already received for the same handler.
                 pass
         try:
+            if self._notification_guard is not None and not self._notification_guard(notification):
+                return
             result = handler(notification)
         except Exception:
             return
@@ -1749,7 +1791,11 @@ class CodexAppServerClient:
                     isinstance(exc, CodexAppServerDisconnected)
                     and exc.request_sent
                 )
-                if ambiguous:
+                # Ephemeral forks disappear with their owning process. After
+                # explicit close there can be no late child left to delete;
+                # durable forks still require their usual ambiguity cleanup.
+                closing_ephemeral = payload.get("ephemeral") is True and self._closing
+                if ambiguous and not closing_ephemeral:
                     cleanup = asyncio.create_task(
                         self._delete_late_fork_child(late_children)
                     )
@@ -2696,6 +2742,7 @@ class CodexAppServerManager:
         process_factory: ProcessFactory | None = None,
         before_start: Callable[[], Awaitable[Any]] | None = None,
         server_request_handler: ServerRequestHandler | None = None,
+        notification_guard: Callable[[dict[str, Any]], bool] | None = None,
         initialize_params: dict[str, Any] | None = None,
         on_process_started: ProcessLifecycleHook | None = None,
         on_process_exited: ProcessLifecycleHook | None = None,
@@ -2715,6 +2762,7 @@ class CodexAppServerManager:
             process_factory=process_factory,
             before_start=before_start,
             server_request_handler=server_request_handler,
+            notification_guard=notification_guard,
             initialize_params=initialize_params,
             on_process_started=on_process_started,
             on_process_exited=on_process_exited,

package/server/codex_auth.py

@@ -1,7 +1,17 @@
 """Read-only native Codex authentication; custom keys belong to codex_provider."""
 from __future__ import annotations
 
+import base64
+from dataclasses import dataclass, field
+import hashlib
+import hmac
+import json
+import os
+from pathlib import Path
 import re
+import secrets
+import stat
+import tomllib
 
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import JSONResponse
@@ -11,6 +21,115 @@ MAX_BODY_BYTES = 8192
 MAX_API_KEY_CHARS = 4096
 AUTH_TIMEOUT_SECONDS = 30.0
 BUSY_MESSAGE = "Wait for Codex chats, goals, queued turns and Side chat requests to finish before changing authentication."
+HANDOFF_MESSAGE = (
+    "Refreshing Codex sign-in. Wait for this chat's running work, approvals, "
+    "goals and background terminals to finish, then retry. Your message has "
+    "not been sent to Codex."
+)
+_REVISION_KEY = secrets.token_bytes(32)
+_MAX_AUTH_BYTES = 128 * 1024
+
+
+@dataclass(frozen=True)
+class LoginRevision:
+    # Process-private change detection only, never authentication evidence.
+    # Do not put paths, account IDs, credentials or digests in repr/logs/API.
+    value: bytes = field(repr=False)
+
+
+def _bounded_file(path: Path) -> bytes:
+    fd = os.open(path, os.O_RDONLY | os.O_NONBLOCK)
+    with os.fdopen(fd, "rb") as stream:
+        before = os.fstat(stream.fileno())
+        if not stat.S_ISREG(before.st_mode) or before.st_size > _MAX_AUTH_BYTES:
+            raise ValueError("unsupported credential file")
+        raw = stream.read(_MAX_AUTH_BYTES + 1)
+        after = os.fstat(stream.fileno())
+        if len(raw) > _MAX_AUTH_BYTES or (before.st_mtime_ns, before.st_size) != (after.st_mtime_ns, after.st_size):
+            raise ValueError("credential file changed during read")
+        return raw
+
+
+def _native_login_config(env: dict[str, str], cwd: str) -> tuple[Path, dict]:
+    home = env.get("HOME")
+    location = env.get("CODEX_HOME")
+    if not location and not home:
+        raise ValueError("native home unavailable")
+    if location and location.startswith("~/"):
+        if not home:
+            raise ValueError("native home unavailable")
+        location = str(Path(home) / location[2:])
+    root = Path(location) if location else Path(home) / ".codex"
+    if not root.is_absolute():
+        root = Path(cwd) / root
+    try:
+        config = tomllib.loads(_bounded_file(root / "config.toml").decode())
+    except FileNotFoundError:
+        config = {}
+    return root, config
+
+
+def native_login_handoff_supported(env: dict[str, str], *, cwd: str) -> bool:
+    try:
+        _, config = _native_login_config(env, cwd)
+        # A process-only login cannot be recovered by starting a replacement.
+        # A malformed config must not retire an otherwise working generation.
+        return config.get("cli_auth_credentials_store", "file") in {"file", "keyring", "auto"}
+    except (OSError, ValueError, TypeError, RecursionError):
+        return False
+
+
+def native_login_revision(env: dict[str, str], *, cwd: str) -> LoginRevision | None:
+    """Conservative file-store signal; native Codex still owns all credentials.
+
+    Ignore rotating access/refresh tokens and last_refresh. OIDC auth_time is
+    stable across refresh but changes on an interactive authentication. Without
+    it we can detect an account switch, not prove a same-account re-login;
+    Recheck CLIs provides an explicit handoff for that case and keyring stores.
+    Missing/malformed files are not evidence of a new login. No secret survives
+    this bounded read except a process-keyed comparison digest.
+    """
+    try:
+        root, config = _native_login_config(env, cwd)
+        if config.get("cli_auth_credentials_store", "file") != "file":
+            return None  # Never infer keyring/auto/ephemeral state from a leftover file.
+        if any(env.get(key) for key in ("CODEX_ACCESS_TOKEN", "CODEX_API_KEY", "OPENAI_API_KEY", "OPENAI_IDENTITY_TOKEN_FILE")):
+            return None
+        data = json.loads(_bounded_file(root / "auth.json"))
+        if not isinstance(data, dict):
+            return None
+        key = data.get("OPENAI_API_KEY")
+        if isinstance(key, str) and key:
+            identity = ("apiKey", key)
+        else:
+            tokens = data.get("tokens")
+            if not isinstance(tokens, dict) or data.get("auth_mode") not in (None, "chatgpt"):
+                return None
+            encoded = tokens.get("id_token")
+            if not isinstance(encoded, str) or len(encoded) > 32768:
+                return None
+            parts = encoded.split(".")
+            if len(parts) != 3:
+                return None
+            claims = json.loads(base64.urlsafe_b64decode(parts[1] + "=" * (-len(parts[1]) % 4)))
+            if not isinstance(claims, dict):
+                return None
+            details = claims.get("https://api.openai.com/auth") or {}
+            if not isinstance(details, dict):
+                return None
+            account = tokens.get("account_id") or details.get("chatgpt_account_id")
+            subject = claims.get("sub")
+            if not isinstance(account, str) or not account or not isinstance(subject, str) or not subject:
+                return None
+            auth_time = claims.get("auth_time")
+            if auth_time is not None and (isinstance(auth_time, bool) or not isinstance(auth_time, int)):
+                return None
+            # Unverified claims are a change hint, never permission/account proof.
+            identity = ("chatgpt", account, subject, auth_time)
+        raw = json.dumps((str(root.resolve()), identity), separators=(",", ":")).encode()
+        return LoginRevision(hmac.new(_REVISION_KEY, raw, hashlib.sha256).digest())
+    except (OSError, ValueError, TypeError, RecursionError):
+        return None
 
 
 def capability(*, available: bool) -> dict:

package/server/codex_provider.py

@@ -21,7 +21,7 @@ from fastapi.responses import JSONResponse
 
 from codex_auth import validate_api_key
 from codex_app_server import CodexAppServerManager, decline_server_request
-from codex_side_question import isolated_config, _verify_protocol
+from codex_side_question import isolated_config, _verify_isolated_protocol as _verify_protocol
 from side_questions import isolated_environment, run_isolated_command