digitaltwin-core 0.11.0 → 0.11.2

package/dist/components/tileset_manager.js

@@ -1,34 +1,60 @@
 import { AssetsManager } from './assets_manager.js';
-import { zipToDict, analyzeTilesetContent } from '../utils/zip_utils.js';
+import { extractAndStoreArchive } from '../utils/zip_utils.js';
 import { ApisixAuthParser } from '../auth/apisix_parser.js';
+import { AuthConfig } from '../auth/auth_config.js';
 import fs from 'fs/promises';
 /**
- * Specialized Assets Manager for handling tileset ZIP files.
+ * Specialized Assets Manager for handling 3D Tiles tilesets.
  *
- * Extends the base AssetsManager with specialized logic for:
- * - Processing ZIP files containing tileset data
- * - Extracting and analyzing tileset metadata
- * - Storing tileset-specific information
+ * This manager extracts uploaded ZIP files and stores each file individually,
+ * allowing Cesium and other 3D viewers to load tilesets directly via URL.
  *
- * Inherits all CRUD endpoints from AssetsManager:
- * - GET /{name} - List all tilesets
- * - POST /{name}/upload - Upload tileset ZIP (overridden)
- * - GET /{name}/:id - Get tileset file
- * - PUT /{name}/:id - Update tileset metadata
- * - DELETE /{name}/:id - Delete tileset
- * - GET /{name}/:id/download - Download tileset ZIP
+ * Key features:
+ * - Extracts ZIP archives on upload (no ZIP stored, only extracted files)
+ * - Detects and tracks the root tileset.json file
+ * - Serves individual files via dedicated endpoint
+ * - Returns tileset.json URL for direct Cesium loading
+ *
+ * Endpoints:
+ * - GET /{endpoint} - List all tilesets with tileset.json URLs
+ * - POST /{endpoint} - Upload tileset ZIP (extracts and stores files)
+ * - GET /{endpoint}/:id - Get tileset metadata
+ * - GET /{endpoint}/:id/files/* - Serve extracted files (tileset.json, .b3dm, etc.)
+ * - PUT /{endpoint}/:id - Update tileset metadata
+ * - DELETE /{endpoint}/:id - Delete tileset and all extracted files
+ *
+ * @example
+ * ```typescript
+ * class MyTilesetManager extends TilesetManager {
+ *   getConfiguration() {
+ *     return {
+ *       name: 'tilesets_manager',
+ *       description: 'Manage 3D Tiles tilesets',
+ *       contentType: 'application/json',
+ *       endpoint: 'api/tilesets',
+ *       tags: ['Tileset']
+ *     }
+ *   }
+ * }
+ *
+ * // After upload, Cesium can load:
+ * // Cesium3DTileset.fromUrl('/api/tilesets/123/files/tileset.json')
+ * ```
  */
 export class TilesetManager extends AssetsManager {
     /**
-     * Override the upload handler to process ZIP files containing tilesets.
+     * Override the upload handler to extract ZIP files and store individual files.
      *
-     * Processes the uploaded ZIP file:
-     * 1. Extracts and analyzes the ZIP content
-     * 2. Stores tileset-specific metadata
-     * 3. Saves the ZIP file using the storage service
+     * Flow:
+     * 1. Validates request and authentication
+     * 2. Reads uploaded ZIP file
+     * 3. Extracts all files and stores them individually
+     * 4. Detects the root tileset.json file
+     * 5. Saves metadata with file_index containing all file paths
+     * 6. Deletes the temporary ZIP file
      *
      * @param req - HTTP request with ZIP file upload
-     * @returns DataResponse with upload result
+     * @returns DataResponse with upload result including tileset.json URL
      */
     async handleUpload(req) {
         try {
@@ -41,46 +67,67 @@ export class TilesetManager extends AssetsManager {
                     headers: { 'Content-Type': 'application/json' }
                 };
             }
-            // Check authentication
-            if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                return {
-                    status: 401,
-                    content: JSON.stringify({
-                        error: 'Authentication required'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
+            // Check authentication (skip if auth is disabled)
+            let userId;
+            if (AuthConfig.isAuthDisabled()) {
+                const anonymousUser = {
+                    id: AuthConfig.getAnonymousUserId(),
+                    roles: []
                 };
+                const userRecord = await this.userService.findOrCreateUser(anonymousUser);
+                userId = userRecord.id;
             }
-            // Parse authenticated user
-            const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
-            if (!authUser) {
-                return {
-                    status: 401,
-                    content: JSON.stringify({
-                        error: 'Invalid authentication headers'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            else {
+                if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
+                    return {
+                        status: 401,
+                        content: JSON.stringify({
+                            error: 'Authentication required'
+                        }),
+                        headers: { 'Content-Type': 'application/json' }
+                    };
+                }
+                const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
+                if (!authUser) {
+                    return {
+                        status: 401,
+                        content: JSON.stringify({
+                            error: 'Invalid authentication headers'
+                        }),
+                        headers: { 'Content-Type': 'application/json' }
+                    };
+                }
+                const userRecord = await this.userService.findOrCreateUser(authUser);
+                if (!userRecord.id) {
+                    return {
+                        status: 500,
+                        content: JSON.stringify({
+                            error: 'Failed to retrieve user information'
+                        }),
+                        headers: { 'Content-Type': 'application/json' }
+                    };
+                }
+                userId = userRecord.id;
             }
-            // Find or create user in database
-            const userRecord = await this.userService.findOrCreateUser(authUser);
-            if (!userRecord.id) {
+            const { description } = req.body;
+            const filePath = req.file?.path;
+            const fileBuffer = req.file?.buffer;
+            const filename = req.file?.originalname || req.body.filename;
+            // Support both disk storage (filePath) and memory storage (fileBuffer)
+            if (!filePath && !fileBuffer) {
                 return {
-                    status: 500,
+                    status: 400,
                     content: JSON.stringify({
-                        error: 'Failed to retrieve user information'
+                        error: 'Missing required fields: ZIP file'
                     }),
                     headers: { 'Content-Type': 'application/json' }
                 };
             }
-            const { description } = req.body;
-            const filePath = req.file?.path;
-            const filename = req.file?.originalname || req.body.filename;
-            if (!filePath || !description) {
+            if (!description) {
                 return {
                     status: 400,
                     content: JSON.stringify({
-                        error: 'Missing required fields: description, ZIP file'
+                        error: 'Missing required fields: description'
                     }),
                     headers: { 'Content-Type': 'application/json' }
                 };
@@ -104,10 +151,15 @@ export class TilesetManager extends AssetsManager {
                     headers: { 'Content-Type': 'application/json' }
                 };
             }
-            // Read and process ZIP file
-            let fileBuffer;
+            // Read ZIP file content
+            let zipBuffer;
             try {
-                fileBuffer = await fs.readFile(filePath);
+                if (fileBuffer) {
+                    zipBuffer = fileBuffer;
+                }
+                else {
+                    zipBuffer = await fs.readFile(filePath);
+                }
             }
             catch (error) {
                 return {
@@ -119,49 +171,67 @@ export class TilesetManager extends AssetsManager {
                 };
             }
             try {
-                // Extract and analyze tileset content
-                const zipDict = await zipToDict(fileBuffer);
-                const tilesetInfo = analyzeTilesetContent(zipDict);
-                // Use the analyzed name or fallback to filename
-                const tilesetName = tilesetInfo.name || filename.replace('.zip', '');
                 const config = this.getConfiguration();
                 const now = new Date();
-                // Store ZIP file using framework pattern
-                const url = await this.storage.save(fileBuffer, config.name, filename);
-                // Create extended metadata with tileset-specific fields
+                // Generate unique ID for this tileset (timestamp-based)
+                const tilesetId = now.getTime().toString();
+                // Base path for storing extracted files: componentName/tilesetId
+                const basePath = `${config.name}/${tilesetId}`;
+                // Extract ZIP and store all files individually
+                const extractResult = await extractAndStoreArchive(zipBuffer, this.storage, basePath);
+                // Validate that we found a tileset.json
+                if (!extractResult.root_file) {
+                    // Clean up stored files if no tileset.json found
+                    for (const file of extractResult.files) {
+                        await this.storage.delete(file.path).catch(() => { });
+                    }
+                    return {
+                        status: 400,
+                        content: JSON.stringify({
+                            error: 'Invalid tileset: no tileset.json found in the ZIP archive'
+                        }),
+                        headers: { 'Content-Type': 'application/json' }
+                    };
+                }
+                // Create metadata with file_index
+                // url stores the base path for all extracted files
                 const metadata = {
                     name: config.name,
-                    type: config.contentType || 'application/zip',
-                    url,
+                    type: 'application/json', // tileset.json content type
+                    url: basePath, // Base path for all files (componentName/timestamp)
                     date: now,
                     description,
-                    source: req.body.source || 'uploaded',
-                    owner_id: userRecord.id,
-                    filename,
-                    // Tileset-specific metadata
-                    tileset_name: tilesetName,
-                    file_count: tilesetInfo.fileCount,
-                    has_metadata: tilesetInfo.hasMetadata,
-                    main_files: tilesetInfo.mainFiles.join(',')
+                    source: req.body.source || '',
+                    owner_id: userId,
+                    filename: filename,
+                    is_public: req.body.is_public !== undefined ? Boolean(req.body.is_public) : true,
+                    file_index: {
+                        files: extractResult.files,
+                        root_file: extractResult.root_file
+                    }
                 };
-                await this.db.save(metadata);
+                const savedRecord = await this.db.save(metadata);
                 // Clean up temporary file after successful upload
-                await fs.unlink(filePath).catch(() => {
-                    // Ignore cleanup errors
-                });
+                if (filePath) {
+                    await fs.unlink(filePath).catch(() => { });
+                }
                 return {
                     status: 200,
                     content: JSON.stringify({
-                        message: 'Tileset uploaded successfully',
-                        tileset_name: tilesetName,
-                        file_count: tilesetInfo.fileCount
+                        message: 'Tileset uploaded and extracted successfully',
+                        id: savedRecord.id,
+                        file_count: extractResult.file_count,
+                        root_file: extractResult.root_file,
+                        tileset_url: `/${config.endpoint}/${savedRecord.id}/files/${extractResult.root_file}`
                     }),
                     headers: { 'Content-Type': 'application/json' }
                 };
             }
             catch (error) {
                 // Clean up temporary file even on error
-                await fs.unlink(filePath).catch(() => { });
+                if (filePath) {
+                    await fs.unlink(filePath).catch(() => { });
+                }
                 throw error;
             }
         }
@@ -176,34 +246,196 @@ export class TilesetManager extends AssetsManager {
         }
     }
     /**
-     * Override retrieve to include tileset-specific metadata in the response
+     * Serve an extracted file from the tileset.
+     *
+     * This endpoint allows Cesium to load tileset.json and all referenced files
+     * (tiles, textures, etc.) using relative paths.
+     *
+     * @param req - HTTP request with params.id and params['0'] (file path)
+     * @returns DataResponse with file content
+     */
+    async handleGetFile(req) {
+        try {
+            const { id } = req.params || {};
+            // Express/ultimate-express captures wildcard path in different ways:
+            // - Express 4.x: params[0] or params['0']
+            // - Express 5.x / ultimate-express: params['*'] or via URL parsing
+            let filePath = req.params[0] || req.params['0'] || req.params['*'] || req.params.path || req.params['*0'];
+            // Fallback: extract from URL if params didn't capture it
+            if (!filePath && req.url) {
+                const match = req.url.match(/\/files\/(.+)$/);
+                if (match) {
+                    filePath = decodeURIComponent(match[1]);
+                }
+            }
+            // Another fallback: use originalUrl
+            if (!filePath && req.originalUrl) {
+                const match = req.originalUrl.match(/\/files\/(.+)$/);
+                if (match) {
+                    filePath = decodeURIComponent(match[1]);
+                }
+            }
+            if (!id) {
+                return {
+                    status: 400,
+                    content: JSON.stringify({ error: 'Asset ID is required' }),
+                    headers: { 'Content-Type': 'application/json' }
+                };
+            }
+            if (!filePath) {
+                return {
+                    status: 400,
+                    content: JSON.stringify({ error: 'File path is required' }),
+                    headers: { 'Content-Type': 'application/json' }
+                };
+            }
+            // Get asset metadata
+            const asset = await this.getAssetById(id);
+            if (!asset) {
+                return {
+                    status: 404,
+                    content: JSON.stringify({ error: 'Tileset not found' }),
+                    headers: { 'Content-Type': 'application/json' }
+                };
+            }
+            // Verify this asset belongs to our component
+            const config = this.getConfiguration();
+            if (asset.name !== config.name) {
+                return {
+                    status: 404,
+                    content: JSON.stringify({ error: 'Tileset not found' }),
+                    headers: { 'Content-Type': 'application/json' }
+                };
+            }
+            // Check access permissions for private assets
+            if (!asset.is_public) {
+                if (ApisixAuthParser.isAdmin(req.headers || {})) {
+                    // Admin can access everything
+                }
+                else if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
+                    return {
+                        status: 401,
+                        content: JSON.stringify({ error: 'Authentication required for private assets' }),
+                        headers: { 'Content-Type': 'application/json' }
+                    };
+                }
+                else {
+                    const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
+                    if (authUser) {
+                        const userRecord = await this.userService.findOrCreateUser(authUser);
+                        if (!userRecord.id || asset.owner_id !== userRecord.id) {
+                            return {
+                                status: 403,
+                                content: JSON.stringify({ error: 'This asset is private' }),
+                                headers: { 'Content-Type': 'application/json' }
+                            };
+                        }
+                    }
+                }
+            }
+            // Build storage path using asset.url as base path
+            // asset.url contains the base path (e.g., 'tilesets_manager/1733064000000')
+            const storagePath = `${asset.url}/${filePath}`;
+            // Retrieve file from storage
+            let fileContent;
+            try {
+                fileContent = await this.storage.retrieve(storagePath);
+            }
+            catch {
+                return {
+                    status: 404,
+                    content: JSON.stringify({ error: 'File not found' }),
+                    headers: { 'Content-Type': 'application/json' }
+                };
+            }
+            // Determine content type based on file extension
+            const contentType = this.getContentTypeForFile(filePath);
+            return {
+                status: 200,
+                content: fileContent,
+                headers: {
+                    'Content-Type': contentType,
+                    'Access-Control-Allow-Origin': '*'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 500,
+                content: JSON.stringify({
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                }),
+                headers: { 'Content-Type': 'application/json' }
+            };
+        }
+    }
+    /**
+     * Determines the MIME content type based on file extension.
+     */
+    getContentTypeForFile(filePath) {
+        const ext = filePath.toLowerCase().split('.').pop();
+        const contentTypes = {
+            json: 'application/json',
+            b3dm: 'application/octet-stream',
+            i3dm: 'application/octet-stream',
+            pnts: 'application/octet-stream',
+            cmpt: 'application/octet-stream',
+            glb: 'model/gltf-binary',
+            gltf: 'model/gltf+json',
+            bin: 'application/octet-stream',
+            png: 'image/png',
+            jpg: 'image/jpeg',
+            jpeg: 'image/jpeg',
+            webp: 'image/webp',
+            ktx2: 'image/ktx2'
+        };
+        return contentTypes[ext || ''] || 'application/octet-stream';
+    }
+    /**
+     * Override retrieve to include tileset.json URL in the response.
      */
-    async retrieve() {
+    async retrieve(req) {
         try {
             const assets = await this.getAllAssets();
             const config = this.getConfiguration();
-            // Transform to include tileset metadata
-            const assetsWithMetadata = assets.map(asset => ({
-                id: asset.id,
-                name: asset.name,
-                date: asset.date,
-                contentType: asset.contentType,
-                description: asset.description || '',
-                source: asset.source || '',
-                owner_id: asset.owner_id || null,
-                filename: asset.filename || '',
-                // Tileset-specific fields
-                tileset_name: asset.tileset_name || '',
-                file_count: asset.file_count || 0,
-                has_metadata: asset.has_metadata || false,
-                main_files: asset.main_files ? asset.main_files.split(',') : [],
-                // URLs for frontend
-                url: `/${config.endpoint}/${asset.id}`,
-                download_url: `/${config.endpoint}/${asset.id}/download`
-            }));
+            const isAdmin = req && ApisixAuthParser.isAdmin(req.headers || {});
+            // Get authenticated user ID if available
+            let authenticatedUserId = null;
+            if (req && ApisixAuthParser.hasValidAuth(req.headers || {})) {
+                const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
+                if (authUser) {
+                    const userRecord = await this.userService.findOrCreateUser(authUser);
+                    authenticatedUserId = userRecord.id || null;
+                }
+            }
+            // Filter to visible assets only (unless admin)
+            const visibleAssets = isAdmin
+                ? assets
+                : assets.filter(asset => asset.is_public || (authenticatedUserId !== null && asset.owner_id === authenticatedUserId));
+            // Transform to include tileset URLs
+            const assetsWithUrls = visibleAssets.map(asset => {
+                const fileIndex = asset.file_index;
+                const rootFile = fileIndex?.root_file || 'tileset.json';
+                return {
+                    id: asset.id,
+                    name: asset.name,
+                    date: asset.date,
+                    contentType: asset.contentType,
+                    description: asset.description || '',
+                    source: asset.source || '',
+                    owner_id: asset.owner_id || null,
+                    filename: asset.filename || '',
+                    is_public: asset.is_public ?? true,
+                    // Tileset-specific URLs
+                    file_count: fileIndex?.files?.length || 0,
+                    root_file: rootFile,
+                    tileset_url: `/${config.endpoint}/${asset.id}/files/${rootFile}`,
+                    files_base_url: `/${config.endpoint}/${asset.id}/files`
+                };
+            });
             return {
                 status: 200,
-                content: JSON.stringify(assetsWithMetadata),
+                content: JSON.stringify(assetsWithUrls),
                 headers: { 'Content-Type': 'application/json' }
             };
         }
@@ -218,36 +450,196 @@ export class TilesetManager extends AssetsManager {
         }
     }
     /**
-     * Override OpenAPI specification to include tileset-specific fields.
-     *
-     * Extends the parent AssetsManager spec with additional properties
-     * specific to tileset uploads (ZIP file analysis metadata).
-     *
-     * @returns {OpenAPIComponentSpec} OpenAPI spec with tileset extensions
+     * Override delete to clean up all extracted files.
+     */
+    async handleDelete(req) {
+        try {
+            // Check authentication (skip if auth is disabled)
+            let userId;
+            if (AuthConfig.isAuthDisabled()) {
+                const anonymousUser = {
+                    id: AuthConfig.getAnonymousUserId(),
+                    roles: []
+                };
+                const userRecord = await this.userService.findOrCreateUser(anonymousUser);
+                userId = userRecord.id;
+            }
+            else {
+                if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
+                    return {
+                        status: 401,
+                        content: JSON.stringify({ error: 'Authentication required' }),
+                        headers: { 'Content-Type': 'application/json' }
+                    };
+                }
+                const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
+                if (!authUser) {
+                    return {
+                        status: 401,
+                        content: JSON.stringify({ error: 'Invalid authentication headers' }),
+                        headers: { 'Content-Type': 'application/json' }
+                    };
+                }
+                const userRecord = await this.userService.findOrCreateUser(authUser);
+                if (!userRecord.id) {
+                    return {
+                        status: 500,
+                        content: JSON.stringify({ error: 'Failed to retrieve user information' }),
+                        headers: { 'Content-Type': 'application/json' }
+                    };
+                }
+                userId = userRecord.id;
+            }
+            const { id } = req.params || {};
+            if (!id) {
+                return {
+                    status: 400,
+                    content: JSON.stringify({ error: 'Asset ID is required' }),
+                    headers: { 'Content-Type': 'application/json' }
+                };
+            }
+            // Get asset metadata
+            const asset = await this.getAssetById(id);
+            if (!asset) {
+                return {
+                    status: 404,
+                    content: JSON.stringify({ error: 'Tileset not found' }),
+                    headers: { 'Content-Type': 'application/json' }
+                };
+            }
+            // Check ownership (admins can delete any asset)
+            const isAdmin = ApisixAuthParser.isAdmin(req.headers || {});
+            if (!isAdmin && asset.owner_id !== null && asset.owner_id !== userId) {
+                return {
+                    status: 403,
+                    content: JSON.stringify({ error: 'You can only delete your own assets' }),
+                    headers: { 'Content-Type': 'application/json' }
+                };
+            }
+            // Delete all extracted files from storage
+            const fileIndex = asset.file_index;
+            if (fileIndex?.files) {
+                for (const file of fileIndex.files) {
+                    await this.storage.delete(file.path).catch(() => {
+                        // Ignore individual file deletion errors
+                    });
+                }
+            }
+            // Delete database record
+            await this.deleteAssetById(id);
+            return {
+                status: 200,
+                content: JSON.stringify({ message: 'Tileset deleted successfully' }),
+                headers: { 'Content-Type': 'application/json' }
+            };
+        }
+        catch (error) {
+            return {
+                status: 500,
+                content: JSON.stringify({
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                }),
+                headers: { 'Content-Type': 'application/json' }
+            };
+        }
+    }
+    /**
+     * Override getEndpoints to add the file serving endpoint.
+     */
+    getEndpoints() {
+        const config = this.getConfiguration();
+        // Get base endpoints from parent but filter out ones we override
+        const baseEndpoints = super.getEndpoints().filter(ep => 
+        // Keep all except GET /:id (we don't serve the raw asset, only files)
+        // and DELETE /:id (we override to clean up files)
+        !(ep.method === 'get' && ep.path === `/${config.endpoint}/:id`) &&
+            !(ep.method === 'delete' && ep.path === `/${config.endpoint}/:id`) &&
+            // Also remove download endpoint - not applicable for extracted tilesets
+            !(ep.method === 'get' && ep.path === `/${config.endpoint}/:id/download`));
+        // IMPORTANT: More specific routes must come BEFORE less specific ones
+        // /:id/files/* must be registered before /:id to avoid incorrect matching
+        return [
+            // File serving endpoint FIRST (most specific)
+            {
+                method: 'get',
+                path: `/${config.endpoint}/:id/files/*`,
+                handler: this.handleGetFile.bind(this),
+                responseType: 'application/octet-stream'
+            },
+            // Then base endpoints (list, create, update, etc.)
+            ...baseEndpoints,
+            // Override delete to clean up files (after base to override)
+            {
+                method: 'delete',
+                path: `/${config.endpoint}/:id`,
+                handler: this.handleDelete.bind(this),
+                responseType: 'application/json'
+            }
+        ];
+    }
+    /**
+     * Override OpenAPI specification to include tileset-specific endpoints.
      */
     getOpenAPISpec() {
         const parentSpec = super.getOpenAPISpec();
         const config = this.getConfiguration();
         const basePath = `/${config.endpoint}`;
-        // Extend the POST response to include tileset-specific fields
+        const tagName = config.tags?.[0] || config.name;
+        // Update POST response
         if (parentSpec.paths[basePath]?.post?.responses?.['200']) {
             parentSpec.paths[basePath].post.responses['200'] = {
-                description: 'Tileset uploaded successfully',
+                description: 'Tileset uploaded and extracted successfully',
                 content: {
                     'application/json': {
                         schema: {
                             type: 'object',
                             properties: {
                                 message: { type: 'string' },
-                                tileset_name: { type: 'string', description: 'Extracted tileset name' },
-                                file_count: { type: 'integer', description: 'Number of files in the tileset' }
+                                file_count: { type: 'integer', description: 'Number of files extracted' },
+                                root_file: { type: 'string', description: 'Root tileset.json path' },
+                                tileset_url: { type: 'string', description: 'URL to load in Cesium' }
                             }
                         }
                     }
                 }
             };
         }
-        // Add tileset-specific schema extending the base AssetResponse
+        // Add file serving endpoint
+        parentSpec.paths[`${basePath}/{id}/files/{filePath}`] = {
+            get: {
+                summary: 'Get tileset file',
+                description: 'Retrieve an extracted file from the tileset (tileset.json, .b3dm, etc.)',
+                tags: [tagName],
+                parameters: [
+                    {
+                        name: 'id',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'string' },
+                        description: 'Tileset ID'
+                    },
+                    {
+                        name: 'filePath',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'string' },
+                        description: 'Path to file within tileset (e.g., tileset.json, tiles/tile_0.b3dm)'
+                    }
+                ],
+                responses: {
+                    '200': {
+                        description: 'File content',
+                        content: {
+                            'application/octet-stream': {
+                                schema: { type: 'string', format: 'binary' }
+                            }
+                        }
+                    },
+                    '404': { description: 'Tileset or file not found' }
+                }
+            }
+        };
+        // Update GET list response schema
         if (parentSpec.schemas) {
             parentSpec.schemas.TilesetResponse = {
                 type: 'object',
@@ -260,26 +652,24 @@ export class TilesetManager extends AssetsManager {
                     source: { type: 'string' },
                     owner_id: { type: 'integer', nullable: true },
                     filename: { type: 'string' },
-                    tileset_name: { type: 'string', description: 'Extracted tileset name from ZIP' },
-                    file_count: { type: 'integer', description: 'Number of files in the tileset' },
-                    has_metadata: { type: 'boolean', description: 'Whether tileset has metadata file' },
-                    main_files: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'Main tileset files (e.g., tileset.json)'
-                    },
-                    url: { type: 'string' },
-                    download_url: { type: 'string' }
+                    is_public: { type: 'boolean' },
+                    file_count: { type: 'integer', description: 'Number of files in tileset' },
+                    root_file: { type: 'string', description: 'Root tileset.json filename' },
+                    tileset_url: { type: 'string', description: 'URL to load tileset in Cesium' },
+                    files_base_url: { type: 'string', description: 'Base URL for all tileset files' }
                 }
             };
         }
-        // Update the GET list response to use tileset schema
         if (parentSpec.paths[basePath]?.get?.responses?.['200']?.content?.['application/json']) {
             parentSpec.paths[basePath].get.responses['200'].content['application/json'].schema = {
                 type: 'array',
                 items: { $ref: '#/components/schemas/TilesetResponse' }
             };
         }
+        // Remove the single asset GET endpoint since we don't serve raw assets
+        delete parentSpec.paths[`${basePath}/{id}`]?.get;
+        // Remove download endpoint
+        delete parentSpec.paths[`${basePath}/{id}/download`];
         return parentSpec;
     }
 }