From 5cdb10b2e6d3ca592299fb68938ca84d5c93260f Mon Sep 17 00:00:00 2001
From: Hans Arnholm <harnholm@nvidia.com>
Date: Tue, 5 May 2026 13:02:10 -0700
Subject: [PATCH 01/11] fix(storage): build dataset URLs against override_url
 for S3-compatible backends
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

S3Backend.parse_uri_to_link hardcoded the AWS pattern
'https://<bucket>.s3.<region>.amazonaws.com/...' regardless of credential
override_url. The UI consumes these URLs to fetch dataset content; for a
CAIOS-backed bucket this produced
'osmo-on-cw-dev-harnholm-datasets.s3.us-east-14a.amazonaws.com', which
ENOTFOUNDs in DNS.

Thread the credential's override_url and addressing_style through
parse_uri_to_link. When override_url is set, S3Backend builds a URL
against that host (virtual-host by default; addressing_style='path'
yields path-style for localstack/MinIO without wildcard DNS). AWS S3
behavior (no override_url) is unchanged. Other backends accept the
new kwargs but ignore them.

Updated callsites:
  - data_service.py: dataset listing payload now respects bucket
    config's default_credential.override_url. This is the immediate
    UI fix.
  - dataset/uploading.py (×2) + migrating.py: new uploads/migrations
    record the correct URL in the manifest. Existing manifest entries
    persisted with AWS-pattern URLs are not migrated (separate concern).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/lib/data/dataset/migrating.py             |  7 +-
 src/lib/data/dataset/uploading.py             |  9 ++-
 src/lib/data/storage/backends/backends.py     | 65 +++++++++++++++----
 src/lib/data/storage/backends/common.py       | 17 ++++-
 .../storage/backends/tests/test_backends.py   | 39 +++++++++++
 src/service/core/data/data_service.py         | 20 ++++--
 6 files changed, 139 insertions(+), 18 deletions(-)

