mbkbucket 1.5.1 → 2.1.0

package/lib/routes/view.js

@@ -1,8 +1,11 @@
 import express from "express";
 import { validateSessionAndRole } from "mbkauthe";
-import { downloadFile, getFileMetadata, ensureKeyHasAppPrefix, generateSignedUrl } from "../s3.js";
+import { downloadFile, getFileMetadata, ensureKeyHasAppPrefix, generateSignedUrl, resolveBucketName } from "../s3.js";
 import { mbkbucketVar } from "../config/index.js";
 import rateLimit from "express-rate-limit";
+import { createLogger } from "../debug.js";
+
+const debugView = createLogger('view');
 
 // ---------------------------------------------------------------------------
 // p_view security: rate limiter + basic bot/security middleware
@@ -42,9 +45,6 @@ function pviewSecurity(req, res, next) {
     return res.status(403).json({ message: 'Forbidden' });
   }
   
-  // Rate limit check - ensure unique fingerprint per request
-  const fingerprint = `${req.headers['x-forwarded-for']?.split(',')[0].trim() || req.socket.remoteAddress}:${ua}`;
-  
   // Verify Accept header is present (legitimate browsers always send this)
   if (!req.headers['accept']) {
     return res.status(403).json({ message: 'Forbidden' });
@@ -63,9 +63,59 @@ function pviewSecurity(req, res, next) {
 
 const router = express.Router();
 
+function escapeHtml(value = '') {
+  return String(value)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function getBaseName(path = '') {
+  const value = String(path || '');
+  const lastSlashIndex = value.lastIndexOf('/');
+  return lastSlashIndex === -1 ? value : value.substring(lastSlashIndex + 1);
+}
+
+function classifyViewError(error, fallbackMessage = 'Request failed') {
+  const message = String(error?.message || fallbackMessage);
+  const lower = message.toLowerCase();
+
+  if (lower.includes('no bucket selected') || lower.includes('not found in bucketconnection')) {
+    return { status: 400, code: 'INVALID_BUCKET', message };
+  }
+  if (lower.includes('access denied')) {
+    return { status: 403, code: 'ACCESS_DENIED', message };
+  }
+  if (lower.includes('not found')) {
+    return { status: 404, code: 'NOT_FOUND', message };
+  }
+  if (lower.includes('invalid') || lower.includes('required')) {
+    return { status: 400, code: 'VALIDATION_ERROR', message };
+  }
+  return { status: 500, code: 'INTERNAL_ERROR', message };
+}
+
+function sendViewError(res, error, fallbackMessage = 'Request failed') {
+  const mapped = classifyViewError(error, fallbackMessage);
+  return res.status(mapped.status).json({ code: mapped.code, message: mapped.message });
+}
+
+// Central bucket guard for view routes except public view (forced default bucket).
+router.use((req, res, next) => {
+  if (req.path.startsWith('/p_view/')) return next();
+  if (req.bucketResolveError) return sendViewError(res, req.bucketResolveError, 'Invalid bucket selection');
+  if (!req.activeBucket) {
+    return sendViewError(res, new Error('No bucket selected. Provide ?bucket=<name> or configure a default bucket in mbkautheVar.bucket.'));
+  }
+  next();
+});
+
 // New: lightweight player page for robust playback in browsers
 router.get('/player/:key(*)', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const key = req.params.key;
     let keyToUse;
     try {
@@ -74,14 +124,16 @@ router.get('/player/:key(*)', validateSessionAndRole('SuperAdmin'), async (req,
       return res.status(400).send(e.message);
     }
     const encoded = encodeURIComponent(keyToUse);
-    const fileName = keyToUse.split('/').pop();
+    const fileName = getBaseName(keyToUse);
+    const safeFileName = escapeHtml(fileName);
 
+    const bucketQuery = `?bucket=${encodeURIComponent(bucketName)}`;
     const html = `<!doctype html>
       <html lang="en">
       <head>
         <meta charset="utf-8">
         <meta name="viewport" content="width=device-width,initial-scale=1">
-        <title>Preview: ${fileName}</title>
+        <title>Preview: ${safeFileName}</title>
         <style>
           * { margin: 0; padding: 0; box-sizing: border-box; }
           body { margin: 0; display: flex; align-items: center; justify-content: center; min-height: 100vh; background: #000; color: #fff; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; }
@@ -91,9 +143,9 @@ router.get('/player/:key(*)', validateSessionAndRole('SuperAdmin'), async (req,
         </style>
       </head>
       <body>
-        <div class="file-name">${fileName}</div>
+        <div class="file-name">${safeFileName}</div>
         <div class="player-container">
-          <video controls preload="metadata" src="/mbkbucket/view/${encoded}">
+          <video controls preload="metadata" src="/mbkbucket/view/${encoded}${bucketQuery}">
             Your browser does not support the video tag.
           </video>
         </div>
@@ -123,6 +175,9 @@ const VIEWABLE_TYPES = new Set([
 ]);
 // Pre-sorted for 415 error responses (avoids re-sorting on every error)
 const VIEWABLE_TYPES_SORTED = Array.from(VIEWABLE_TYPES).sort();
+const STATIC_ASSET_TYPES = new Set(['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'bmp', 'ico', 'css', 'js']);
+const VIDEO_TYPES = new Set(['mp4', 'webm', 'ogg', 'avi', 'mov']);
+const AUDIO_TYPES = new Set(['mp3', 'wav', 'flac', 'aac', 'm4a']);
 
 const MIME_TYPES = {
   // Images
@@ -160,11 +215,33 @@ const MIME_TYPES = {
 // Options:
 //   noindex {boolean} – adds X-Robots-Tag: noindex, nofollow (default false)
 // ---------------------------------------------------------------------------
-async function serveFileInline(req, res, keyToUse, { noindex = true } = {}) {
-  const fileName = keyToUse.split('/').pop();
-  const fileExtension = fileName.includes('.') ? fileName.split('.').pop().toLowerCase() : '';
+function isSensitiveTextType(contentType = '') {
+  const type = String(contentType || '').toLowerCase();
+  return type.startsWith('text/')
+    || type.includes('json')
+    || type.includes('xml')
+    || type.includes('javascript')
+    || type.includes('typescript');
+}
 
-  console.log(`[mbkbucket] 📥 Request for ${fileName} (type: ${fileExtension}, range: ${req.headers.range || 'none'})`);
+function buildCacheControl(contentType, { isStaticAsset = false, supportsRanges = false, publicCache = false } = {}) {
+  if (publicCache) {
+    if (isStaticAsset) return 'public, max-age=3600, immutable';
+    if (supportsRanges) return 'public, max-age=86400, must-revalidate';
+    return 'public, max-age=300, must-revalidate';
+  }
+
+  if (isSensitiveTextType(contentType)) return 'private, no-store';
+  if (supportsRanges) return 'private, max-age=1800, must-revalidate';
+  return 'private, max-age=300, must-revalidate';
+}
+
+async function serveFileInline(req, res, keyToUse, { noindex = true, bucketName, publicCache = false } = {}) {
+  const fileName = getBaseName(keyToUse);
+  const dotIndex = fileName.lastIndexOf('.');
+  const fileExtension = dotIndex === -1 ? '' : fileName.substring(dotIndex + 1).toLowerCase();
+
+  debugView('Request for %s (type: %s, range: %s)', fileName, fileExtension, req.headers.range || 'none');
 
   if (!VIEWABLE_TYPES.has(fileExtension)) {
     return res.status(415).json({
@@ -177,9 +254,9 @@ async function serveFileInline(req, res, keyToUse, { noindex = true } = {}) {
   const ifModifiedSince = req.headers['if-modified-since'];
   const rangeHeader = req.headers.range;
 
-  const isStaticAsset = ['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'bmp', 'ico', 'css', 'js'].includes(fileExtension);
-  const isVideo = ['mp4', 'webm', 'ogg', 'avi', 'mov'].includes(fileExtension);
-  const isAudio = ['mp3', 'wav', 'flac', 'aac', 'm4a'].includes(fileExtension);
+  const isStaticAsset = STATIC_ASSET_TYPES.has(fileExtension);
+  const isVideo = VIDEO_TYPES.has(fileExtension);
+  const isAudio = AUDIO_TYPES.has(fileExtension);
   const isPdf = fileExtension === 'pdf';
   const supportsRanges = isVideo || isAudio || isPdf;
   const contentType = MIME_TYPES[fileExtension] || 'application/octet-stream';
@@ -190,10 +267,10 @@ async function serveFileInline(req, res, keyToUse, { noindex = true } = {}) {
   // requested byte range — avoids downloading the full file first.
   // ---------------------------------------------------------------------------
   if (supportsRanges && rangeHeader) {
-    console.log(`[mbkbucket] Processing range request: ${rangeHeader} for ${fileName}`);
+    debugView('Processing range request: %s for %s', rangeHeader, fileName);
     let meta;
     try {
-      meta = await getFileMetadata(keyToUse);
+      meta = await getFileMetadata(keyToUse, bucketName);
     } catch (err) {
       console.error('[mbkbucket] serveFileInline metadata error:', err);
       return res.status(500).json({ message: 'Failed to fetch file metadata', error: err.message });
@@ -249,19 +326,19 @@ async function serveFileInline(req, res, keyToUse, { noindex = true } = {}) {
       const chunksize = end - start + 1;
 
       try {
-        const rangeResult = await downloadFile(keyToUse, { range: `bytes=${start}-${end}` });
+        const rangeResult = await downloadFile(keyToUse, { range: `bytes=${start}-${end}`, bucketName });
 
         if (typeof rangeResult.ContentLength === 'number' && rangeResult.ContentLength !== chunksize) {
-          console.warn(`Range size mismatch for ${keyToUse}: expected=${chunksize} got=${rangeResult.ContentLength}`);
+          debugView('Range size mismatch for %s: expected=%s got=%s', keyToUse, chunksize, rangeResult.ContentLength);
         }
 
-        console.log(`[mbkbucket] ✓ Serving range bytes ${start}-${end}/${total} (${chunksize} bytes) for ${fileName}`);
+        debugView('Serving range bytes %s-%s/%s (%s bytes) for %s', start, end, total, chunksize, fileName);
 
         res.status(206);
         res.setHeader('Content-Range', `bytes ${start}-${end}/${total}`);
         res.setHeader('Content-Length', chunksize);
         res.setHeader('Content-Type', contentType);
-        res.setHeader('Cache-Control', 'public, max-age=86400, must-revalidate');
+        res.setHeader('Cache-Control', buildCacheControl(contentType, { supportsRanges: true, publicCache }));
         res.setHeader('ETag', etag);
         res.setHeader('Accept-Ranges', 'bytes');
         if (noindex) res.setHeader('X-Robots-Tag', 'noindex, nofollow');
@@ -308,11 +385,12 @@ async function serveFileInline(req, res, keyToUse, { noindex = true } = {}) {
   // ---------------------------------------------------------------------------
   const downloadOptions = {
     ...(ifNoneMatch && { ifNoneMatch }),
-    ...(ifModifiedSince && { ifModifiedSince: new Date(ifModifiedSince) })
+    ...(ifModifiedSince && { ifModifiedSince: new Date(ifModifiedSince) }),
+    bucketName
   };
 
   if (isPdf) {
-    console.log(`[mbkbucket] Serving full PDF (no range header) for ${fileName}`);
+    debugView('Serving full PDF (no range header) for %s', fileName);
   }
 
   let result;
@@ -346,14 +424,7 @@ async function serveFileInline(req, res, keyToUse, { noindex = true } = {}) {
   }
   if (supportsRanges) res.setHeader('Accept-Ranges', 'bytes');
 
-  if (isStaticAsset) {
-    res.setHeader('Cache-Control', 'public, max-age=3600, immutable');
-  } else if (supportsRanges) {
-    // For video, audio, and PDF - enable caching with revalidation
-    res.setHeader('Cache-Control', 'public, max-age=86400, must-revalidate');
-  } else {
-    res.setHeader('Cache-Control', 'public, max-age=300');
-  }
+  res.setHeader('Cache-Control', buildCacheControl(contentType, { isStaticAsset, supportsRanges, publicCache }));
 
   res.status(200);
 
@@ -393,6 +464,7 @@ async function serveFileInline(req, res, keyToUse, { noindex = true } = {}) {
 
 router.get('/view/:key(*)', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     let keyToUse;
     try {
       keyToUse = ensureKeyHasAppPrefix(req.params.key);
@@ -400,7 +472,7 @@ router.get('/view/:key(*)', validateSessionAndRole('SuperAdmin'), async (req, re
       return res.status(400).json({ message: e.message });
     }
 
-    await serveFileInline(req, res, keyToUse, { noindex: true });
+    await serveFileInline(req, res, keyToUse, { noindex: true, bucketName, publicCache: false });
 
   } catch (error) {
     console.error("Error viewing file:", error);
@@ -417,6 +489,7 @@ router.get('/view/:key(*)', validateSessionAndRole('SuperAdmin'), async (req, re
 if (mbkbucketVar?.publiView_enabled) {
   router.get('/p_view/:key(*)', pviewRateLimit, pviewSecurity, async (req, res) => {
     try {
+      const bucketName = resolveBucketName();
       const key = req.params.key;
 
       // No directory indexing — reject folder-like or empty keys
@@ -438,7 +511,7 @@ if (mbkbucketVar?.publiView_enabled) {
       if (!p_view_inline) {
         // Signed URL mode — redirect to a pre-signed S3 URL (1 hour expiry)
         try {
-          const signed = await generateSignedUrl(keyToUse, 'getObject', 3600);
+          const signed = await generateSignedUrl(keyToUse, 'getObject', 3600, bucketName);
           return res.redirect(302, signed.url);
         } catch (err) {
           console.error('[mbkbucket] p_view signed URL error:', err);
@@ -447,7 +520,7 @@ if (mbkbucketVar?.publiView_enabled) {
       }
 
       // Direct serve mode — stream file inline (with noindex header)
-      await serveFileInline(req, res, keyToUse, { noindex: true });
+      await serveFileInline(req, res, keyToUse, { noindex: true, bucketName, publicCache: true });
     } catch (error) {
       console.error('[mbkbucket] p_view error:', error);
       res.status(500).json({ message: 'Internal server error', error: error.message });
@@ -455,4 +528,4 @@ if (mbkbucketVar?.publiView_enabled) {
   });
 }
 
-export default router;
+export default router;