coderland 1.0.0

package/README.md

@@ -0,0 +1,16 @@
+# Codeland Client Application
+
+A client application for Codeland.
+
+## Installation
+
+```bash
+npm install codeland
+```
+
+## Usage
+
+```javascript
+const codeland = require("codeland");
+// usage here
+```

package/config.js

@@ -0,0 +1,6 @@
+require("dotenv").config();
+
+module.exports = {
+  port: 3210,
+  serverUrl: "",
+};

package/index.js

@@ -0,0 +1,52 @@
+const express = require("express");
+const path = require("path");
+const config = require("./config");
+const logger = require("./utils/logger.util");
+
+const authRoutes = require("./routes/auth.routes");
+const systemRoutes = require("./routes/system.routes");
+const actionRoutes = require("./routes/action.routes");
+
+const app = express();
+
+// Middleware
+app.use(express.json());
+app.use(express.static(path.join(__dirname, "public")));
+
+// Routes
+app.use("/api/auth", authRoutes);
+app.use("/api/system", systemRoutes);
+app.use("/api/action", actionRoutes);
+
+// Root route to serve index.html (redundant with static, but explicit is good)
+app.get("/", (req, res) => {
+  res.sendFile(path.join(__dirname, "public", "index.html"));
+});
+
+// Dashboard route
+app.get("/dashboard", (req, res) => {
+  res.sendFile(path.join(__dirname, "public", "dashboard.html"));
+});
+
+const readline = require("readline");
+
+// Interactive startup to get Server URL
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+// (default: ${config.serverUrl})
+rl.question(`Enter Server URL : `, (url) => {
+  if (url && url.trim()) {
+    config.serverUrl = url.trim().replace(/\/$/, "");
+  }
+
+  console.log(`Using Server URL: ${config.serverUrl}`);
+  rl.close();
+
+  // Start server after configuration
+  app.listen(config.port, () => {
+    logger.info(`Client running on http://localhost:${config.port}`);
+    // logger.info(`Connected to Server at: ${config.serverUrl}`);
+  });
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "coderland",
+  "version": "1.0.0",
+  "description": "Coderland works to bridge the gap between trainer and students",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "dev": "nodemon index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/programmerrush/coderland.git"
+  },
+  "keywords": [
+    "coderland",
+    "client",
+    "collaboration",
+    "student",
+    "trainer"
+  ],
+  "author": "Rushikesh",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/programmerrush/coderland/issues"
+  },
+  "homepage": "https://github.com/programmerrush/coderland#readme",
+  "dependencies": {
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "node-fetch": "^2.7.0",
+    "systeminformation": "^5.21.22"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.1"
+  }
+}

package/public/client.js

@@ -0,0 +1,133 @@
+// Client-side shared logic
+
+// Helper Status Fetcher
+async function getStatus() {
+  try {
+    const response = await fetch("/api/system/status");
+    if (!response.ok) {
+      throw new Error("Failed to fetch status");
+    }
+    return await response.json();
+  } catch (error) {
+    console.error("Error fetching status:", error);
+    return null;
+  }
+}
+
+document.addEventListener("DOMContentLoaded", async () => {
+  // --- JOIN PAGE LOGIC (index.html) ---
+  const joinForm = document.getElementById("join-form");
+  if (joinForm) {
+    joinForm.addEventListener("submit", async (e) => {
+      e.preventDefault();
+      const uid = document.getElementById("uid").value;
+      // Removed classCode input, handled by backend default
+      const consent = document.getElementById("consent").checked;
+      const msgEl = document.getElementById("message");
+
+      if (!consent) {
+        msgEl.textContent = "You must agree to continue.";
+        return;
+      }
+
+      try {
+        const res = await fetch("/api/auth/join", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ uid, consent }), // Removed classCode from body
+        });
+        const data = await res.json();
+
+        if (data.redirect) {
+          window.location.href = data.redirect;
+        } else {
+          msgEl.textContent = data.message || "Join failed.";
+          msgEl.className = "error";
+        }
+      } catch (err) {
+        msgEl.textContent = "Error connecting to server.";
+      }
+    });
+  }
+
+  // --- DASHBOARD PAGE LOGIC (dashboard.html) ---
+  const uidDisplay = document.getElementById("uid-display");
+  if (uidDisplay) {
+    const status = await getStatus();
+    if (status && status.uid) {
+      uidDisplay.textContent = status.uid;
+    }
+
+    // Fetch Trainer Messages
+    const msgContainer = document.getElementById("trainer-messages");
+    if (msgContainer) {
+      try {
+        const res = await fetch("/api/action/messages");
+        const data = await res.json();
+
+        msgContainer.innerHTML = ""; // Clear loading
+
+        if (data.success && data.messages && data.messages.length > 0) {
+          data.messages.forEach((msg) => {
+            const div = document.createElement("div");
+            div.className = "message-item";
+
+            const text = document.createElement("div");
+            text.textContent = msg.text;
+
+            const time = document.createElement("span");
+            time.className = "message-time";
+            time.textContent = new Date(msg.timestamp).toLocaleTimeString();
+
+            div.appendChild(text);
+            div.appendChild(time);
+            msgContainer.appendChild(div);
+          });
+        } else {
+          msgContainer.innerHTML =
+            '<div style="color: #666;">No messages from trainer.</div>';
+        }
+      } catch (err) {
+        msgContainer.innerHTML =
+          '<div style="color: red;">Failed to load messages.</div>';
+      }
+    }
+  }
+
+  const raiseHandBtn = document.getElementById("raise-hand-btn");
+  if (raiseHandBtn) {
+    raiseHandBtn.addEventListener("click", async () => {
+      const msgEl = document.getElementById("hand-message");
+      msgEl.textContent = "Raising hand...";
+      try {
+        const res = await fetch("/api/action/raise-hand", { method: "POST" });
+        const data = await res.json();
+        msgEl.textContent = data.message;
+        setTimeout(() => (msgEl.textContent = ""), 3000);
+      } catch (err) {
+        msgEl.textContent = "Failed to raise hand.";
+        msgEl.className = "error";
+      }
+    });
+  }
+
+  // Removed messageForm logic
+
+  const resetBtn = document.getElementById("reset-btn");
+  if (resetBtn) {
+    resetBtn.addEventListener("click", async () => {
+      if (!confirm("Are you sure you want to reset? This will sign you out."))
+        return;
+
+      try {
+        const res = await fetch("/api/action/reset", { method: "POST" });
+        const data = await res.json();
+        if (data.redirect) {
+          window.location.href = data.redirect;
+        }
+      } catch (err) {
+        alert("Reset failed.");
+      }
+    });
+  }
+});