diff --git a/src/lib/data/dataset/migrating.py b/src/lib/data/dataset/migrating.py
index 50cfbbee2..9909ce567 100644
--- a/src/lib/data/dataset/migrating.py
+++ b/src/lib/data/dataset/migrating.py
@@ -150,6 +150,7 @@ def _dataset_migrate_worker(
     migrate_entry: DatasetMigrateEntry = worker_input.entry
     destination_backend = migrate_entry.destination_backend
     destination_region = migrate_entry.destination_region
+    destination_data_cred = destination_backend.resolved_data_credential
 
     def _callback(
         copy_input: copying.CopyWorkerInput,
@@ -160,7 +161,11 @@ def _callback(
             relative_path=migrate_entry.relative_path,
             storage_path=os.path.join(destination_backend.uri, migrate_entry.source_checksum),
             url=os.path.join(
-                destination_backend.parse_uri_to_link(destination_region),
+                destination_backend.parse_uri_to_link(
+                    destination_region,
+                    override_url=destination_data_cred.override_url,
+                    addressing_style=destination_data_cred.addressing_style,
+                ),
                 migrate_entry.source_checksum,
             ),
             size=migrate_entry.size,
diff --git a/src/lib/data/dataset/uploading.py b/src/lib/data/dataset/uploading.py
index 91ce4a19b..45bc49335 100644
--- a/src/lib/data/dataset/uploading.py
+++ b/src/lib/data/dataset/uploading.py
@@ -146,6 +146,8 @@ def dataset_upload_remote_file_entry_generator(
     data_cred = storage_client.data_credential
     url_base = storage_backend.parse_uri_to_link(
         region=storage_backend.region(data_cred),
+        override_url=data_cred.override_url,
+        addressing_style=data_cred.addressing_style,
     )
 
     # Iterate over the objects in the remote path.
@@ -282,6 +284,7 @@ def _write_to_manifest_cache(
             etag = utils_common.etag_checksum(upload_entry.source)
 
             destination: storage.StorageBackend = upload_entry.destination
+            destination_data_cred = destination.resolved_data_credential
 
             def _callback(
                 upload_input: uploading.UploadWorkerInput,
@@ -293,7 +296,11 @@ def _callback(
                     relative_path=upload_entry.relative_path,
                     storage_path=os.path.join(destination.uri, etag),
                     url=os.path.join(
-                        destination.parse_uri_to_link(upload_entry.destination_region),
+                        destination.parse_uri_to_link(
+                            upload_entry.destination_region,
+                            override_url=destination_data_cred.override_url,
+                            addressing_style=destination_data_cred.addressing_style,
+                        ),
                         etag,
                     ),
                     size=upload_entry.size,
diff --git a/src/lib/data/storage/backends/backends.py b/src/lib/data/storage/backends/backends.py
index f1d0901ac..55d592b77 100644
--- a/src/lib/data/storage/backends/backends.py
+++ b/src/lib/data/storage/backends/backends.py
@@ -296,10 +296,16 @@ def container_uri(self) -> str:
         return f'{self.profile}/{self.container}'
 
     @override
-    def parse_uri_to_link(self, region: str) -> str:
+    def parse_uri_to_link(
+        self,
+        region: str,
+        *,
+        override_url: str | None = None,
+        addressing_style: str | None = None,
+    ) -> str:
         # pylint: disable=unused-argument
         """
-        Returns the https link corresponding to the uri
+        Returns the https link corresponding to the uri.
         """
         return f'https://{self.netloc}/v1/{self.namespace}/{self.container}/{self.path}'.rstrip('/')
 
@@ -456,10 +462,29 @@ def container_uri(self) -> str:
         return f'{self.profile}'
 
     @override
-    def parse_uri_to_link(self, region: str) -> str:
-        """
-        Returns the https link corresponding to the uri
+    def parse_uri_to_link(
+        self,
+        region: str,
+        *,
+        override_url: str | None = None,
+        addressing_style: str | None = None,
+    ) -> str:
         """
+        Returns the https link corresponding to the uri.
+
+        When the credential has an override_url (CAIOS, R2, Wasabi, MinIO,
+        etc.) we build a URL against that host. The default is virtual-host
+        addressing because that's what modern S3-compatibles expect; pass
+        addressing_style='path' for legacy bucket names or path-style-only
+        deployments.
+        """
+        if override_url:
+            parsed = parse.urlparse(override_url)
+            scheme = parsed.scheme or 'https'
+            host = parsed.netloc or parsed.path
+            if addressing_style == 'path':
+                return f'{scheme}://{host}/{self.container}/{self.path}'.rstrip('/')
+            return f'{scheme}://{self.container}.{host}/{self.path}'.rstrip('/')
         return f'https://{self.container}.s3.{region}.amazonaws.com/{self.path}'.rstrip('/')
 
     @override
@@ -658,10 +683,16 @@ def container_uri(self) -> str:
         return f'{self.profile}'
 
     @override
-    def parse_uri_to_link(self, region: str) -> str:
+    def parse_uri_to_link(
+        self,
+        region: str,
+        *,
+        override_url: str | None = None,
+        addressing_style: str | None = None,
+    ) -> str:
         # pylint: disable=unused-argument
         """
-        Returns the https link corresponding to the uri
+        Returns the https link corresponding to the uri.
         """
         return (
             f'https://storage.googleapis.com/storage/v1/b/{self.container}/o/{self.path}'
@@ -778,10 +809,16 @@ def container_uri(self) -> str:
         return f'{self.profile}'
 
     @override
-    def parse_uri_to_link(self, region: str) -> str:
+    def parse_uri_to_link(
+        self,
+        region: str,
+        *,
+        override_url: str | None = None,
+        addressing_style: str | None = None,
+    ) -> str:
         # pylint: disable=unused-argument
         """
-        Returns the https link corresponding to the uri
+        Returns the https link corresponding to the uri.
         """
         return f'https://{self.container}.{self.netloc}/{self.path}'.rstrip('/')
 
@@ -893,10 +930,16 @@ def container_uri(self) -> str:
         return f'{self.profile}/{self.container}'
 
     @override
-    def parse_uri_to_link(self, region: str) -> str:
+    def parse_uri_to_link(
+        self,
+        region: str,
+        *,
+        override_url: str | None = None,
+        addressing_style: str | None = None,
+    ) -> str:
         # pylint: disable=unused-argument
         """
-        Returns the https link corresponding to the uri
+        Returns the https link corresponding to the uri.
         """
         return f'{self.endpoint}/{self.container}/{self.path}'.rstrip('/')
 
diff --git a/src/lib/data/storage/backends/common.py b/src/lib/data/storage/backends/common.py
index 405c65757..bfafdd205 100644
--- a/src/lib/data/storage/backends/common.py
+++ b/src/lib/data/storage/backends/common.py
@@ -185,9 +185,24 @@ def container_uri(self) -> str:
         pass
 
     @abc.abstractmethod
-    def parse_uri_to_link(self, region: str) -> str:
+    def parse_uri_to_link(
+        self,
+        region: str,
+        *,
+        override_url: str | None = None,
+        addressing_style: str | None = None,
+    ) -> str:
         """
         Returns the https link corresponding to the uri.
+
+        Args:
+            region: Region used by AWS-pattern URLs when no override is given.
+            override_url: Custom endpoint (S3-compatible providers). When set,
+                S3 backends build a URL against this host rather than AWS S3.
+                Other backends ignore it.
+            addressing_style: 'virtual' or 'path'. Used by S3 backends with a
+                custom override_url to select host-based vs path-based URLs.
+                Defaults to virtual (the form modern S3-compatibles expect).
         """
         pass
 
diff --git a/src/lib/data/storage/backends/tests/test_backends.py b/src/lib/data/storage/backends/tests/test_backends.py
index 1f0aaf089..88ec88404 100644
--- a/src/lib/data/storage/backends/tests/test_backends.py
+++ b/src/lib/data/storage/backends/tests/test_backends.py
@@ -563,6 +563,45 @@ def test_env_override_invalid_raises(self):
         self.assertIn("'virtua'", str(ctx.exception))
 
 
+class S3BackendParseUriToLinkTest(unittest.TestCase):
+    """Tests for S3Backend.parse_uri_to_link override-aware URL building."""
+
+    def _backend(self, uri: str = 's3://my-bucket/foo/bar') -> backends.S3Backend:
+        return cast(backends.S3Backend, backends.construct_storage_backend(uri))
+
+    def test_no_override_uses_aws_pattern(self):
+        """Without an override_url, fall back to the AWS-host pattern (preserved)."""
+        link = self._backend().parse_uri_to_link('us-east-1')
+        self.assertEqual(link, 'https://my-bucket.s3.us-east-1.amazonaws.com/foo/bar')
+
+    def test_override_url_uses_virtual_host(self):
+        """With an override_url, build a virtual-host URL against the custom endpoint
+        (CAIOS, R2, Wasabi, MinIO with wildcard DNS)."""
+        link = self._backend().parse_uri_to_link(
+            'US-EAST-14A',
+            override_url='https://cwobject.com',
+        )
+        self.assertEqual(link, 'https://my-bucket.cwobject.com/foo/bar')
+
+    def test_override_url_path_style(self):
+        """addressing_style='path' yields a path-style URL — needed for
+        localstack/MinIO setups without wildcard DNS."""
+        link = self._backend().parse_uri_to_link(
+            'us-east-1',
+            override_url='http://localstack-s3.osmo:4566',
+            addressing_style='path',
+        )
+        self.assertEqual(link, 'http://localstack-s3.osmo:4566/my-bucket/foo/bar')
+
+    def test_override_url_preserves_scheme(self):
+        """Scheme of the override is preserved in the link."""
+        link = self._backend().parse_uri_to_link(
+            'us-east-1',
+            override_url='http://minio.local:9000',
+        )
+        self.assertEqual(link, 'http://my-bucket.minio.local:9000/foo/bar')
+
+
 class S3BackendRegionTest(unittest.TestCase):
     """Tests for S3Backend.region() endpoint routing."""
 
diff --git a/src/service/core/data/data_service.py b/src/service/core/data/data_service.py
index b89d64e16..64a8bd652 100755
--- a/src/service/core/data/data_service.py
+++ b/src/service/core/data/data_service.py
@@ -121,14 +121,20 @@ def get_collection_info(postgres: connectors.PostgresConnector,
 
     dataset_rows = get_collection_datasets(postgres, bucket, name)
     bucket_config = postgres.get_dataset_configs().get_bucket_config(bucket)
+    default_cred = bucket_config.default_credential
+    override_url = default_cred.override_url if default_cred else None
+    addressing_style = default_cred.addressing_style if default_cred else None
 
     rows: List[objects.DataInfoCollectionEntry] = []
     for row in dataset_rows:
         rows.append(objects.DataInfoCollectionEntry(
             name=row.name,
             version=row.version_id,
-            location=storage.construct_storage_backend(row.location)\
-                .parse_uri_to_link(bucket_config.region),
+            location=storage.construct_storage_backend(row.location).parse_uri_to_link(
+                bucket_config.region,
+                override_url=override_url,
+                addressing_style=addressing_style,
+            ),
             uri=row.location,
             hash_location=row.hash_location,
             size=row.size))
@@ -177,6 +183,9 @@ def get_dataset_info(postgres: connectors.PostgresConnector,
                                             f'any entry fitting the parameters in bucket {bucket}.')
 
     bucket_config = postgres.get_dataset_configs().get_bucket_config(bucket)
+    default_cred = bucket_config.default_credential
+    override_url = default_cred.override_url if default_cred else None
+    addressing_style = default_cred.addressing_style if default_cred else None
 
     rows: List[objects.DataInfoDatasetEntry] = []
     for row in dataset_rows:
@@ -199,8 +208,11 @@ def get_dataset_info(postgres: connectors.PostgresConnector,
             last_used=row.last_used.replace(microsecond=0),
             size=row.size if row.size else 0,
             checksum=row.checksum if row.checksum else '',
-            location=storage.construct_storage_backend(row.location)\
-                .parse_uri_to_link(bucket_config.region),
+            location=storage.construct_storage_backend(row.location).parse_uri_to_link(
+                bucket_config.region,
+                override_url=override_url,
+                addressing_style=addressing_style,
+            ),
             uri=row.location,
             metadata=row.metadata,
             tags=[element.tag for element in tags],

From e47af4e9398bae2a257020b6129ed80374fcd720 Mon Sep 17 00:00:00 2001
From: Keita Watanabe <keitaw09@gmail.com>
Date: Thu, 2 Apr 2026 23:36:56 +0000
Subject: [PATCH 02/11] fix: route dataset file browser and preview through
 service to support private buckets (#793)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The UI's fetchManifest and file preview proxy performed unsigned fetch()
against S3 HTTPS URLs, which fails with 403 on private buckets.

Added two service-side proxy endpoints:
- GET /{bucket}/dataset/{name}/manifest — reads manifest JSON from storage
  using bucket credentials (supports S3, GCS, Azure, Swift, TOS)
- GET /{bucket}/dataset/{name}/file-content — streams individual file
  content with storage_path validation against dataset container

Updated UI to call these endpoints through the existing /api catch-all
proxy instead of direct unsigned fetch. Removed unused fetchManifest
server action files.
---
 src/service/core/data/data_service.py         | 60 ++++++++++++
 src/ui/next.config.ts                         |  3 -
 .../dataset/file/route.impl.production.ts     | 95 +++++++++++++------
 .../components/dataset-detail-content.tsx     | 16 +++-
 .../detail/components/file-preview-panel.tsx  | 67 +++++++++----
 src/ui/src/lib/api/adapter/datasets-hooks.ts  |  7 +-
 src/ui/src/lib/api/adapter/datasets.ts        | 21 +++-
 .../api/server/dataset-actions.production.ts  | 31 ------
 src/ui/src/lib/api/server/dataset-actions.ts  | 59 ------------
 src/ui/src/mocks/handlers.ts                  | 14 +++
 10 files changed, 224 insertions(+), 149 deletions(-)
 delete mode 100644 src/ui/src/lib/api/server/dataset-actions.production.ts
 delete mode 100644 src/ui/src/lib/api/server/dataset-actions.ts

diff --git a/src/service/core/data/data_service.py b/src/service/core/data/data_service.py
index 64a8bd652..7001b0fcc 100755
--- a/src/service/core/data/data_service.py
+++ b/src/service/core/data/data_service.py
@@ -19,6 +19,7 @@
 import base64
 import datetime
 import json
+import mimetypes
 import shlex
 from typing import Any, Dict, List, Sequence
 import uuid
@@ -1005,6 +1006,65 @@ def get_info(
                                     versions=rows)
 
 
+@router.get('/{bucket}/dataset/{name}/manifest')
+def get_manifest(
+    bucket: objects.DatasetPattern,
+    name: objects.DatasetPattern,
+    version: str = fastapi.Query(...),
+) -> List:
+    """ This api returns the manifest for a dataset version. """
+    postgres = connectors.PostgresConnector.get_instance()
+    dataset_info = get_dataset(postgres, bucket=bucket, name=name)
+
+    fetch_command = '''
+        SELECT location FROM dataset_version
+        WHERE dataset_id = %s AND version_id = %s AND status = %s;
+    '''
+    rows = postgres.execute_fetch_command(
+        fetch_command, (dataset_info.id, version, objects.DatasetStatus.READY.name))
+    if not rows:
+        raise osmo_errors.OSMODatabaseError(
+            f'Version {version} not found for dataset {name} in bucket {bucket}.')
+
+    bucket_config = postgres.get_dataset_configs().get_bucket_config(bucket)
+    client = storage.Client.create(
+        storage_uri=rows[0].location,
+        data_credential=bucket_config.default_credential,
+    )
+    manifest_content = client.get_object_stream(as_io=True).read()
+    return json.loads(manifest_content)
+
+
+@router.get('/{bucket}/dataset/{name}/file-content')
+def get_file_content(
+    bucket: objects.DatasetPattern,
+    name: objects.DatasetPattern,
+    storage_path: str = fastapi.Query(...),
+) -> fastapi.responses.StreamingResponse:
+    """ This api streams file content from storage for the dataset file preview. """
+    postgres = connectors.PostgresConnector.get_instance()
+    dataset_info = get_dataset(postgres, bucket=bucket, name=name)
+
+    # Validate that the storage path belongs to this dataset's storage prefix
+    requested_backend = storage.construct_storage_backend(storage_path)
+    dataset_backend = storage.construct_storage_backend(dataset_info.hash_location)
+    if requested_backend.container != dataset_backend.container:
+        raise osmo_errors.OSMOUserError(
+            'Storage path does not belong to this dataset.')
+
+    bucket_config = postgres.get_dataset_configs().get_bucket_config(bucket)
+    client = storage.Client.create(
+        storage_uri=storage_path,
+        data_credential=bucket_config.default_credential,
+    )
+
+    content_type = mimetypes.guess_type(storage_path)[0] or 'application/octet-stream'
+    return fastapi.responses.StreamingResponse(
+        client.get_object_stream(),
+        media_type=content_type,
+    )
+
+
 @router.get('/list_dataset', response_model=objects.DataListResponse, deprecated=True)
 def list_dataset_from_bucket(name: objects.DatasetPattern | None = None,
                              user: List[str] | None = fastapi.Query(default = None),
diff --git a/src/ui/next.config.ts b/src/ui/next.config.ts
index d65685c4e..32732d8d5 100644
--- a/src/ui/next.config.ts
+++ b/src/ui/next.config.ts
@@ -198,9 +198,6 @@ const nextConfig: NextConfig = {
             // This allows Turbopack aliasing to work (aliases work for imports, not file discovery)
             "@/app/api/[...path]/route.impl": "@/app/api/[...path]/route.impl.production",
 
-            // Dataset manifest server action - alias to production version (zero mock code)
-            "@/lib/api/server/dataset-actions": "@/lib/api/server/dataset-actions.production",
-
             // Dataset file proxy route - alias to production version (zero mock code)
             "@/app/proxy/dataset/file/route.impl":
               "@/app/proxy/dataset/file/route.impl.production",
diff --git a/src/ui/src/app/proxy/dataset/file/route.impl.production.ts b/src/ui/src/app/proxy/dataset/file/route.impl.production.ts
index 17c7ef928..2c5e3c0f5 100644
--- a/src/ui/src/app/proxy/dataset/file/route.impl.production.ts
+++ b/src/ui/src/app/proxy/dataset/file/route.impl.production.ts
@@ -18,55 +18,96 @@
  * Dataset File Proxy — Production Implementation
  *
  * Server-side proxy for fetching dataset files from storage URLs.
- * Routes requests through the server to avoid CSP restrictions.
  *
- * GET /proxy/dataset/file?url={encodedFileUrl}  → streams file content
- * HEAD /proxy/dataset/file?url={encodedFileUrl} → returns headers only
+ * When bucket/name/storagePath params are present, routes through the backend
+ * service's file-content endpoint (handles private buckets with credentials).
+ * Falls back to direct fetch for legacy callers that only provide a url param.
+ *
+ * GET /proxy/dataset/file?bucket=...&name=...&storagePath=...  → service proxy
+ * GET /proxy/dataset/file?url={encodedFileUrl}                 → direct fetch (legacy)
+ * HEAD variants of the above                                   → headers only
  */
 
+import type { NextRequest } from "next/server";
+import { getServerApiBaseUrl } from "@/lib/api/server/config";
+import { forwardAuthHeaders } from "@/lib/api/server/proxy-headers";
+
 const FORWARDED_HEADERS = ["content-type", "content-length", "last-modified", "etag", "cache-control"] as const;
 
-function parseAndValidateUrl(request: Request): { url: string } | Response {
+function forwardResponseHeaders(upstream: Response): Headers {
+  const headers = new Headers();
+  for (const header of FORWARDED_HEADERS) {
+    const value = upstream.headers.get(header);
+    if (value) headers.set(header, value);
+  }
+  return headers;
+}
+
+interface ServiceParams {
+  bucket: string;
+  name: string;
+  storagePath: string;
+}
+
+interface LegacyParams {
+  url: string;
+}
+
+function parseParams(request: Request): ServiceParams | LegacyParams | Response {
   const { searchParams } = new URL(request.url);
-  const url = searchParams.get("url");
 
-  if (!url) {
-    return Response.json({ error: "url parameter is required" }, { status: 400 });
+  const bucket = searchParams.get("bucket");
+  const name = searchParams.get("name");
+  const storagePath = searchParams.get("storagePath");
+
+  if (bucket && name && storagePath) {
+    return { bucket, name, storagePath };
   }
 
+  // Legacy fallback: direct URL fetch (works for public buckets only)
+  const url = searchParams.get("url");
+  if (!url) {
+    return Response.json({ error: "bucket/name/storagePath or url parameter is required" }, { status: 400 });
+  }
   if (!url.startsWith("http://") && !url.startsWith("https://")) {
     return Response.json({ error: "Only http/https URLs are supported" }, { status: 400 });
   }
-
   return { url };
 }
 
-export async function GET(request: Request) {
-  const result = parseAndValidateUrl(request);
-  if (result instanceof Response) return result;
-
-  const upstream = await fetch(result.url);
+function isServiceParams(params: ServiceParams | LegacyParams): params is ServiceParams {
+  return "storagePath" in params;
+}
 
-  const headers = new Headers();
-  for (const header of FORWARDED_HEADERS) {
-    const value = upstream.headers.get(header);
-    if (value) headers.set(header, value);
+async function fetchUpstream(
+  request: NextRequest,
+  params: ServiceParams | LegacyParams,
+  method: string,
+): Promise<Response> {
+  if (isServiceParams(params)) {
+    const backendUrl = getServerApiBaseUrl();
+    const query = new URLSearchParams({ storage_path: params.storagePath });
+    const serviceUrl = `${backendUrl}/api/bucket/${encodeURIComponent(params.bucket)}/dataset/${encodeURIComponent(params.name)}/file-content?${query}`;
+    const headers = forwardAuthHeaders(request);
+    return fetch(serviceUrl, { method, headers });
   }
-
-  return new Response(upstream.body, { status: upstream.status, headers });
+  return fetch(params.url, { method });
 }
 
-export async function HEAD(request: Request) {
-  const result = parseAndValidateUrl(request);
+export async function GET(request: NextRequest) {
+  const result = parseParams(request);
   if (result instanceof Response) return result;
 
-  const upstream = await fetch(result.url, { method: "HEAD" });
+  const upstream = await fetchUpstream(request, result, "GET");
+  const headers = forwardResponseHeaders(upstream);
+  return new Response(upstream.body, { status: upstream.status, headers });
+}
 
-  const headers = new Headers();
-  for (const header of FORWARDED_HEADERS) {
-    const value = upstream.headers.get(header);
-    if (value) headers.set(header, value);
-  }
+export async function HEAD(request: NextRequest) {
+  const result = parseParams(request);
+  if (result instanceof Response) return result;
 
+  const upstream = await fetchUpstream(request, result, "HEAD");
+  const headers = forwardResponseHeaders(upstream);
   return new Response(null, { status: upstream.status, headers });
 }
diff --git a/src/ui/src/features/datasets/detail/components/dataset-detail-content.tsx b/src/ui/src/features/datasets/detail/components/dataset-detail-content.tsx
index 2e3c5e741..c05137402 100644
--- a/src/ui/src/features/datasets/detail/components/dataset-detail-content.tsx
+++ b/src/ui/src/features/datasets/detail/components/dataset-detail-content.tsx
@@ -176,6 +176,8 @@ export function DatasetDetailContent({ bucket, name }: Props) {
   const {
     versions,
     location,
+    resolvedName,
+    resolvedVersion,
     files: virtualFiles,
     memberSubPath,
     segmentLabels,
@@ -184,6 +186,8 @@ export function DatasetDetailContent({ bucket, name }: Props) {
       return {
         versions: [],
         location: null as string | null,
+        resolvedName: name,
+        resolvedVersion: "",
         files: null as DatasetFile[] | null,
         memberSubPath: "",
         segmentLabels: {} as Record<string, string>,
@@ -197,6 +201,8 @@ export function DatasetDetailContent({ bucket, name }: Props) {
       return {
         versions: detail.versions,
         location: currentVersionData?.location ?? null,
+        resolvedName: name,
+        resolvedVersion: currentVersionData?.version ?? "",
         files: null,
         memberSubPath: path,
         segmentLabels: {},
@@ -221,6 +227,8 @@ export function DatasetDetailContent({ bucket, name }: Props) {
       return {
         versions: [],
         location: null,
+        resolvedName: name,
+        resolvedVersion: "",
         files: memberEntries,
         memberSubPath: "",
         segmentLabels: labels,
@@ -234,11 +242,13 @@ export function DatasetDetailContent({ bucket, name }: Props) {
     return {
       versions: [],
       location: member?.location ?? null,
+      resolvedName: member?.name ?? name,
+      resolvedVersion: member?.version ?? "",
       files: null,
       memberSubPath: subPath,
       segmentLabels: labels,
     };
-  }, [detail, version, path]);
+  }, [detail, version, path, name]);
 
   // ==========================================================================
   // File listing — fetch manifest for selected version/member
@@ -249,7 +259,7 @@ export function DatasetDetailContent({ bucket, name }: Props) {
     isLoading: isFilesLoading,
     error: filesError,
     refetch: refetchFiles,
-  } = useDatasetFiles(location);
+  } = useDatasetFiles(bucket, resolvedName, resolvedVersion, location);
 
   // Normal (unfiltered) directory listing — used for FilterBar suggestions and as base view
   const normalFiles = useMemo(
@@ -573,6 +583,8 @@ export function DatasetDetailContent({ bucket, name }: Props) {
                       <FilePreviewPanel
                         file={panelFileData}
                         path={fileDirPath}
+                        bucket={bucket}
+                        datasetName={resolvedName}
                         onClose={handleClosePanel}
                       />
                     )}
diff --git a/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx b/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx
index 9274ecdef..90dd58e8e 100644
--- a/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx
+++ b/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx
@@ -24,7 +24,7 @@
  * - image/* → <img> via proxy
  * - video/* → <video controls> via proxy
  * - other  → "preview unavailable" message
- * - 401/403 → lock icon + "bucket must be public" error
+ * - 401/403 → lock icon + "access denied" error
  * - 404    → "file not found" error
  * - No URL → metadata-only view
  */
@@ -62,6 +62,10 @@ interface FilePreviewPanelProps {
   file: DatasetFile;
   /** Current directory path (empty = root) */
   path: string;
+  /** Dataset bucket name — required for service-proxied file access */
+  bucket: string;
+  /** Dataset name — required for service-proxied file access */
+  datasetName: string;
   onClose: () => void;
 }
 
@@ -74,12 +78,21 @@ interface HeadResult {
 // HEAD preflight fetch
 // =============================================================================
 
-function toProxyUrl(url: string): string {
-  return getBasePathUrl(`/proxy/dataset/file?url=${encodeURIComponent(url)}`);
+function toProxyUrl(bucket: string, datasetName: string, file: { url?: string; storagePath?: string }): string {
+  if (file.storagePath) {
+    const params = new URLSearchParams({ bucket, name: datasetName, storagePath: file.storagePath });
+    return getBasePathUrl(`/proxy/dataset/file?${params}`);
+  }
+  // Legacy fallback for public buckets without storagePath
+  return getBasePathUrl(`/proxy/dataset/file?url=${encodeURIComponent(file.url ?? "")}`);
 }
 
-async function fetchHeadResult(url: string): Promise<HeadResult> {
-  const response = await fetch(toProxyUrl(url), { method: "HEAD" });
+async function fetchHeadResult(
+  bucket: string,
+  datasetName: string,
+  file: { url?: string; storagePath?: string },
+): Promise<HeadResult> {
+  const response = await fetch(toProxyUrl(bucket, datasetName, file), { method: "HEAD" });
   const contentType = response.headers.get("Content-Type") ?? "";
   return { status: response.status, contentType };
 }
@@ -207,9 +220,15 @@ function TextPreview({ url, contentType, fileName }: { url: string; contentType:
   );
 }
 
-function PreviewContent({ url, contentType, fileName }: { url: string; contentType: string; fileName: string }) {
-  const proxyUrl = toProxyUrl(url);
-
+function PreviewContent({
+  proxyUrl,
+  contentType,
+  fileName,
+}: {
+  proxyUrl: string;
+  contentType: string;
+  fileName: string;
+}) {
   if (isImageType(contentType, fileName)) {
     return (
       <div className="flex flex-1 items-center justify-center overflow-auto p-4">
@@ -279,22 +298,22 @@ type PreviewState =
   | { kind: "error"; retry: () => void }
   | { kind: "denied" }
   | { kind: "not-found" }
-  | { kind: "ready"; url: string; contentType: string };
+  | { kind: "ready"; proxyUrl: string; contentType: string };
 
 function resolvePreviewState(
-  url: string | undefined,
+  proxyUrl: string | undefined,
   isLoading: boolean,
   error: unknown,
   head: HeadResult | undefined,
   retry: () => void,
 ): PreviewState {
-  if (!url) return { kind: "no-url" };
+  if (!proxyUrl) return { kind: "no-url" };
   if (isLoading) return { kind: "loading" };
   if (error) return { kind: "error", retry };
   if (!head) return { kind: "loading" };
   if (head.status === 401 || head.status === 403) return { kind: "denied" };
   if (head.status === 404) return { kind: "not-found" };
-  if (head.status === 200) return { kind: "ready", url, contentType: head.contentType };
+  if (head.status === 200) return { kind: "ready", proxyUrl, contentType: head.contentType };
   // Unexpected status (e.g. 500) — treat as retriable error
   return { kind: "error", retry };
 }
@@ -303,24 +322,32 @@ function resolvePreviewState(
 // Main component
 // =============================================================================
 
-export const FilePreviewPanel = memo(function FilePreviewPanel({ file, path, onClose }: FilePreviewPanelProps) {
+export const FilePreviewPanel = memo(function FilePreviewPanel({
+  file,
+  path,
+  bucket,
+  datasetName,
+  onClose,
+}: FilePreviewPanelProps) {
   const relativePath = file.relativePath ?? (path ? `${path}/${file.name}` : file.name);
+  const hasPreviewSource = !!(file.storagePath || file.url);
+  const proxyUrl = hasPreviewSource ? toProxyUrl(bucket, datasetName, file) : undefined;
 
-  // HEAD preflight — only when we have a URL to check
+  // HEAD preflight — only when we have a source to check
   const {
     data: head,
     isLoading: headLoading,
     error: headError,
     refetch,
   } = useQuery({
-    queryKey: ["file-preview-head", file.url],
-    queryFn: () => fetchHeadResult(file.url!),
-    enabled: !!file.url,
+    queryKey: ["file-preview-head", proxyUrl],
+    queryFn: () => fetchHeadResult(bucket, datasetName, file),
+    enabled: hasPreviewSource,
     staleTime: Infinity,
     retry: false,
   });
 
-  const previewState = resolvePreviewState(file.url, headLoading, headError, head, () => void refetch());
+  const previewState = resolvePreviewState(proxyUrl, headLoading, headError, head, () => void refetch());
 
   return (
     <div className="flex h-full flex-col overflow-hidden">
@@ -366,13 +393,13 @@ export const FilePreviewPanel = memo(function FilePreviewPanel({ file, path, onC
         {previewState.kind === "denied" && (
           <PreviewError
             icon="lock"
-            message="The bucket must be public to preview files. Contact your administrator to enable public access."
+            message="Access denied. The storage bucket may require credentials or the file may not be accessible."
           />
         )}
         {previewState.kind === "not-found" && <PreviewError message="File not found at this path." />}
         {previewState.kind === "ready" && (
           <PreviewContent
-            url={previewState.url}
+            proxyUrl={previewState.proxyUrl}
             contentType={previewState.contentType}
             fileName={file.name}
           />
diff --git a/src/ui/src/lib/api/adapter/datasets-hooks.ts b/src/ui/src/lib/api/adapter/datasets-hooks.ts
index 137eff487..775484986 100644
--- a/src/ui/src/lib/api/adapter/datasets-hooks.ts
+++ b/src/ui/src/lib/api/adapter/datasets-hooks.ts
@@ -105,12 +105,15 @@ export function useDatasetLatest(bucket: string, name: string, options?: { enabl
  * @param options - Query options
  */
 export function useDatasetFiles(
+  bucket: string,
+  name: string,
+  version: string,
   location: string | null,
   options?: { enabled?: boolean },
 ): ReturnType<typeof useQuery<ProcessedManifest>> {
   return useQuery<ProcessedManifest>({
-    queryKey: buildDatasetFilesQueryKey(location),
-    queryFn: () => fetchDatasetFiles(location),
+    queryKey: buildDatasetFilesQueryKey(bucket, name, version),
+    queryFn: () => fetchDatasetFiles(bucket, name, version, location),
     enabled: (options?.enabled ?? true) && !!location,
     staleTime: 60_000, // 1 minute
   });
diff --git a/src/ui/src/lib/api/adapter/datasets.ts b/src/ui/src/lib/api/adapter/datasets.ts
index 9af715526..47e2faa70 100644
--- a/src/ui/src/lib/api/adapter/datasets.ts
+++ b/src/ui/src/lib/api/adapter/datasets.ts
@@ -507,10 +507,21 @@ export function processManifestItems(items: RawFileItem[]): ProcessedManifest {
  *
  * @param location - The version's location URL (DatasetVersion.location)
  */
-export async function fetchDatasetFiles(location: string | null): Promise<ProcessedManifest> {
+export async function fetchDatasetFiles(
+  bucket: string,
+  name: string,
+  version: string,
+  location: string | null,
+): Promise<ProcessedManifest> {
   if (!location) return { byPath: [], byFilename: [], fileTypes: [] };
-  const { fetchManifest } = await import("@/lib/api/server/dataset-actions");
-  const items = (await fetchManifest(location)) as RawFileItem[];
+  const params = new URLSearchParams({ version });
+  const response = await fetch(
+    `/api/bucket/${encodeURIComponent(bucket)}/dataset/${encodeURIComponent(name)}/manifest?${params}`,
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to fetch manifest: ${response.status}`);
+  }
+  const items = (await response.json()) as RawFileItem[];
   return processManifestItems(items);
 }
 
@@ -643,8 +654,8 @@ export function buildDatasetLatestQueryKey(bucket: string, name: string): readon
  * Build query key for the dataset version's full file manifest.
  * Keyed by location URL only — path filtering is done client-side via buildDirectoryListing.
  */
-export function buildDatasetFilesQueryKey(location: string | null): readonly unknown[] {
-  return ["datasets", "files", location] as const;
+export function buildDatasetFilesQueryKey(bucket: string, name: string, version: string): readonly unknown[] {
+  return ["datasets", "files", bucket, name, version] as const;
 }
 
 /**
diff --git a/src/ui/src/lib/api/server/dataset-actions.production.ts b/src/ui/src/lib/api/server/dataset-actions.production.ts
deleted file mode 100644
index 2faf26641..000000000
--- a/src/ui/src/lib/api/server/dataset-actions.production.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// SPDX-License-Identifier: Apache-2.0
-
-"use server";
-
-export async function fetchManifest(url: string): Promise<unknown[]> {
-  if (!url.startsWith("http://") && !url.startsWith("https://")) {
-    throw new Error("Invalid URL: must start with http:// or https://");
-  }
-
-  const response = await fetch(url);
-
-  if (!response.ok) {
-    throw new Error(`Failed to fetch manifest: ${response.status}`);
-  }
-
-  return (await response.json()) as unknown[];
-}
diff --git a/src/ui/src/lib/api/server/dataset-actions.ts b/src/ui/src/lib/api/server/dataset-actions.ts
deleted file mode 100644
index a0b2ed199..000000000
--- a/src/ui/src/lib/api/server/dataset-actions.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// SPDX-License-Identifier: Apache-2.0
-
-"use server";
-
-import http from "node:http";
-import { fetchManifest as prodFetchManifest } from "@/lib/api/server/dataset-actions.production";
-
-/**
- * In mock mode, routes through Node.js http.request to localhost:9999
- * where MSW intercepts it. MSW intercepts http.request but NOT Next.js's
- * undici-based fetch, so we must use the Node.js HTTP client.
- */
-function mockFetchManifest(url: string): Promise<unknown[]> {
-  const params = new URLSearchParams({ url });
-  const path = `/api/datasets/location-files?${params.toString()}`;
-
-  return new Promise((resolve, reject) => {
-    const request = http.request({ hostname: "localhost", port: 9999, path, method: "GET" }, (response) => {
-      const chunks: Buffer[] = [];
-      response.on("data", (chunk: Buffer) => chunks.push(chunk));
-      response.on("end", () => {
-        const body = Buffer.concat(chunks).toString("utf-8");
-        if ((response.statusCode ?? 0) >= 400) {
-          reject(new Error(`Mock request failed: ${response.statusCode ?? "unknown"}`));
-          return;
-        }
-        try {
-          resolve(JSON.parse(body) as unknown[]);
-        } catch {
-          reject(new Error("Mock request returned invalid JSON"));
-        }
-      });
-      response.on("error", reject);
-    });
-    request.on("error", reject);
-    request.end();
-  });
-}
-
-export async function fetchManifest(url: string): Promise<unknown[]> {
-  if (process.env.NEXT_PUBLIC_MOCK_API === "true") {
-    return mockFetchManifest(url);
-  }
-  return prodFetchManifest(url);
-}
diff --git a/src/ui/src/mocks/handlers.ts b/src/ui/src/mocks/handlers.ts
index d8cb275f3..b6f8b01cd 100644
--- a/src/ui/src/mocks/handlers.ts
+++ b/src/ui/src/mocks/handlers.ts
@@ -220,6 +220,20 @@ export const handlers = [
   http.all("*/proxy/dataset/file", datasetGenerator.handleFileProxy),
   http.head("*/api/bucket/:bucket/dataset/:name/preview", datasetGenerator.handleFilePreviewHead),
   http.get("*/api/bucket/:bucket/dataset/:name/preview", datasetGenerator.handleFilePreviewGet),
+  // Service-proxied manifest endpoint (private-bucket support, see PR #795).
+  http.get("*/api/bucket/:bucket/dataset/:name/manifest", async ({ request, params }) => {
+    const url = new URL(request.url);
+    const version = url.searchParams.get("version") ?? "1";
+    const datasetName = Array.isArray(params.name) ? params.name[0] : params.name;
+    const bucketName = Array.isArray(params.bucket) ? params.bucket[0] : params.bucket;
+    const locationUrl = `s3://${bucketName}/datasets/${datasetName}/v${version}/`;
+    const items = datasetGenerator.generateFlatManifest(
+      datasetName ?? "",
+      bucketName ?? "",
+      locationUrl,
+    );
+    return HttpResponse.json(items);
+  }),
 
   // Profile and credentials
   getGetNotificationSettingsApiProfileSettingsGetMockHandler(profileGenerator.handleGetSettings),

From 7672288e7cf2fa6826db9e84f01d5a8b1ab0be92 Mon Sep 17 00:00:00 2001
From: Keita Watanabe <keitaw09@gmail.com>
Date: Fri, 3 Apr 2026 00:06:50 +0000
Subject: [PATCH 03/11] fix: support HEAD method on file-content endpoint for
 preview preflight

The file preview panel sends a HEAD request before GET to check
content-type and access. FastAPI's @router.get does not handle HEAD,
returning 405 Method Not Allowed. Changed to @router.api_route with
both GET and HEAD methods.
---
 src/service/core/data/data_service.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/service/core/data/data_service.py b/src/service/core/data/data_service.py
index 7001b0fcc..9ad52ef47 100755
--- a/src/service/core/data/data_service.py
+++ b/src/service/core/data/data_service.py
@@ -1035,7 +1035,7 @@ def get_manifest(
     return json.loads(manifest_content)
 
 
-@router.get('/{bucket}/dataset/{name}/file-content')
+@router.api_route('/{bucket}/dataset/{name}/file-content', methods=['GET', 'HEAD'])
 def get_file_content(
     bucket: objects.DatasetPattern,
     name: objects.DatasetPattern,

From d5f1fb2c6c71ee2b651f33500fefb74deebb36be Mon Sep 17 00:00:00 2001
From: Keita Watanabe <keitaw09@gmail.com>
Date: Fri, 3 Apr 2026 00:17:33 +0000
Subject: [PATCH 04/11] fix: use server action for manifest fetch to avoid SSR
 auth failure

fetchDatasetFiles used a relative fetch('/api/bucket/...') which fails
during SSR because the request goes through the proxy without browser
auth cookies, resulting in 403 from the API gateway.

Re-introduced the server action pattern: fetchManifest now calls the
backend service directly using getServerApiBaseUrl() (internal URL),
bypassing the auth gateway. Works for both SSR and client hydration.
---
 src/ui/src/lib/api/adapter/datasets.ts        | 10 +----
 .../api/server/dataset-actions.production.ts  | 41 +++++++++++++++++++
 2 files changed, 43 insertions(+), 8 deletions(-)
 create mode 100644 src/ui/src/lib/api/server/dataset-actions.production.ts

diff --git a/src/ui/src/lib/api/adapter/datasets.ts b/src/ui/src/lib/api/adapter/datasets.ts
index 47e2faa70..6da37b7ab 100644
--- a/src/ui/src/lib/api/adapter/datasets.ts
+++ b/src/ui/src/lib/api/adapter/datasets.ts
@@ -514,14 +514,8 @@ export async function fetchDatasetFiles(
   location: string | null,
 ): Promise<ProcessedManifest> {
   if (!location) return { byPath: [], byFilename: [], fileTypes: [] };
-  const params = new URLSearchParams({ version });
-  const response = await fetch(
-    `/api/bucket/${encodeURIComponent(bucket)}/dataset/${encodeURIComponent(name)}/manifest?${params}`,
-  );
-  if (!response.ok) {
-    throw new Error(`Failed to fetch manifest: ${response.status}`);
-  }
-  const items = (await response.json()) as RawFileItem[];
+  const { fetchManifest } = await import("@/lib/api/server/dataset-actions.production");
+  const items = (await fetchManifest(bucket, name, version)) as RawFileItem[];
   return processManifestItems(items);
 }
 
diff --git a/src/ui/src/lib/api/server/dataset-actions.production.ts b/src/ui/src/lib/api/server/dataset-actions.production.ts
new file mode 100644
index 000000000..d91c50f03
--- /dev/null
+++ b/src/ui/src/lib/api/server/dataset-actions.production.ts
@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+"use server";
+
+import { getServerApiBaseUrl } from "@/lib/api/server/config";
+
+/**
+ * Fetch a dataset manifest through the backend service.
+ *
+ * Runs server-side (via "use server") so it can call the backend directly
+ * using the internal service URL, bypassing the API gateway auth layer.
+ * This is necessary because this function is called during both SSR and
+ * client hydration — during SSR there are no browser auth cookies.
+ */
+export async function fetchManifest(bucket: string, name: string, version: string): Promise<unknown[]> {
+  const baseUrl = getServerApiBaseUrl();
+  const params = new URLSearchParams({ version });
+  const url = `${baseUrl}/api/bucket/${encodeURIComponent(bucket)}/dataset/${encodeURIComponent(name)}/manifest?${params}`;
+
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch manifest: ${response.status}`);
+  }
+
+  return (await response.json()) as unknown[];
+}

From d8b8741059fd8d1a9f5de8168077aebf9bac5564 Mon Sep 17 00:00:00 2001
From: Hans Arnholm <harnholm@nvidia.com>
Date: Tue, 5 May 2026 15:06:24 -0700
Subject: [PATCH 05/11] fix(service): use SingleObjectClient for manifest +
 file-content endpoints
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

accepted no positional args. On main, the public overloads now require a
remote_path argument. Single-object fetches should go through
storage.SingleObjectClient (already used by cli/dataset.py and
lib/data/dataset/downloading.py) — its get_object_stream() takes no path
because the path is bound at create() time from storage_uri.

mypy on data_service.py now passes; behavior is unchanged.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Signed-off-by: Hans Arnholm <harnholm@nvidia.com>
---
 src/service/core/data/data_service.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/service/core/data/data_service.py b/src/service/core/data/data_service.py
index 9ad52ef47..dbee16399 100755
--- a/src/service/core/data/data_service.py
+++ b/src/service/core/data/data_service.py
@@ -1027,7 +1027,7 @@ def get_manifest(
             f'Version {version} not found for dataset {name} in bucket {bucket}.')
 
     bucket_config = postgres.get_dataset_configs().get_bucket_config(bucket)
-    client = storage.Client.create(
+    client = storage.SingleObjectClient.create(
         storage_uri=rows[0].location,
         data_credential=bucket_config.default_credential,
     )
@@ -1053,7 +1053,7 @@ def get_file_content(
             'Storage path does not belong to this dataset.')
 
     bucket_config = postgres.get_dataset_configs().get_bucket_config(bucket)
-    client = storage.Client.create(
+    client = storage.SingleObjectClient.create(
         storage_uri=storage_path,
         data_credential=bucket_config.default_credential,
     )

From 351424d9055f30a2c74988a09ae3c6398c14fd09 Mon Sep 17 00:00:00 2001
From: Hans Arnholm <harnholm@nvidia.com>
Date: Tue, 5 May 2026 15:38:20 -0700
Subject: [PATCH 06/11] fix(ui): forward auth headers in SSR manifest fetch
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The server-action call to /api/bucket/{bucket}/dataset/{name}/manifest
went out without the incoming request's session cookie, so oauth2-proxy
returned 401 with "No valid authentication in request" and the dataset
detail page crashed with "Failed to fetch manifest: 401".

getServerFetchHeaders() already exists in config.production.ts for
exactly this purpose — it pulls authorization + cookie from the SSR
request via next/headers and forwards them upstream. Use it.

The original docstring claimed the server action would "bypass the API
gateway auth layer" by hitting an internal service URL, but
getServerApiBaseUrl() returns the public hostname (Envoy + oauth2-proxy
front), so requests still pass through the gateway. Forwarding the
caller's session is the simpler fix and doesn't require a new internal
URL knob in deployment config.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Signed-off-by: Hans Arnholm <harnholm@nvidia.com>
---
 .../lib/api/server/dataset-actions.production.ts   | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/ui/src/lib/api/server/dataset-actions.production.ts b/src/ui/src/lib/api/server/dataset-actions.production.ts
index d91c50f03..d3b9bbd60 100644
--- a/src/ui/src/lib/api/server/dataset-actions.production.ts
+++ b/src/ui/src/lib/api/server/dataset-actions.production.ts
@@ -16,22 +16,24 @@
 
 "use server";
 
-import { getServerApiBaseUrl } from "@/lib/api/server/config";
+import { getServerApiBaseUrl, getServerFetchHeaders } from "@/lib/api/server/config";
 
 /**
  * Fetch a dataset manifest through the backend service.
  *
- * Runs server-side (via "use server") so it can call the backend directly
- * using the internal service URL, bypassing the API gateway auth layer.
- * This is necessary because this function is called during both SSR and
- * client hydration — during SSR there are no browser auth cookies.
+ * Runs server-side (via "use server") so the request originates from the
+ * Next.js process. We forward the incoming request's authorization + cookie
+ * headers via getServerFetchHeaders so the API gateway (oauth2-proxy) can
+ * authenticate the SSR fetch as the same user — without this, oauth2-proxy
+ * returns 401 because the SSR fetch carries no session cookie of its own.
  */
 export async function fetchManifest(bucket: string, name: string, version: string): Promise<unknown[]> {
   const baseUrl = getServerApiBaseUrl();
   const params = new URLSearchParams({ version });
   const url = `${baseUrl}/api/bucket/${encodeURIComponent(bucket)}/dataset/${encodeURIComponent(name)}/manifest?${params}`;
 
-  const response = await fetch(url);
+  const headers = await getServerFetchHeaders();
+  const response = await fetch(url, { headers });
 
   if (!response.ok) {
     throw new Error(`Failed to fetch manifest: ${response.status}`);

From 5d51655035e730d71e762ebbe14ea89d6e3919d0 Mon Sep 17 00:00:00 2001
From: Hans Arnholm <harnholm@nvidia.com>
Date: Tue, 5 May 2026 15:57:36 -0700
Subject: [PATCH 07/11] fix(ui): forward filename to file-content endpoint for
 Content-Type guessing

storage_path is hash-keyed (e.g. .../hashes/<etag>) and carries no
extension. mimetypes.guess_type(storage_path) returned None, the service
fell back to application/octet-stream, and the preview panel rendered
every text file as a binary download.

Forward the original relative_path through the proxy as a 'filename'
query param. The service uses it for media-type guessing only; access
control still hinges on storage_path's container check. Falls through
cleanly when filename is absent (preserves current behavior for any
legacy caller).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Signed-off-by: Hans Arnholm <harnholm@nvidia.com>
---
 src/service/core/data/data_service.py             | 15 +++++++++++++--
 .../proxy/dataset/file/route.impl.production.ts   |  8 +++++++-
 .../detail/components/file-preview-panel.tsx      | 12 ++++++++++--
 3 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/src/service/core/data/data_service.py b/src/service/core/data/data_service.py
index dbee16399..e5e6cf292 100755
--- a/src/service/core/data/data_service.py
+++ b/src/service/core/data/data_service.py
@@ -1040,8 +1040,17 @@ def get_file_content(
     bucket: objects.DatasetPattern,
     name: objects.DatasetPattern,
     storage_path: str = fastapi.Query(...),
+    filename: str | None = fastapi.Query(default=None),
 ) -> fastapi.responses.StreamingResponse:
-    """ This api streams file content from storage for the dataset file preview. """
+    """
+    Streams file content from storage for the dataset file preview.
+
+    storage_path is hash-keyed in the dataset layout (e.g. .../hashes/<etag>),
+    so it carries no extension that mimetypes.guess_type can use. The optional
+    filename param carries the original name (e.g. 'lipsum.txt') so we can
+    return a useful Content-Type. filename is purely for media-type guessing;
+    access control still hinges on storage_path's container check.
+    """
     postgres = connectors.PostgresConnector.get_instance()
     dataset_info = get_dataset(postgres, bucket=bucket, name=name)
 
@@ -1058,7 +1067,9 @@ def get_file_content(
         data_credential=bucket_config.default_credential,
     )
 
-    content_type = mimetypes.guess_type(storage_path)[0] or 'application/octet-stream'
+    content_type = (
+        mimetypes.guess_type(filename)[0] if filename else None
+    ) or mimetypes.guess_type(storage_path)[0] or 'application/octet-stream'
     return fastapi.responses.StreamingResponse(
         client.get_object_stream(),
         media_type=content_type,
diff --git a/src/ui/src/app/proxy/dataset/file/route.impl.production.ts b/src/ui/src/app/proxy/dataset/file/route.impl.production.ts
index 2c5e3c0f5..06e34e19e 100644
--- a/src/ui/src/app/proxy/dataset/file/route.impl.production.ts
+++ b/src/ui/src/app/proxy/dataset/file/route.impl.production.ts
@@ -47,6 +47,10 @@ interface ServiceParams {
   bucket: string;
   name: string;
   storagePath: string;
+  /** Original filename used by the service for Content-Type guessing only.
+   *  storage_path is hash-keyed (no extension), so without this every file
+   *  comes back as application/octet-stream. */
+  filename?: string;
 }
 
 interface LegacyParams {
@@ -59,9 +63,10 @@ function parseParams(request: Request): ServiceParams | LegacyParams | Response
   const bucket = searchParams.get("bucket");
   const name = searchParams.get("name");
   const storagePath = searchParams.get("storagePath");
+  const filename = searchParams.get("filename") ?? undefined;
 
   if (bucket && name && storagePath) {
-    return { bucket, name, storagePath };
+    return { bucket, name, storagePath, filename };
   }
 
   // Legacy fallback: direct URL fetch (works for public buckets only)
@@ -87,6 +92,7 @@ async function fetchUpstream(
   if (isServiceParams(params)) {
     const backendUrl = getServerApiBaseUrl();
     const query = new URLSearchParams({ storage_path: params.storagePath });
+    if (params.filename) query.set("filename", params.filename);
     const serviceUrl = `${backendUrl}/api/bucket/${encodeURIComponent(params.bucket)}/dataset/${encodeURIComponent(params.name)}/file-content?${query}`;
     const headers = forwardAuthHeaders(request);
     return fetch(serviceUrl, { method, headers });
diff --git a/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx b/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx
index 90dd58e8e..2945bb7d6 100644
--- a/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx
+++ b/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx
@@ -78,9 +78,17 @@ interface HeadResult {
 // HEAD preflight fetch
 // =============================================================================
 
-function toProxyUrl(bucket: string, datasetName: string, file: { url?: string; storagePath?: string }): string {
+function toProxyUrl(
+  bucket: string,
+  datasetName: string,
+  file: { url?: string; storagePath?: string; relativePath?: string; name?: string },
+): string {
   if (file.storagePath) {
     const params = new URLSearchParams({ bucket, name: datasetName, storagePath: file.storagePath });
+    // Forward original filename so the service can derive a useful Content-Type
+    // (storage_path is hash-keyed and carries no extension).
+    const filename = file.relativePath ?? file.name;
+    if (filename) params.set("filename", filename);
     return getBasePathUrl(`/proxy/dataset/file?${params}`);
   }
   // Legacy fallback for public buckets without storagePath
@@ -90,7 +98,7 @@ function toProxyUrl(bucket: string, datasetName: string, file: { url?: string; s
 async function fetchHeadResult(
   bucket: string,
   datasetName: string,
-  file: { url?: string; storagePath?: string },
+  file: { url?: string; storagePath?: string; relativePath?: string; name?: string },
 ): Promise<HeadResult> {
   const response = await fetch(toProxyUrl(bucket, datasetName, file), { method: "HEAD" });
   const contentType = response.headers.get("Content-Type") ?? "";

From 9540372a5fa4bc362e957e6eaa31dc9908fbca89 Mon Sep 17 00:00:00 2001
From: Hans Arnholm <harnholm@nvidia.com>
Date: Tue, 5 May 2026 16:02:05 -0700
Subject: [PATCH 08/11] chore(ui): prettier-format manifest mock handler

The conflict resolution when cherry-picking #795 left a multi-line
generateFlatManifest call that prettier wants on one line under the
project's print-width settings. Pure formatting; no behavior change.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Signed-off-by: Hans Arnholm <harnholm@nvidia.com>
---
 src/ui/src/mocks/handlers.ts | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/ui/src/mocks/handlers.ts b/src/ui/src/mocks/handlers.ts
index b6f8b01cd..0059ade75 100644
--- a/src/ui/src/mocks/handlers.ts
+++ b/src/ui/src/mocks/handlers.ts
@@ -227,11 +227,7 @@ export const handlers = [
     const datasetName = Array.isArray(params.name) ? params.name[0] : params.name;
     const bucketName = Array.isArray(params.bucket) ? params.bucket[0] : params.bucket;
     const locationUrl = `s3://${bucketName}/datasets/${datasetName}/v${version}/`;
-    const items = datasetGenerator.generateFlatManifest(
-      datasetName ?? "",
-      bucketName ?? "",
-      locationUrl,
-    );
+    const items = datasetGenerator.generateFlatManifest(datasetName ?? "", bucketName ?? "", locationUrl);
     return HttpResponse.json(items);
   }),
 

From de7afbe26798b8da1bce8c9efca8caa4a70b02f3 Mon Sep 17 00:00:00 2001
From: Hans Arnholm <harnholm@nvidia.com>
Date: Tue, 5 May 2026 16:26:31 -0700
Subject: [PATCH 09/11] fix: dataset proxy hardening and override URL prefix
 support
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Four review-driven fixes that all touched the dataset preview path:

1. parse_uri_to_link preserves override_url base path (CAIOS via reverse
   proxy). Previously dropped parsed.path; an override of
   'https://gateway.example.com/s3' produced URLs against
   gateway.example.com with no /s3 segment. Now host + base_path are
   preserved through both addressing styles, including the
   no-scheme-prefix case where urlparse drops the whole input into 'path'.

2. get_file_content validates against dataset hash_location prefix, not
   just the bucket container. This was the unresolved CodeRabbit feedback
   on #795 — container-only matching let an authenticated caller request
   any object in the same bucket via the dataset endpoint.

3. Forward Range request and accept-ranges/content-range response headers
   through the proxy so 206 Partial Content semantics survive (needed for
   video/large-file preview).

4. Remove the legacy 'url=' fallback from the proxy. It accepted any
   http(s) URL — a clear SSRF vector (cloud metadata endpoints, RFC1918,
   loopback). Manifests since #795 always carry storage_path; the legacy
   path was effectively dead. UI's file-preview-panel updated to drop the
   matching client-side fallback.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Signed-off-by: Hans Arnholm <harnholm@nvidia.com>
---
 src/lib/data/storage/backends/backends.py     | 18 ++++-
 .../storage/backends/tests/test_backends.py   | 17 ++++
 src/service/core/data/data_service.py         |  8 +-
 .../dataset/file/route.impl.production.ts     | 81 +++++++++----------
 .../detail/components/file-preview-panel.tsx  | 35 ++++----
 5 files changed, 95 insertions(+), 64 deletions(-)

diff --git a/src/lib/data/storage/backends/backends.py b/src/lib/data/storage/backends/backends.py
index 55d592b77..ebf90a5d9 100644
--- a/src/lib/data/storage/backends/backends.py
+++ b/src/lib/data/storage/backends/backends.py
@@ -481,10 +481,22 @@ def parse_uri_to_link(
         if override_url:
             parsed = parse.urlparse(override_url)
             scheme = parsed.scheme or 'https'
-            host = parsed.netloc or parsed.path
+            if parsed.netloc:
+                host = parsed.netloc
+                base_path = parsed.path.rstrip('/')
+            else:
+                # No scheme prefix on override_url: urlparse drops the whole
+                # input into 'path'. Split off the host from any base path so
+                # reverse-proxied endpoints like 'gateway.example.com/s3' keep
+                # the '/s3' prefix in the resulting link.
+                bare = parsed.path.lstrip('/')
+                host, _, rest = bare.partition('/')
+                base_path = ('/' + rest).rstrip('/') if rest else ''
             if addressing_style == 'path':
-                return f'{scheme}://{host}/{self.container}/{self.path}'.rstrip('/')
-            return f'{scheme}://{self.container}.{host}/{self.path}'.rstrip('/')
+                return (
+                    f'{scheme}://{host}{base_path}/{self.container}/{self.path}'.rstrip('/')
+                )
+            return f'{scheme}://{self.container}.{host}{base_path}/{self.path}'.rstrip('/')
         return f'https://{self.container}.s3.{region}.amazonaws.com/{self.path}'.rstrip('/')
 
     @override
diff --git a/src/lib/data/storage/backends/tests/test_backends.py b/src/lib/data/storage/backends/tests/test_backends.py
index 88ec88404..12b6ff14b 100644
--- a/src/lib/data/storage/backends/tests/test_backends.py
+++ b/src/lib/data/storage/backends/tests/test_backends.py
@@ -601,6 +601,23 @@ def test_override_url_preserves_scheme(self):
         )
         self.assertEqual(link, 'http://my-bucket.minio.local:9000/foo/bar')
 
+    def test_override_url_preserves_base_path_virtual_host(self):
+        """Reverse-proxied endpoint (gateway.example.com/s3) keeps the /s3 prefix."""
+        link = self._backend().parse_uri_to_link(
+            'us-east-1',
+            override_url='https://gateway.example.com/s3',
+        )
+        self.assertEqual(link, 'https://my-bucket.gateway.example.com/s3/foo/bar')
+
+    def test_override_url_preserves_base_path_path_style(self):
+        """Reverse-proxied endpoint with addressing_style=path preserves base path."""
+        link = self._backend().parse_uri_to_link(
+            'us-east-1',
+            override_url='https://gateway.example.com/s3',
+            addressing_style='path',
+        )
+        self.assertEqual(link, 'https://gateway.example.com/s3/my-bucket/foo/bar')
+
 
 class S3BackendRegionTest(unittest.TestCase):
     """Tests for S3Backend.region() endpoint routing."""
diff --git a/src/service/core/data/data_service.py b/src/service/core/data/data_service.py
index e5e6cf292..c769c0483 100755
--- a/src/service/core/data/data_service.py
+++ b/src/service/core/data/data_service.py
@@ -1054,10 +1054,14 @@ def get_file_content(
     postgres = connectors.PostgresConnector.get_instance()
     dataset_info = get_dataset(postgres, bucket=bucket, name=name)
 
-    # Validate that the storage path belongs to this dataset's storage prefix
+    # Validate that the storage path belongs to this dataset's hash storage
+    # prefix. Container-only matching would let a caller request any object
+    # in the same bucket (e.g. another dataset's manifest) via this endpoint.
     requested_backend = storage.construct_storage_backend(storage_path)
     dataset_backend = storage.construct_storage_backend(dataset_info.hash_location)
-    if requested_backend.container != dataset_backend.container:
+    hash_prefix = dataset_backend.path.rstrip('/') + '/'
+    if (requested_backend.container != dataset_backend.container
+            or not requested_backend.path.startswith(hash_prefix)):
         raise osmo_errors.OSMOUserError(
             'Storage path does not belong to this dataset.')
 
diff --git a/src/ui/src/app/proxy/dataset/file/route.impl.production.ts b/src/ui/src/app/proxy/dataset/file/route.impl.production.ts
index 06e34e19e..f6b9739cc 100644
--- a/src/ui/src/app/proxy/dataset/file/route.impl.production.ts
+++ b/src/ui/src/app/proxy/dataset/file/route.impl.production.ts
@@ -17,26 +17,44 @@
 /**
  * Dataset File Proxy — Production Implementation
  *
- * Server-side proxy for fetching dataset files from storage URLs.
- *
- * When bucket/name/storagePath params are present, routes through the backend
- * service's file-content endpoint (handles private buckets with credentials).
- * Falls back to direct fetch for legacy callers that only provide a url param.
+ * Server-side proxy for fetching dataset files. All requests route through
+ * the backend service's authenticated /file-content endpoint, which signs
+ * the upstream call against the bucket credential. The proxy itself does
+ * not accept arbitrary URLs — that would be an SSRF vector
+ * (cloud-metadata endpoints, RFC1918 ranges, loopback). Manifests since
+ * #795 always carry storage_path, so callers no longer need a url= form.
  *
  * GET /proxy/dataset/file?bucket=...&name=...&storagePath=...  → service proxy
- * GET /proxy/dataset/file?url={encodedFileUrl}                 → direct fetch (legacy)
- * HEAD variants of the above                                   → headers only
+ * HEAD variant                                                 → headers only
  */
 
 import type { NextRequest } from "next/server";
 import { getServerApiBaseUrl } from "@/lib/api/server/config";
 import { forwardAuthHeaders } from "@/lib/api/server/proxy-headers";
 
-const FORWARDED_HEADERS = ["content-type", "content-length", "last-modified", "etag", "cache-control"] as const;
+const FORWARDED_REQUEST_HEADERS = ["range"] as const;
+const FORWARDED_RESPONSE_HEADERS = [
+  "content-type",
+  "content-length",
+  "last-modified",
+  "etag",
+  "cache-control",
+  "accept-ranges",
+  "content-range",
+] as const;
+
+function forwardRequestHeaders(request: NextRequest, base: HeadersInit = {}): HeadersInit {
+  const headers = new Headers(base);
+  for (const header of FORWARDED_REQUEST_HEADERS) {
+    const value = request.headers.get(header);
+    if (value) headers.set(header, value);
+  }
+  return headers;
+}
 
 function forwardResponseHeaders(upstream: Response): Headers {
   const headers = new Headers();
-  for (const header of FORWARDED_HEADERS) {
+  for (const header of FORWARDED_RESPONSE_HEADERS) {
     const value = upstream.headers.get(header);
     if (value) headers.set(header, value);
   }
@@ -53,11 +71,7 @@ interface ServiceParams {
   filename?: string;
 }
 
-interface LegacyParams {
-  url: string;
-}
-
-function parseParams(request: Request): ServiceParams | LegacyParams | Response {
+function parseParams(request: Request): ServiceParams | Response {
   const { searchParams } = new URL(request.url);
 
   const bucket = searchParams.get("bucket");
@@ -65,39 +79,20 @@ function parseParams(request: Request): ServiceParams | LegacyParams | Response
   const storagePath = searchParams.get("storagePath");
   const filename = searchParams.get("filename") ?? undefined;
 
-  if (bucket && name && storagePath) {
-    return { bucket, name, storagePath, filename };
-  }
-
-  // Legacy fallback: direct URL fetch (works for public buckets only)
-  const url = searchParams.get("url");
-  if (!url) {
-    return Response.json({ error: "bucket/name/storagePath or url parameter is required" }, { status: 400 });
+  if (!bucket || !name || !storagePath) {
+    return Response.json({ error: "bucket, name, and storagePath query params are required" }, { status: 400 });
   }
-  if (!url.startsWith("http://") && !url.startsWith("https://")) {
-    return Response.json({ error: "Only http/https URLs are supported" }, { status: 400 });
-  }
-  return { url };
-}
 
-function isServiceParams(params: ServiceParams | LegacyParams): params is ServiceParams {
-  return "storagePath" in params;
+  return { bucket, name, storagePath, filename };
 }
 
-async function fetchUpstream(
-  request: NextRequest,
-  params: ServiceParams | LegacyParams,
-  method: string,
-): Promise<Response> {
-  if (isServiceParams(params)) {
-    const backendUrl = getServerApiBaseUrl();
-    const query = new URLSearchParams({ storage_path: params.storagePath });
-    if (params.filename) query.set("filename", params.filename);
-    const serviceUrl = `${backendUrl}/api/bucket/${encodeURIComponent(params.bucket)}/dataset/${encodeURIComponent(params.name)}/file-content?${query}`;
-    const headers = forwardAuthHeaders(request);
-    return fetch(serviceUrl, { method, headers });
-  }
-  return fetch(params.url, { method });
+async function fetchUpstream(request: NextRequest, params: ServiceParams, method: string): Promise<Response> {
+  const backendUrl = getServerApiBaseUrl();
+  const query = new URLSearchParams({ storage_path: params.storagePath });
+  if (params.filename) query.set("filename", params.filename);
+  const serviceUrl = `${backendUrl}/api/bucket/${encodeURIComponent(params.bucket)}/dataset/${encodeURIComponent(params.name)}/file-content?${query}`;
+  const headers = forwardRequestHeaders(request, forwardAuthHeaders(request));
+  return fetch(serviceUrl, { method, headers });
 }
 
 export async function GET(request: NextRequest) {
diff --git a/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx b/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx
index 2945bb7d6..2dc277a58 100644
--- a/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx
+++ b/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx
@@ -81,24 +81,20 @@ interface HeadResult {
 function toProxyUrl(
   bucket: string,
   datasetName: string,
-  file: { url?: string; storagePath?: string; relativePath?: string; name?: string },
+  file: { storagePath: string; relativePath?: string; name?: string },
 ): string {
-  if (file.storagePath) {
-    const params = new URLSearchParams({ bucket, name: datasetName, storagePath: file.storagePath });
-    // Forward original filename so the service can derive a useful Content-Type
-    // (storage_path is hash-keyed and carries no extension).
-    const filename = file.relativePath ?? file.name;
-    if (filename) params.set("filename", filename);
-    return getBasePathUrl(`/proxy/dataset/file?${params}`);
-  }
-  // Legacy fallback for public buckets without storagePath
-  return getBasePathUrl(`/proxy/dataset/file?url=${encodeURIComponent(file.url ?? "")}`);
+  const params = new URLSearchParams({ bucket, name: datasetName, storagePath: file.storagePath });
+  // Forward original filename so the service can derive a useful Content-Type
+  // (storage_path is hash-keyed and carries no extension).
+  const filename = file.relativePath ?? file.name;
+  if (filename) params.set("filename", filename);
+  return getBasePathUrl(`/proxy/dataset/file?${params}`);
 }
 
 async function fetchHeadResult(
   bucket: string,
   datasetName: string,
-  file: { url?: string; storagePath?: string; relativePath?: string; name?: string },
+  file: { storagePath: string; relativePath?: string; name?: string },
 ): Promise<HeadResult> {
   const response = await fetch(toProxyUrl(bucket, datasetName, file), { method: "HEAD" });
   const contentType = response.headers.get("Content-Type") ?? "";
@@ -338,8 +334,11 @@ export const FilePreviewPanel = memo(function FilePreviewPanel({
   onClose,
 }: FilePreviewPanelProps) {
   const relativePath = file.relativePath ?? (path ? `${path}/${file.name}` : file.name);
-  const hasPreviewSource = !!(file.storagePath || file.url);
-  const proxyUrl = hasPreviewSource ? toProxyUrl(bucket, datasetName, file) : undefined;
+  // Preview requires storagePath — the proxy no longer accepts arbitrary URLs.
+  const previewSource = file.storagePath
+    ? { storagePath: file.storagePath, relativePath: file.relativePath, name: file.name }
+    : undefined;
+  const proxyUrl = previewSource ? toProxyUrl(bucket, datasetName, previewSource) : undefined;
 
   // HEAD preflight — only when we have a source to check
   const {
@@ -349,8 +348,12 @@ export const FilePreviewPanel = memo(function FilePreviewPanel({
     refetch,
   } = useQuery({
     queryKey: ["file-preview-head", proxyUrl],
-    queryFn: () => fetchHeadResult(bucket, datasetName, file),
-    enabled: hasPreviewSource,
+    queryFn: () => {
+      // Type narrowed by `enabled` below; assertion mirrors the React Query contract.
+      if (!previewSource) throw new Error("preview source not available");
+      return fetchHeadResult(bucket, datasetName, previewSource);
+    },
+    enabled: !!previewSource,
     staleTime: Infinity,
     retry: false,
   });

From b9e76a1165d15141319848397bd156677d8d298b Mon Sep 17 00:00:00 2001
From: Hans Arnholm <harnholm@nvidia.com>
Date: Tue, 5 May 2026 16:50:09 -0700
Subject: [PATCH 10/11] fix(ui): cache hardening on auth-gated dataset proxy +
 HEAD query
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two review fixes for the auth-sensitive dataset preview path:

1. Stop forwarding upstream Cache-Control on /proxy/dataset/file. Storage
   providers commonly set 'public, max-age=…' on object responses; passing
   that through on a per-user authenticated route lets intermediate caches
   serve one user's bytes to another. Drop 'cache-control' from
   FORWARDED_RESPONSE_HEADERS and explicitly set 'Cache-Control:
   private, no-store' on every response. ('vary' was never forwarded — left
   as is.)

2. Drop staleTime: Infinity from the file-preview HEAD useQuery. Caching a
   401/403 forever would prevent revalidation after the user's session
   refreshes. staleTime: 0 restores standard React Query revalidation
   semantics (refetch on focus/mount when stale).

The text-preview useQuery one block up still has staleTime: Infinity; left
alone here since the reviewer scoped the finding to the HEAD query, but
worth a follow-up if we see stuck 401s on the text preview specifically.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Signed-off-by: Hans Arnholm <harnholm@nvidia.com>
---
 .../src/app/proxy/dataset/file/route.impl.production.ts   | 8 +++++++-
 .../datasets/detail/components/file-preview-panel.tsx     | 4 +++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/ui/src/app/proxy/dataset/file/route.impl.production.ts b/src/ui/src/app/proxy/dataset/file/route.impl.production.ts
index f6b9739cc..408569322 100644
--- a/src/ui/src/app/proxy/dataset/file/route.impl.production.ts
+++ b/src/ui/src/app/proxy/dataset/file/route.impl.production.ts
@@ -33,12 +33,16 @@ import { getServerApiBaseUrl } from "@/lib/api/server/config";
 import { forwardAuthHeaders } from "@/lib/api/server/proxy-headers";
 
 const FORWARDED_REQUEST_HEADERS = ["range"] as const;
+// Upstream cache directives are intentionally NOT forwarded — this is a
+// per-user authenticated route and any 'public' / 'max-age' from the storage
+// provider could let an intermediate cache serve another user's bytes. We
+// override with 'private, no-store' below. 'vary' is similarly not forwarded
+// for the same reason.
 const FORWARDED_RESPONSE_HEADERS = [
   "content-type",
   "content-length",
   "last-modified",
   "etag",
-  "cache-control",
   "accept-ranges",
   "content-range",
 ] as const;
@@ -58,6 +62,8 @@ function forwardResponseHeaders(upstream: Response): Headers {
     const value = upstream.headers.get(header);
     if (value) headers.set(header, value);
   }
+  // Authenticated, per-user — never let an intermediate cache hold this.
+  headers.set("cache-control", "private, no-store");
   return headers;
 }
 
diff --git a/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx b/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx
index 2dc277a58..734a0a4cf 100644
--- a/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx
+++ b/src/ui/src/features/datasets/detail/components/file-preview-panel.tsx
@@ -354,7 +354,9 @@ export const FilePreviewPanel = memo(function FilePreviewPanel({
       return fetchHeadResult(bucket, datasetName, previewSource);
     },
     enabled: !!previewSource,
-    staleTime: Infinity,
+    // staleTime: 0 — auth-sensitive: a cached 401/403 must re-validate when
+    // the user's session changes. Default React Query cadence is fine.
+    staleTime: 0,
     retry: false,
   });
 

From 7f99f57586ddb0327b7e6c3dead525f50c0b014b Mon Sep 17 00:00:00 2001
From: Hans Arnholm <harnholm@nvidia.com>
Date: Tue, 5 May 2026 17:00:51 -0700
Subject: [PATCH 11/11] fix(service): thread override_url/addressing_style
 through query_dataset link
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

query_dataset's metadata-enabled branch was the third parse_uri_to_link
callsite I missed when threading override_url + addressing_style for
private S3-compatible buckets — get_collection_info and get_dataset_info
already do this. Without it, /api/bucket/{bucket}/query results
on a CAIOS-backed bucket return AWS-pattern hostnames that ENOTFOUND on
the UI side, same failure mode the original parse_uri_to_link bug had.

Mirrors the default_credential fallback pattern (override_url and
addressing_style live on bucket_config.default_credential, not directly
on bucket_config).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Signed-off-by: Hans Arnholm <harnholm@nvidia.com>
---
 src/service/core/data/data_service.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/service/core/data/data_service.py b/src/service/core/data/data_service.py
index c769c0483..260439038 100755
--- a/src/service/core/data/data_service.py
+++ b/src/service/core/data/data_service.py
@@ -1241,6 +1241,9 @@ def query_dataset(
     postgres = connectors.PostgresConnector.get_instance()
 
     bucket_config = postgres.get_dataset_configs().get_bucket_config(str(bucket))
+    default_cred = bucket_config.default_credential
+    override_url = default_cred.override_url if default_cred else None
+    addressing_style = default_cred.addressing_style if default_cred else None
 
     query_term = query.QueryParser.get_instance().parse(' '.join(command_parsed))
 
@@ -1271,8 +1274,11 @@ def query_dataset(
                 last_used=row.last_used.replace(microsecond=0),
                 size=row.size if row.size else 0,
                 checksum=row.checksum if row.checksum else '',
-                location=storage.construct_storage_backend(row.location)\
-                    .parse_uri_to_link(bucket_config.region),
+                location=storage.construct_storage_backend(row.location).parse_uri_to_link(
+                    bucket_config.region,
+                    override_url=override_url,
+                    addressing_style=addressing_style,
+                ),
                 uri=row.location,
                 metadata=row.metadata,
                 tags=[],