fix: normalize neuroglancer public urls

Author: akgohain

README.md

@@ -34,6 +34,7 @@ Optional runtime environment variables:
 ```
 PYTC_AUTH_SECRET=replace-me
 PYTC_ALLOWED_ORIGINS=http://localhost:3000,http://127.0.0.1:3000,null
+PYTC_NEUROGLANCER_PUBLIC_BASE=http://localhost:4244
 ```
 
 If restarting after a crash or interrupted session, kill any lingering processes first:

client/src/views/Visualization.js

@@ -1,19 +1,17 @@
-import React, { useState, useContext, useEffect } from "react";
+import React, { useState } from "react";
 import { Button, Tabs, Input, Space, Typography, message } from "antd";
 import {
   ArrowRightOutlined,
   InboxOutlined,
   ReloadOutlined,
 } from "@ant-design/icons";
-import { AppContext } from "../contexts/GlobalContext";
 import { getNeuroglancerViewer } from "../api";
 import UnifiedFileInput from "../components/UnifiedFileInput";
 
 const { Title } = Typography;
 
 function Visualization(props) {
   const { viewers, setViewers } = props;
-  const context = useContext(AppContext);
   const [activeKey, setActiveKey] = useState(
     viewers.length > 0 ? viewers[0].key : null,
   );
@@ -24,9 +22,6 @@ function Visualization(props) {
   const [scales, setScales] = useState("30,6,6");
   const [isLoading, setIsLoading] = useState(false);
 
-  // Update file list options - No longer needed for UnifiedFileInput but keeping context access
-  const { files } = context;
-
   const handleImageChange = (value) => {
     console.log(`selected image:`, value);
     setCurrentImage(value);
@@ -84,8 +79,7 @@ function Visualization(props) {
         scalesArray,
       );
 
-      const newUrl = res.replace(/\/\/[^:/]+/, "//localhost");
-      console.log("Current Viewer at ", newUrl);
+      console.log("Current Viewer at ", res);
 
       // Extract name from path for title
       const getImageName = (val) => {
@@ -102,7 +96,7 @@ function Visualization(props) {
           title:
             getImageName(currentImage) +
             (currentLabel ? " & " + getImageName(currentLabel) : ""),
-          viewer: newUrl,
+          viewer: res,
         },
       ];
 

runtime_settings.py

@@ -1,5 +1,6 @@
 import os
 import secrets
+from typing import Optional
 
 DEFAULT_ALLOWED_ORIGINS = (
     "http://localhost:3000",
@@ -23,3 +24,10 @@ def get_allowed_origins() -> list[str]:
 
 def get_auth_secret() -> str:
     return _AUTH_SECRET
+
+
+def get_neuroglancer_public_base() -> Optional[str]:
+    raw_base = os.getenv("PYTC_NEUROGLANCER_PUBLIC_BASE", "").strip()
+    if not raw_base:
+        return None
+    return raw_base.rstrip("/")

server_api/main.py

@@ -4,13 +4,17 @@
 import shutil
 import tempfile
 from typing import List, Optional
+from urllib.parse import urlsplit, urlunsplit
 
 import requests
 import uvicorn
 from fastapi import Depends, FastAPI, HTTPException, Request, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
 from sqlalchemy.orm import Session
-from runtime_settings import get_allowed_origins
+from runtime_settings import (
+    get_allowed_origins,
+    get_neuroglancer_public_base,
+)
 from server_api.utils.io import readVol
 from server_api.utils.utils import process_path
 from server_api.auth import models, database, router as auth_router
@@ -94,6 +98,42 @@ def _worker_url(path: str) -> str:
     return f"{REACT_APP_SERVER_PROTOCOL}://{REACT_APP_SERVER_URL}{path}"
 
 
+def _derive_neuroglancer_public_base(request: Request) -> str:
+    configured_base = get_neuroglancer_public_base()
+    if configured_base:
+        return configured_base
+
+    forwarded_proto = request.headers.get("x-forwarded-proto")
+    scheme = (forwarded_proto.split(",")[0].strip() if forwarded_proto else "") or (
+        request.url.scheme or "http"
+    )
+
+    forwarded_host = request.headers.get("x-forwarded-host")
+    request_host = (
+        forwarded_host.split(",")[0].strip() if forwarded_host else request.url.netloc
+    )
+    hostname = request_host.split(":")[0] or "localhost"
+    return f"{scheme}://{hostname}:4244"
+
+
+def _build_neuroglancer_public_url(viewer_url: str, request: Request) -> str:
+    viewer_parts = urlsplit(viewer_url)
+    base_parts = urlsplit(_derive_neuroglancer_public_base(request))
+    base_path = base_parts.path.rstrip("/")
+    viewer_path = viewer_parts.path or ""
+    combined_path = f"{base_path}{viewer_path}" if base_path else viewer_path
+
+    return urlunsplit(
+        (
+            base_parts.scheme or "http",
+            base_parts.netloc,
+            combined_path,
+            viewer_parts.query,
+            viewer_parts.fragment,
+        )
+    )
+
+
 def _extract_upstream_payload(response: requests.Response):
     try:
         return response.json()
@@ -394,8 +434,9 @@ def ngLayer(data, res, oo=[0, 0, 0], tt="segmentation"):
             if gt is not None:
                 s.layers.append(name="gt", layer=ngLayer(gt, res, tt="segmentation"))
 
-        print(viewer)
-        return str(viewer)
+        public_url = _build_neuroglancer_public_url(str(viewer), req)
+        print(public_url)
+        return public_url
     finally:
         for path in cleanup_paths:
             try:

tests/test_neuroglancer_url_contract.py

@@ -0,0 +1,74 @@
+import unittest
+from unittest.mock import patch
+
+from starlette.requests import Request
+
+from server_api.main import _build_neuroglancer_public_url
+
+
+def make_request(*, host="localhost:4242", scheme="http", extra_headers=None):
+    headers = [(b"host", host.encode("utf-8"))]
+    for key, value in (extra_headers or {}).items():
+        headers.append((key.lower().encode("utf-8"), value.encode("utf-8")))
+
+    scope = {
+        "type": "http",
+        "http_version": "1.1",
+        "method": "POST",
+        "scheme": scheme,
+        "path": "/neuroglancer",
+        "raw_path": b"/neuroglancer",
+        "query_string": b"",
+        "headers": headers,
+        "server": ("localhost", 4242),
+        "client": ("127.0.0.1", 12345),
+    }
+    return Request(scope)
+
+
+class NeuroglancerUrlContractTests(unittest.TestCase):
+    def test_default_public_url_uses_request_host_with_neuroglancer_port(self):
+        request = make_request(host="localhost:4242", scheme="http")
+
+        public_url = _build_neuroglancer_public_url(
+            "http://0.0.0.0:4244/v/abc123?foo=1",
+            request,
+        )
+
+        self.assertEqual(public_url, "http://localhost:4244/v/abc123?foo=1")
+
+    def test_public_base_env_prefixes_viewer_path(self):
+        request = make_request(host="localhost:4242", scheme="http")
+
+        with patch.dict(
+            "os.environ",
+            {"PYTC_NEUROGLANCER_PUBLIC_BASE": "https://viewer.example.com/ng"},
+            clear=True,
+        ):
+            public_url = _build_neuroglancer_public_url(
+                "http://0.0.0.0:4244/v/demo",
+                request,
+            )
+
+        self.assertEqual(public_url, "https://viewer.example.com/ng/v/demo")
+
+    def test_forwarded_headers_override_request_scheme_and_host(self):
+        request = make_request(
+            host="localhost:4242",
+            scheme="http",
+            extra_headers={
+                "x-forwarded-proto": "https",
+                "x-forwarded-host": "viewer.internal:4242",
+            },
+        )
+
+        public_url = _build_neuroglancer_public_url(
+            "http://0.0.0.0:4244/v/proxy",
+            request,
+        )
+
+        self.assertEqual(public_url, "https://viewer.internal:4244/v/proxy")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_runtime_settings.py

@@ -38,6 +38,18 @@ def test_auth_secret_uses_env_when_present(self):
 
         self.assertEqual(module.get_auth_secret(), "test-secret")
 
+    def test_neuroglancer_public_base_uses_env_when_present(self):
+        with patch.dict(
+            os.environ,
+            {"PYTC_NEUROGLANCER_PUBLIC_BASE": "https://viewer.example.com/ng/"},
+            clear=True,
+        ):
+            module = importlib.reload(runtime_settings)
+            self.assertEqual(
+                module.get_neuroglancer_public_base(),
+                "https://viewer.example.com/ng",
+            )
+
 
 if __name__ == "__main__":
     unittest.main()