mbkbucket 1.5.1 → 2.1.0

package/lib/routes/api.js

@@ -2,12 +2,60 @@ import express from "express";
 import { validateSessionAndRole,  } from "mbkauthe";
 import { listfiles, uploadFile, deleteFile, deleteFiles, deleteFolder, downloadFile, getFileMetadata, fileExists, ensureKeyHasAppPrefix, ensurePrefix, getAppName, createMultipartUpload, uploadPart, completeMultipartUpload, abortMultipartUpload, listIncompleteMultipartUploads, cleanupIncompleteMultipartUploads } from "../s3.js";
 import multer from "multer";
+import { createLogger } from "../debug.js";
 
 const router = express.Router();
+const debugApi = createLogger('api');
 
-// This is the maximum size we allow per chunk upload. It should be >=
-// the client chunk size (5MB) and leave room for any encoding overhead.
-// If you need to support larger chunks, increase this accordingly.
+function classifyApiError(error, fallbackMessage = 'Request failed') {
+  const message = String(error?.message || fallbackMessage);
+  const lower = message.toLowerCase();
+
+  if (lower.includes('bucketconnection environment variable is not set')) {
+    return { status: 503, code: 'BUCKET_CONFIG_ERROR', message };
+  }
+  if (lower.includes('no bucket selected') || lower.includes('not found in bucketconnection')) {
+    return { status: 400, code: 'INVALID_BUCKET', message };
+  }
+  if (lower.includes('already exists')) {
+    return { status: 409, code: 'CONFLICT', message };
+  }
+  if (lower.includes('not found')) {
+    return { status: 404, code: 'NOT_FOUND', message };
+  }
+  if (lower.includes('access denied')) {
+    return { status: 403, code: 'ACCESS_DENIED', message };
+  }
+  if (lower.includes('required') || lower.includes('invalid') || lower.includes('must be')) {
+    return { status: 400, code: 'VALIDATION_ERROR', message };
+  }
+  return { status: 500, code: 'INTERNAL_ERROR', message };
+}
+
+function sendApiError(res, error, fallbackMessage = 'Request failed') {
+  const mapped = classifyApiError(error, fallbackMessage);
+  return res.status(mapped.status).json({ success: false, code: mapped.code, error: mapped.message });
+}
+
+function getBaseName(path = '') {
+  const value = String(path || '');
+  const lastSlashIndex = value.lastIndexOf('/');
+  return lastSlashIndex === -1 ? value : value.substring(lastSlashIndex + 1);
+}
+
+// Central bucket guard for all API routes under /mbkbucket
+router.use((req, res, next) => {
+  if (req.bucketResolveError) {
+    return sendApiError(res, req.bucketResolveError, 'Invalid bucket selection');
+  }
+  if (!req.activeBucket) {
+    return sendApiError(res, new Error('No bucket selected. Provide ?bucket=<name> or configure a default bucket in mbkautheVar.bucket.'));
+  }
+  next();
+});
+
+// This is the maximum size we allow per file part. The dashboard uses the same
+// size as its single-upload threshold and multipart chunk size.
 const MAX_CHUNK_SIZE = 50 * 1024 * 1024; // 50 MB
 
 const upload = multer({
@@ -31,10 +79,25 @@ const uploadChunk = (req, res, next) => {
   });
 };
 
+async function cleanupFolderMarker(folderPath, bucketName) {
+  if (!folderPath) return;
+
+  try {
+    const metadata = await getFileMetadata(folderPath, bucketName);
+    if (metadata.exists && (metadata.ContentLength === 0 || metadata.Metadata?.marker === 'true')) {
+      await deleteFile(folderPath, bucketName);
+      debugApi('Cleaned up folder marker: %s', folderPath);
+    }
+  } catch (cleanupErr) {
+    debugApi('Failed to clean up folder marker: %s', cleanupErr.message);
+  }
+}
+
 // API endpoint for multipart upload cleanup
 router.post('/api/cleanup-uploads', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
     const { olderThanDays = 7, prefix = '' } = req.body;
+    const bucketName = req.activeBucket;
 
     // Validate olderThanDays
     const days = parseInt(olderThanDays, 10);
@@ -42,8 +105,8 @@ router.post('/api/cleanup-uploads', validateSessionAndRole('SuperAdmin'), async
       return res.status(400).json({ success: false, error: 'olderThanDays must be a positive integer' });
     }
 
-    console.log(`[mbkbucket] Starting cleanup of incomplete uploads older than ${days} days`);
-    const result = await cleanupIncompleteMultipartUploads(days, prefix);
+    debugApi('Starting cleanup of incomplete uploads older than %s days', days);
+    const result = await cleanupIncompleteMultipartUploads(days, prefix, bucketName);
 
     res.json({
       success: true,
@@ -52,10 +115,7 @@ router.post('/api/cleanup-uploads', validateSessionAndRole('SuperAdmin'), async
     });
   } catch (error) {
     console.error('[mbkbucket] Cleanup failed:', error);
-    res.status(500).json({
-      success: false,
-      error: error.message
-    });
+    return sendApiError(res, error, 'Cleanup failed');
   }
 });
 
