@mahidsec/nest 1.0.2 → 1.0.4

package/bin/nest.js

@@ -314,7 +314,12 @@ async function handleSelect() {
     console.log("  \x1b[90mServer: http://localhost:" + PORT + "\x1b[0m");
     console.log();
 
-    if (serverProcess) serverProcess.unref();
+    // Redirect server stdout/stderr so logs don't leak to terminal
+    if (serverProcess) {
+      serverProcess.stdout?.destroy();
+      serverProcess.stderr?.destroy();
+      serverProcess.unref();
+    }
 
     spawn("node", [__filename, "--tray"], {
       stdio: "ignore",

package/dist/server.js

@@ -141,11 +141,14 @@ var countVideoFiles = async (dirPath) => {
   const videoExts = [".mp4", ".mkv", ".avi", ".mov", ".webm", ".m4v"];
   try {
     const entries = await readdir(dirPath, { withFileTypes: true });
+    const promises = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      if (entry.isDirectory()) count += await countVideoFiles(path.join(dirPath, entry.name));
+      if (entry.isDirectory()) promises.push(countVideoFiles(path.join(dirPath, entry.name)));
       else if (videoExts.includes(path.extname(entry.name).toLowerCase())) count++;
     }
+    const results = await Promise.all(promises);
+    count += results.reduce((a, b) => a + b, 0);
   } catch {
   }
   return count;
@@ -153,16 +156,47 @@ var countVideoFiles = async (dirPath) => {
 var videoCountCache = /* @__PURE__ */ new Map();
 var CACHE_TTL = 3e4;
 var CACHE_MAX = 200;
-var getCachedVideoCount = async (dirPath) => {
+var triggerVideoCountUpdate = async (course) => {
+  const dirPath = course.localPath;
+  let cached = videoCountCache.get(dirPath);
+  if (!cached) {
+    cached = { count: course.totalVideos || 0, ts: 0, updating: true };
+    if (videoCountCache.size >= CACHE_MAX) {
+      const oldest = videoCountCache.keys().next().value;
+      if (oldest) videoCountCache.delete(oldest);
+    }
+    videoCountCache.set(dirPath, cached);
+  } else {
+    cached.updating = true;
+  }
+  try {
+    const count = await countVideoFiles(dirPath);
+    videoCountCache.set(dirPath, { count, ts: Date.now(), updating: false });
+    if (course.totalVideos !== count) {
+      const allCourses = await getCourses();
+      const target = allCourses.find((c) => c.id === course.id);
+      if (target && target.totalVideos !== count) {
+        target.totalVideos = count;
+        await saveCourses(allCourses);
+      }
+    }
+  } catch (err) {
+    if (cached) cached.updating = false;
+  }
+};
+var getCachedVideoCount = (course) => {
+  const dirPath = course.localPath;
   const cached = videoCountCache.get(dirPath);
-  if (cached && Date.now() - cached.ts < CACHE_TTL) return cached.count;
-  const count = await countVideoFiles(dirPath);
-  if (videoCountCache.size >= CACHE_MAX) {
-    const oldest = videoCountCache.keys().next().value;
-    if (oldest) videoCountCache.delete(oldest);
+  if (cached) {
+    if (Date.now() - cached.ts > CACHE_TTL && !cached.updating) {
+      triggerVideoCountUpdate(course).catch(() => {
+      });
+    }
+    return cached.count;
   }
-  videoCountCache.set(dirPath, { count, ts: Date.now() });
-  return count;
+  triggerVideoCountUpdate(course).catch(() => {
+  });
+  return course.totalVideos || 0;
 };
 var invalidateVideoCount = (dirPath) => {
   videoCountCache.delete(dirPath);
@@ -198,15 +232,12 @@ function findCloudflared() {
   } catch {
   }
   if (fs.existsSync(CLOUDFLARED_PATH)) return CLOUDFLARED_PATH;
-  console.log("[Tunnel] cloudflared not found \u2014 downloading...");
   try {
     if (!fs.existsSync(NEST_BIN_DIR)) fs.mkdirSync(NEST_BIN_DIR, { recursive: true });
     execSync(`curl -fSL -o "${CLOUDFLARED_PATH}" "${getCloudflaredDownloadUrl()}"`, { stdio: "inherit" });
     fs.chmodSync(CLOUDFLARED_PATH, 493);
-    console.log("[Tunnel] cloudflared installed");
     return CLOUDFLARED_PATH;
   } catch {
-    console.error("[Tunnel] Failed to download cloudflared");
     return null;
   }
 }
@@ -281,13 +312,12 @@ app.post("/api/tunnel/stop", (_req, res) => {
 app.get("/api/courses", async (_req, res) => {
   try {
     const courses = await getCourses();
-    const enriched = await Promise.all(courses.map(async (c) => ({
+    const enriched = courses.map((c) => ({
       ...c,
-      totalVideos: await getCachedVideoCount(c.localPath)
-    })));
+      totalVideos: getCachedVideoCount(c)
+    }));
     res.json(enriched);
-  } catch (err) {
-    console.error("[Courses] List error:", err);
+  } catch {
     res.status(500).json({ error: "Failed to load courses" });
   }
 });
@@ -317,7 +347,6 @@ app.post("/api/courses", async (req, res) => {
   courses.push(course);
   await saveCourses(courses);
   invalidateVideoCount(resolved);
-  console.log(`[Courses] Added "${name}" \u2192 ${resolved}`);
   res.json({ success: true, course });
 });
 app.delete("/api/courses/:id", async (req, res) => {
@@ -326,9 +355,16 @@ app.delete("/api/courses/:id", async (req, res) => {
   if (!target) return res.status(404).json({ error: "Course not found" });
   invalidateVideoCount(target.localPath);
   await saveCourses(courses.filter((c) => c.id !== req.params.id));
-  console.log(`[Courses] Removed course ${req.params.id}`);
   res.json({ success: true });
 });
+app.get("/api/courses/progress", async (_req, res) => {
+  const all = await getCourseProgressData();
+  const result = {};
+  for (const [courseId, files] of Object.entries(all)) {
+    result[courseId] = Object.keys(files).length;
+  }
+  res.json(result);
+});
 app.get("/api/courses/:id/browse", async (req, res) => {
   const courses = await getCourses();
   const course = courses.find((c) => c.id === req.params.id);
@@ -342,8 +378,7 @@ app.get("/api/courses/:id/browse", async (req, res) => {
     const result = await scanDirectory(course.localPath, course.localPath);
     invalidateVideoCount(course.localPath);
     res.json({ ...course, ...result });
-  } catch (err) {
-    console.error("[Courses] Browse error:", err);
+  } catch {
     res.status(500).json({ error: "Failed to scan directory" });
   }
 });
@@ -442,8 +477,7 @@ app.get("/api/courses/:id/file", async (req, res) => {
       "Cache-Control": "public, max-age=3600"
     });
     safePipe(fs.createReadStream(realResolved), res);
-  } catch (err) {
-    console.error("[Courses] File error:", err);
+  } catch {
     res.status(500).json({ error: "Failed to serve file" });
   }
 });
@@ -472,9 +506,6 @@ app.get("*", (_req, res) => {
   }
 });
 httpServer.listen(PORT, "0.0.0.0", () => {
-  console.log(`[Nest] Server running on http://localhost:${PORT}`);
-  console.log(`[Nest] Data dir: ${DATA_DIR}`);
-  if (IS_TUNNEL) console.log(`[Nest] Tunnel mode: enabled`);
 });
 var shuttingDown = false;
 var shutdown = (signal) => {