fix: gate launch tracebacks on logs:list and harden copy/stringify

Address review feedback.

Launching a model only requires `models:write`, but reading logs requires
`logs:list`. Returning a full traceback to every caller who may launch a
model therefore handed internal filesystem paths and runtime details to
operators who cannot reach them through the log center, bypassing that
boundary. Gate the `traceback` field on `logs:list` (admins always
qualify, and an unauthenticated cluster has no boundary to protect). The
normalized root-cause `detail` still goes to anyone who may launch a
model, so the UI remains useful without auth changes. API keys are
restricted to model query and inference scopes and so never qualify. The
check live-reads DB permissions, matching the auth service's own policy
so a revoked permission takes effect immediately, and fails closed.

Reuse the existing `copyToClipboard` helper for both copy affordances
instead of calling `navigator.clipboard` directly: it reports real
success or failure rather than always claiming success, and falls back to
`execCommand` where the Clipboard API is unavailable (non-HTTPS origins).
This also fixes a wrong i18n key on the toast action, which referenced a
nonexistent `common.copy` and would have rendered the literal key path.

Guard the remaining `JSON.stringify` in `extractDetail`'s array branch,
which could throw on a BigInt or circular reference while the interceptor
is already handling an error.

Author: OliverBryant

frontend/src/components/pages/launch-model/launch-dialog/launch-dialog.tsx

@@ -12,7 +12,7 @@ import { useGlobal } from '@/contexts/global-context';
 import { useI18n } from '@/contexts/i18n-context';
 import { useForm, useFormValues, useWatch } from '@/hooks/use-form';
 import { useMenuAuth } from '@/hooks/use-menu-auth';
-import { cn } from '@/lib/utils';
+import { cn, copyToClipboard } from '@/lib/utils';
 import { Progress } from '@/components/ui/progress';
 import { Button } from '@/components/ui/button';
 import { Switch } from '@/components/ui/switch';
@@ -1350,8 +1350,7 @@ export default function LaunchDialog({
               size="sm"
               className="ml-auto h-7 shrink-0 gap-1 text-xs"
               onClick={() => {
-                void navigator.clipboard?.writeText(copyText);
-                toast.success(t('common.copySuccess'));
+                void copyToClipboard(copyText);
               }}
             >
               <Copy className="size-3" />

frontend/src/contexts/request-context.tsx

@@ -8,6 +8,7 @@ import { RequestEvents } from '@/constants';
 import { requestManager } from '@/lib/request-manager';
 import { removeAuthTokens } from '@/lib/auth-storage';
 import { translate as t } from '@/contexts/i18n-context';
+import { copyToClipboard } from '@/lib/utils';
 import type { ServerErrorPayload } from '@/lib/request';
 
 export default function RequestProvider({ children }: PropsWithChildren) {
@@ -54,9 +55,9 @@ export default function RequestProvider({ children }: PropsWithChildren) {
           </pre>
         ),
         action: {
-          label: t('common.copy'),
+          label: t('launchModel.copyError'),
           onClick: () => {
-            void navigator.clipboard?.writeText(`${message ?? ''}\n\n${traceback}`);
+            void copyToClipboard(`${message ?? ''}\n\n${traceback}`);
           },
         },
       });

frontend/src/lib/request.ts

@@ -46,21 +46,25 @@ function extractDetail(data: unknown): string {
           ? String((item as { msg: unknown }).msg)
           : typeof item === 'string'
             ? item
-            : JSON.stringify(item)
+            : safeStringify(item)
       )
       .filter(Boolean);
     if (messages.length) return messages.join('; ');
   }
-  if (data && typeof data === 'object') {
-    try {
-      return JSON.stringify(data);
-    } catch {
-      return String(data);
-    }
-  }
+  if (data && typeof data === 'object') return safeStringify(data);
   return String(data ?? '');
 }
 
