mbkbucket 2.1.0 → 3.0.0

package/{lib/routes/index.js → src/controllers/dashboard.controller.js}

@@ -1,25 +1,20 @@
-import express from "express";
-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";
+import { resolveBucketName, getAvailableBucketNames } from "../services/s3.service.js";
+import { renderPage, mbkautheVar } from "mbkauthe";
 
-const router = express.Router();
-
-function renderBucketDashboard(req, res) {
+/**
+ * Render the main bucket dashboard page.
+ */
+export function renderBucketDashboard(req, res) {
   const allBuckets = getAvailableBucketNames();
   const configuredDefaultBucket = mbkautheVar?.bucket;
 
   let bucketfilePath;
-
-  if(mbkautheVar?.APP_NAME === "portal") {
-    bucketfilePath ="bucketportal.handlebars";
+  if (mbkautheVar?.APP_NAME === "portal") {
+    bucketfilePath = "bucketportal.handlebars";
   } else {
     bucketfilePath = "bucket.handlebars";
   }
 
-
   let selectedBucket;
 
   try {
@@ -61,26 +56,3 @@ function renderBucketDashboard(req, res) {
     availableBuckets: allBuckets
   });
 }
-
-router.get('/mbkbucket', validateSessionAndRole('SuperAdmin'), async (req, res) => {
-  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);
-
-export default router;

package/src/controllers/info.controller.js

@@ -0,0 +1,37 @@
+import { renderPage, mbkautheVar } from "mbkauthe";
+import { packageJson, getLatestVersion } from "../config/index.js";
+
+/**
+ * Render the mbkbucket info page (Handlebars).
+ */
+export async function infoPage(req, res) {
+  let latestVersion = 'unknown';
+  try {
+    latestVersion = await getLatestVersion();
+  } catch (err) {
+    console.error("[mbkauthe] Error fetching package-lock.json:", err);
+  }
+  renderPage(req, res, "mbkbucket_info.handlebars", false, {
+    page: "MBK Bucket Info",
+    CurrentVersion: packageJson.version,
+    latestVersion,
+    APP_NAME: mbkautheVar?.APP_NAME
+  });
+}
+
+/**
+ * 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
+  });
+}

package/src/controllers/view.controller.js

@@ -0,0 +1,276 @@
+import {
+  downloadFile, getFileMetadata, ensureKeyHasAppPrefix,
+  generateSignedUrl, resolveBucketName
+} from "../services/s3.service.js";
+import { mbkbucketVar } from "../config/index.js";
+import {
+  escapeHtml, getBaseName, VIEWABLE_TYPES, VIEWABLE_TYPES_SORTED,
+  STATIC_ASSET_TYPES, VIDEO_TYPES, AUDIO_TYPES, MIME_TYPES,
+  buildCacheControl, parseRangeHeader, renderPlayerPage
+} from "../utils/helpers.js";
+import { createLogger } from "../utils/logger.js";
+
+const debugView = createLogger('view');
+
+// ---------------------------------------------------------------------------
+// Stream helpers
+// ---------------------------------------------------------------------------
+
+function attachStreamCleanup(req, res, stream, timeoutMs = 120000) {
+  const cleanup = () => {
+    if (stream && typeof stream.destroy === 'function') {
+      stream.removeAllListeners();
+      stream.destroy();
+    }
+  };
+
+  stream.on('error', (err) => {
+    console.error('Stream error:', err);
+    cleanup();
+    if (!res.headersSent) res.status(500).end('Stream error');
+  });
+
+  req.on('close', cleanup);
+  req.on('aborted', cleanup);
+
+  req.setTimeout(timeoutMs, () => {
+    console.error('Request timeout for stream');
+    cleanup();
+    if (!res.headersSent) res.status(408).end('Request timeout');
+  });
+
+  res.on('finish', cleanup);
+  res.on('close', cleanup);
+}
+
+// ---------------------------------------------------------------------------
+// Inline file serving (used by /view/:key and /p_view/:key)
+// ---------------------------------------------------------------------------
+
+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({
+      message: 'File type not supported for viewing',
+      supportedTypes: VIEWABLE_TYPES_SORTED
+    });
+  }
+
+  const ifNoneMatch = req.headers['if-none-match'];
+  const ifModifiedSince = req.headers['if-modified-since'];
+  const rangeHeader = req.headers.range;
+
+  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';
+
+  // Fast path for range requests (video / audio / PDF streaming)
+  if (supportsRanges && rangeHeader) {
+    debugView('Processing range request: %s for %s', rangeHeader, fileName);
+    let meta;
+    try {
+      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 });
+    }
+
+    if (!meta || !meta.exists) {
+      return res.status(404).json({ message: 'File not found', key: keyToUse });
+    }
+
+    const etag = `"${meta.LastModified?.getTime() || Date.now()}-${meta.ContentLength || 0}"`;
+    if (ifNoneMatch === etag) return res.status(304).end();
+
+    const total = Number(meta.ContentLength);
+    if (!total) {
+      // No content-length — fall through to full-file path
+    } else {
+      const range = parseRangeHeader(rangeHeader, total);
+      if (!range) {
+        // Invalid or unsatisfiable range
+        res.status(416).setHeader('Content-Range', `bytes */${total}`);
+        return res.end();
+      }
+
+      const { start, end, size: chunksize } = range;
+
+      try {
+        const rangeResult = await downloadFile(keyToUse, { range: `bytes=${start}-${end}`, bucketName });
+
+        if (typeof rangeResult.ContentLength === 'number' && rangeResult.ContentLength !== chunksize) {
+          debugView('Range size mismatch for %s: expected=%s got=%s', keyToUse, chunksize, rangeResult.ContentLength);
+        }
+
+        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', buildCacheControl(contentType, { supportsRanges: true, publicCache }));
+        res.setHeader('ETag', etag);
+        res.setHeader('Accept-Ranges', 'bytes');
+        if (noindex) res.setHeader('X-Robots-Tag', 'noindex, nofollow');
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        if (meta.LastModified) res.setHeader('Last-Modified', meta.LastModified.toUTCString());
+
+        attachStreamCleanup(req, res, rangeResult.Body);
+        return rangeResult.Body.pipe(res);
+
+      } catch (rangeError) {
+        console.error('Range request failed:', rangeError);
+        // fall through to full-file path
+      }
+    }
+  }
+
+  // Standard path: full-file download
+  const downloadOptions = {
+    ...(ifNoneMatch && { ifNoneMatch }),
+    ...(ifModifiedSince && { ifModifiedSince: new Date(ifModifiedSince) }),
+    bucketName
+  };
+
+  if (isPdf) {
+    debugView('Serving full PDF (no range header) for %s', fileName);
+  }
+
+  let result;
+  try {
+    result = await downloadFile(keyToUse, downloadOptions);
+  } catch (err) {
+    if (err.name === 'NoSuchKey' || err.name === 'NotFound') {
+      return res.status(404).json({ message: 'File not found', key: keyToUse });
+    } else if (err.name === 'AccessDenied') {
+      return res.status(403).json({ message: 'Access denied' });
+    }
+    console.error('[mbkbucket] serveFileInline download error:', err);
+    return res.status(500).json({ message: 'Failed to fetch file', error: err.message });
+  }
+
+  if (result && result.notModified) return res.status(304).end();
+
+  const etag = `"${result.LastModified?.getTime() || Date.now()}-${result.ContentLength || 0}"`;
+  if (ifNoneMatch === etag) return res.status(304).end();
+
+  res.setHeader('Content-Type', contentType);
+  res.setHeader('Content-Disposition', `inline; filename="${fileName}"`);
+  res.setHeader('ETag', etag);
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.setHeader('X-Frame-Options', 'SAMEORIGIN');
+  if (noindex) res.setHeader('X-Robots-Tag', 'noindex, nofollow');
+  if (result.ContentLength) res.setHeader('Content-Length', result.ContentLength);
+  if (result.LastModified) res.setHeader('Last-Modified', result.LastModified.toUTCString());
+  if (fileExtension === 'html' || fileExtension === 'htm') {
+    res.setHeader('Content-Security-Policy', "default-src 'self'; script-src 'none'; object-src 'none';");
+  }
+  if (supportsRanges) res.setHeader('Accept-Ranges', 'bytes');
+
+  res.setHeader('Cache-Control', buildCacheControl(contentType, { isStaticAsset, supportsRanges, publicCache }));
+
+  res.status(200);
+
+  const timeoutDuration = result.ContentLength > 50 * 1024 * 1024 ? 300000 : 120000;
+  attachStreamCleanup(req, res, result.Body, timeoutDuration);
+
+  result.Body.pipe(res);
+}
+
+// ---------------------------------------------------------------------------
+// Controller handlers
+// ---------------------------------------------------------------------------
+
+export async function viewFile(req, res) {
+  try {
+    const bucketName = req.activeBucket;
+    let keyToUse;
+    try {
+      keyToUse = ensureKeyHasAppPrefix(req.params.key);
+    } catch (e) {
+      return res.status(400).json({ message: e.message });
+    }
+
+    await serveFileInline(req, res, keyToUse, { noindex: true, bucketName, publicCache: false });
+
+  } catch (error) {
+    console.error("Error viewing file:", error);
+    if (error.name === 'NoSuchKey' || error.name === 'NotFound') {
+      res.status(404).json({ message: "File not found", key: req.params.key });
+    } else if (error.name === 'AccessDenied') {
+      res.status(403).json({ message: "Access denied" });
+    } else {
+      res.status(500).json({ message: "View failed", error: error.message });
+    }
+  }
+}
+
+export async function playerPage(req, res) {
+  try {
+    const bucketName = req.activeBucket;
+    const key = req.params.key;
+    let keyToUse;
+    try {
+      keyToUse = ensureKeyHasAppPrefix(key);
+    } catch (e) {
+      return res.status(400).send(e.message);
+    }
+    const encoded = encodeURIComponent(keyToUse);
+    const safeFileName = escapeHtml(getBaseName(keyToUse));
+    const bucketQuery = `?bucket=${encodeURIComponent(bucketName)}`;
+    const html = renderPlayerPage(safeFileName, encoded, bucketQuery);
+
+    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    return res.status(200).send(html);
+  } catch (err) {
+    console.error('Error rendering player page:', err);
+    return res.status(500).send('Failed to render player');
+  }
+}
+
+export async function publicView(req, res) {
+  try {
+    const bucketName = resolveBucketName();
+    const key = req.params.key;
+
+    // No directory indexing
+    if (!key || key.endsWith('/')) {
+      return res.status(403).json({ message: 'Directory indexing is not allowed' });
+    }
+
+    let keyToUse;
+    try {
+      keyToUse = ensureKeyHasAppPrefix(key);
+    } catch (e) {
+      return res.status(400).json({ message: e.message });
+    }
+
+    let p_view_inline = !!mbkbucketVar?.p_view_inline;
+
+    if (!p_view_inline) {
+      // Signed URL mode
+      try {
+        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);
+        return res.status(500).json({ message: 'Failed to generate access URL' });
+      }
+    }
+
+    // Direct serve mode
+    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 });
+  }
+}

package/src/middleware/async-handler.js

@@ -0,0 +1,38 @@
+/**
+ * Wraps an async Express route handler so that any thrown/rejected errors
+ * are forwarded to `next(err)` instead of crashing the process.
+ *
+ * Usage:
+ *   router.get('/path', wrap(myAsyncHandler));
+ *
+ * If a custom error handler is provided, it receives (error, req, res, next)
+ * and can send a custom response instead of forwarding to Express error middleware.
+ */
+export function wrap(handler, onError) {
+  return (req, res, next) => {
+    const result = handler(req, res, next);
+    if (result && typeof result.catch === 'function') {
+      result.catch((err) => {
+        if (onError) {
+          return onError(err, req, res, next);
+        }
+        next(err);
+      });
+    }
+  };
+}
+
+/**
+ * Combines wrap() with a standard JSON error response for API routes.
+ * The `fallbackMessage` is used when the error has no message.
+ */
+export function wrapApi(handler, fallbackMessage = 'Request failed') {
+  return wrap(handler, (err, _req, res) => {
+    console.error(`[mbkbucket] ${err.stack || err.message}`);
+    res.status(500).json({
+      success: false,
+      code: 'INTERNAL_ERROR',
+      error: err.message || fallbackMessage,
+    });
+  });
+}

package/src/middleware/bucket-resolver.js

@@ -0,0 +1,43 @@
+import { resolveBucketName } from "../services/s3.service.js";
+import { sendApiError, sendViewError } from "../utils/errors.js";
+
+/**
+ * Middleware that resolves `?bucket=<name>` query param and attaches
+ * `req.activeBucket` and `req.bucketResolveError` to every request under /mbkbucket.
+ */
+export function bucketResolver(req, _res, next) {
+  try {
+    req.activeBucket = resolveBucketName(req.query.bucket);
+    req.bucketResolveError = null;
+  } catch (err) {
+    req.activeBucket = null;
+    req.bucketResolveError = err;
+  }
+  next();
+}
+
+/**
+ * Guard middleware for API routes — returns 400/503 JSON if bucket is invalid.
+ */
+export function requireBucketApi(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();
+}
+
+/**
+ * Guard middleware for view routes — returns 400/503 JSON if bucket is invalid.
+ * Skips public view routes (/p_view/...) which use the default bucket.
+ */
+export function requireBucketView(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();
+}

package/src/middleware/error-handler.js

@@ -0,0 +1,34 @@
+import { createLogger } from "../utils/logger.js";
+
+const debugServer = createLogger('server');
+
+/**
+ * Global 404 handler — renders error page via Handlebars.
+ */
+export function notFoundHandler(req, res) {
+  debugServer("Path not found: %s %s", req.method, req.url);
+  return res.status(404).render("Error/dError.handlebars", {
+    layout: false,
+    code: 404,
+    error: "Not Found",
+    message: "The requested page was not found.",
+    pagename: "Home",
+    page: "/",
+  });
+}
+
+/**
+ * Global error handler — catches unhandled errors from routes/middleware.
+ */
+export function globalErrorHandler(err, req, res, _next) {
+  console.error(`[mbkbucket] ${err.stack}`);
+  return res.status(500).render("Error/dError.handlebars", {
+    layout: false,
+    code: 500,
+    error: "Internal app Error",
+    message: "An unexpected error occurred on the app.",
+    details: err.message,
+    pagename: "Home",
+    page: "/",
+  });
+}

package/src/middleware/rate-limiter.js

@@ -0,0 +1,30 @@
+import rateLimit from "express-rate-limit";
+
+/**
+ * General rate limiter for typical browsing/API usage.
+ * 150 requests per 2 minutes per IP.
+ */
+export const generalLimiter = rateLimit({
+  windowMs: 2 * 60 * 1000, // 2 minutes
+  max: 150,
+  standardHeaders: true,
+  legacyHeaders: false,
+  handler: (req, res) => {
+    res.status(429).render('error.handlebars', { message: 'Too many requests from your IP. Try again later.', code: 429 });
+  }
+});
+
+/**
+ * Stricter rate limiter for public view (p_view) routes.
+ * 10 requests per minute per IP.
+ */
+export const pviewRateLimit = rateLimit({
+  windowMs: 60 * 1000, // 1 minute
+  max: 10,
+  standardHeaders: 'draft-7',
+  legacyHeaders: false,
+  keyGenerator: (req) => req.headers['x-forwarded-for']?.split(',')[0].trim() || req.socket.remoteAddress || 'unknown',
+  handler: (_req, res) => {
+    res.status(429).json({ message: 'Too many requests. Please slow down and try again later.' });
+  }
+});

package/src/middleware/security.js

@@ -0,0 +1,43 @@
+/**
+ * Security middleware for public view (p_view) routes.
+ * Blocks bot/scraper User-Agents and sets security headers.
+ */
+
+const BLOCKED_UA_PATTERNS = /curl|wget|python-requests|python-urllib|go-http|scrapy|libwww|java\/|bot|crawl|spider|headless|phantom|selenium|puppeteer|playwright|postman|insomnia|httpie/i;
+
+const SUSPICIOUS_HEADERS = [
+  'x-devtools-emulate-network-conditions-client-id',
+  'x-chromedriver-clientid',
+  'x-automated-tool'
+];
+
+/**
+ * p_view security middleware: blocks bots, sets security headers.
+ */
+export function pviewSecurity(req, res, next) {
+  const ua = req.headers['user-agent'] || '';
+
+  // Block empty or obviously automated UAs
+  if (!ua || BLOCKED_UA_PATTERNS.test(ua)) {
+    return res.status(403).json({ message: 'Forbidden' });
+  }
+
+  // Block suspicious headers that indicate automation
+  const hasSuspiciousHeaders = SUSPICIOUS_HEADERS.some(header => header in req.headers);
+  if (hasSuspiciousHeaders) {
+    return res.status(403).json({ message: 'Forbidden' });
+  }
+
+  // Verify Accept header is present (legitimate browsers always send this)
+  if (!req.headers['accept']) {
+    return res.status(403).json({ message: 'Forbidden' });
+  }
+
+  // Set security headers for the public view response
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.setHeader('X-Frame-Options', 'SAMEORIGIN');
+  res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+  res.removeHeader('Access-Control-Allow-Origin');
+
+  next();
+}

package/src/routes/api.routes.js

@@ -0,0 +1,66 @@
+import express from "express";
+import { sessRole } from "mbkauthe";
+import multer from "multer";
+import { requireBucketApi } from "../middleware/bucket-resolver.js";
+import {
+  cleanupUploads, listIncompleteUploads, listFiles,
+  uploadSingleFile, initiateMultipartUpload, uploadChunk,
+  completeUpload, abortUpload, createFolder, deleteItems,
+  downloadFileHandler
+} from "../controllers/api.controller.js";
+
+const router = express.Router();
+
+const MAX_CHUNK_SIZE = 50 * 1024 * 1024; // 50 MB
+
+const upload = multer({
+  storage: multer.memoryStorage(),
+  limits: { fileSize: MAX_CHUNK_SIZE }
+});
+
+const uploadChunkMiddleware = (req, res, next) => {
+  upload.single('chunk')(req, res, (err) => {
+    if (err) {
+      if (err.code === 'LIMIT_FILE_SIZE') {
+        return res.status(413).json({
+          success: false,
+          error: `Chunk too large (max ${Math.round(MAX_CHUNK_SIZE / (1024 * 1024))} MB).`,
+        });
+      }
+      return next(err);
+    }
+    next();
+  });
+};
+
+// Bucket guard for all API routes
+router.use(requireBucketApi);
+
+// Multipart upload cleanup
+router.post('/api/cleanup-uploads', sessRole('SuperAdmin'), cleanupUploads);
+
+// List incomplete multipart uploads
+router.get('/api/incomplete-uploads', sessRole('SuperAdmin'), listIncompleteUploads);
+
+// List files
+router.get('/api/files', sessRole('SuperAdmin'), listFiles);
+
+// Single-file upload
+router.post('/upload', sessRole('SuperAdmin'), upload.single('file'), uploadSingleFile);
+
+// Multipart upload flow
+router.post('/upload-init', sessRole('SuperAdmin'), initiateMultipartUpload);
+router.post('/upload-chunk', sessRole('SuperAdmin'), uploadChunkMiddleware, uploadChunk);
+router.post('/upload-complete', sessRole('SuperAdmin'), completeUpload);
+router.post('/upload-abort', sessRole('SuperAdmin'), abortUpload);
+
+// Folder operations
+router.post('/create-folder', sessRole('SuperAdmin'), createFolder);
+
+// Delete operations
+router.post('/delete', sessRole('SuperAdmin'), deleteItems);
+
+// Download
+router.get('/download/:key(*)', sessRole('SuperAdmin'), downloadFileHandler);
+
+export default router;

package/src/routes/index.js

@@ -0,0 +1,22 @@
+import express from "express";
+import { sessRole } from "mbkauthe";
+import { bucketResolver } from "../middleware/bucket-resolver.js";
+import { renderBucketDashboard } from "../controllers/dashboard.controller.js";
+import infoRoutes from "./info.routes.js";
+import viewRoutes from "./view.routes.js";
+import apiRoutes from "./api.routes.js";
+
+const router = express.Router();
+
+// Dashboard home
+router.get('/mbkbucket', sessRole('SuperAdmin'), renderBucketDashboard);
+
+// Central bucket resolution for all /mbkbucket subroutes
+router.use('/mbkbucket', bucketResolver);
+
+// Mount sub-routers
+router.use("/mbkbucket", infoRoutes);
+router.use("/mbkbucket", viewRoutes);
+router.use("/mbkbucket", apiRoutes);
+
+export default router;

package/src/routes/info.routes.js

@@ -0,0 +1,10 @@
+import express from "express";
+import { sessRole } from "mbkauthe";
+import { infoPage, infoJson } from "../controllers/info.controller.js";
+
+const router = express.Router();
+
+router.get(['/info', "/i"], infoPage);
+router.get(['/info.json', "/i.json"], infoJson);
+
+export default router;