package/public/dashboard.html

@@ -0,0 +1,54 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Classroom Client - Dashboard</title>
+    <link rel="stylesheet" href="style.css" />
+    <style>
+      #trainer-messages {
+        background: #e9ecef;
+        border-radius: 4px;
+        padding: 10px;
+        margin: 1.5rem 0;
+        text-align: left;
+        min-height: 100px;
+        max-height: 300px;
+        overflow-y: auto;
+      }
+      .message-item {
+        background: white;
+        padding: 8px;
+        margin-bottom: 8px;
+        border-radius: 4px;
+        box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+      }
+      .message-time {
+        font-size: 0.75rem;
+        color: #888;
+        margin-top: 4px;
+        display: block;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1>Dashboard</h1>
+      <div class="input-group">
+        <label>Welcome, <span id="uid-display">Student</span></label>
+      </div>
+
+      <button id="raise-hand-btn">✋ Raise Hand</button>
+      <div id="hand-message" class="success"></div>
+
+      <div id="trainer-messages">
+        <div style="color: #666; font-style: italic">Loading messages...</div>
+      </div>
+
+      <button id="reset-btn" class="secondary" style="margin-top: 2rem">
+        Reset Client
+      </button>
+    </div>
+    <script src="client.js"></script>
+  </body>
+</html>

package/public/index.html

@@ -0,0 +1,37 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Classroom Client - Join</title>
+    <link rel="stylesheet" href="style.css" />
+  </head>
+  <body>
+    <div class="container">
+      <h1>Join Class</h1>
+
+      <form id="join-form">
+        <div class="input-group">
+          <label for="uid">Name</label>
+          <input
+            type="text"
+            id="uid"
+            name="uid"
+            required
+            placeholder="Enter your name"
+          />
+        </div>
+
+        <div class="input-group">
+          <label>
+            <input type="checkbox" id="consent" required />
+            I agree to send my system data for academic purposes
+          </label>
+        </div>
+        <button type="submit">Join Class</button>
+        <div id="message" class="error"></div>
+      </form>
+    </div>
+    <script src="client.js"></script>
+  </body>
+</html>

package/public/style.css

@@ -0,0 +1,95 @@
+/* Basic Clean Style */
+body {
+  font-family: "Segoe UI", Tahoma, Geneva, Verdana, sans-serif;
+  background-color: #f4f4f9;
+  color: #333;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  height: 100vh;
+  margin: 0;
+}
+
+.container {
+  background: white;
+  padding: 2rem;
+  border-radius: 8px;
+  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+  width: 100%;
+  max-width: 400px;
+  text-align: center;
+}
+
+h1 {
+  margin-bottom: 1.5rem;
+  color: #444;
+}
+
+.input-group {
+  margin-bottom: 1rem;
+  text-align: left;
+}
+
+label {
+  display: block;
+  margin-bottom: 0.5rem;
+  font-weight: bold;
+}
+
+input[type="text"],
+textarea {
+  width: 100%;
+  padding: 0.75rem;
+  border: 1px solid #ddd;
+  border-radius: 4px;
+  box-sizing: border-box;
+  font-size: 1rem;
+}
+
+input[type="checkbox"] {
+  margin-right: 0.5rem;
+}
+
+button {
+  background-color: #007bff;
+  color: white;
+  border: none;
+  padding: 0.75rem 1.5rem;
+  font-size: 1rem;
+  border-radius: 4px;
+  cursor: pointer;
+  transition: background-color 0.2s;
+  width: 100%;
+  margin-top: 1rem;
+}
+
+button:hover {
+  background-color: #0056b3;
+}
+
+button.secondary {
+  background-color: #6c757d;
+  margin-top: 0.5rem;
+}
+
+button.secondary:hover {
+  background-color: #545b62;
+}
+
+.info {
+  margin-top: 1rem;
+  font-size: 0.9rem;
+  color: #666;
+}
+
+.error {
+  color: #dc3545;
+  margin-top: 0.5rem;
+  font-size: 0.9rem;
+}
+
+.success {
+  color: #28a745;
+  margin-top: 0.5rem;
+  font-size: 0.9rem;
+}

package/routes/action.routes.js

@@ -0,0 +1,68 @@
+const express = require("express");
+const router = express.Router();
+const apiService = require("../services/api.service");
+const uidUtil = require("../utils/uid.util");
+
+// Raise Hand
+router.post("/raise-hand", async (req, res) => {
+  try {
+    await apiService.post("/raise-hand", { timestamp: Date.now() });
+    res.json({ success: true, message: "Hand raised!" });
+  } catch (error) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+});
+
+// Send Message
+router.post("/message", async (req, res) => {
+  const { title, message } = req.body;
+
+  if (!title || title.length > 5) {
+    return res
+      .status(400)
+      .json({ success: false, message: "Title must be 1-5 characters." });
+  }
+  if (!message || message.length > 200) {
+    return res
+      .status(400)
+      .json({ success: false, message: "Message must be 1-200 characters." });
+  }
+
+  try {
+    await apiService.post("/message", {
+      title,
+      message,
+      timestamp: Date.now(),
+    });
+    res.json({ success: true, message: "Message sent!" });
+  } catch (error) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+});
+
+// Reset Client
+router.post("/reset", (req, res) => {
+  try {
+    uidUtil.resetData();
+    res.json({ success: true, redirect: "/" });
+  } catch (error) {
+    res
+      .status(500)
+      .json({ success: false, message: "Failed to reset client." });
+  }
+});
+
+// Get Trainer Messages
+router.get("/messages", async (req, res) => {
+  try {
+    // In real scenario, we might pass a timestamp or since param
+    const response = await apiService.get("/messages");
+    const messages = response.messages || [];
+    res.json({ success: true, messages });
+  } catch (error) {
+    // Fallback or empty if error
+    res.json({ success: false, messages: [] });
+  }
+});
+
+module.exports = router;

package/routes/auth.routes.js

@@ -0,0 +1,39 @@
+const express = require("express");
+const router = express.Router();
+const authService = require("../services/auth.service");
+const systemService = require("../services/system.service");
+
+router.post("/join", async (req, res) => {
+  try {
+    let { uid, consent } = req.body;
+
+    if (!uid || typeof uid !== "string") {
+      return res
+        .status(400)
+        .json({ success: false, message: "Name/UID is required." });
+    }
+
+    // Alphanumeric check - relaxed to allow spaces for Names if needed,
+    // but user requirement was previously alphanumeric.
+    // "Name of the user" implies spaces might be needed.
+    // Let's allow spaces for now.
+    if (!/^[a-zA-Z0-9 ]+$/.test(uid)) {
+      return res
+        .status(400)
+        .json({ success: false, message: "Name must be alphanumeric." });
+    }
+
+    const uidUtil = require("../utils/uid.util");
+    uidUtil.saveUID(uid);
+
+    await authService.joinClass(consent);
+    // After joining, send system info immediately
+    await systemService.sendSystemInfo();
+
+    res.json({ success: true, redirect: "/dashboard.html" });
+  } catch (error) {
+    res.status(400).json({ success: false, message: error.message });
+  }
+});
+
+module.exports = router;

package/routes/system.routes.js

@@ -0,0 +1,33 @@
+const express = require("express");
+const router = express.Router();
+const systemService = require("../services/system.service");
+const uidUtil = require("../utils/uid.util");
+
+router.get("/status", (req, res) => {
+  try {
+    const uid = uidUtil.getUID();
+    res.json({ uid });
+  } catch (error) {
+    res.status(500).json({ success: false, message: "Failed to get status." });
+  }
+});
+
+router.post("/info", async (req, res) => {
+  try {
+    await systemService.sendSystemInfo();
+    res.json({ success: true, message: "System info sent." });
+  } catch (error) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+});
+
+router.get("/preview", async (req, res) => {
+  try {
+    const details = await systemService.getSystemDetails();
+    res.json(details);
+  } catch (error) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+});
+
+module.exports = router;

package/services/api.service.js

@@ -0,0 +1,72 @@
+const fetch = require("node-fetch");
+const config = require("../config");
+const uidUtil = require("../utils/uid.util");
+const logger = require("../utils/logger.util");
+
+async function post(endpoint, body) {
+  const uid = uidUtil.getUID();
+  const url = `${config.serverUrl}${endpoint}`;
+
+  // Ensure UID is in body for identification
+  const finalBody = { ...body };
+  if (!finalBody.uid && uid) {
+    finalBody.uid = uid;
+  }
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      body: JSON.stringify(finalBody),
+      headers: {
+        "Content-Type": "application/json",
+        "x-uid": uid || "",
+      },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger.error(
+        `API Error: ${response.status} ${response.statusText} - ${errorText}`,
+      );
+      throw new Error(`API Error: ${response.statusText}`);
+    }
+
+    return await response.json();
+  } catch (error) {
+    logger.error(`Network Error: ${error.message}`);
+    throw error;
+  }
+}
+
+async function get(endpoint) {
+  const uid = uidUtil.getUID();
+  const url = `${config.serverUrl}${endpoint}`;
+
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "x-uid": uid || "",
+      },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger.error(
+        `API Error: ${response.status} ${response.statusText} - ${errorText}`,
+      );
+      throw new Error(`API Error: ${response.statusText}`);
+    }
+
+    return await response.json();
+  } catch (error) {
+    logger.error(`Network Error: ${error.message}`);
+    throw error;
+  }
+}
+
+module.exports = {
+  post,
+  get,
+};