+/** `JSON.stringify` throws on BigInt and circular references; this runs while
+ * already handling an error, so it must never throw itself. */
+function safeStringify(value: unknown): string {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+
 // Keep untyped request calls backward-compatible while typed calls can still pass <T>.
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type LooseResponse = any;

xinference/api/restful_api.py

@@ -280,6 +280,51 @@ def _is_ip_allowed(self, ip: str) -> bool:
     def is_authenticated(self):
         return self._advanced_auth_service is not None
 
+    def _caller_may_see_diagnostics(self, request) -> bool:
+        """Whether the caller is allowed to receive internal diagnostics.
+
+        Launching a model only requires ``models:write``, but a traceback
+        exposes filesystem paths and runtime internals that are otherwise
+        reachable only through the log center, which requires ``logs:list``.
+        Gate the traceback on that same permission so this endpoint does not
+        become a way around the diagnostic boundary. Admins always qualify.
+
+        When auth is disabled entirely there is no boundary to respect, so
+        diagnostics are returned to everyone.
+        """
+        if not self._advanced_auth_service:
+            return True
+        token = request.headers.get("Authorization", "").replace("Bearer ", "")
+        if not token:
+            return False
+        try:
+            payload = self._advanced_auth_service.verify_access_token(token)
+            if not payload:
+                # An API key rather than a JWT. API keys are restricted to
+                # model query and inference scopes, so they never qualify.
+                return False
+            user = self._advanced_auth_service.db.get_user_by_id(payload.get("user_id"))
+            if not user:
+                return False
+            # Live-read the DB permissions rather than the JWT snapshot, so a
+            # revoked permission takes effect immediately -- the same policy
+            # the auth service itself applies.
+            from .oauth2.scope_aliases import _normalize_scopes
+
+            scopes = _normalize_scopes(user.get("permissions", []))
+        except Exception:
+            # Never let the diagnostics check break the error response itself;
+            # fail closed.
+            logger.debug("Failed to resolve caller scopes", exc_info=True)
+            return False
+        return "admin" in scopes or "logs:list" in scopes
+
+    def _launch_error_traceback(self, request, exc: BaseException) -> Optional[str]:
+        """Format ``exc``'s traceback, or None if the caller may not see it."""
+        if not self._caller_may_see_diagnostics(request):
+            return None
+        return format_error_traceback(exc)
+
     def _check_model_access(
         self, request, model_uid: str, model_type: Optional[str] = None
     ):
@@ -944,17 +989,18 @@ async def launch_model(
             )
         # A launch failure originates deep inside an engine and crosses several
         # actor boundaries before arriving here. Report the root cause of the
-        # chain rather than the outermost wrapper's message, and pass the
-        # traceback along so the UI can show where it actually broke.
+        # chain rather than the outermost wrapper's message. The traceback is
+        # only attached for callers who may already read it in the log center;
+        # the root-cause summary goes to everyone who may launch a model.
         except ValueError as ve:
             logger.error(str(ve), exc_info=True)
             raise DetailedHTTPException(
-                400, format_error_summary(ve), format_error_traceback(ve)
+                400, format_error_summary(ve), self._launch_error_traceback(request, ve)
             )
         except RuntimeError as re:
             logger.error(str(re), exc_info=True)
             raise DetailedHTTPException(
-                503, format_error_summary(re), format_error_traceback(re)
+                503, format_error_summary(re), self._launch_error_traceback(request, re)
             )
         except asyncio.CancelledError as ce:
             # cancelled by user -- not a defect, so no traceback
@@ -963,7 +1009,7 @@ async def launch_model(
         except Exception as e:
             logger.error(str(e), exc_info=True)
             raise DetailedHTTPException(
-                500, format_error_summary(e), format_error_traceback(e)
+                500, format_error_summary(e), self._launch_error_traceback(request, e)
             )
 
         # Clear negative cache so that get_model for this uid is not blocked

xinference/api/tests/test_launch_error_response.py

@@ -23,7 +23,7 @@
 from fastapi.testclient import TestClient
 
 from ...core.error_utils import format_error_summary, format_error_traceback
-from ..restful_api import DetailedHTTPException
+from ..restful_api import DetailedHTTPException, RESTfulAPI
 
 
 def _build_app() -> FastAPI:
@@ -113,3 +113,105 @@ def test_exception_subclasses_http_exception():
     assert exc.status_code == 503
     assert exc.detail == "boom"
     assert exc.tb is None
+
+
+class _FakeDB:
+    def __init__(self, permissions):
+        self._permissions = permissions
+
+    def get_user_by_id(self, user_id):
+        if user_id is None:
+            return None
+        return {"id": user_id, "permissions": list(self._permissions)}
+
+
+class _FakeAuthService:
+    """Minimal stand-in for AdvancedAuthService's diagnostics-relevant surface."""
+
+    def __init__(self, permissions, valid_jwt=True):
+        self.db = _FakeDB(permissions)
+        self._valid_jwt = valid_jwt
+
+    def verify_access_token(self, token):
+        # A None payload is how an API key (rather than a JWT) presents here.
+        return {"user_id": 1} if self._valid_jwt else None
+
+
+def _api_with_auth(auth_service):
+    api = RESTfulAPI.__new__(RESTfulAPI)
+    api._advanced_auth_service = auth_service
+    return api
+
+
+def _request_with_token(token="tok"):
+    headers = [(b"authorization", f"Bearer {token}".encode())] if token else []
+    return Request({"type": "http", "headers": headers, "method": "POST", "path": "/"})
+
+
+class TestDiagnosticsPermission:
+    """Launching needs models:write; a traceback needs logs:list."""
+
+    def test_no_auth_configured_allows_diagnostics(self):
+        api = _api_with_auth(None)
+        assert api._caller_may_see_diagnostics(_request_with_token()) is True
+
+    def test_logs_list_allows_diagnostics(self):
+        api = _api_with_auth(_FakeAuthService(["models:write", "logs:list"]))
+        assert api._caller_may_see_diagnostics(_request_with_token()) is True
+
+    def test_admin_allows_diagnostics(self):
+        api = _api_with_auth(_FakeAuthService(["admin"]))
+        assert api._caller_may_see_diagnostics(_request_with_token()) is True
+
+    def test_models_write_alone_is_denied(self):
+        # The whole point of the gate: a model operator without log access
+        # must not receive filesystem paths and runtime internals.
+        api = _api_with_auth(_FakeAuthService(["models:write"]))
+        assert api._caller_may_see_diagnostics(_request_with_token()) is False
+
+    def test_legacy_scope_alias_is_honoured(self):
+        # models:start normalizes to models:write -- still not logs:list.
+        api = _api_with_auth(_FakeAuthService(["models:start"]))
+        assert api._caller_may_see_diagnostics(_request_with_token()) is False
+
+    def test_missing_token_is_denied(self):
+        api = _api_with_auth(_FakeAuthService(["logs:list"]))
+        assert api._caller_may_see_diagnostics(_request_with_token(None)) is False
+
+    def test_api_key_is_denied(self):
+        # API keys cannot hold logs:list, so they never qualify.
+        api = _api_with_auth(_FakeAuthService(["logs:list"], valid_jwt=False))
+        assert api._caller_may_see_diagnostics(_request_with_token()) is False
+
+    def test_unknown_user_is_denied(self):
+        service = _FakeAuthService(["logs:list"])
+        service.db.get_user_by_id = lambda _uid: None
+        api = _api_with_auth(service)
+        assert api._caller_may_see_diagnostics(_request_with_token()) is False
+
+    def test_auth_failure_fails_closed(self):
+        service = _FakeAuthService(["logs:list"])
+
+        def _boom(_token):
+            raise RuntimeError("auth backend down")
+
+        service.verify_access_token = _boom
+        api = _api_with_auth(service)
+        # Must not propagate out of the error path, and must deny.
+        assert api._caller_may_see_diagnostics(_request_with_token()) is False
+
+
+class TestLaunchErrorTraceback:
+    def test_traceback_withheld_without_permission(self):
+        api = _api_with_auth(_FakeAuthService(["models:write"]))
+        assert (
+            api._launch_error_traceback(_request_with_token(), ValueError("x")) is None
+        )
+
+    def test_traceback_returned_with_permission(self):
+        api = _api_with_auth(_FakeAuthService(["logs:list"]))
+        try:
+            raise ValueError("boom")
+        except ValueError as e:
+            tb = api._launch_error_traceback(_request_with_token(), e)
+        assert tb is not None and "ValueError: boom" in tb

xinference/core/error_utils.py

@@ -116,8 +116,10 @@ def format_error_summary(exc: BaseException) -> str:
 def format_error_traceback(exc: BaseException) -> Optional[str]:
     """Render the full traceback of ``exc``, including its cause chain.
 
-    Returns ``None`` when ``XINFERENCE_DISABLE_ERROR_TRACEBACK`` is set, for
-    deployments that would rather not expose filesystem paths over HTTP.
+    Returns ``None`` when ``XINFERENCE_DISABLE_ERROR_TRACEBACK`` is set, which
+    withholds tracebacks over HTTP even from callers who would otherwise be
+    permitted them. Callers are responsible for the permission check itself;
+    see ``RESTfulAPI._caller_may_see_diagnostics``.
 
     Formats ``exc`` rather than its root cause on purpose: the outer exception
     carries the frames from every layer, and xoscar attaches the remote