Working on my machine

server/logger.js

@@ -0,0 +1,66 @@
+const { createLogger, format, transports } = require("winston");
+const DailyRotateFile = require("winston-daily-rotate-file");
+const fs = require("fs");
+const path = require("path");
+
+const logDir = path.join(__dirname, "../logs");
+if (!fs.existsSync(logDir)) fs.mkdirSync(logDir);
+
+function getSessionStartLine() {
+  const now = new Date().toISOString();
+  return `--- Démarrage de la session : ${now} ---`;
+}
+
+function getSessionEndLine() {
+  const now = new Date().toISOString();
+  return `--- Fin de la session : ${now} ---`;
+}
+
+const logger = createLogger({
+  level: "info",
+  format: format.combine(
+    format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+    format.printf(({ timestamp, level, message }) =>
+      `${timestamp} | ${level.toUpperCase()} |  ${message}`
+    )
+  ),
+  transports: [
+    new DailyRotateFile({
+      dirname: logDir,
+      filename: "combined-%DATE%.log",
+      datePattern: "YYYY-MM-DD",
+      zippedArchive: false,  // tu peux mettre true si tu veux compresser
+      maxFiles: "14d",       // conserve les logs des 14 derniers jours
+      format: format.combine(
+        format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+        format.printf(({ timestamp, level, message }) =>
+          `${timestamp} | ${level.toUpperCase()} |  ${message}`
+        )
+      ),
+      options: { flags: "a" },
+    }),
+    new transports.Console({
+      format: format.combine(
+        format.colorize(),
+        format.timestamp({ format: "HH:mm:ss" }),
+        format.printf(({ timestamp, level, message }) =>
+          `${timestamp} | ${level} |  ${message}`
+        )
+      ),
+    }),
+  ],
+});
+
+function logSessionStart() {
+  logger.info(getSessionStartLine());
+}
+
+function logSessionEnd() {
+  logger.info(getSessionEndLine());
+}
+
+module.exports = {
+  logger,
+  logSessionStart,
+  logSessionEnd,
+};

server/routes/download.js

@@ -1,51 +1,87 @@
 const express = require("express");
 const router = express.Router();
-const { exec } = require("child_process");
+const { execFile } = require("child_process");
 const path = require("path");