@@ -63,7 +123,8 @@ router.post('/api/cleanup-uploads', validateSessionAndRole('SuperAdmin'), async
 router.get('/api/incomplete-uploads', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
     const { prefix = '' } = req.query;
-    const uploads = await listIncompleteMultipartUploads(prefix);
+    const bucketName = req.activeBucket;
+    const uploads = await listIncompleteMultipartUploads(prefix, bucketName);
 
     res.json({
       success: true,
@@ -77,10 +138,7 @@ router.get('/api/incomplete-uploads', validateSessionAndRole('SuperAdmin'), asyn
     });
   } catch (error) {
     console.error('[mbkbucket] Failed to list incomplete uploads:', error);
-    res.status(500).json({
-      success: false,
-      error: error.message
-    });
+    return sendApiError(res, error, 'Failed to list incomplete uploads');
   }
 });
 
@@ -88,6 +146,7 @@ router.get('/api/incomplete-uploads', validateSessionAndRole('SuperAdmin'), asyn
 router.get('/api/files', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   const { prefix = '', page = '1', search = '', recursive = 'true', token = '' } = req.query;
   const pageSize = 100;
+  const bucketName = req.activeBucket;
   let effectivePrefix;
   try {
     effectivePrefix = ensurePrefix(prefix);
@@ -124,14 +183,16 @@ router.get('/api/files', validateSessionAndRole('SuperAdmin'), async (req, res)
       const result = await listfiles(listPrefix, {
         continuationToken: token || undefined, // Use token from query if provided
         delimiter: '/',
-        maxKeys: 1000 // Fetch a healthy batch.
+        maxKeys: 1000, // Fetch a healthy batch.
+        bucketName
       });
 
-      files = result.Contents || [];
       // Filter out folder marker objects (zero-byte files ending with /)
-      files = files.filter(f => !f.Key.endsWith('/'));
+      files = (result.Contents || []).filter(f => !f.Key.endsWith('/'));
       // S3 returns CommonPrefixes for folders when delimiter is used
-      folders = (result.CommonPrefixes || []).map(p => p.Prefix).filter(p => p !== effectivePrefix);
+      folders = (result.CommonPrefixes || [])
+        .filter(p => p.Prefix !== effectivePrefix)
+        .map(p => p.Prefix);
       nextContinuationToken = result.NextContinuationToken;
 
       // Note: In optimized mode, totalFiles is unknown without scanning everything.
@@ -141,11 +202,12 @@ router.get('/api/files', validateSessionAndRole('SuperAdmin'), async (req, res)
 
       // Fetch all files recursively (handling S3 pagination)
       do {
-        const result = await listfiles(effectivePrefix, { continuationToken });
-        if (result.Contents) {
+        const result = await listfiles(effectivePrefix, { continuationToken, bucketName });
+        if (result.Contents?.length) {
           // Filter out folder marker objects (zero-byte files ending with /)
-          const actualFiles = result.Contents.filter(f => !f.Key.endsWith('/'));
-          files = files.concat(actualFiles);
+          for (const file of result.Contents) {
+            if (!file.Key.endsWith('/')) files.push(file);
+          }
         }
         continuationToken = result.nextToken;
       } while (continuationToken);
@@ -153,23 +215,21 @@ router.get('/api/files', validateSessionAndRole('SuperAdmin'), async (req, res)
       // If no files found under the app prefixed path, try root as a legacy fallback
       if (!files.length && !search) {
         try {
-          const rootResult = await listfiles('');
+          const rootResult = await listfiles('', { bucketName });
           if ((rootResult.Contents || []).length) {
             files = rootResult.Contents || [];
             usedPrefix = '';
             legacyFallback = true;
           }
         } catch (fallbackErr) {
-          console.warn('Fallback root listing failed:', fallbackErr.message);
+          debugApi('Fallback root listing failed: %s', fallbackErr.message);
         }
       }
 
       // Apply search filter if provided
       if (isSearch) {
-        const searchLower = search.toLowerCase();
-        files = files.filter(file => {
-          return file.Key.toLowerCase().includes(searchLower);
-        });
+        const searchLower = search.trim().toLowerCase();
+        files = files.filter(file => file.Key.toLowerCase().includes(searchLower));
       }
     }
 
@@ -218,9 +278,11 @@ router.get('/api/files', validateSessionAndRole('SuperAdmin'), async (req, res)
 
   } catch (error) {
     console.error("Error listing files:", error);
-    res.status(500).json({
+    const mapped = classifyApiError(error, 'Error listing files');
+    return res.status(mapped.status).json({
       success: false,
-      error: "Error listing files: " + error.message,
+      code: mapped.code,
+      error: mapped.message,
       files: [],
       totalFiles: 0
     });
@@ -230,6 +292,7 @@ router.get('/api/files', validateSessionAndRole('SuperAdmin'), async (req, res)
 // Standard single-file upload
 router.post('/upload', validateSessionAndRole('SuperAdmin'), upload.single('file'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     if (!req.file) {
       return res.status(400).json({ success: false, error: 'No file selected' });
     }
@@ -250,32 +313,16 @@ router.post('/upload', validateSessionAndRole('SuperAdmin'), upload.single('file
         'upload-source': 'web-portal',
         'user-agent': req.headers['user-agent'] || 'unknown'
       },
+      bucketName,
       preventOverwrite: true // Use atomic operation to prevent race conditions
     };
 
     try {
       await uploadFile(key, req.file.buffer, req.file.mimetype, uploadOptions);
 
-      // Clean up folder marker if it exists in the parent directory
-      // This happens when a file is uploaded to a folder that was previously empty
+      // Clean up folder marker if it exists in the parent directory.
       const folderPath = key.substring(0, key.lastIndexOf('/') + 1);
-      if (folderPath) {
-        const folderMarkerKey = folderPath; // Already ends with /
-        try {
-          const markerExists = await fileExists(folderMarkerKey);
-          if (markerExists) {
-            // Check if this is actually a folder marker (zero-byte file)
-            const metadata = await getFileMetadata(folderMarkerKey);
-            if (metadata.ContentLength === 0 || metadata.Metadata?.marker === 'true') {
-              await deleteFile(folderMarkerKey);
-              console.log(`[mbkbucket] Cleaned up folder marker: ${folderMarkerKey}`);
-            }
-          }
-        } catch (cleanupErr) {
-          // Non-critical error, just log it
-          console.warn('[mbkbucket] Failed to clean up folder marker:', cleanupErr.message);
-        }
-      }
+      await cleanupFolderMarker(folderPath, bucketName);
 
       res.json({ success: true, message: 'File uploaded successfully', key: key });
     } catch (uploadError) {
@@ -287,7 +334,7 @@ router.post('/upload', validateSessionAndRole('SuperAdmin'), upload.single('file
     }
   } catch (error) {
     console.error("Error uploading file:", error);
-    res.status(500).json({ success: false, error: `Upload failed: ${error.message}` });
+    return sendApiError(res, error, 'Upload failed');
   }
 });
 
@@ -296,6 +343,7 @@ router.post('/upload', validateSessionAndRole('SuperAdmin'), upload.single('file
 // Returns: { uploadId, key }
 router.post('/upload-init', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const { fileName, prefix = '', contentType = 'application/octet-stream' } = req.body;
     if (!fileName) return res.status(400).json({ success: false, error: 'fileName is required' });
 
@@ -306,14 +354,14 @@ router.post('/upload-init', validateSessionAndRole('SuperAdmin'), async (req, re
     // Check if file exists before initiating multipart upload
     // Note: This is still slightly racy, but multipart uploads take time so collision risk is lower
     // A complete solution would require server-side locking or unique upload IDs
-    const exists = await fileExists(key);
+    const exists = await fileExists(key, bucketName);
     if (exists) return res.status(409).json({ success: false, error: `File already exists: ${fileName}` });
 
-    const result = await createMultipartUpload(key, contentType);
+    const result = await createMultipartUpload(key, contentType, {}, bucketName);
     return res.json({ success: true, uploadId: result.uploadId, key: result.key });
   } catch (err) {
     console.error('[mbkbucket] upload-init failed:', err);
-    return res.status(500).json({ success: false, error: err.message });
+    return sendApiError(res, err, 'upload-init failed');
   }
 });
 
@@ -322,6 +370,7 @@ router.post('/upload-init', validateSessionAndRole('SuperAdmin'), async (req, re
 // Returns: { partNumber, ETag }
 router.post('/upload-chunk', validateSessionAndRole('SuperAdmin'), uploadChunk, async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const { uploadId, key, partNumber } = req.body;
     if (!req.file || !uploadId || !key || !partNumber) {
       return res.status(400).json({ success: false, error: 'chunk file, uploadId, key, and partNumber are required' });
@@ -331,11 +380,11 @@ router.post('/upload-chunk', validateSessionAndRole('SuperAdmin'), uploadChunk,
       return res.status(400).json({ success: false, error: 'partNumber must be an integer between 1 and 10000' });
     }
 
-    const result = await uploadPart(key, uploadId, part, req.file.buffer);
+    const result = await uploadPart(key, uploadId, part, req.file.buffer, bucketName);
     return res.json({ success: true, partNumber: result.partNumber, ETag: result.ETag });
   } catch (err) {
     console.error('[mbkbucket] upload-chunk failed:', err);
-    return res.status(500).json({ success: false, error: err.message });
+    return sendApiError(res, err, 'upload-chunk failed');
   }
 });
 
@@ -344,35 +393,22 @@ router.post('/upload-chunk', validateSessionAndRole('SuperAdmin'), uploadChunk,
 // Returns: { key }
 router.post('/upload-complete', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const { uploadId, key, parts } = req.body;
     if (!uploadId || !key || !Array.isArray(parts) || !parts.length) {
       return res.status(400).json({ success: false, error: 'uploadId, key, and parts array are required' });
     }
 
-    const result = await completeMultipartUpload(key, uploadId, parts);
+    const result = await completeMultipartUpload(key, uploadId, parts, bucketName);
 
     // Clean up folder marker if it exists in the parent directory
     const folderPath = result.key.substring(0, result.key.lastIndexOf('/') + 1);
-    if (folderPath) {
-      const folderMarkerKey = folderPath;
-      try {
-        const markerExists = await fileExists(folderMarkerKey);
-        if (markerExists) {
-          const metadata = await getFileMetadata(folderMarkerKey);
-          if (metadata.ContentLength === 0 || metadata.Metadata?.marker === 'true') {
-            await deleteFile(folderMarkerKey);
-            console.log(`[mbkbucket] Cleaned up folder marker: ${folderMarkerKey}`);
-          }
-        }
-      } catch (cleanupErr) {
-        console.warn('[mbkbucket] Failed to clean up folder marker:', cleanupErr.message);
-      }
-    }
+    await cleanupFolderMarker(folderPath, bucketName);
 
     return res.json({ success: true, message: 'File uploaded successfully', key: result.key });
   } catch (err) {
     console.error('[mbkbucket] upload-complete failed:', err);
-    return res.status(500).json({ success: false, error: err.message });
+    return sendApiError(res, err, 'upload-complete failed');
   }
 });
 
@@ -380,20 +416,22 @@ router.post('/upload-complete', validateSessionAndRole('SuperAdmin'), async (req
 // Body: { uploadId, key }
 router.post('/upload-abort', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const { uploadId, key } = req.body;
     if (!uploadId || !key) return res.status(400).json({ success: false, error: 'uploadId and key are required' });
 
-    await abortMultipartUpload(key, uploadId);
+    await abortMultipartUpload(key, uploadId, bucketName);
     return res.json({ success: true, message: 'Multipart upload aborted' });
   } catch (err) {
     console.error('[mbkbucket] upload-abort failed:', err);
-    return res.status(500).json({ success: false, error: err.message });
+    return sendApiError(res, err, 'upload-abort failed');
   }
 });
 
 // Create folder (zero-byte object with trailing slash)
 router.post('/create-folder', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const { prefix = '', folderName } = req.body;
     if (!folderName) return res.status(400).json({ success: false, error: 'folderName is required' });
 
@@ -403,11 +441,11 @@ router.post('/create-folder', validateSessionAndRole('SuperAdmin'), async (req,
     const folderKey = `${effectivePrefix.replace(/\/+$/, '')}/${folderName}/`;
 
     // Check if folder marker already exists
-    const markerExists = await fileExists(folderKey);
+    const markerExists = await fileExists(folderKey, bucketName);
     if (markerExists) return res.status(409).json({ success: false, error: 'Folder already exists' });
 
     // Check if any files already exist under this prefix (folder already has content)
-    const existingFiles = await listfiles(folderKey, { maxKeys: 1 });
+    const existingFiles = await listfiles(folderKey, { maxKeys: 1, bucketName });
     const hasContent = existingFiles.Contents && existingFiles.Contents.length > 0;
 
     if (hasContent) {
@@ -422,23 +460,25 @@ router.post('/create-folder', validateSessionAndRole('SuperAdmin'), async (req,
 
     // Create zero-byte object to represent empty folder
     await uploadFile(folderKey, Buffer.alloc(0), 'application/x-empty', {
-      metadata: { 'folder': 'true', 'marker': 'true' }
+      metadata: { 'folder': 'true', 'marker': 'true' },
+      bucketName
     });
 
     return res.json({ success: true, message: 'Folder created', key: folderKey });
   } catch (err) {
     console.error('Create folder failed:', err);
-    return res.status(500).json({ success: false, error: err.message });
+    return sendApiError(res, err, 'Create folder failed');
   }
 });
 
 router.post('/delete', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const { key, keys, folder } = req.body;
 
     if (keys && Array.isArray(keys) && keys.length) {
       // Bulk delete
-      await deleteFiles(keys);
+      await deleteFiles(keys, bucketName);
       return res.json({ success: true, message: 'Files deleted successfully' });
     }
 
@@ -449,21 +489,22 @@ router.post('/delete', validateSessionAndRole('SuperAdmin'), async (req, res) =>
 
     // If caller indicates it's a folder (or key ends with '/'), delete all objects under the prefix
     if (folder === true || String(keyToDelete).endsWith('/')) {
-      await deleteFolder(keyToDelete);
+      await deleteFolder(keyToDelete, bucketName);
       return res.json({ success: true, message: 'Folder deleted successfully' });
     }
 
-    await deleteFile(keyToDelete);
+    await deleteFile(keyToDelete, bucketName);
     res.json({ success: true, message: 'File deleted successfully' });
   } catch (error) {
     console.error("Error deleting file:", error);
-    res.status(500).json({ success: false, error: `Delete failed: ${error.message}` });
+    return sendApiError(res, error, 'Delete failed');
   }
 });
 
 router.get('/download/:key(*)', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   let stream = null;
   try {
+    const bucketName = req.activeBucket;
     const key = req.params.key;
     let keyToUse;
     try {
@@ -471,19 +512,37 @@ router.get('/download/:key(*)', validateSessionAndRole('SuperAdmin'), async (req
     } catch (e) {
       return res.status(400).json({ success: false, error: e.message });
     }
-    const result = await downloadFile(keyToUse);
+    const result = await downloadFile(keyToUse, { bucketName });
     stream = result.Body;
 
-    res.setHeader('Content-Disposition', `attachment; filename="${keyToUse.split('/').pop()}"`);
-    res.setHeader('Content-Type', result.ContentType || 'application/octet-stream');
+    res.setHeader('Content-Disposition', `attachment; filename="${getBaseName(keyToUse).replace(/"/g, '\\"')}"`);
+    const contentType = result.ContentType || 'application/octet-stream';
+    res.setHeader('Content-Type', contentType);
 
     // Set Content-Length header for proper download progress indication
     if (result.ContentLength) {
       res.setHeader('Content-Length', result.ContentLength);
     }
 
-    // Add cache headers for downloads
-    res.setHeader('Cache-Control', 'private, max-age=3600');
+    if (result.ETag) res.setHeader('ETag', result.ETag);
+    if (result.LastModified) res.setHeader('Last-Modified', result.LastModified.toUTCString());
+
+    const typeLower = String(contentType).toLowerCase();
+    const isSensitiveText = typeLower.startsWith('text/')
+      || typeLower.includes('json')
+      || typeLower.includes('xml')
+      || typeLower.includes('javascript')
+      || typeLower.includes('typescript');
+    const isLargeFile = Number(result.ContentLength || 0) > 50 * 1024 * 1024;
+
+    // Smarter cache policy for authenticated downloads.
+    if (isSensitiveText) {
+      res.setHeader('Cache-Control', 'private, no-store');
+    } else if (isLargeFile) {
+      res.setHeader('Cache-Control', 'private, max-age=600, must-revalidate');
+    } else {
+      res.setHeader('Cache-Control', 'private, max-age=1800, must-revalidate');
+    }
 
     // Proper stream error handling
     stream.on('error', (err) => {
@@ -523,4 +582,4 @@ router.get('/download/:key(*)', validateSessionAndRole('SuperAdmin'), async (req
   }
 });
 
-export default router;
+export default router;

package/lib/routes/index.js

@@ -3,13 +3,82 @@ import infoRoutes from "./info.js";
 import viewRoutes from "./view.js";
 import apiRoutes from "./api.js";
 import { validateSessionAndRole, renderPage, mbkautheVar } from "mbkauthe";
+import { resolveBucketName, getAvailableBucketNames } from "../s3.js";
 
 const router = express.Router();
 
+function renderBucketDashboard(req, res) {
+  const allBuckets = getAvailableBucketNames();
+  const configuredDefaultBucket = mbkautheVar?.bucket;
+
+  let bucketfilePath;
+
+  if(mbkautheVar?.APP_NAME === "portal") {
+    bucketfilePath ="bucketportal.handlebars";
+  } else {
+    bucketfilePath = "bucket.handlebars";
+  }
+
+
+  let selectedBucket;
+
+  try {
+    selectedBucket = resolveBucketName(req.query.bucket);
+  } catch (err) {
+    const fallbackSelected = mbkautheVar?.bucket;
+    const bucketOptions = allBuckets.map((name) => ({
+      name,
+      isSelected: name === fallbackSelected,
+      isDefault: name === configuredDefaultBucket
+    }));
+    return renderPage(req, res, bucketfilePath, mbkautheVar?.APP_NAME === "portal" ? true : false, {
+      page: "Admin Bucket",
+      layout: true,
+      bucketvar: mbkautheVar?.bucket,
+      selectedBucket: fallbackSelected,
+      bucketOptions,
+      APP_NAME: mbkautheVar?.APP_NAME,
+      message: req.query.message,
+      error: req.query.error || err.message,
+      availableBuckets: allBuckets
+    });
+  }
+
+  const bucketOptions = allBuckets.map((name) => ({
+    name,
+    isSelected: name === selectedBucket,
+    isDefault: name === configuredDefaultBucket
+  }));
+
+  renderPage(req, res, bucketfilePath, mbkautheVar?.APP_NAME === "portal" ? true : false, {
+    page: "Admin Bucket",
+    bucketvar: selectedBucket,
+    selectedBucket,
+    bucketOptions,
+    APP_NAME: mbkautheVar?.APP_NAME,
+    message: req.query.message,
+    error: req.query.error,
+    availableBuckets: allBuckets
+  });
+}
+
 router.get('/mbkbucket', validateSessionAndRole('SuperAdmin'), async (req, res) => {
-  renderPage(req, res, "bucket.handlebars", false, { page: "Admin Bucket", bucketvar: mbkautheVar?.bucket, APP_NAME: mbkautheVar?.APP_NAME, message: req.query.message, error: req.query.error });
+  return renderBucketDashboard(req, res);
 });
 
+// Central bucket resolution for all /mbkbucket subroutes.
+router.use('/mbkbucket', (req, _res, next) => {
+  try {
+    req.activeBucket = resolveBucketName(req.query.bucket);
+    req.bucketResolveError = null;
+  } catch (err) {
+    req.activeBucket = null;
+    req.bucketResolveError = err;
+  }
+  next();
+});
+
+
 router.use("/mbkbucket", infoRoutes);
 router.use("/mbkbucket", viewRoutes);
 router.use("/mbkbucket", apiRoutes);