mbkbucket 3.3.0 → 3.3.2

package/{src → lib/src}/app.js

@@ -1,5 +1,6 @@
 import express from "express";
 import path from "path";
+import fs from "fs";
 import { fileURLToPath } from "url";
 import { engine } from "express-handlebars";
 import compression from "compression";
@@ -8,34 +9,25 @@ import { generalLimiter } from "./middleware/rate-limiter.js";
 import { notFoundHandler, globalErrorHandler } from "./middleware/error-handler.js";
 import bucketRoutes from "./routes/index.js";
 import { packageJson } from "./config/index.js";
-import { createLogger } from "./utils/logger.js";
+import { createLogger } from "#logger";
 import { commonHandlebarsHelpers } from "./utils/helpers.js";
 
 const debugServer = createLogger('server');
-
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const isDevMode = process.env.NODE_ENV === "dev";
 
-/**
- * Creates and configures the Express application.
- * @returns {express.Application}
- */
 export function createApp() {
   const server = express();
   server.set('trust proxy', 1);
 
-  // Compression
   server.use(compression());
-
-  // Body parsing
   server.use(express.json({ limit: '10mb' }));
   server.use(express.urlencoded({ extended: true, limit: '10mb' }));
 
-  // Static assets (CSS/JS for dashboard)
-  const dashboardAssetCacheControl = 'public, max-age=300, must-revalidate';
-  const serveAsset = (filename) => (req, res) => {
-    res.set('Cache-Control', dashboardAssetCacheControl);
+  // Static dashboard & helper assets
+  const serveAsset = (filename) => (_req, res) => {
+    res.set('Cache-Control', 'public, max-age=300, must-revalidate');
     res.sendFile(path.join(__dirname, '..', 'public', filename), (err) => {
       if (err) res.status(err.status || 404).end();
     });
@@ -43,71 +35,66 @@ export function createApp() {
 
   server.get('/mbkbucket/bucketadmin.css', serveAsset('bucketadmin.css'));
   server.get('/mbkbucket/bucketadmin.js', serveAsset('bucketadmin.js'));
-
-  // Frontend helper utilities (drop-in for any HTML page)
   server.get('/mbkbucket/mbkbucket-helper.css', serveAsset('mbkbucket-helper.css'));
   server.get('/mbkbucket/mbkbucket-helper.js', serveAsset('mbkbucket-helper.js'));
-
-  // Helper component demo page (no auth — purely static HTML)
   server.get('/mbkbucket/helper-demo', serveAsset('mbkbucket-helper-demo.html'));
 
-  // Handlebars configuration
+  const rootDir = path.resolve(__dirname, "..", "..");
+  const libDir = path.resolve(__dirname, "..");
+  const cwd = process.cwd();
+
+  const viewDirs = [
+    path.join(rootDir, "views"),
+    path.join(libDir, "views"),
+    path.join(rootDir, "node_modules", "mbkauthe", "views"),
+    path.resolve(cwd, "views"),
+    path.resolve(cwd, "node_modules", "mbkauthe", "views"),
+  ].filter(dir => fs.existsSync(dir));
+
+  const partialsDir = [
+    path.join(rootDir, "views", "templates"),
+    path.join(rootDir, "views", "templates", "notice"),
+    path.join(rootDir, "views"),
+    path.join(rootDir, "views", "partial"),
+    path.join(libDir, "views", "templates"),
+    path.join(libDir, "views", "templates", "notice"),
+    path.join(libDir, "views"),
+    path.join(libDir, "views", "partial"),
+    path.join(rootDir, "node_modules", "mbkauthe", "views"),
+    path.resolve(cwd, "node_modules", "mbkauthe", "views"),
+  ].filter(dir => fs.existsSync(dir));
+
+  // Handlebars template engine
   server.engine("handlebars", engine({
     extname: ".handlebars",
     defaultLayout: false,
-    partialsDir: [
-      path.join(__dirname, "..", "views", "templates"),
-      path.join(__dirname, "..", "views", "templates", "notice"),
-      path.join(__dirname, "..", "views"),
-      path.join(__dirname, "..", "views", "partial"),
-      path.join(__dirname, "..", "node_modules", "mbkauthe", "views"),
-      path.join(__dirname, "..", "..", "mbkauthe", "views")
-    ],
+    partialsDir: [...new Set(partialsDir)],
     cache: process.env.NODE_ENV === "production",
     helpers: {
       ...commonHandlebarsHelpers,
-      mbkbucket_cachebuster: function () {
-        return "?v=" + packageJson.version;
-      }
+      mbkbucket_cachebuster: () => `?v=${packageJson.version}`
     }
   }));
 
   server.set("view engine", "handlebars");
-  server.set("views", [
-    path.join(__dirname, "..", "views"),
-    path.join(__dirname, "..", "node_modules", "mbkauthe", "views"),
-    path.join(__dirname, "..", "..", "mbkauthe", "views")
-  ]);
+  server.set("views", [...new Set(viewDirs)]);
 
-  // Auth routes
   server.use(mbkautheRoutes);
-
-  // Rate limiting
   server.use(generalLimiter);
-
-  // Bucket routes
   server.use(bucketRoutes);
 
-  // Dev-mode request timing
   if (isDevMode) {
-    debugServer("Dev mode is enabled. Starting server in dev mode.");
-
     server.use((req, res, next) => {
-      const start = process.hrtime();
+      const start = Date.now();
       res.on('finish', () => {
-        const diff = process.hrtime(start);
-        const ms = diff[0] * 1000 + diff[1] / 1e6;
-        debugServer("[%s] %s %s %s - %s ms", new Date().toISOString(), req.method, req.originalUrl, res.statusCode, ms.toFixed(3));
+        debugServer('%s %s %s (%sms)', req.method, req.originalUrl, res.statusCode, Date.now() - start);
       });
       next();
     });
 
-    server.get("/", async (req, res) => {
-      res.redirect("/mbkbucket");
-    });
+    server.get("/", (_req, res) => res.redirect("/mbkbucket"));
   }
 
-  // Error handlers
   server.use(notFoundHandler);
   server.use(globalErrorHandler);
 

package/{src → lib/src}/cli/auth-helper.js

@@ -1,6 +1,5 @@
 /**
  * CLI Authentication Helper
- *
  * Handles mbkauthe device-flow login for the mbkbucket CLI.
  * Stores credentials in ~/.mbkbucket/config.json
  */
@@ -8,39 +7,27 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { createLogger } from '../utils/logger.js';
+import { createLogger } from '#logger';
 
 const debugCli = createLogger('cli:auth');
 
 export const CONFIG_DIR = path.join(os.homedir(), '.mbkbucket');
 export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-const POLL_INTERVAL_MS = 5000;
 const MAX_POLL_TIME_MS = 15 * 60 * 1000; // 15 minutes
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
 
-/**
- * Read the stored CLI config.
- * @returns {{ token?: string, tokenPrefix?: string, username?: string, serverUrl?: string, profile?: object }}
- */
 export function readConfig() {
   try {
-    if (!fs.existsSync(CONFIG_FILE)) return {};
-    const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
-    return JSON.parse(raw);
+    return fs.existsSync(CONFIG_FILE) ? JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8')) : {};
   } catch (err) {
     debugCli('Failed to read config: %s', err.message);
     return {};
   }
 }
 
-/**
- * Write config to disk.
- * @param {object} config
- */
 export function writeConfig(config) {
   try {
-    if (!fs.existsSync(CONFIG_DIR)) {
-      fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    }
+    if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
   } catch (err) {
     console.error(`❌ Failed to write config: ${err.message}`);
@@ -48,14 +35,9 @@ export function writeConfig(config) {
   }
 }
 
-/**
- * Clear stored credentials (logout).
- */
 export function clearConfig() {
   try {
-    if (fs.existsSync(CONFIG_FILE)) {
-      fs.unlinkSync(CONFIG_FILE);
-    }
+    if (fs.existsSync(CONFIG_FILE)) fs.unlinkSync(CONFIG_FILE);
     return true;
   } catch (err) {
     debugCli('Failed to clear config: %s', err.message);
@@ -63,49 +45,27 @@ export function clearConfig() {
   }
 }
 
-/**
- * Merge partial config into stored config.
- * @param {object} partial
- */
 export function updateConfig(partial) {
-  const current = readConfig();
-  const updated = { ...current, ...partial };
+  const updated = { ...readConfig(), ...partial };
   writeConfig(updated);
   return updated;
 }
 
-/**
- * Check if the user is logged in (has a stored token).
- */
 export function isLoggedIn() {
-  const cfg = readConfig();
-  return !!(cfg.token && cfg.serverUrl);
+  const { token, serverUrl } = readConfig();
+  return Boolean(token && serverUrl);
 }
 
-/**
- * Get the stored API token.
- */
 export function getStoredToken() {
   return readConfig().token || null;
 }
 
-/**
- * Get the stored server URL.
- */
 export function getStoredServerUrl() {
   return readConfig().serverUrl || null;
 }
 
-/**
- * Perform a device-flow login against an mbkauthe-powered server.
- *
- * @param {{ serverUrl: string, profileKey?: string }} options
- * @returns {Promise<{ token: string, tokenPrefix: string, username: string, profile: object }>}
- */
 export async function deviceFlowLogin({ serverUrl, profileKey }) {
   const baseUrl = String(serverUrl).replace(/\/+$/, '');
-
-  // --- Step 1: Request a device code ---
   console.log(`🔑 Requesting device login from ${baseUrl} ...`);
 
   let deviceResp;
@@ -115,53 +75,32 @@ export async function deviceFlowLogin({ serverUrl, profileKey }) {
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
         clientName: `mbkbucket-cli-${os.hostname()}`,
-        ...(profileKey ? { profileKey } : {}),
+        ...(profileKey && { profileKey }),
       }),
     });
-
     deviceResp = await res.json();
-
-    if (!deviceResp.success) {
-      throw new Error(deviceResp.message || 'Failed to initiate device login');
-    }
+    if (!deviceResp.success) throw new Error(deviceResp.message || 'Failed to initiate device login');
   } catch (err) {
     if (err.message.includes('Failed to initiate') || err.message.includes('fetch')) {
-      throw new Error(
-        `Could not reach mbkauthe server at ${baseUrl}/api/cli/device.\n` +
-        `Verify the server URL and that CLI_AUTH_ENABLED=true on the server.`
-      );
+      throw new Error(`Could not reach mbkauthe server at ${baseUrl}/api/cli/device.\nVerify the server URL and that CLI_AUTH_ENABLED=true on the server.`);
     }
     throw err;
   }
 
-  const {
-    verificationUrl,
-    userCode,
-    deviceCode,
-    expiresIn,
-    interval,
-    profile,
-  } = deviceResp;
-
-  // --- Step 2: Prompt user to approve ---
-  console.log('');
-  console.log('┌─────────────────────────────────────────────────────────┐');
+  const { verificationUrl, userCode, deviceCode, expiresIn, interval, profile } = deviceResp;
+
+  console.log('\n┌─────────────────────────────────────────────────────────┐');
   console.log('│                                                         │');
-  console.log(`│   🌐 Open this URL in your browser to approve:           │`);
+  console.log('│   🌐 Open this URL in your browser to approve:           │');
   console.log(`│   ${verificationUrl.padEnd(53)}│`);
-  console.log(`│                                                         │`);
+  console.log('│                                                         │');
   console.log(`│   🔢 Or enter this code:  ${userCode.padEnd(30)}│`);
   console.log('│                                                         │');
-  console.log('└─────────────────────────────────────────────────────────┘');
-  console.log('');
+  console.log('└─────────────────────────────────────────────────────────┘\n');
 
-  if (profile) {
-    console.log(`   Profile: ${profile.name} (scope: ${profile.scope || 'full'})`);
-  }
-  console.log(`   Waiting for approval (expires in ${Math.floor(expiresIn / 60)} minutes)...`);
-  console.log('');
+  if (profile) console.log(`   Profile: ${profile.name} (scope: ${profile.scope || 'full'})`);
+  console.log(`   Waiting for approval (expires in ${Math.floor(expiresIn / 60)} minutes)...\n`);
 
-  // --- Step 3: Poll for token ---
   const pollInterval = (interval || 5) * 1000;
   const deadline = Date.now() + MAX_POLL_TIME_MS;
   let attempts = 0;
@@ -190,34 +129,16 @@ export async function deviceFlowLogin({ serverUrl, profileKey }) {
         };
       }
 
-      if (pollBody.status === 'denied') {
-        throw new Error('Login request was denied.');
-      }
+      if (pollBody.status === 'denied') throw new Error('Login request was denied.');
+      if (pollBody.status === 'expired') throw new Error('Login request expired. Please try again.');
+      if (pollBody.status === 'completed') throw new Error('This login session has already been completed.');
 
-      if (pollBody.status === 'expired') {
-        throw new Error('Login request expired. Please try again.');
-      }
-
-      if (pollBody.status === 'completed') {
-        throw new Error('This login session has already been completed.');
-      }
-
-      // Still pending — show a dot every 5 polls
-      if (attempts % 5 === 0) {
-        process.stdout.write('.');
-      }
+      if (attempts % 5 === 0) process.stdout.write('.');
     } catch (err) {
-      if (err.message.includes('denied') || err.message.includes('expired') || err.message.includes('completed')) {
-        throw err;
-      }
-      // Network errors during poll — retry
+      if (['denied', 'expired', 'completed'].some(k => err.message.includes(k))) throw err;
       debugCli('Poll error (will retry): %s', err.message);
     }
   }
 
   throw new Error('Login timed out. Please try again.');
 }
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/lib/src/config/index.js

