Initial commit: EduBox V2 platform

server/lib/auth-config.ts

@@ -0,0 +1,45 @@
+import CredentialsProvider from "next-auth/providers/credentials";
+import { prisma } from "./prisma";
+import { verifyPassword } from "./auth";
+
+export const authOptions = {
+  providers: [
+    CredentialsProvider({
+      name: "Credentials",
+      credentials: {
+        email: { label: "Email", type: "email" },
+        password: { label: "Password", type: "password" },
+      },
+      async authorize(credentials) {
+        if (!credentials?.email || !credentials?.password) return null;
+        const user = await prisma.user.findUnique({
+          where: { email: credentials.email },
+        });
+        if (!user) return null;
+        const valid = await verifyPassword(credentials.password, user.password);
+        if (!valid) return null;
+        return { id: user.id, email: user.email, role: user.role, establishmentId: user.establishmentId ?? undefined };
+      },
+    }),
+  ],
+  callbacks: {
+    async jwt({ token, user }: any) {
+      if (user) {
+        token.role = user.role;
+        token.establishmentId = user.establishmentId;
+      }
+      return token;
+    },
+    async session({ session, token }: any) {
+      session.user.role = token.role;
+      session.user.establishmentId = token.establishmentId;
+      return session;
+    },
+  },
+  pages: {
+    signIn: "/login",
+  },
+  session: {
+    strategy: "jwt" as const,
+  },
+};

server/lib/auth.ts

@@ -0,0 +1,16 @@
+import { prisma } from "./prisma";
+import bcrypt from "bcryptjs";
+
+export async function hashPassword(password: string): Promise<string> {
+  return bcrypt.hash(password, 12);
+}
+
+export async function verifyPassword(password: string, hashed: string): Promise<boolean> {
+  return bcrypt.compare(password, hashed);
+}
+
+export function requireRole(user: { role: string }, ...allowed: string[]) {
+  if (!allowed.includes(user.role)) {
+    throw new Error("Forbidden");
+  }
+}

server/lib/prisma.ts

@@ -0,0 +1,7 @@
+import { PrismaClient } from "@prisma/client";
+
+const globalForPrisma = globalThis as unknown as { prisma: PrismaClient };
+
+export const prisma = globalForPrisma.prisma || new PrismaClient();
+
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;

server/lib/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

server/lib/websocket.ts

@@ -0,0 +1,105 @@
+import { WebSocketServer, WebSocket } from "ws";
+import { prisma } from "./prisma";
+
+interface NodeMessage {
+  action: string;
+  nodeId?: string;
+  code?: string;
+  instanceId?: string;
+  type?: string;
+  port?: number;
+  composeConfig?: string;
+  studentName?: string;
+  error?: string;
+}
+
+const nodes = new Map<string, WebSocket>();
+
+export function initWebSocketServer(wss: WebSocketServer) {
+  wss.on("connection", (ws: WebSocket) => {
+    let nodeId: string | null = null;
+
+    ws.on("message", async (raw) => {
+      try {
+        const msg: NodeMessage = JSON.parse(raw.toString());
+
+        if (msg.action === "register" && msg.nodeId) {
+          nodeId = msg.nodeId;
+          nodes.set(nodeId, ws);
+          await prisma.node.upsert({
+            where: { id: nodeId },
+            update: { status: "online", lastSeen: new Date() },
+            create: { id: nodeId, status: "online", lastSeen: new Date() },
+          });
+          ws.send(JSON.stringify({ action: "registered" }));
+          return;
+        }
+
+        if (msg.action === "activate" && msg.code && msg.nodeId) {
+          nodeId = msg.nodeId;
+          const student = await prisma.student.findUnique({
+            where: { activationCode: msg.code },
+          });
+          if (!student) {
+            ws.send(JSON.stringify({ action: "activation_failed", error: "Invalid code" }));
+            return;
+          }
+          await prisma.node.upsert({
+            where: { id: nodeId },
+            update: { studentId: student.id, status: "online", lastSeen: new Date() },
+            create: { id: nodeId, studentId: student.id, status: "online", lastSeen: new Date() },
+          });
+          ws.send(JSON.stringify({ action: "activated", studentName: `${student.firstName} ${student.lastName}` }));
+          return;
+        }
+
+        if (msg.action === "heartbeat" && nodeId) {
+          await prisma.node.upsert({
+            where: { id: nodeId },
+            update: { lastSeen: new Date() },
+            create: { id: nodeId, status: "online", lastSeen: new Date() },
+          });
+          return;
+        }
+
+        if (msg.action === "instance_started" && msg.instanceId) {
+          await prisma.instance.update({
+            where: { id: msg.instanceId },
+            data: { status: "running" },
+          });
+          return;
+        }
+
+        if (msg.action === "instance_error" && msg.instanceId) {
+          await prisma.instance.update({
+            where: { id: msg.instanceId },
+            data: { status: "error" },
+          });
+          return;
+        }
+      } catch (err) {
+        console.error("WS error:", err);
+      }
+    });
+
+    ws.on("close", async () => {
+      if (nodeId) {
+        nodes.delete(nodeId);
+        await prisma.node.upsert({
+          where: { id: nodeId },
+          update: { status: "offline" },
+          create: { id: nodeId, status: "offline" },
+        });
+      }
+    });
+  });
+}
+
+export function sendToNode(nodeId: string, message: object) {
+  const ws = nodes.get(nodeId);
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify(message));
+    return true;
+  }
+  return false;
+}