mbkbucket 3.3.1 → 3.4.0

package/lib/src/config/validation.js

@@ -1,20 +1,18 @@
 const TRUE_VALUES = new Set(['true', 't', '1', 'yes', 'y', 'on']);
 const FALSE_VALUES = new Set(['false', 'f', '0', 'no', 'n', 'off']);
 
-function normalizeBooleanLike(value) {
+export function normalizeBooleanLike(value) {
   if (typeof value === 'boolean') return value;
   if (typeof value === 'string') {
-    const normalized = value.trim().toLowerCase();
-    if (TRUE_VALUES.has(normalized)) return true;
-    if (FALSE_VALUES.has(normalized)) return false;
+    const norm = value.trim().toLowerCase();
+    if (TRUE_VALUES.has(norm)) return true;
+    if (FALSE_VALUES.has(norm)) return false;
   }
   return value;
 }
 
 export function parseAndValidateMbkbucketVar(rawValue) {
-  const errors = [];
   let parsed;
-
   try {
     parsed = rawValue ? JSON.parse(rawValue) : {};
   } catch {
@@ -25,14 +23,10 @@ export function parseAndValidateMbkbucketVar(rawValue) {
     throw new Error('mbkbucketVar must be a valid object');
   }
 
-  const defaults = {
-    p_view_inline: true,
-    publiView_enabled: false
-  };
-
+  const defaults = { p_view_inline: true, publiView_enabled: false };
   for (const [key, defaultVal] of Object.entries(defaults)) {
-    const current = parsed[key];
-    if (current === undefined || (typeof current === 'string' && current.trim() === '')) {
+    const val = parsed[key];
+    if (val === undefined || (typeof val === 'string' && val.trim() === '')) {
       parsed[key] = defaultVal;
     }
   }
@@ -40,24 +34,16 @@ export function parseAndValidateMbkbucketVar(rawValue) {
   parsed.p_view_inline = normalizeBooleanLike(parsed.p_view_inline);
   parsed.publiView_enabled = normalizeBooleanLike(parsed.publiView_enabled);
 
-  if (typeof parsed.p_view_inline !== 'boolean') {
-    errors.push('mbkbucketVar.p_view_inline must be a boolean if provided');
-  }
-  if (typeof parsed.publiView_enabled !== 'boolean') {
-    errors.push('mbkbucketVar.publiView_enabled must be a boolean if provided');
-  }
-
-  if (errors.length) {
-    throw new Error(errors.join(' | '));
-  }
+  const errors = [];
+  if (typeof parsed.p_view_inline !== 'boolean') errors.push('mbkbucketVar.p_view_inline must be a boolean if provided');
+  if (typeof parsed.publiView_enabled !== 'boolean') errors.push('mbkbucketVar.publiView_enabled must be a boolean if provided');
+  if (errors.length) throw new Error(errors.join(' | '));
 
   return parsed;
 }
 
 export function parseAndValidateBucketConnection(rawValue) {
-  if (!rawValue) {
-    return null;
-  }
+  if (!rawValue) return null;
 
   let parsed;
   try {
@@ -66,7 +52,7 @@ export function parseAndValidateBucketConnection(rawValue) {
     throw new Error('BucketConnection is not valid JSON');
   }
 
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || Object.keys(parsed).length === 0) {
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || !Object.keys(parsed).length) {
     throw new Error('BucketConnection must be a non-empty object');
   }
 
@@ -77,7 +63,7 @@ export function parseAndValidateBucketConnection(rawValue) {
       throw new Error(`Bucket '${bucketName}' configuration must be an object, not a string. Remove quotes around the inner JSON object.`);
     }
 
-    const missingFields = requiredFields.filter((field) => !config[field]);
+    const missingFields = requiredFields.filter(field => !config[field]);
     if (missingFields.length) {
       throw new Error(`Bucket '${bucketName}' is missing required fields: ${missingFields.join(', ')}`);
     }
@@ -85,5 +71,3 @@ export function parseAndValidateBucketConnection(rawValue) {
 
   return parsed;
 }
-
-export { normalizeBooleanLike };

package/lib/src/controllers/api.controller.js

@@ -1,26 +1,11 @@
 import { pipeline } from "stream/promises";
-import {
-  listfiles, uploadFile, deleteFile, deleteFiles, deleteFolder,
-  downloadFile, getFileMetadata, fileExists,
-  ensureKeyHasAppPrefix, ensurePrefix, getAppName,
-  createMultipartUpload, uploadPart, completeMultipartUpload,
-  abortMultipartUpload, listIncompleteMultipartUploads,
-  cleanupIncompleteMultipartUploads
-} from "../services/s3.service.js";
+import { listfiles, uploadFile, deleteFile, deleteFiles, deleteFolder, downloadFile, getFileMetadata, fileExists, ensureKeyHasAppPrefix, ensurePrefix, createMultipartUpload, uploadPart, completeMultipartUpload, abortMultipartUpload, listIncompleteMultipartUploads, cleanupIncompleteMultipartUploads } from "../services/s3.service.js";
 import { sendApiError, classifyApiError } from "../utils/errors.js";
-import { getBaseName } from "../utils/helpers.js";
-import { createLogger } from "../utils/logger.js";
+import { getBaseName, isSensitiveTextType, buildKey, normalizeKeyParam, getFolderPath, destroyStream } from "../utils/helpers.js";
+import { createLogger } from "#logger";
 
 const debugApi = createLogger('api');
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve & validate a prefix from request input. Returns the effective prefix
- * or sends a 400 JSON error response (and returns null).
- */
 function resolvePrefix(req, res, prefix) {
   try {
     return ensurePrefix(prefix);
@@ -30,45 +15,29 @@ function resolvePrefix(req, res, prefix) {
   }
 }
 
-/**
- * Build a full S3 key from a prefix and filename, stripping trailing slashes.
- */
-function buildKey(prefix, fileName) {
-  const cleanPrefix = String(prefix || '').replace(/^\/+/, '').replace(/\/+$/, '');
-  const cleanName = String(fileName || '').replace(/^\/+/, '');
-  return cleanPrefix ? `${cleanPrefix}/${cleanName}` : cleanName;
-}
-
 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')) {
+    const meta = await getFileMetadata(folderPath, bucketName);
+    if (meta.exists && (meta.ContentLength === 0 || meta.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);
+  } catch (err) {
+    debugApi('Failed to clean up folder marker: %s', err.message);
   }
 }
 
-// ---------------------------------------------------------------------------
-// Controller handlers
-// ---------------------------------------------------------------------------
-
 export async function cleanupUploads(req, res) {
   try {
     const { olderThanDays = 7, prefix = '' } = req.body;
-    const bucketName = req.activeBucket;
-
     const days = parseInt(olderThanDays, 10);
     if (isNaN(days) || days < 1) {
       return res.status(400).json({ success: false, error: 'olderThanDays must be a positive integer' });
     }
 
     debugApi('Starting cleanup of incomplete uploads older than %s days', days);
-    const result = await cleanupIncompleteMultipartUploads(days, prefix, bucketName);
+    const result = await cleanupIncompleteMultipartUploads(days, prefix, req.activeBucket);
 
     res.json({
       success: true,
@@ -84,9 +53,7 @@ export async function cleanupUploads(req, res) {
 export async function listIncompleteUploads(req, res) {
   try {
     const { prefix = '' } = req.query;
-    const bucketName = req.activeBucket;
-    const uploads = await listIncompleteMultipartUploads(prefix, bucketName);
-
+    const uploads = await listIncompleteMultipartUploads(prefix, req.activeBucket);
     res.json({
       success: true,
       count: uploads.length,
@@ -111,7 +78,7 @@ export async function listFiles(req, res) {
   const effectivePrefix = resolvePrefix(req, res, prefix);
   if (effectivePrefix === null) return;
 
-  const isSearch = search && search.trim().length > 0;
+  const isSearch = Boolean(search && search.trim());
   const isRecursive = recursive === 'true';
   const useOptimizedListing = !isSearch && !isRecursive;
 
@@ -119,14 +86,10 @@ export async function listFiles(req, res) {
     let files = [];
     let folders = [];
     let nextContinuationToken = null;
-    let usedPrefix = effectivePrefix;
-    let legacyFallback = false;
 
     if (useOptimizedListing) {
       let listPrefix = effectivePrefix ? String(effectivePrefix).replace(/^\/+/, '') : '';
-      if (listPrefix && !listPrefix.endsWith('/')) {
-        listPrefix += '/';
-      }
+      if (listPrefix && !listPrefix.endsWith('/')) listPrefix += '/';
 
       const result = await listfiles(listPrefix, {
         continuationToken: token || undefined,
@@ -140,42 +103,8 @@ export async function listFiles(req, res) {
         .filter(p => p.Prefix !== listPrefix && p.Prefix !== effectivePrefix)
         .map(p => p.Prefix);
       nextContinuationToken = result.NextContinuationToken;
-    }
-
-    else {
-      let continuationToken = undefined;
-
-      do {
-        const result = await listfiles(effectivePrefix, { continuationToken, bucketName });
-        if (result.Contents?.length) {
-          for (const file of result.Contents) {
-            if (!file.Key.endsWith('/')) files.push(file);
-          }
-        }
-        continuationToken = result.nextToken;
-      } while (continuationToken);
-
-      if (!files.length && !search) {
-        try {
-          const rootResult = await listfiles('', { bucketName });
-          if ((rootResult.Contents || []).length) {
-            files = rootResult.Contents || [];
-            usedPrefix = '';
-            legacyFallback = true;
-          }
-        } catch (fallbackErr) {
-          debugApi('Fallback root listing failed: %s', fallbackErr.message);
-        }
-      }
 
-      if (isSearch) {
-        const searchLower = search.trim().toLowerCase();
-        files = files.filter(file => file.Key.toLowerCase().includes(searchLower));
-      }
-    }
-
-    if (useOptimizedListing) {
-      res.json({
+      return res.json({
         success: true,
         files,
         folders,
@@ -190,29 +119,50 @@ export async function listFiles(req, res) {
         totalFiles: -1,
         paginationType: 'continuation-token'
       });
-    } else {
-      const totalFiles = files.length;
-      const totalPages = Math.max(1, Math.ceil(totalFiles / pageSize));
-      const currentPage = Math.max(1, parseInt(page, 10) || 1);
-      const startIndex = (currentPage - 1) * pageSize;
-      const paginatedFiles = files.slice(startIndex, startIndex + pageSize);
-
-      res.json({
-        success: true,
-        files: paginatedFiles,
-        folders: [],
-        prefix: effectivePrefix,
-        search,
-        currentPage,
-        totalPages,
-        hasNextPage: currentPage < totalPages,
-        hasPrevPage: currentPage > 1,
-        nextPage: currentPage + 1,
-        prevPage: Math.max(1, currentPage - 1),
-        totalFiles
+    }
+
+    let continuationToken;
+    do {
+      const result = await listfiles(effectivePrefix, { continuationToken, bucketName });
+      (result.Contents || []).forEach(file => {
+        if (!file.Key.endsWith('/')) files.push(file);
       });
+      continuationToken = result.nextToken;
+    } while (continuationToken);
+
+    if (!files.length && !search) {
+      try {
+        const rootResult = await listfiles('', { bucketName });
+        if (rootResult.Contents?.length) files = rootResult.Contents;
+      } catch (fallbackErr) {
+        debugApi('Fallback root listing failed: %s', fallbackErr.message);
+      }
     }
 
+    if (isSearch) {
+      const searchLower = search.trim().toLowerCase();
+      files = files.filter(file => file.Key.toLowerCase().includes(searchLower));
+    }
+
+    const totalFiles = files.length;
+    const totalPages = Math.max(1, Math.ceil(totalFiles / pageSize));
+    const currentPage = Math.max(1, parseInt(page, 10) || 1);
+    const paginatedFiles = files.slice((currentPage - 1) * pageSize, currentPage * pageSize);
+
+    res.json({
+      success: true,
+      files: paginatedFiles,
+      folders: [],
+      prefix: effectivePrefix,
+      search,
+      currentPage,
+      totalPages,
+      hasNextPage: currentPage < totalPages,
+      hasPrevPage: currentPage > 1,
+      nextPage: currentPage + 1,
+      prevPage: Math.max(1, currentPage - 1),
+      totalFiles
+    });
   } catch (error) {
     console.error("Error listing files:", error);
     const mapped = classifyApiError(error, 'Error listing files');
@@ -229,16 +179,12 @@ export async function listFiles(req, res) {
 export async function uploadSingleFile(req, res) {
   try {
     const bucketName = req.activeBucket;
-    if (!req.file) {
-      return res.status(400).json({ success: false, error: 'No file selected' });
-    }
+    if (!req.file) return res.status(400).json({ success: false, error: 'No file selected' });
 
-    const { prefix = '' } = req.body;
-    const effectivePrefix = resolvePrefix(req, res, prefix);
+    const effectivePrefix = resolvePrefix(req, res, req.body.prefix || '');
     if (effectivePrefix === null) return;
 
     const key = buildKey(effectivePrefix, req.file.originalname);
-
     const uploadOptions = {
       metadata: {
         'original-name': req.file.originalname,
@@ -251,10 +197,7 @@ export async function uploadSingleFile(req, res) {
 
     try {
       await uploadFile(key, req.file.buffer, req.file.mimetype, uploadOptions);
-
-      const folderPath = key.substring(0, key.lastIndexOf('/') + 1);
-      await cleanupFolderMarker(folderPath, bucketName);
-
+      await cleanupFolderMarker(getFolderPath(key), bucketName);
       res.json({ success: true, message: 'File uploaded successfully', key });
     } catch (uploadError) {
       if (uploadError.message.includes('already exists')) {
@@ -278,9 +221,9 @@ export async function initiateMultipartUpload(req, res) {
     if (effectivePrefix === null) return;
 
     const key = buildKey(effectivePrefix, fileName);
-
-    const exists = await fileExists(key, bucketName);
-    if (exists) return res.status(409).json({ success: false, error: `File already exists: ${fileName}` });
+    if (await fileExists(key, bucketName)) {
+      return res.status(409).json({ success: false, error: `File already exists: ${fileName}` });
+    }
 
     const result = await createMultipartUpload(key, contentType, {}, bucketName);
     return res.json({ success: true, uploadId: result.uploadId, key: result.key });
@@ -292,7 +235,6 @@ export async function initiateMultipartUpload(req, res) {
 
 export async function uploadChunk(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' });
@@ -302,7 +244,7 @@ export async function uploadChunk(req, res) {
       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, bucketName);
+    const result = await uploadPart(key, uploadId, part, req.file.buffer, req.activeBucket);
     return res.json({ success: true, partNumber: result.partNumber, ETag: result.ETag });
   } catch (err) {
     console.error('[mbkbucket] upload-chunk failed:', err);
@@ -319,9 +261,7 @@ export async function completeUpload(req, res) {
     }
 
     const result = await completeMultipartUpload(key, uploadId, parts, bucketName);
-
-    const folderPath = result.key.substring(0, result.key.lastIndexOf('/') + 1);
-    await cleanupFolderMarker(folderPath, bucketName);
+    await cleanupFolderMarker(getFolderPath(result.key), bucketName);
 
     return res.json({ success: true, message: 'File uploaded successfully', key: result.key });
   } catch (err) {
@@ -332,11 +272,10 @@ export async function completeUpload(req, res) {
 
 export async function abortUpload(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, bucketName);
+    await abortMultipartUpload(key, uploadId, req.activeBucket);
     return res.json({ success: true, message: 'Multipart upload aborted' });
   } catch (err) {
     console.error('[mbkbucket] upload-abort failed:', err);
@@ -354,31 +293,22 @@ export async function createFolder(req, res) {
     if (effectivePrefix === null) return;
 
     const cleanName = String(folderName).replace(/^\/+/, '').replace(/\/+$/, '');
-    let folderKey;
-    if (effectivePrefix && !cleanName.startsWith(effectivePrefix)) {
-      const cleanPrefix = effectivePrefix.replace(/\/+$/, '');
-      folderKey = `${cleanPrefix}/${cleanName}/`;
-    } else {
-      folderKey = `${cleanName}/`;
-    }
+    const cleanPrefix = effectivePrefix.replace(/\/+$/, '');
+    const folderKey = (effectivePrefix && !cleanName.startsWith(effectivePrefix))
+      ? `${cleanPrefix}/${cleanName}/`
+      : `${cleanName}/`;
 
-    const markerExists = await fileExists(folderKey, bucketName);
-    if (markerExists) return res.status(409).json({ success: false, error: 'Folder already exists' });
+    if (await fileExists(folderKey, bucketName)) {
+      return res.status(409).json({ success: false, error: 'Folder already exists' });
+    }
 
     const existingFiles = await listfiles(folderKey, { maxKeys: 1, bucketName });
-    const hasContent = existingFiles.Contents && existingFiles.Contents.length > 0;
-
-    if (hasContent) {
-      return res.json({
-        success: true,
-        message: 'Folder already exists with content',
-        key: folderKey,
-        skipMarker: true
-      });
+    if (existingFiles.Contents?.length) {
+      return res.json({ success: true, message: 'Folder already exists with content', key: folderKey, skipMarker: true });
     }
 
     await uploadFile(folderKey, Buffer.alloc(0), 'application/x-empty', {
-      metadata: { 'folder': 'true', 'marker': 'true' },
+      metadata: { folder: 'true', marker: 'true' },
       bucketName
     });
 
@@ -402,7 +332,11 @@ export async function deleteItems(req, res) {
     if (!key) return res.status(400).json({ success: false, error: 'Key is required' });
 
     let keyToDelete;
-    try { keyToDelete = ensureKeyHasAppPrefix(key); } catch (e) { return res.status(400).json({ success: false, error: e.message }); }
+    try {
+      keyToDelete = ensureKeyHasAppPrefix(key);
+    } catch (e) {
+      return res.status(400).json({ success: false, error: e.message });
+    }
 
     if (folder === true || String(keyToDelete).endsWith('/')) {
       await deleteFolder(keyToDelete, bucketName);
@@ -418,15 +352,12 @@ export async function deleteItems(req, res) {
 }
 
 export async function downloadFileHandler(req, res) {
-  // Track whether this request has been aborted (client disconnected)
   let aborted = false;
   req.once('aborted', () => { aborted = true; });
   req.once('close', () => { aborted = true; });
 
   try {
-    const bucketName = req.activeBucket;
-    const rawKey = req.params.key;
-    const key = Array.isArray(rawKey) ? rawKey.join('/') : (rawKey || '');
+    const key = normalizeKeyParam(req.params.key);
     let keyToUse;
     try {
       keyToUse = ensureKeyHasAppPrefix(key);
@@ -434,14 +365,11 @@ export async function downloadFileHandler(req, res) {
       return res.status(400).json({ success: false, error: e.message });
     }
 
-    // If client already disconnected before we fetched, bail early
     if (aborted) return;
 
-    const result = await downloadFile(keyToUse, { bucketName });
-
-    // Re-check: client may have disconnected while waiting for S3
+    const result = await downloadFile(keyToUse, { bucketName: req.activeBucket });
     if (aborted) {
-      if (result.Body && typeof result.Body.destroy === 'function') result.Body.destroy();
+      destroyStream(result.Body);
       return;
     }
 
@@ -449,50 +377,31 @@ export async function downloadFileHandler(req, res) {
     const contentType = result.ContentType || 'application/octet-stream';
     const contentLength = result.ContentLength;
 
-    // Set headers BEFORE piping — this allows the browser to show filename
-    // and progress bar even before the first byte arrives
     res.setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
     res.setHeader('Content-Type', contentType);
     if (contentLength) res.setHeader('Content-Length', contentLength);
     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 isSensitive = isSensitiveTextType(contentType);
     const isLargeFile = Number(contentLength || 0) > 50 * 1024 * 1024;
+    res.setHeader('Cache-Control', isSensitive ? 'private, no-store' : isLargeFile ? 'private, max-age=600, must-revalidate' : 'private, max-age=1800, must-revalidate');
 
-    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');
-    }
-
-    // Use pipeline for proper backpressure + cleanup. On abort, the
-    // pipeline will be rejected and we clean up the S3 stream.
     try {
       await pipeline(result.Body, res);
     } catch (pipeErr) {
-      // Aborted by client — expected, not an error
       if (aborted) {
-        if (result.Body && typeof result.Body.destroy === 'function') result.Body.destroy();
+        destroyStream(result.Body);
         return;
       }
       throw pipeErr;
     }
   } catch (error) {
-    // Don't try to send error response if client already disconnected
     if (aborted) return;
-
     console.error("Error downloading file:", error);
-    if (error.message && error.message.includes('File not found')) {
+    if (error.message?.includes('File not found')) {
       res.status(404).json({ message: "File not found", key: req.params.key });
-    } else if (error.message && error.message.includes('Access denied')) {
+    } else if (error.message?.includes('Access denied')) {
       res.status(403).json({ message: "Access denied" });
     } else if (!res.headersSent) {
       res.status(500).json({ message: "Download failed", error: error.message });

package/lib/src/controllers/dashboard.controller.js

@@ -1,3 +1,4 @@
+import fs from "fs";
 import path from "path";
 import { resolveBucketName, getAvailableBucketNames } from "../services/s3.service.js";
 import { renderPage, mbkautheVar } from "mbkauthe";
@@ -11,49 +12,37 @@ export function renderBucketDashboard(req, res) {
   const configuredDefaultBucket = mbkautheVar?.bucket;
   const isPortal = mbkautheVar?.APP_NAME === "portal";
   const bucketfilePath = isPortal ? "bucketportal.handlebars" : "bucket.handlebars";
-  const portalLayout = isPortal ? path.resolve(process.cwd(), "views", "layouts", "main") : false;
+
+  const mainLayoutPath = path.resolve(process.cwd(), "views", "layouts", "main");
+  const hasMainLayout = fs.existsSync(`${mainLayoutPath}.handlebars`) || fs.existsSync(mainLayoutPath);
+  const portalLayout = (isPortal && hasMainLayout) ? mainLayoutPath : false;
 
   let selectedBucket;
+  let error = req.query.error;
 
   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, isPortal, {
-      page: "Admin Bucket",
-      helpers: commonHandlebarsHelpers,
-      ...(isPortal ? { layout: portalLayout } : {}),
-      bucketvar: mbkautheVar?.bucket,
-      selectedBucket: fallbackSelected,
-      bucketOptions,
-      APP_NAME: mbkautheVar?.APP_NAME,
-      message: req.query.message,
-      error: req.query.error || err.message,
-      availableBuckets: allBuckets
-    });
+    selectedBucket = mbkautheVar?.bucket;
+    error ||= err.message;
   }
 
-  const bucketOptions = allBuckets.map((name) => ({
+  const bucketOptions = allBuckets.map(name => ({
     name,
     isSelected: name === selectedBucket,
     isDefault: name === configuredDefaultBucket
   }));
 
-  renderPage(req, res, bucketfilePath, isPortal, {
+  renderPage(req, res, bucketfilePath, portalLayout ? true : false, {
     page: "Admin Bucket",
     helpers: commonHandlebarsHelpers,
-    ...(isPortal ? { layout: portalLayout } : {}),
+    ...(portalLayout ? { layout: portalLayout } : { layout: false }),
     bucketvar: selectedBucket,
     selectedBucket,
     bucketOptions,
     APP_NAME: mbkautheVar?.APP_NAME,
     message: req.query.message,
-    error: req.query.error,
+    error,
     availableBuckets: allBuckets
   });
 }

package/lib/src/controllers/info.controller.js

@@ -1,37 +1,34 @@
 import { renderPage, mbkautheVar } from "mbkauthe";
 import { packageJson, getLatestVersion } from "../config/index.js";
 
-/**
- * Render the mbkbucket info page (Handlebars).
- */
-export async function infoPage(req, res) {
+async function getInfoData() {
   let latestVersion = 'unknown';
   try {
-    latestVersion = await getLatestVersion();
+    latestVersion = (await getLatestVersion()) || 'unknown';
   } catch (err) {
-    console.error("[mbkauthe] Error fetching package-lock.json:", err);
+    console.error("[mbkbucket] Error fetching latest version:", err);
   }
-  renderPage(req, res, "mbkbucket_info.handlebars", false, {
-    page: "MBK Bucket Info",
+  return {
     CurrentVersion: packageJson.version,
     latestVersion,
     APP_NAME: mbkautheVar?.APP_NAME
+  };
+}
+
+/**
+ * Render the mbkbucket info page (Handlebars).
+ */
+export async function infoPage(req, res) {
+  const data = await getInfoData();
+  renderPage(req, res, "mbkbucket_info.handlebars", false, {
+    page: "MBK Bucket Info",
+    ...data
   });
 }
 
 /**
  * Return bucket info as JSON.
  */
-export async function infoJson(req, res) {
-  let latestVersion = 'unknown';
-  try {
-    latestVersion = await getLatestVersion();
-  } catch (err) {
-    console.error("[mbkauthe] Error fetching package-lock.json:", err);
-  }
-  res.json({
-    CurrentVersion: packageJson.version,
-    latestVersion,
-    APP_NAME: mbkautheVar?.APP_NAME
-  });
+export async function infoJson(_req, res) {
+  res.json(await getInfoData());
 }