sketchboard-app 1.0.0

package/routes/collab.js

@@ -0,0 +1,52 @@
+const express = require("express");
+const storage = require("../storage");
+
+const router = express.Router();
+
+// GET /api/v1/collab/:roomId — load encrypted scene
+router.get("/:roomId", (req, res) => {
+  const scene = storage.getCollabScene(req.params.roomId);
+  if (!scene) return res.status(404).json({ error: "Not found" });
+  res.json(scene);
+});
+
+// PUT /api/v1/collab/:roomId — save encrypted scene
+router.put("/:roomId", (req, res) => {
+  const { sceneVersion, ciphertext, iv } = req.body;
+  if (!ciphertext || !iv) return res.status(400).json({ error: "Missing data" });
+  storage.saveCollabScene(req.params.roomId, { sceneVersion, ciphertext, iv });
+  res.json({ ok: true });
+});
+
+// GET /api/v1/collab/:roomId/files/:fileId — load a collab file
+router.get("/:roomId/files/:fileId", (req, res) => {
+  const buf = storage.getCollabFile(req.params.roomId, req.params.fileId);
+  if (!buf) return res.status(404).json({ error: "Not found" });
+  res.set("Content-Type", "application/octet-stream");
+  res.set("Cache-Control", "public, max-age=31536000");
+  res.send(buf);
+});
+
+// POST /api/v1/collab/:roomId/files — save collab files (array of {id, buffer})
+router.post("/:roomId/files", express.raw({ type: "*/*", limit: "50mb" }), (req, res) => {
+  // files arrive as JSON array: [{ id, buffer: base64 }]
+  try {
+    const files = req.body; // already parsed by outer json middleware
+    const saved = [];
+    const errored = [];
+    for (const { id, buffer } of files) {
+      try {
+        const buf = Buffer.from(buffer, "base64");
+        storage.saveCollabFile(req.params.roomId, id, buf);
+        saved.push(id);
+      } catch {
+        errored.push(id);
+      }
+    }
+    res.json({ saved, errored });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+module.exports = router;

package/routes/drawings.js

@@ -0,0 +1,49 @@
+const router  = require("express").Router();
+const storage = require("../storage");
+
+// GET /api/v1/drawings/shared/:shareId  — must come before /:id
+router.get("/shared/:shareId", (req, res) => {
+  const drawing = storage.getSharedDrawing(req.params.shareId);
+  if (!drawing) return res.status(404).json({ status: "fail", message: "Drawing not found" });
+  res.json({ status: "success", data: { drawing } });
+});
+
+// GET /api/v1/drawings
+router.get("/", (_req, res) => {
+  res.json({ status: "success", data: { drawings: storage.listDrawings() } });
+});
+
+// POST /api/v1/drawings
+router.post("/", (req, res) => {
+  const drawing = storage.createDrawing(req.body);
+  res.status(201).json({ status: "success", data: { drawing } });
+});
+
+// GET /api/v1/drawings/:id
+router.get("/:id", (req, res) => {
+  const drawing = storage.readDrawing(req.params.id);
+  if (!drawing) return res.status(404).json({ status: "fail", message: "Drawing not found" });
+  res.json({ status: "success", data: { drawing } });
+});
+
+// PUT /api/v1/drawings/:id
+router.put("/:id", (req, res) => {
+  const drawing = storage.updateDrawing(req.params.id, req.body);
+  if (!drawing) return res.status(404).json({ status: "fail", message: "Drawing not found" });
+  res.json({ status: "success", data: { drawing } });
+});
+
+// DELETE /api/v1/drawings/:id
+router.delete("/:id", (req, res) => {
+  storage.deleteDrawing(req.params.id);
+  res.json({ status: "success", data: { message: "Drawing deleted" } });
+});
+
+// PATCH /api/v1/drawings/:id/share
+router.patch("/:id/share", (req, res) => {
+  const result = storage.toggleShare(req.params.id);
+  if (!result) return res.status(404).json({ status: "fail", message: "Drawing not found" });
+  res.json({ status: "success", data: result });
+});
+
+module.exports = router;

package/routes/library.js

@@ -0,0 +1,15 @@
+const router  = require("express").Router();
+const storage = require("../storage");
+
+// GET /api/v1/library
+router.get("/", (_req, res) => {
+  res.json({ status: "success", data: { items: storage.getLibrary() } });
+});
+
+// PUT /api/v1/library
+router.put("/", (req, res) => {
+  const items = storage.saveLibrary(Array.isArray(req.body.items) ? req.body.items : []);
+  res.json({ status: "success", data: { items } });
+});
+
+module.exports = router;

package/routes/users.js

@@ -0,0 +1,32 @@
+const router = require("express").Router();
+const { body } = require("express-validator");
+const { getProfile, updateProfile, changePassword, getStats } = require("../controllers/userController");
+const { protect } = require("../middleware/auth");
+const validate = require("../middleware/validate");
+
+router.use(protect);
+
+router.get ("/me",          getProfile);
+router.get ("/me/stats",    getStats);
+
+router.put(
+  "/me",
+  [
+    body("name").optional().trim().notEmpty().withMessage("Name cannot be empty").isLength({ max: 80 }).withMessage("Name too long"),
+    body("avatar").optional({ nullable: true }),
+  ],
+  validate,
+  updateProfile,
+);
+
+router.put(
+  "/me/password",
+  [
+    body("currentPassword").notEmpty().withMessage("Current password is required"),
+    body("newPassword").isLength({ min: 6 }).withMessage("New password must be at least 6 characters"),
+  ],
+  validate,
+  changePassword,
+);
+
+module.exports = router;

package/server.js

@@ -0,0 +1,109 @@
+require("dotenv").config();
+
+const fs          = require("fs");
+const http        = require("http");
+const express     = require("express");
+const cors        = require("cors");
+const helmet      = require("helmet");
+const morgan      = require("morgan");
+const compression = require("compression");
+const { Server }  = require("socket.io");
+
+const app        = express();
+const httpServer = http.createServer(app);
+
+const CLIENT_URL = process.env.CLIENT_URL || "http://localhost:3001";
+
+// ── Socket.io ─────────────────────────────────────────────────────────────────
+const io = new Server(httpServer, {
+  cors: { origin: CLIENT_URL, methods: ["GET", "POST"] },
+  maxHttpBufferSize: 50 * 1024 * 1024, // 50 MB for large scenes
+});
+
+io.on("connection", (socket) => {
+  socket.emit("init-room");
+
+  socket.on("join-room", (roomId) => {
+    socket.join(roomId);
+    const room = io.sockets.adapter.rooms.get(roomId);
+    const clients = room ? [...room] : [];
+
+    if (clients.length === 1) {
+      socket.emit("first-in-room");
+    } else {
+      socket.broadcast.to(roomId).emit("new-user", socket.id);
+    }
+    io.to(roomId).emit("room-user-change", clients);
+  });
+
+  socket.on("server-broadcast", (roomId, encryptedData, iv) => {
+    socket.broadcast.to(roomId).emit("client-broadcast", encryptedData, iv);
+  });
+
+  socket.on("server-volatile-broadcast", (roomId, encryptedData, iv) => {
+    socket.volatile.broadcast.to(roomId).emit("client-broadcast", encryptedData, iv);
+  });
+
+  socket.on("user-follow", (payload) => {
+    const rooms = [...socket.rooms].filter((r) => r !== socket.id);
+    rooms.forEach((roomId) => {
+      socket.broadcast.to(roomId).emit("user-follow", payload);
+    });
+  });
+
+  socket.on("disconnecting", () => {
+    [...socket.rooms]
+      .filter((r) => r !== socket.id)
+      .forEach((roomId) => {
+        const room = io.sockets.adapter.rooms.get(roomId);
+        const remaining = room ? [...room].filter((id) => id !== socket.id) : [];
+        socket.broadcast.to(roomId).emit("room-user-change", remaining);
+      });
+  });
+});
+
+// ── HTTP middleware ───────────────────────────────────────────────────────────
+app.use(helmet());
+app.use(compression());
+app.use(morgan(process.env.NODE_ENV === "production" ? "combined" : "dev"));
+
+app.use(
+  cors({
+    origin:         CLIENT_URL,
+    methods:        ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+    allowedHeaders: ["Content-Type"],
+  }),
+);
+
+app.use(express.json({ limit: "25mb" }));
+
+// ── Routes ────────────────────────────────────────────────────────────────────
+app.use("/api/v1/drawings", require("./routes/drawings"));
+app.use("/api/v1/library",  require("./routes/library"));
+app.use("/api/v1/collab",   require("./routes/collab"));
+
+// ── Health ────────────────────────────────────────────────────────────────────
+app.get("/health", (_req, res) =>
+  res.json({ status: "ok", env: process.env.NODE_ENV || "development" }),
+);
+
+// ── Static frontend (npm package mode) ───────────────────────────────────────
+const STATIC_DIR = process.env.STATIC_DIR;
+if (STATIC_DIR && fs.existsSync(STATIC_DIR)) {
+  app.use(express.static(STATIC_DIR));
+  // SPA fallback — all non-API routes serve index.html
+  app.get("*", (req, res) => {
+    res.sendFile(require("path").join(STATIC_DIR, "index.html"));
+  });
+} else {
+  // ── 404 (dev mode — frontend served separately by Vite) ──────────────────
+  app.all("*", (req, res) =>
+    res.status(404).json({ status: "fail", message: `Cannot ${req.method} ${req.originalUrl}` }),
+  );
+}
+
+// ── Start ─────────────────────────────────────────────────────────────────────
+const PORT = process.env.PORT || 5000;
+httpServer.listen(PORT, () =>
+  console.log(`SketchBoard server running on port ${PORT} [${process.env.NODE_ENV || "development"}]`),
+);

package/storage.js

@@ -0,0 +1,171 @@
+const fs   = require("fs");
+const path = require("path");
+const { v4: uuidv4 } = require("uuid");
+
+const os           = require("os");
+const DATA_DIR     = process.env.DATA_DIR || path.join(os.homedir(), ".sketchboard");
+const DRAWINGS_DIR = path.join(DATA_DIR, "drawings");
+const LIBRARY_FILE = path.join(DATA_DIR, "library.json");
+const COLLAB_DIR   = path.join(DATA_DIR, "collab");
+const COLLAB_FILES_DIR = path.join(DATA_DIR, "collab-files");
+
+fs.mkdirSync(DRAWINGS_DIR,   { recursive: true });
+fs.mkdirSync(COLLAB_DIR,     { recursive: true });
+fs.mkdirSync(COLLAB_FILES_DIR, { recursive: true });
+
+// ── Internal helpers ──────────────────────────────────────────────────────────
+
+function drawingPath(id) {
+  return path.join(DRAWINGS_DIR, `${id}.json`);
+}
+
+function readFile(id) {
+  const p = drawingPath(id);
+  if (!fs.existsSync(p)) return null;
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function writeFile(drawing) {
+  fs.writeFileSync(drawingPath(drawing._id), JSON.stringify(drawing, null, 2), "utf8");
+}
+
+// ── Drawings ──────────────────────────────────────────────────────────────────
+
+function listDrawings() {
+  return fs
+    .readdirSync(DRAWINGS_DIR)
+    .filter((f) => f.endsWith(".json"))
+    .map((f) => {
+      try {
+        const d = JSON.parse(fs.readFileSync(path.join(DRAWINGS_DIR, f), "utf8"));
+        return {
+          _id:       d._id,
+          title:     d.title,
+          thumbnail: d.thumbnail || null,
+          isPublic:  d.isPublic  || false,
+          shareId:   d.shareId   || null,
+          tags:      d.tags      || [],
+          updatedAt: d.updatedAt,
+          createdAt: d.createdAt,
+        };
+      } catch { return null; }
+    })
+    .filter(Boolean)
+    .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+}
+
+function createDrawing({ title, elements, appState, files, thumbnail, tags } = {}) {
+  const now     = new Date().toISOString();
+  const drawing = {
+    _id:       uuidv4(),
+    title:     title     || "Untitled Drawing",
+    elements:  elements  || [],
+    appState:  appState  || {},
+    files:     files     || {},
+    thumbnail: thumbnail || null,
+    isPublic:  false,
+    shareId:   uuidv4(),
+    tags:      tags      || [],
+    createdAt: now,
+    updatedAt: now,
+  };
+  writeFile(drawing);
+  return drawing;
+}
+
+function readDrawing(id) {
+  return readFile(id);
+}
+
+function updateDrawing(id, updates) {
+  const drawing = readFile(id);
+  if (!drawing) return null;
+  const ALLOWED = ["title", "elements", "appState", "files", "isPublic", "thumbnail", "tags"];
+  ALLOWED.forEach((k) => { if (updates[k] !== undefined) drawing[k] = updates[k]; });
+  drawing.updatedAt = new Date().toISOString();
+  writeFile(drawing);
+  return drawing;
+}
+
+function deleteDrawing(id) {
+  const p = drawingPath(id);
+  if (fs.existsSync(p)) fs.unlinkSync(p);
+}
+
+function toggleShare(id) {
+  const drawing = readFile(id);
+  if (!drawing) return null;
+  drawing.isPublic  = !drawing.isPublic;
+  drawing.updatedAt = new Date().toISOString();
+  writeFile(drawing);
+  return { isPublic: drawing.isPublic, shareId: drawing.shareId };
+}
+
+function getSharedDrawing(shareId) {
+  const files = fs.readdirSync(DRAWINGS_DIR).filter((f) => f.endsWith(".json"));
+  for (const f of files) {
+    try {
+      const d = JSON.parse(fs.readFileSync(path.join(DRAWINGS_DIR, f), "utf8"));
+      if (d.shareId === shareId && d.isPublic) {
+        return { _id: d._id, title: d.title, elements: d.elements,
+                 appState: d.appState, files: d.files,
+                 shareId: d.shareId, updatedAt: d.updatedAt };
+      }
+    } catch { /* skip corrupt files */ }
+  }
+  return null;
+}
+
+// ── Library ───────────────────────────────────────────────────────────────────
+
+function getLibrary() {
+  if (!fs.existsSync(LIBRARY_FILE)) return [];
+  try { return JSON.parse(fs.readFileSync(LIBRARY_FILE, "utf8")); } catch { return []; }
+}
+
+function saveLibrary(items) {
+  fs.writeFileSync(LIBRARY_FILE, JSON.stringify(items, null, 2), "utf8");
+  return items;
+}
+
+// ── Collab scenes ─────────────────────────────────────────────────────────────
+
+function collabScenePath(roomId) {
+  return path.join(COLLAB_DIR, `${roomId}.json`);
+}
+
+function getCollabScene(roomId) {
+  const p = collabScenePath(roomId);
+  if (!fs.existsSync(p)) return null;
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function saveCollabScene(roomId, scene) {
+  fs.writeFileSync(collabScenePath(roomId), JSON.stringify(scene), "utf8");
+}
+
+// ── Collab files ──────────────────────────────────────────────────────────────
+
+function collabFilePath(roomId, fileId) {
+  const dir = path.join(COLLAB_FILES_DIR, roomId);
+  fs.mkdirSync(dir, { recursive: true });
+  return path.join(dir, fileId);
+}
+
+function getCollabFile(roomId, fileId) {
+  const p = collabFilePath(roomId, fileId);
+  if (!fs.existsSync(p)) return null;
+  return fs.readFileSync(p); // returns Buffer
+}
+
+function saveCollabFile(roomId, fileId, buffer) {
+  fs.writeFileSync(collabFilePath(roomId, fileId), buffer);
+}
+
+module.exports = {
+  listDrawings, createDrawing, readDrawing,
+  updateDrawing, deleteDrawing, toggleShare,
+  getSharedDrawing, getLibrary, saveLibrary,
+  getCollabScene, saveCollabScene,
+  getCollabFile, saveCollabFile,
+};