@seip/blue-bird 0.8.0 → 0.9.1

package/README.md

@@ -2,7 +2,7 @@
 
 **High-Performance Express Framework — Built for Speed, Caching, and Visual Excellence**
 
-![Blue Bird Logo](https://seip25.github.io/Blue-bird/blue-bird.png)
+![Blue Bird Logo](https://seip25.github.io/Blue-bird/favicon.ico)
 
 [![npm version](https://img.shields.io/npm/v/@seip/blue-bird.svg)](https://www.npmjs.com/package/@seip/blue-bird)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -15,6 +15,25 @@ Blue Bird is a powerful, performance-first API framework built on Express. It fe
 
 ---
 
+## 🕊️ The Blue Bird Philosophy
+
+Stop wasting time configuring CORS, security headers, database connections, and authentication flows. Blue Bird provides an opinionated, highly efficient core structure allowing you to focus on writing clean business logic. Nginx handles the static frontend directly from the filesystem, Express handles the backend APIs. Includes a preconfigured Docker stack with Nginx reverse proxy, Redis cache, and PM2 cluster scaling.
+
+### 🧩 Decoupled Architecture
+Nginx natively serves static frontend assets and extensionless HTML pages from `frontend/`. Express owns the API layer, keeping your backend entirely focused on performance and logic.
+
+- **Cross-Platform Versatility**: Because the Express backend API is fully decoupled from the HTML/JS/CSS frontend layer, developers can easily build and maintain multiple application targets pointing to the same core API:
+  - **Web Applications**: Static HTML, CSS, and client-side JS served natively by Nginx.
+  - **Mobile Applications**: Powered by **Capacitor**, Cordova, or React Native.
+  - **Desktop Applications**: Built with **Electron** or **Tauri**.
+- **Strong Business Logic**: Enforces a strict separation of concerns — Nginx excels at ultra-fast static file delivery and public assets, while Express handles API routing, business rules, validation, and data operations without UI rendering overhead.
+- **Lightweight Footprint**: Offloading static assets to Nginx optimizes Node.js event loop performance, resulting in extremely minimal RAM, CPU, and disk consumption under high concurrent workloads.
+
+### 🐳 Built-in Orchestration
+Includes a comprehensive Docker Compose CLI wrapper to bootstrap, build, stop, and clean dev and production environments with zero manual scripting.
+
+---
+
 ## 🚀 Key Features / Características Clave
 
 - All-In-One: Pre-configured Express API server with JSON, URL encoding, Cookies, and CORS.
@@ -76,7 +95,34 @@ project/
 
 ## 📖 Core Modules Documentation / Documentación de Módulos
 
-### 1. Routing (`Router`)
+### 1. Application Class (`App`)
+
+Initializes the Express server. If Docker/Nginx is not used (or for lightweight setups like Express + SQLite), you can configure Express to serve static frontend files directly via the `static` parameter:
+
+```javascript
+import App from "@seip/blue-bird/core/app.js";
+import routerApi from "./backend/routes/api.js";
+
+const app = new App({
+  port: process.env.PORT || 3000,
+  host: "http://localhost",
+  routes: [routerApi],
+  cors: [],
+  middlewares: [],
+  logger: false,
+  // Standalone Express Static Asset Serving (No Nginx/Docker required)
+  static: {
+    path: "../frontend", // relative directory path to frontend files
+    options: {}           // express.static options
+  }
+});
+
+app.run();
+```
+
+---
+
+### 2. Routing (`Router`)
 
 Do not use Express' native router. Always use Blue Bird's wrapper class:
 
@@ -116,57 +162,86 @@ routerApi.post("/users", validateUser.middleware(), (req, res) => {
 
 ---
 
-### 4. JWT Authentication (`Auth`)
+### 4. JWT Authentication & Redis Sessions (`Auth`)
 
-Secure user sessions using stateless AES-256-GCM encrypted JWTs stored in secure HTTP-Only cookies.
+Secure user authentication with AES-256-GCM encrypted tokens. Transmitted via HTTP-Only cookies or `Authorization` headers, with optional Redis session storage and invalidation.
 
 #### Protecting Routes
 
 ```javascript
 import Auth from "@seip/blue-bird/core/auth.js";
 
-// Secure API endpoint (returns 401 on failure)
+// 1. Secure API endpoint (returns 401 JSON on failure)
 router.get("/profile", Auth.protect(), (req, res) => {
   res.json({ user: req.user });
 });
 
-// Secure web page (redirects to /login on failure)
-router.get("/dashboard", Auth.protect({ redirect: "/login" }), (req, res) => {
-  Template.render(res, "dashboard");
+// 2. Secure web page (redirects to /login on failure)
+router.get("/dashboard", Auth.protect({ redirect: "/login", key: "user", cookieKey: "auth" }), (req, res) => {
+  res.send(`<h1>Welcome ${req.user.name}</h1>`);
 });
 ```
 
-#### Authentication Sessions
+#### Authentication Sessions & Utilities
 
 ```javascript
+// Login & Sync Session state in Redis (if active)
 router.post("/login", async (req, res) => {
-  const user = { id: 1, name: "John Doe" };
-  await Auth.login(res, user);
+  const user = { id: 1, name: "John Doe", role: "admin" };
+  await Auth.login(res, user, "auth", { expiresIn: "7d" });
   res.json({ message: "Logged in successfully" });
 });
 
+// Logout & Delete Session from Redis
 router.post("/logout", async (req, res) => {
-  await Auth.logout(res);
+  await Auth.logout(res, "auth", {}, req);
   res.json({ message: "Logged out" });
 });
+
+// Manual Encrypted JWT Tokens & AES-256-GCM Encryption
+const token = Auth.generateToken({ id: 1 }, process.env.JWT_SECRET, "2h");
+const decoded = Auth.verifyToken(token, process.env.JWT_SECRET);
+const encrypted = Auth.encrypt({ secret: "1234" }, process.env.JWT_SECRET);
+const decrypted = Auth.decrypt(encrypted, process.env.JWT_SECRET);
 ```
 
 ---
 
-### 5. Performance Cache Middleware (`Cache`)
+### 5. Performance Cache & Redis Client (`Cache`)
 
-Applies caching at the route handler level. Automatically caches JSON payloads (`res.json`) and rendered outputs (`res.send`).
+Applies route-level response caching for JSON payloads (`res.json`) and HTML output (`res.send`). Automatically uses Redis when `REDIS_HOST` is configured, and transparently degrades to an in-memory cache if Redis is unavailable or offline.
+
+#### Route Caching Middleware
 
 ```javascript
-import Cache from "@seip/blue-bird/core/cache.js";
+import Cache, { getRedisClient } from "@seip/blue-bird/core/cache.js";
 
-// Cache endpoint for 60 seconds
+// Cache endpoint for 60 seconds (sets X-Blue-Bird-Cache: HIT/MISS headers)
 router.get("/stats", Cache.middleware(60), (req, res) => {
   res.json({ usersOnline: 42 });
 });
 ```
 
-Integrates with Redis if `REDIS_HOST` is defined in the environment. Falls back to an in-memory cache automatically if Redis is not configured or not running.
+#### Custom Database & Data Caching with `getRedisClient()`
+
+```javascript
+// Direct access to the active Redis client for database query or custom key caching
+router.get("/custom-cache", async (req, res) => {
+  const redis = getRedisClient();
+  if (redis) {
+    const cached = await redis.get("my_custom_key");
+    if (cached) return res.json(JSON.parse(cached));
+
+    const dbData = await fetchHeavyDataFromDB();
+    await redis.set("my_custom_key", JSON.stringify(dbData), { EX: 120 }); // Expiry 120s
+    return res.json(dbData);
+  }
+  
+  // Fallback if Redis is disabled
+  const dbData = await fetchHeavyDataFromDB();
+  res.json(dbData);
+});
+```
 
 ---
 
@@ -250,8 +325,17 @@ npx blue-bird docker <command> [options]
 - **`npx blue-bird docker ps`**: Lists running project containers and ports.
 - **`npx blue-bird docker logs [app|db|postgres|mysql]`**: Tails logs for the specified container.
 - **`npx blue-bird docker pm2 [args]`**: Runs PM2 commands inside the Node.js application container (e.g. `status`, `monit`, `reload all`).
-- **`npx blue-bird docker db`** (or `psql` / `mysql`): Connects into the container's interactive database shell (`psql` for PostgreSQL, `mysql` for MySQL) using credentials from `.env`.
-- **`npx blue-bird docker redis`**: Connects into the container's interactive Redis CLI terminal.
+- **`npx blue-bird docker db`** (or `psql` / `mysql`): Connects into the container's interactive database shell (`psql` for PostgreSQL, `mysql` for MySQL). Supports smart table queries, schema inspection, and backups:
+  - `npx blue-bird docker mysql users` -> executes `SELECT * FROM users;` formatted as ASCII table.
+  - `npx blue-bird docker mysql users --limit=10 --where="id > 5"` -> executes filtered query.
+  - `npx blue-bird docker mysql tables` -> lists database tables (`SHOW TABLES`).
+  - `npx blue-bird docker mysql columns users` -> describes table schema (`SHOW COLUMNS`).
+- **`npx blue-bird docker export [filename.sql]`** (or `npx blue-bird docker mysql export`): Dumps database schema and data into `backups/backup_YYYY-MM-DD.sql` (creates `backups/` folder automatically).
+- **`npx blue-bird docker import [filename.sql]`** (or `npx blue-bird docker mysql import`): Restores database from a `.sql` file in `backups/` (uses the most recent `.sql` backup if no filename is specified).
+- **`npx blue-bird docker redis`**: Connects into the container's interactive Redis CLI terminal. Supports smart subcommands:
+  - `npx blue-bird docker redis monitor` -> live stream of all incoming Redis commands.
+  - `npx blue-bird docker redis keys [pattern]` -> lists all matching Redis keys (defaults to `*`).
+  - `npx blue-bird docker redis key <keyname>` -> gets value for specific Redis key.
 - **`npx blue-bird docker prune`**: Safely clears orphaned volumes, dangling build caches, and images.
 
 ---

package/core/cli/docker.js

@@ -278,7 +278,12 @@ async function logsCommand(service, followOpt) {
  * @param {boolean} rootOpt - Flag for overriding database credentials to connect as root/postgres.
  * @param {string} explicitService - Explicit target service if specified ('mysql' or 'postgres').
  */
-async function dbClientCommand(userOpt, passOpt, dbOpt, rootOpt, explicitService) {
+/**
+ * Handles interactive shell connections or smart queries into the MySQL or PostgreSQL container.
+ * @param {string[]} clientArgs - CLI arguments.
+ * @param {string} explicitService - Explicit target service if specified ('mysql', 'postgres', 'psql', 'db').
+ */
+async function dbClientCommand(clientArgs = [], explicitService) {
   checkComposeFile();
   const env = getEnvVars();
   const dbType = explicitService === "postgres" || explicitService === "psql" ? "postgres" : (explicitService === "mysql" ? "mysql" : getDbType(env));
@@ -287,25 +292,111 @@ async function dbClientCommand(userOpt, passOpt, dbOpt, rootOpt, explicitService
     return;
   }
 
+  let userOpt, passOpt, dbOpt, rootOpt = false;
+  let limitOpt = null, whereOpt = null;
+  const positionalArgs = [];
+
+  for (let i = 0; i < clientArgs.length; i++) {
+    const arg = clientArgs[i];
+    if (arg === "-u" || arg === "--user") {
+      userOpt = clientArgs[++i];
+    } else if (arg.startsWith("--user=")) {
+      userOpt = arg.split("=")[1];
+    } else if (arg === "-p" || arg === "--password") {
+      passOpt = clientArgs[++i];
+    } else if (arg.startsWith("--password=")) {
+      passOpt = arg.split("=")[1];
+    } else if (arg === "-d" || arg === "--db") {
+      dbOpt = clientArgs[++i];
+    } else if (arg.startsWith("--db=")) {
+      dbOpt = arg.split("=")[1];
+    } else if (arg === "--root") {
+      rootOpt = true;
+    } else if (arg === "--limit" || arg === "-l") {
+      limitOpt = clientArgs[++i];
+    } else if (arg.startsWith("--limit=")) {
+      limitOpt = arg.split("=")[1];
+    } else if (arg === "--where" || arg === "-w") {
+      whereOpt = clientArgs[++i];
+    } else if (arg.startsWith("--where=")) {
+      whereOpt = arg.split("=")[1];
+    } else if (!arg.startsWith("-")) {
+      positionalArgs.push(arg);
+    }
+  }
+
   let dbUser = userOpt;
   let dbPass = passOpt;
   let dbName = dbOpt;
 
-  if (dbType === "postgres") {
-    if (rootOpt) {
-      dbUser = "postgres";
+  let sqlQuery = null;
+  if (positionalArgs.length > 0) {
+    const firstPos = positionalArgs[0].toLowerCase();
+
+    if (firstPos === "export" || firstPos === "dump") {
+      await exportDbCommand(dbType, positionalArgs[1], userOpt, passOpt, dbOpt);
+      return;
+    }
+    if (firstPos === "import" || firstPos === "restore") {
+      await importDbCommand(dbType, positionalArgs[1], userOpt, passOpt, dbOpt);
+      return;
+    }
+    if (firstPos === "tables") {
+      if (dbType === "postgres") {
+        sqlQuery = "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';";
+      } else {
+        sqlQuery = "SHOW TABLES;";
+      }
+    } else if (firstPos === "columns" || firstPos === "cols" || firstPos === "describe" || firstPos === "desc") {
+      const tableName = positionalArgs[1];
+      if (!tableName) {
+        console.error(chalk.red("Error: Please specify a table name. Example: npx blue-bird docker mysql columns users"));
+        process.exit(1);
+      }
+      if (dbType === "postgres") {
+        sqlQuery = `SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = '${tableName}';`;
+      } else {
+        sqlQuery = `SHOW COLUMNS FROM ${tableName};`;
+      }
     } else {
-      dbUser = dbUser || env.DB_USER || "postgres";
+      const rawInput = positionalArgs.join(" ").trim();
+      const isFullQuery = /^(select|show|desc|describe|explain|insert|update|delete|create|drop|alter|truncate)\b/i.test(rawInput) || rawInput.includes(" ");
+      if (isFullQuery) {
+        sqlQuery = rawInput;
+      } else {
+        const tableName = rawInput;
+        sqlQuery = `SELECT * FROM ${tableName}`;
+        if (whereOpt) {
+          sqlQuery += ` WHERE ${whereOpt}`;
+        }
+        if (limitOpt) {
+          sqlQuery += ` LIMIT ${limitOpt}`;
+        }
+      }
+      if (!sqlQuery.endsWith(";")) {
+        sqlQuery += ";";
+      }
     }
-    dbName = dbName || env.DB_NAME || "blue_bird";
+  }
 
-    const targetDb = dbName ? ` (database: ${dbName})` : "";
-    console.log(chalk.cyan(`Connecting to PostgreSQL shell (psql) in container as '${dbUser}'${targetDb}...`));
+  if (dbType === "postgres") {
+    dbUser = rootOpt ? "postgres" : (dbUser || env.DB_USER || "postgres");
+    dbName = dbName || env.DB_NAME || "blue_bird";
 
     const cmdArgs = ["compose", "exec", "postgres", "psql", `-U${dbUser}`];
     if (dbName) {
       cmdArgs.push("-d", dbName);
     }
+
+    if (sqlQuery) {
+      console.log(chalk.cyan(`🔍 Executing PostgreSQL query on database '${dbName}':`));
+      console.log(chalk.gray(`   ${sqlQuery}\n`));
+      cmdArgs.push("-c", sqlQuery);
+    } else {
+      const targetDb = dbName ? ` (database: ${dbName})` : "";
+      console.log(chalk.cyan(`Connecting to PostgreSQL shell (psql) in container as '${dbUser}'${targetDb}...`));
+    }
+
     const code = await runCmd("docker", cmdArgs);
     if (code !== 0) {
       console.error(chalk.yellow("Make sure the PostgreSQL container is running: npx blue-bird docker start postgres"));
@@ -329,8 +420,14 @@ async function dbClientCommand(userOpt, passOpt, dbOpt, rootOpt, explicitService
       cmdArgs.push(dbName);
     }
 
-    const targetDb = dbName ? ` (database: ${dbName})` : "";
-    console.log(chalk.cyan(`Connecting to MySQL shell in container as '${dbUser}'${targetDb}...`));
+    if (sqlQuery) {
+      console.log(chalk.cyan(`🔍 Executing MySQL query on database '${dbName}':`));
+      console.log(chalk.gray(`   ${sqlQuery}\n`));
+      cmdArgs.push("-t", "-e", sqlQuery);
+    } else {
+      const targetDb = dbName ? ` (database: ${dbName})` : "";
+      console.log(chalk.cyan(`Connecting to MySQL shell in container as '${dbUser}'${targetDb}...`));
+    }
 
     const code = await runCmd("docker", cmdArgs);
     if (code !== 0) {
@@ -340,6 +437,196 @@ async function dbClientCommand(userOpt, passOpt, dbOpt, rootOpt, explicitService
   }
 }
 
+/**
+ * Exports database schema & data into a .sql file inside backups/ folder.
+ * @param {string} dbType - Target db type ('mysql', 'postgres', 'none').
+ * @param {string} [filenameArg] - Custom backup filename.
+ * @param {string} [userOpt] - Custom db user.
+ * @param {string} [passOpt] - Custom db password.
+ * @param {string} [dbOpt] - Custom db name.
+ */
+async function exportDbCommand(dbType, filenameArg, userOpt, passOpt, dbOpt) {
+  checkComposeFile();
+  const env = getEnvVars();
+  const targetDbType = dbType === "none" ? getDbType(env) : dbType;
+
+  if (targetDbType === "none") {
+    console.error(chalk.yellow("[INFO] DB_TYPE is set to 'none'. No database available to export."));
+    return;
+  }
+
+  const backupsDir = path.join(process.cwd(), "backups");
+  if (!fs.existsSync(backupsDir)) {
+    fs.mkdirSync(backupsDir, { recursive: true });
+  }
+
+  let outputFile;
+  if (filenameArg) {
+    let name = filenameArg;
+    if (!name.endsWith(".sql")) name += ".sql";
+    if (path.isAbsolute(name)) {
+      outputFile = name;
+    } else if (name.includes("/") || name.includes("\\")) {
+      outputFile = path.resolve(process.cwd(), name);
+    } else {
+      outputFile = path.join(backupsDir, name);
+    }
+  } else {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
+    outputFile = path.join(backupsDir, `backup_${targetDbType}_${timestamp}.sql`);
+  }
+
+  const dbUser = userOpt || env.DB_USER || (targetDbType === "postgres" ? "postgres" : "root");
+  const dbPass = passOpt || env.DB_PASSWORD || (targetDbType === "postgres" ? "postgres" : "root");
+  const dbName = dbOpt || env.DB_NAME || "blue_bird";
+
+  let cmdArgs = [];
+  if (targetDbType === "postgres") {
+    cmdArgs = ["compose", "exec", "-T", "postgres", "pg_dump", `-U${dbUser}`, "-d", dbName];
+  } else {
+    cmdArgs = ["compose", "exec", "-T", "mysql", "mysqldump", `-u${dbUser}`, `-p${dbPass}`, dbName];
+  }
+
+  const relPath = path.relative(process.cwd(), outputFile);
+  console.log(chalk.cyan(`📦 Exporting ${targetDbType.toUpperCase()} database '${dbName}' to '${relPath}'...`));
+
+  const success = await exportDbToFile(cmdArgs, outputFile);
+  if (success) {
+    const stats = fs.statSync(outputFile);
+    const sizeKb = (stats.size / 1024).toFixed(2);
+    console.log(chalk.green(`\n✔ Database exported successfully!`));
+    console.log(chalk.cyan(`   File: ${relPath} (${sizeKb} KB)`));
+  } else {
+    console.error(chalk.red(`\n✖ Database export failed.`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Streams stdout from container dump command into a local file.
+ */
+function exportDbToFile(cmdArgs, outputFile) {
+  return new Promise((resolve) => {
+    const outStream = fs.createWriteStream(outputFile);
+    const proc = spawn("docker", cmdArgs, { stdio: ["inherit", "pipe", "pipe"], env: process.env });
+    proc.stdout.pipe(outStream);
+
+    let errOutput = "";
+    proc.stderr.on("data", (chunk) => {
+      errOutput += chunk.toString();
+    });
+
+    proc.on("close", (code) => {
+      outStream.close();
+      if (code === 0) {
+        resolve(true);
+      } else {
+        if (errOutput) console.error(chalk.yellow(`Warning/Stderr: ${errOutput.trim()}`));
+        resolve(code === 0);
+      }
+    });
+  });
+}
+
+/**
+ * Imports a .sql file from backups/ folder into the container database.
+ * @param {string} dbType - Target db type ('mysql', 'postgres', 'none').
+ * @param {string} [filenameArg] - Custom backup filename.
+ * @param {string} [userOpt] - Custom db user.
+ * @param {string} [passOpt] - Custom db password.
+ * @param {string} [dbOpt] - Custom db name.
+ */
+async function importDbCommand(dbType, filenameArg, userOpt, passOpt, dbOpt) {
+  checkComposeFile();
+  const env = getEnvVars();
+  const targetDbType = dbType === "none" ? getDbType(env) : dbType;
+
+  if (targetDbType === "none") {
+    console.error(chalk.yellow("[INFO] DB_TYPE is set to 'none'. No database available to import into."));
+    return;
+  }
+
+  const backupsDir = path.join(process.cwd(), "backups");
+  if (!fs.existsSync(backupsDir)) {
+    fs.mkdirSync(backupsDir, { recursive: true });
+  }
+
+  let inputFile;
+  if (filenameArg) {
+    let name = filenameArg;
+    if (!name.endsWith(".sql") && !fs.existsSync(name)) name += ".sql";
+    if (fs.existsSync(name)) {
+      inputFile = path.resolve(process.cwd(), name);
+    } else if (fs.existsSync(path.join(backupsDir, name))) {
+      inputFile = path.join(backupsDir, name);
+    } else {
+      console.error(chalk.red(`Error: Backup file '${filenameArg}' not found in current directory or 'backups/' folder.`));
+      process.exit(1);
+    }
+  } else {
+    const files = fs.readdirSync(backupsDir)
+      .filter(f => f.endsWith(".sql"))
+      .map(f => ({ name: f, time: fs.statSync(path.join(backupsDir, f)).mtimeMs }))
+      .sort((a, b) => b.time - a.time);
+
+    if (files.length === 0) {
+      console.error(chalk.red(`Error: No .sql backup files found in 'backups/' directory.`));
+      console.log(chalk.yellow(`Usage: npx blue-bird docker import <file.sql>`));
+      process.exit(1);
+    }
+
+    inputFile = path.join(backupsDir, files[0].name);
+    console.log(chalk.yellow(`[INFO] No file specified. Using most recent backup: '${files[0].name}'`));
+  }
+
+  const dbUser = userOpt || env.DB_USER || (targetDbType === "postgres" ? "postgres" : "root");
+  const dbPass = passOpt || env.DB_PASSWORD || (targetDbType === "postgres" ? "postgres" : "root");
+  const dbName = dbOpt || env.DB_NAME || "blue_bird";
+
+  let cmdArgs = [];
+  if (targetDbType === "postgres") {
+    cmdArgs = ["compose", "exec", "-T", "postgres", "psql", `-U${dbUser}`, "-d", dbName];
+  } else {
+    cmdArgs = ["compose", "exec", "-T", "mysql", "mysql", `-u${dbUser}`, `-p${dbPass}`, dbName];
+  }
+
+  const relPath = path.relative(process.cwd(), inputFile);
+  console.log(chalk.cyan(`📥 Importing SQL dump '${relPath}' into ${targetDbType.toUpperCase()} database '${dbName}'...`));
+
+  const success = await importDbFromFile(cmdArgs, inputFile);
+  if (success) {
+    console.log(chalk.green(`\n✔ Database imported successfully from '${relPath}'!`));
+  } else {
+    console.error(chalk.red(`\n✖ Database import failed.`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Streams a local .sql file into container stdin.
+ */
+function importDbFromFile(cmdArgs, inputFile) {
+  return new Promise((resolve) => {
+    const inStream = fs.createReadStream(inputFile);
+    const proc = spawn("docker", cmdArgs, { stdio: ["pipe", "inherit", "pipe"], env: process.env });
+    inStream.pipe(proc.stdin);
+
+    let errOutput = "";
+    proc.stderr.on("data", (chunk) => {
+      errOutput += chunk.toString();
+    });
+
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(true);
+      } else {
+        if (errOutput) console.error(chalk.yellow(`Warning/Stderr: ${errOutput.trim()}`));
+        resolve(code === 0);
+      }
+    });
+  });
+}
+
 /**
  * Handles cleaning up and pruning unused Docker resources.
  * @param {boolean} forceOpt - Force cleaning without user confirmation.
@@ -385,12 +672,43 @@ async function pm2Command(pm2Args = []) {
 }
 
 /**
- * Handles interactive shell connections into the Redis container.
+ * Handles interactive shell connections or smart query subcommands into the Redis container.
+ * @param {string[]} redisArgs - Subcommands or key parameters.
  */
-async function redisCommand() {
+async function redisCommand(redisArgs = []) {
   checkComposeFile();
   const cmdArgs = ["compose", "exec", "redis", "redis-cli"];
-  await runCmd("docker", cmdArgs);
+
+  if (redisArgs.length > 0) {
+    const firstArg = redisArgs[0].toLowerCase();
+
+    if (firstArg === "monitor") {
+      console.log(chalk.cyan("📡 Monitoring live Redis commands... (Press Ctrl+C to exit)"));
+      cmdArgs.push("monitor");
+    } else if (firstArg === "keys") {
+      const pattern = redisArgs[1] || "*";
+      console.log(chalk.cyan(`🔑 Fetching Redis keys matching '${pattern}'...`));
+      cmdArgs.push("keys", pattern);
+    } else if (firstArg === "key") {
+      const keyName = redisArgs[1];
+      if (!keyName) {
+        console.error(chalk.red("Error: Please specify a key name. Example: npx blue-bird docker redis key session:123"));
+        process.exit(1);
+      }
+      console.log(chalk.cyan(`📄 Getting value for Redis key '${keyName}'...`));
+      cmdArgs.push("get", keyName);
+    } else {
+      cmdArgs.push(...redisArgs);
+    }
+  } else {
+    console.log(chalk.cyan("Connecting to Redis interactive terminal (redis-cli)..."));
+  }
+
+  const code = await runCmd("docker", cmdArgs);
+  if (code !== 0) {
+    console.error(chalk.yellow("Make sure the Redis container is running: npx blue-bird docker start redis"));
+    process.exit(1);
+  }
 }
 
 /**
@@ -450,23 +768,23 @@ async function main() {
     case "pm2":
       await pm2Command(args.slice(1));
       break;
+    case "export":
+    case "dump":
+      await exportDbCommand("none", args[1]);
+      break;
+    case "import":
+    case "restore":
+      await importDbCommand("none", args[1]);
+      break;
     case "redis":
-      await redisCommand();
+      await redisCommand(args.slice(1));
       break;
     case "mysql":
     case "postgres":
     case "psql":
-    case "db": {
-      let user, password, db, root = false;
-      for (let i = 1; i < args.length; i++) {
-        if (args[i] === "-u" || args[i] === "--user") user = args[++i];
-        else if (args[i] === "-p" || args[i] === "--password") password = args[++i];
-        else if (args[i] === "-d" || args[i] === "--db") db = args[++i];
-        else if (args[i] === "--root") root = true;
-      }
-      await dbClientCommand(user, password, db, root, command);
+    case "db":
+      await dbClientCommand(args.slice(1), command);
       break;
-    }
     case "df":
     case "disk":
       console.log(chalk.cyan("📊 Docker Disk Usage:"));
@@ -481,7 +799,7 @@ async function main() {
     }
     default:
       console.log(chalk.yellow(`Unknown docker command: ${command}`));
-      console.log("Available commands: dev, start, stop, build, ps, logs, pm2, mysql/postgres/db, redis, df/disk, prune/clean");
+      console.log("Available commands: dev, start, stop, build, ps, logs, pm2, export/dump, import/restore, mysql/postgres/db, redis, df/disk, prune/clean");
   }
 }
 

package/core/cli/init.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import fs from "node:fs";
 import path from "node:path";

package/docker/docker-compose.dev.yml

@@ -1,6 +1,6 @@
-services:
-  app:
-    command: ["npm", "run", "dev"]
-    environment:
-      - NODE_ENV=development
-      - DEBUG=true
+services:
+  app:
+    command: ["npm", "run", "dev"]
+    environment:
+      - NODE_ENV=development
+      - DEBUG=true

package/docker/nginx.conf

@@ -66,6 +66,7 @@ http {
         }
 
         location / {
+            add_header Cache-Control "no-cache";
             try_files $uri $uri.html $uri/ @node_app;
         }
 

package/frontend/about.html

@@ -10,7 +10,7 @@
                     visual elegance and performance with raw HTML and CSS.">
     <meta name="keywords" content="">
     <meta name="author" content="Seip25">
-    <link rel="icon" href="/favicon.ico" />
+    <link rel="icon" href="/images/favicon.ico" />
 </head>
 
 <body class="min-h-screen bg-slate-950 text-white font-sans antialiased selection:bg-blue-500 selection:text-white">
@@ -56,10 +56,13 @@
             <article class="p-8 rounded-2xl bg-slate-900/40 border border-white/5 shadow-xl">
                 <h2 class="text-2xl font-bold text-white mb-4">Our Philosophy</h2>
                 <p class="text-slate-400 leading-relaxed mb-4">
-                    Blue Bird was born out of a desire for a clean, performance-first approach to web development. We believe in harnessing the raw power of Express.js and Nginx, stripping away unnecessary bloat, and providing developers with a robust foundation that just works.
+                    Blue Bird was born out of a desire for a clean, performance-first approach to web development. We
+                    believe in harnessing the raw power of Express.js and Nginx, stripping away unnecessary bloat, and
+                    providing developers with a robust foundation that just works.
                 </p>
                 <p class="text-slate-400 leading-relaxed">
-                    By separating the static frontend delivery (handled blazingly fast by Nginx) from the dynamic API layer (powered by Express and Redis), Blue Bird achieves unparalleled performance out of the box.
+                    By separating the static frontend delivery (handled blazingly fast by Nginx) from the dynamic API
+                    layer (powered by Express and Redis), Blue Bird achieves unparalleled performance out of the box.
                 </p>
             </article>
 
@@ -76,11 +79,13 @@
                     </li>
                     <li class="flex items-start">
                         <span class="text-blue-500 mr-2">✓</span>
-                        <span><strong>High Performance:</strong> Redis caching for the data layer and Nginx static delivery.</span>
+                        <span><strong>High Performance:</strong> Redis caching for the data layer and Nginx static
+                            delivery.</span>
                     </li>
                     <li class="flex items-start">
                         <span class="text-blue-500 mr-2">✓</span>
-                        <span><strong>Pure HTML/CSS:</strong> No bloated frontend frameworks. Write code close to the metal.</span>
+                        <span><strong>Pure HTML/CSS:</strong> No bloated frontend frameworks. Write code close to the
+                            metal.</span>
                     </li>
                 </ul>
             </article>
@@ -92,7 +97,7 @@
             <p>Powered by Blue Bird Framework. All rights reserved.</p>
         </div>
     </footer>
-    <script src="/js/bundle.js"></script>
+    <script src="/js/tailwind.js"></script>
 </body>
 
 </html>

package/frontend/index.html

@@ -10,7 +10,7 @@
                     visual elegance and performance with raw HTML and CSS.">
     <meta name="keywords" content="">
     <meta name="author" content="Seip25">
-    <link rel="icon" href="/favicon.ico" />
+    <link rel="icon" href="/images/favicon.ico" />
 </head>
 
 <body class="min-h-screen bg-slate-950 text-white font-sans antialiased selection:bg-blue-500 selection:text-white">
@@ -135,7 +135,7 @@
             <p>Powered by Blue Bird Framework. All rights reserved.</p>
         </div>
     </footer>
-    <script src="/js/bundle.js"></script>
+    <script src="/js/tailwind.js"></script>
 </body>
 
 </html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seip/blue-bird",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Express opinionated API framework with built-in JWT auth, validation, and caching",
   "type": "module",
   "exports": {