+const fs = require("fs");
+
+const logger = require("../logger").logger;  // importe ton logger Winston
+
+const ytDlpPath = path.join(__dirname, '../../yt-dlp.exe');
 
 router.post("/", (req, res) => {
-  const options = {
-    url: req.body.url,
-    audioOnly: req.body.audioOnly === "1",
-    quality: req.body.quality || "best",
-    subtitles: req.body.subs === "1",
-  };
+  try {
+    const options = {
+      url: req.body.url,
+      audioOnly: req.body.audioOnly === "1",
+      quality: req.body.quality || "best",
+      subtitles: req.body.subs === "1",
+    };
 
-  if (!options.url) {
-    return res.status(400).send("❌ URL manquante !");
-  }
-
-  // Récupérer le chemin Freedom Loader Output depuis app.locals
-  const outputFolder = req.app.locals.outputFolder;
-
-  // Construire le template de sortie
-  const outputTemplate = path.join(outputFolder, "%(title)s.%(ext)s");
-
-  let command = `yt-dlp`;
-
-  if (options.audioOnly) {
-    command += " --extract-audio --audio-format mp3";
-  }
-
-  if (options.subtitles) {
-    command += " --write-subs --sub-lang en";
-  }
-
-  command += ` -f ${options.quality}`;
-  command += ` -o "${outputTemplate}"`;
-  command += ` "${options.url}"`;
-
-  console.log("🔧 Commande finale :", command);
-
-  exec(command, (error, stdout, stderr) => {
-    if (error) {
-      console.error("❌ Erreur yt-dlp :", stderr || error.message);
-      return res.status(500).send("❌ Erreur pendant le téléchargement.");
+    if (!options.url) {
+      logger.warn("Requête POST /download sans URL");
+      return res.status(400).send("❌ URL manquante !");
     }
 
-    console.log("✅ yt-dlp terminé :", stdout);
-    res.send("✅ Téléchargement terminé !");
-  });
+    // Récupérer le chemin Freedom Loader Output depuis app.locals
+    const outputFolder = req.app.locals.outputFolder;
+
+    if (!fs.existsSync(outputFolder)) {
+      fs.mkdirSync(outputFolder, { recursive: true });
+      logger.info("Dossier Freedom Loader Output créé à la volée dans Téléchargements.");
+    }
+
+    // Construire le template de sortie
+    const outputTemplate = path.join(outputFolder, "%(title)s.%(ext)s");
+
+    // Construire les arguments pour execFile
+    const args = [];
+
+    if (options.audioOnly) {
+      args.push("--extract-audio", "--audio-format", "mp3");
+    }
+
+    if (options.subtitles) {
+      args.push("--write-subs", "--sub-lang", "en");
+    }
+
+    args.push("-f", options.quality);
+    args.push("-o", outputTemplate);
+    args.push(options.url);
+
+    logger.info(`Commande yt-dlp : ${ytDlpPath} ${args.join(" ")}`);
+
+    const child = execFile(ytDlpPath, args);
+
+    child.stdout.on("data", (data) => {
+      data.toString().split("\n").forEach(line => {
+        if(line.trim()) logger.info(`[yt-dlp stdout] ${line.trim()}`);
+      });
+    });
+
+    child.stderr.on("data", (data) => {
+      data.toString().split("\n").forEach(line => {
+        if(line.trim()) logger.error(`[yt-dlp stderr] ${line.trim()}`);
+      });
+    });
+
+    child.on("error", (err) => {
+      logger.error(`Erreur lancement yt-dlp : ${err.message}`);
+      res.status(500).send(`❌ Erreur lors de l'exécution : ${err.message}`);
+    });
+
+    child.on("close", (code) => {
+      logger.info(`yt-dlp terminé avec code de sortie : ${code}`);
+      if(code === 0) {
+        res.send("✅ Téléchargement terminé !");
+      } else {
+        res.status(500).send(`❌ yt-dlp a échoué avec le code : ${code}`);
+      }
+    });
+
+  } catch (err) {
+    logger.error(`Erreur serveur dans /download : ${err.message}`);
+    res.status(500).send(`Erreur serveur : ${err.message}`);
+  }
 });
 
 module.exports = router;

server/server.js

@@ -2,58 +2,74 @@ const express = require("express");
 const { exec } = require("child_process");
 const fs = require("fs");
 const path = require("path");
+const debug = require("debug")("freedom-loader:server");
+const { logger, logSessionStart, logSessionEnd } = require("./logger");
 
 const app = express();
 
-// import des routes
-const infoRoute = require("./routes/info");
-const downloadRoute = require("./routes/download");
+// // Lancement d'une nouvelle session de log
+// logSessionStart();
 
-// Chemin vers le dossier Téléchargements de l'utilisateur
-const downloadsPath = path.join(process.env.USERPROFILE, 'Downloads');
-
-// Créer un sous-dossier "Freedom Loader Output" dans le dossier Téléchargements
-const outputFolder = path.join(downloadsPath, 'Freedom Loader Output');
+// dossier de sortie
+const downloadsPath = path.join(process.env.USERPROFILE, "Downloads");
+const outputFolder = path.join(downloadsPath, "Freedom Loader Output");
 
 if (!fs.existsSync(outputFolder)) {
-  fs.mkdirSync(outputFolder);
-  console.log("✅ Dossier Freedom Loader Output créé dans Téléchargements.");
+  try {
+    fs.mkdirSync(outputFolder, { recursive: true });
+    logger.info("Dossier Freedom Loader Output cree dans Telechargements.");
+  } catch (err) {
+    logger.error("Impossible de creer le dossier :", err);
+    process.exit(1);
+  }
+} else {
+  logger.info("Dossier Freedom Loader Output deja existant.");
 }
 
-// rendre le chemin accessible à tes routes
 app.locals.outputFolder = outputFolder;
-
 app.use(express.urlencoded({ extended: true }));
 
-// servir le dossier public comme site
-// app.use(express.static("public"));
-app.use(express.static(path.join(__dirname, "../public")));
-
+const staticPath = path.join(__dirname, "../public");
+debug("Serveur statique sur", staticPath);
+app.use(express.static(staticPath));
 
 // routes
-app.use("/download", downloadRoute); // ex: /download
-app.use("/info", infoRoute);         // ex: /info
+const infoRoute = require("./routes/info");
+const downloadRoute = require("./routes/download");
+debug("Routes /download et /info installees");
+app.use("/download", downloadRoute);
+app.use("/info", infoRoute);
 
 app.get("/", (req, res) => {
+  debug("Requete GET / servie");
   res.sendFile(path.join(__dirname, "../public/index.html"));
 });
 
-// Export d'une fonction startServer qui retourne une promesse
 function startServer() {
   return new Promise((resolve, reject) => {
-    console.log("🟢 Démarrage du serveur Express...");
+    logger.info("Demarrage du serveur Express...");
     const serverInstance = app.listen(8080, () => {
-      console.log("🟢 Serveur Express prêt sur http://localhost:8080");
+      logger.info("Serveur Express pret sur http://localhost:8080");
       resolve(serverInstance);
     });
-    serverInstance.on('error', (err) => {
-      console.error("❌ Erreur serveur Express :", err);
+    serverInstance.on("error", (err) => {
+      logger.error("Erreur serveur Express :", err);
       reject(err);
     });
   });
 }
 
-app.get("/", (req, res) => {
-  res.sendFile(path.join(__dirname, "../public/index.html"));
+// Gestion propre de la fin de session à la fermeture du process
+// process.on("exit", () => {
+//   logSessionEnd();
+// });
+process.on("SIGINT", () => {
+  logSessionEnd();
+  process.exit();
 });
+process.on("SIGTERM", () => {
+  logSessionEnd();
+  process.exit();
+});
+
 module.exports = { startServer };