@@ -0,0 +1,108 @@
+import { createRequire } from "module";
+import dotenv from "dotenv";
+import { parseAndValidateMbkbucketVar, parseAndValidateBucketConnection } from "./validation.js";
+import { createLogger } from "#logger";
+
+dotenv.config();
+const debugConfig = createLogger('config');
+const require = createRequire(import.meta.url);
+
+// Load mbkbucket package.json
+let packageJson;
+try {
+  packageJson = require("mbkbucket/package.json");
+} catch {
+  packageJson = require("../../../package.json");
+}
+
+// Parent project version
+let appVersion = "unknown";
+try {
+  appVersion = require("../../../../package.json")?.version ?? require(`${process.cwd()}/package.json`)?.version ?? "unknown";
+} catch {
+  try {
+    appVersion = require(`${process.cwd()}/package.json`)?.version ?? "unknown";
+  } catch {}
+}
+
+export function compareVersions(a = '', b = '') {
+  const left = String(a).split(/[.-]/).map(p => parseInt(p, 10) || 0);
+  const right = String(b).split(/[.-]/).map(p => parseInt(p, 10) || 0);
+  const len = Math.max(left.length, right.length);
+
+  for (let i = 0; i < len; i++) {
+    const diff = (left[i] || 0) - (right[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+export async function getLatestVersion() {
+  try {
+    const res = await fetch('https://raw.githubusercontent.com/MIbnEKhalid/mbkbucket/master/package.json');
+    if (!res.ok) {
+      debugConfig('GitHub API responded with status %s', res.status);
+      return "0.0.0";
+    }
+    const data = await res.json();
+    return data.version;
+  } catch (err) {
+    debugConfig('Error fetching latest version from GitHub: %s', err.message);
+    return null;
+  }
+}
+
+export async function checkVersion() {
+  try {
+    const latest = await getLatestVersion();
+    if (!latest) return;
+    const diff = compareVersions(latest, packageJson.version);
+    if (diff > 0) {
+      console.log(`[mbkbucket] ⚠️  Update available: v${latest} (current: v${packageJson.version})`);
+    } else {
+      debugConfig('Running latest version (%s).', packageJson.version);
+    }
+  } catch (err) {
+    debugConfig('Failed to check for updates: %s', err.message);
+  }
+}
+
+export function validateConfiguration() {
+  try {
+    return parseAndValidateMbkbucketVar(process.env.mbkbucketVar);
+  } catch (err) {
+    throw new Error(`[mbkbucket] Configuration Validation Failed:\n  - ${err.message}`);
+  }
+}
+
+export function validateBucketConnection() {
+  if (!process.env.BucketConnection) {
+    console.warn(`[mbkbucket] ⚠️  BucketConnection not configured. You need to set this environment variable.`);
+    console.warn(`[mbkbucket] Example format:\n[mbkbucket] BucketConnection={"r2":{"BUCKET_NAME":"my-bucket","ACCESS_KEY_ID":"key","SECRET_ACCESS_KEY":"secret","ENDPOINT":"https://..."}}`);
+    return;
+  }
+  try {
+    parseAndValidateBucketConnection(process.env.BucketConnection);
+    debugConfig('BucketConnection validated');
+  } catch (err) {
+    throw new Error(`[mbkbucket] BucketConnection validation failed:\n  - ${err.message}`);
+  }
+}
+
+export function validateAllConfiguration() {
+  try {
+    validateConfiguration();
+    validateBucketConnection();
+    return true;
+  } catch (err) {
+    console.error(err.message);
+    return false;
+  }
+}
+
+export const mbkbucketVar = validateConfiguration();
+
+export {
+  packageJson,
+  appVersion
+};

package/{src → 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 };