package/services/auth.service.js

@@ -0,0 +1,24 @@
+const apiService = require("./api.service");
+const uidUtil = require("../utils/uid.util");
+
+async function joinClass(consent) {
+  if (!consent) {
+    throw new Error("You must agree to send system data.");
+  }
+
+  const uid = uidUtil.getUID();
+  if (!uid) {
+    throw new Error("UID not found. Please restart the application.");
+  }
+
+  try {
+    await apiService.post("/join", { uid });
+    return { success: true, message: "Joined class successfully." };
+  } catch (error) {
+    throw new Error("Failed to join class: " + error.message);
+  }
+}
+
+module.exports = {
+  joinClass,
+};

package/services/system.service.js

@@ -0,0 +1,38 @@
+const si = require("systeminformation");
+const apiService = require("./api.service");
+const uidUtil = require("../utils/uid.util");
+
+async function getSystemDetails() {
+  const osInfo = await si.osInfo();
+  const cpu = await si.cpu();
+  const mem = await si.mem();
+  const nodeVersion = process.version;
+
+  return {
+    os: `${osInfo.platform} ${osInfo.release}`,
+    cpu: `${cpu.manufacturer} ${cpu.brand}`,
+    totalRam: `${(mem.total / 1024 / 1024 / 1024).toFixed(2)} GB`,
+    nodeVersion: nodeVersion,
+    platform: process.platform,
+  };
+}
+
+async function sendSystemInfo() {
+  try {
+    const details = await getSystemDetails();
+    const systemData = {
+      ...details,
+      uid: uidUtil.getUID(),
+    };
+
+    await apiService.post("/system-info", systemData);
+    return { success: true, message: "System info sent successfully." };
+  } catch (error) {
+    throw new Error("Failed to send system info: " + error.message);
+  }
+}
+
+module.exports = {
+  sendSystemInfo,
+  getSystemDetails,
+};

package/utils/logger.util.js

@@ -0,0 +1,17 @@
+function log(message, type = "INFO") {
+  const timestamp = new Date().toISOString();
+  console.log(`[${timestamp}] [${type}] ${message}`);
+}
+
+function info(message) {
+  log(message, "INFO");
+}
+
+function error(message) {
+  log(message, "ERROR");
+}
+
+module.exports = {
+  info,
+  error,
+};

package/utils/uid.util.js

@@ -0,0 +1,27 @@
+// In-memory storage for UID (no file persistence)
+let currentUid = null;
+
+function getUID() {
+  return currentUid;
+}
+
+function saveUID(uid) {
+  currentUid = uid;
+  return currentUid;
+}
+
+function resetData() {
+  currentUid = null;
+  return null;
+}
+
+function getUIDData() {
+  return { uid: currentUid };
+}
+
+module.exports = {
+  getUID,
+  saveUID,
+  resetData,
+  getUIDData,
+};