@learnpack/learnpack 5.0.277 → 5.0.279

package/lib/commands/serve.js

@@ -1303,9 +1303,10 @@ class ServeCommand extends SessionCommand_1.default {
                 res.status(500).json({ error: "Failed to fetch the resource" });
             }
         });
-        app.get("/export/:course_slug/:format", async (req, res) => {
+        // Export endpoint (POST) - supports both SCORM and EPUB
+        app.post("/export/:course_slug/:format", async (req, res) => {
             const { course_slug, format } = req.params;
-            const { language } = req.query;
+            const { language = "en", metadata } = req.body;
             try {
                 let outputPath;
                 let filename;
@@ -1319,19 +1320,33 @@ class ServeCommand extends SessionCommand_1.default {
                     filename = `${course_slug}-scorm.zip`;
                 }
                 else if (format === "epub") {
+                    console.log("EPUB export", metadata);
+                    // Validate required metadata for EPUB
+                    if (!metadata ||
+                        !metadata.creator ||
+                        !metadata.publisher ||
+                        !metadata.title ||
+                        !metadata.rights ||
+                        !metadata.lang) {
+                        console.log("Missing required metadata for EPUB export", metadata);
+                        return res.status(400).json({
+                            error: "Missing required metadata for EPUB export",
+                            required: ["creator", "publisher", "title", "rights", "lang"],
+                        });
+                    }
                     outputPath = await (0, export_1.exportToEpub)({
                         courseSlug: course_slug,
                         format: "epub",
                         bucket,
                         outDir: path.join(__dirname, "../output/directory"),
-                        language: language || "en",
-                    });
+                        language: language,
+                    }, metadata);
                     filename = `${course_slug}.epub`;
                 }
                 else {
-                    return res
-                        .status(400)
-                        .json({ error: "Invalid format. Supported formats: scorm, epub" });
+                    return res.status(400).json({
+                        error: "Invalid format. Supported formats: scorm, epub",
+                    });
                 }
                 // Send the file and clean up
                 res.download(outputPath, filename, err => {
@@ -1340,6 +1355,12 @@ class ServeCommand extends SessionCommand_1.default {
                     // Clean up the generated file
                     if (fs.existsSync(outputPath)) {
                         fs.unlinkSync(outputPath);
+                        if (format === "epub") {
+                            const tempDir = path.dirname(outputPath);
+                            if (fs.existsSync(tempDir)) {
+                                rimraf.sync(tempDir);
+                            }
+                        }
                     }
                 });
             }

package/lib/utils/export/epub.d.ts

@@ -1,2 +1,2 @@
-import { ExportOptions } from "./types";
-export declare function exportToEpub(options: ExportOptions): Promise<string>;
+import { ExportOptions, EpubMetadata } from "./types";
+export declare function exportToEpub(options: ExportOptions, epubMetadata: EpubMetadata): Promise<string>;

package/lib/utils/export/epub.js

@@ -8,13 +8,87 @@ const rimraf = require("rimraf");
 const uuid_1 = require("uuid");
 const child_process_1 = require("child_process");
 const shared_1 = require("./shared");
+const replaceQuestionsFromMarkdown = (markdown) => {
+    // Search for all code blocks like this (No breaking lines sensitive)
+    // ```question some parameters
+    // some text
+    // ```
+    const questionRegex = /```question([\s\S]*?)```/g;
+    return markdown.replace(questionRegex, "");
+};
+const replaceMermaidFromMarkdown = (markdown) => {
+    // Search for all code blocks like this (No breaking lines sensitive)
+    // ```mermaid
+    // some graphs in mermaid syntax
+    // ```
+    const mermaidRegex = /```mermaid([\s\S]*?)```/g;
+    return markdown.replace(mermaidRegex, "");
+};
+// Download cover image from bucket
+async function downloadCoverImage(bucket, courseSlug, outputDir) {
+    try {
+        const coverImagePath = path.join(outputDir, "cover.png");
+        const [coverBuf] = await bucket
+            .file(`courses/${courseSlug}/preview.png`)
+            .download();
+        fs.writeFileSync(coverImagePath, coverBuf);
+        console.log("Cover image downloaded:", coverImagePath);
+        return coverImagePath;
+    }
+    catch (error) {
+        console.log("No cover image found, skipping...");
+        return undefined;
+    }
+}
 // Convert markdown to HTML using pandoc
-async function convertMarkdownToHtml(markdownPath, outputPath) {
+async function convertMarkdownToHtml(markdownPath, outputPath, learnAssetsDir) {
     return new Promise((resolve, reject) => {
         let stdout = "";
         let stderr = "";
+        // Process markdown content to fix image paths
+        let markdownContent = fs.readFileSync(markdownPath, "utf-8");
+        if (learnAssetsDir && fs.existsSync(learnAssetsDir)) {
+            // Find all image references in markdown
+            const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g;
+            let match;
+            let imageCount = 0;
+            while ((match = imageRegex.exec(markdownContent)) !== null) {
+                const [fullMatch, altText, imagePath] = match;
+                // Check if it's a relative path starting with /learn/assets/
+                if (imagePath.startsWith("/.learn/assets/")) {
+                    const imageName = path.basename(imagePath);
+                    const absoluteImagePath = path.join(learnAssetsDir, imageName);
+                    console.log(`📸 Looking for image: ${imageName}`);
+                    console.log(`📁 Learn assets dir: ${learnAssetsDir}`);
+                    console.log(`📁 Absolute path: ${absoluteImagePath}`);
+                    console.log(`📁 Path exists: ${fs.existsSync(absoluteImagePath)}`);
+                    if (fs.existsSync(absoluteImagePath)) {
+                        // Use absolute path for the image
+                        console.log(`✅ Found image, replacing path: ${imagePath} -> ${absoluteImagePath}`);
+                        markdownContent = markdownContent.replace(fullMatch, `![${altText}](${absoluteImagePath})`);
+                        imageCount++;
+                    }
+                    else {
+                        console.log(`❌ Image not found: ${absoluteImagePath}`);
+                        // List files in the assets directory for debugging
+                        if (fs.existsSync(learnAssetsDir)) {
+                            const files = fs.readdirSync(learnAssetsDir);
+                            console.log(`📁 Files in assets directory: ${files.join(", ")}`);
+                        }
+                        else {
+                            console.log(`❌ Assets directory does not exist: ${learnAssetsDir}`);
+                        }
+                    }
+                }
+            }
+        }
+        markdownContent = replaceQuestionsFromMarkdown(markdownContent);
+        markdownContent = replaceMermaidFromMarkdown(markdownContent);
+        // Write processed markdown to a temporary file
+        const tempMarkdownPath = markdownPath + ".processed";
+        fs.writeFileSync(tempMarkdownPath, markdownContent, "utf-8");
         const pandocArgs = [
-            markdownPath,
+            tempMarkdownPath,
             "-o",
             outputPath,
             "--from",
@@ -25,9 +99,6 @@ async function convertMarkdownToHtml(markdownPath, outputPath) {
             "--css",
             path.join(__dirname, "../templates/epub/epub.css"),
         ];
-        console.log("Executing pandoc command:", "pandoc", pandocArgs.join(" "));
-        console.log("Input file exists:", fs.existsSync(markdownPath));
-        console.log("Output directory exists:", fs.existsSync(path.dirname(outputPath)));
         const pandoc = (0, child_process_1.spawn)("pandoc", pandocArgs);
         pandoc.stdout.on("data", (data) => {
             stdout += data.toString();
@@ -36,7 +107,12 @@ async function convertMarkdownToHtml(markdownPath, outputPath) {
             stderr += data.toString();
         });
         pandoc.on("close", (code) => {
+            // Clean up temporary file
+            // if (fs.existsSync(tempMarkdownPath)) {
+            //   fs.unlinkSync(tempMarkdownPath);
+            // }
             if (code === 0) {
+                console.log("Successfully converted:", markdownPath, "->", outputPath);
                 resolve();
             }
             else {
@@ -52,11 +128,27 @@ async function convertMarkdownToHtml(markdownPath, outputPath) {
     });
 }
 // Generate EPUB using pandoc
-async function generateEpub(htmlFiles, outputPath, metadata) {
+async function generateEpub(htmlFiles, outputPath, metadata, epubMetadata, coverImagePath) {
     return new Promise((resolve, reject) => {
         var _a;
         let stdout = "";
         let stderr = "";
+        const yamlPath = path.join(path.dirname(outputPath), "metadata.yaml");
+        const escapeYaml = (str) => {
+            if (!str)
+                return "";
+            return str.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+        };
+        const yamlContent = `---
+title: "${epubMetadata.title}"
+creator: "${epubMetadata.creator}"
+publisher: "${epubMetadata.publisher}"
+rights: "${epubMetadata.rights}"
+lang: "${epubMetadata.lang}"
+description: "${escapeYaml(metadata.description || "")}"
+subject: "${((_a = metadata.technologies) === null || _a === void 0 ? void 0 : _a.join(", ")) || "Programming"}"
+---`;
+        fs.writeFileSync(yamlPath, yamlContent, "utf-8");
         // Include all HTML files in the EPUB
         const pandocArgs = [
             ...htmlFiles, // All HTML files
@@ -66,59 +158,62 @@ async function generateEpub(htmlFiles, outputPath, metadata) {
             "html",
             "--to",
             "epub",
-            "--metadata",
-            `title=${metadata.title}`,
-            "--metadata",
-            `language=${metadata.language || "en"}`,
-            "--metadata",
-            `creator=FourGeeksAcademy`,
-            "--metadata",
-            `description=${metadata.description || ""}`,
-            "--metadata",
-            `subject=${((_a = metadata.technologies) === null || _a === void 0 ? void 0 : _a.join(", ")) || "Programming"}`,
+            "--metadata-file",
+            yamlPath,
             "--css",
             path.join(__dirname, "../templates/epub/epub.css"),
         ];
-        console.log("Executing pandoc EPUB command:", "pandoc", pandocArgs.join(" "));
-        console.log("HTML files to include:", htmlFiles);
-        console.log("All input files exist:", htmlFiles.every((file) => fs.existsSync(file)));
-        console.log("Output directory exists:", fs.existsSync(path.dirname(outputPath)));
+        // Add cover image if available - use absolute path
+        if (coverImagePath) {
+            pandocArgs.push("--epub-cover-image", coverImagePath);
+        }
+        console.log("🔧 Executing pandoc EPUB command:");
+        console.log("Command:", "pandoc", pandocArgs.join(" "));
         const pandoc = (0, child_process_1.spawn)("pandoc", pandocArgs);
         pandoc.stdout.on("data", (data) => {
-            stdout += data.toString();
+            const output = data.toString();
+            stdout += output;
+            console.log("📤 Pandoc STDOUT:", output);
         });
         pandoc.stderr.on("data", (data) => {
-            stderr += data.toString();
+            const output = data.toString();
+            stderr += output;
+            console.log("⚠️ Pandoc STDERR:", output);
         });
         pandoc.on("close", (code) => {
+            console.log(`🏁 Pandoc process finished with exit code: ${code}`);
             if (code === 0) {
+                console.log("✅ EPUB generation successful!");
                 resolve();
             }
             else {
                 const errorMessage = `Pandoc process exited with code ${code}\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${stderr}`;
-                console.error("Pandoc Error Details:", errorMessage);
+                console.error("❌ Pandoc Error Details:", errorMessage);
                 reject(new Error(errorMessage));
             }
         });
         pandoc.on("error", (err) => {
-            console.error("Pandoc spawn error:", err);
+            console.error("❌ Pandoc spawn error:", err);
             reject(err);
         });
     });
 }
 // Process exercises and convert to HTML
-async function processExercises(exercisesDir, outputDir, language = "en") {
+async function processExercises(exercisesDir, outputDir, language = "en", learnAssetsDir) {
     const htmlFiles = [];
     console.log("Processing exercises directory:", exercisesDir);
     console.log("Output directory:", outputDir);
     console.log("Language:", language);
+    console.log("Learn assets directory:", learnAssetsDir);
     if (!fs.existsSync(exercisesDir)) {
         console.log("Exercises directory does not exist:", exercisesDir);
         return htmlFiles;
     }
     console.log("Exercises directory exists, scanning for files...");
     const processDirectory = async (dir, relativePath = "") => {
+        console.log(`🔍 Processing directory: ${dir} (relative: ${relativePath})`);
         const entries = fs.readdirSync(dir, { withFileTypes: true });
+        console.log(`📁 Found ${entries.length} entries in ${dir}:`, entries.map((e) => e.name));
         // Sort entries to prioritize README files first
         entries.sort((a, b) => {
             const aName = a.name.toLowerCase();
@@ -143,28 +238,41 @@ async function processExercises(exercisesDir, outputDir, language = "en") {
                 // Apply language filtering for all markdown files
                 const baseName = entry.name.replace(/\.(md|markdown)$/, "");
                 if (language === "en") {
-                    // For English: exclude files with language suffixes
-                    if (baseName.includes(".") &&
+                    // For English: only include README.md and files without language suffixes
+                    if (entry.name.toLowerCase() === "readme.md") {
+                        console.log(`✅ Including English README: ${relativeFilePath}`);
+                    }
+                    else if (baseName.includes(".") &&
                         /\.(es|fr|de|it|pt|ja|ko|zh|ar|ru)$/i.test(baseName)) {
-                        console.log("Skipping language-specific file for English:", relativeFilePath);
+                        console.log(`❌ Skipping language-specific file for English: ${relativeFilePath}`);
                         continue;
                     }
+                    else {
+                        console.log(`✅ Including English file: ${relativeFilePath}`);
+                    }
                 }
                 else {
                     // For other languages: only include files with the correct language suffix
-                    if (!baseName.endsWith(`.${language}`)) {
-                        console.log("Skipping file with different language:", relativeFilePath);
+                    if (entry.name.toLowerCase() === "readme.md") {
+                        console.log(`❌ Skipping English README for language ${language}: ${relativeFilePath}`);
                         continue;
                     }
+                    else if (!baseName.endsWith(`.${language}`)) {
+                        console.log(`❌ Skipping file with different language: ${relativeFilePath}`);
+                        continue;
+                    }
+                    else {
+                        console.log(`✅ Including ${language} file: ${relativeFilePath}`);
+                    }
                 }
                 // Convert markdown to HTML
                 console.log("Converting markdown file:", relativeFilePath);
-                const htmlFileName = entry.name.replace(/\.(md|markdown)$/, ".html");
+                // const htmlFileName = entry.name.replace(/\.(md|markdown)$/, ".html");
                 const htmlPath = path.join(outputDir, relativeFilePath.replace(/\.(md|markdown)$/, ".html"));
                 console.log("HTML output path:", htmlPath);
                 mkdirp.sync(path.dirname(htmlPath));
                 // esling-disable-next-line
-                await convertMarkdownToHtml(fullPath, htmlPath);
+                await convertMarkdownToHtml(fullPath, htmlPath, learnAssetsDir);
                 htmlFiles.push(htmlPath);
                 console.log("Successfully converted:", relativeFilePath, "->", htmlPath);
             }
@@ -186,8 +294,25 @@ async function processExercises(exercisesDir, outputDir, language = "en") {
     await processDirectory(exercisesDir);
     return htmlFiles;
 }
+const titlelify = (title) => {
+    return title.replace(/[-_]/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
+};
+// Read sidebar.json to get exercise titles
+function readSidebarData(learnDir) {
+    try {
+        const sidebarPath = path.join(learnDir, "sidebar.json");
+        if (fs.existsSync(sidebarPath)) {
+            const sidebarContent = fs.readFileSync(sidebarPath, "utf-8");
+            return JSON.parse(sidebarContent);
+        }
+    }
+    catch (error) {
+        console.log("⚠️ Could not read sidebar.json:", error);
+    }
+    return null;
+}
 // Create EPUB table of contents
-function createTocHtml(htmlFiles, metadata) {
+function createTocHtml(htmlFiles, metadata, sidebarData, language) {
     let tocContent = `
 <!DOCTYPE html>
 <html>
@@ -205,11 +330,24 @@ function createTocHtml(htmlFiles, metadata) {
 `;
     htmlFiles.forEach((file) => {
         const fileName = path.basename(file, ".html");
-        const displayName = fileName
-            .replace(/[-_]/g, " ")
-            .replace(/\b\w/g, (l) => l.toUpperCase());
-        // Use the full relative path for the href to ensure proper navigation
-        const relativePath = file.replace(/.*\/html\//, "").replace(/\\/g, "/");
+        const relativePath = fileName + ".html";
+        // Get the parent directory name (exercise slug) to look up in sidebar
+        const parentDir = path.basename(path.dirname(file));
+        // Try to get the title from sidebar.json using the parent directory name
+        let displayName = fileName;
+        if (sidebarData && sidebarData[parentDir]) {
+            console.log("🔍 Found title in sidebar.json:", sidebarData[parentDir], "; language: ", language);
+            // Get the title for the current language, fallback to English, then to the key itself
+            displayName =
+                sidebarData[parentDir][language] ||
+                    sidebarData[parentDir]["en"] ||
+                    titlelify(parentDir);
+        }
+        else {
+            console.log("🔍 No title found in sidebar.json for parent directory:", parentDir);
+            // Fallback to titlelify if not found in sidebar
+            displayName = titlelify(parentDir);
+        }
         tocContent += `            <li><a href="${relativePath}">${displayName}</a></li>\n`;
     });
     tocContent += `
@@ -219,12 +357,13 @@ function createTocHtml(htmlFiles, metadata) {
 </html>`;
     return tocContent;
 }
-async function exportToEpub(options) {
+async function exportToEpub(options, epubMetadata) {
     var _a, _b, _c;
     const { courseSlug, bucket, outDir, language = "en" } = options;
-    console.log("Starting EPUB export for course:", courseSlug);
-    console.log("Output directory:", outDir);
-    console.log("Language:", language);
+    console.log("🚀 Starting EPUB export for course:", courseSlug);
+    console.log("📁 Output directory:", outDir);
+    console.log("🌍 Language:", language);
+    console.log("📋 EPUB Metadata:", epubMetadata);
     // 1. Create temporary folder
     const tmpName = (0, uuid_1.v4)();
     const epubOutDir = path.join(outDir, tmpName);
@@ -234,29 +373,51 @@ async function exportToEpub(options) {
     // 2. Create EPUB template directory
     const epubTemplateDir = path.join(epubOutDir, "template");
     mkdirp.sync(epubTemplateDir);
-    // 3. Download exercises and .learn from bucket
-    console.log("Downloading exercises...");
+    // 3. Download exercises, .learn, and cover image from bucket
+    console.log("📥 Downloading exercises...");
     await (0, shared_1.downloadS3Folder)(bucket, `courses/${courseSlug}/exercises/`, path.join(epubOutDir, "exercises"));
-    console.log("Downloading .learn files...");
-    await (0, shared_1.downloadS3Folder)(bucket, `courses/${courseSlug}/.learn/`, path.join(epubOutDir, ".learn"));
+    console.log("✅ Exercises downloaded successfully");
+    console.log("📥 Downloading .learn files...");
+    await (0, shared_1.downloadS3Folder)(bucket, `courses/${courseSlug}/.learn/`, path.join(epubOutDir, "learn"));
+    console.log("✅ .learn files downloaded successfully");
+    console.log("📥 Downloading cover image...");
+    const coverImagePath = await downloadCoverImage(bucket, courseSlug, epubOutDir);
+    console.log("✅ Cover image download completed:", coverImagePath ? "Found" : "Not found");
     // 4. Read learn.json for course info
     console.log("Reading course metadata...");
     const learnJson = await (0, shared_1.getCourseMetadata)(bucket, courseSlug);
     const metadata = {
-        title: ((_a = learnJson.title) === null || _a === void 0 ? void 0 : _a.en) || learnJson.title || courseSlug,
-        description: ((_b = learnJson.description) === null || _b === void 0 ? void 0 : _b.en) || learnJson.description,
-        language: learnJson.language || "en",
+        title: ((_a = learnJson.title) === null || _a === void 0 ? void 0 : _a[epubMetadata.lang]) || courseSlug,
+        description: ((_b = learnJson.description) === null || _b === void 0 ? void 0 : _b[epubMetadata.lang]) || learnJson.description,
+        language: epubMetadata.lang,
         technologies: learnJson.technologies || [],
         difficulty: learnJson.difficulty || "beginner",
     };
     console.log("Course metadata:", metadata);
     // 5. Process exercises and convert to HTML
-    console.log("Processing exercises and converting to HTML...");
-    const htmlFiles = await processExercises(path.join(epubOutDir, "exercises"), path.join(epubOutDir, "html"), language);
-    console.log("Generated HTML files:", htmlFiles.length);
-    console.log("HTML files:", htmlFiles);
-    // 6. Create table of contents
-    const tocHtml = createTocHtml(htmlFiles, metadata);
+    console.log("🔄 Processing exercises and converting to HTML...");
+    // First, let's see what files were downloaded
+    const exercisesPath = path.join(epubOutDir, "exercises");
+    console.log("📂 Exercises directory contents:");
+    if (fs.existsSync(exercisesPath)) {
+        const exerciseDirs = fs.readdirSync(exercisesPath, { withFileTypes: true });
+        console.log(`Found ${exerciseDirs.length} exercise directories:`);
+        exerciseDirs.forEach((dir) => {
+            if (dir.isDirectory()) {
+                const dirPath = path.join(exercisesPath, dir.name);
+                const files = fs.readdirSync(dirPath);
+                console.log(`  📁 ${dir.name}: ${files.length} files - ${files.join(", ")}`);
+            }
+        });
+    }
+    else {
+        console.log("❌ Exercises directory does not exist!");
+    }
+    const htmlFiles = await processExercises(path.join(epubOutDir, "exercises"), path.join(epubOutDir, "html"), language, path.join(epubOutDir, "learn", "assets"));
+    // 6. Read sidebar data and create table of contents
+    const sidebarData = readSidebarData(path.join(epubOutDir, "learn"));
+    console.log("📋 Sidebar data loaded:", sidebarData ? "Success" : "Not found");
+    const tocHtml = createTocHtml(htmlFiles, metadata, sidebarData, language);
     const tocPath = path.join(epubOutDir, "html", "toc.html");
     mkdirp.sync(path.dirname(tocPath));
     fs.writeFileSync(tocPath, tocHtml, "utf-8");
@@ -282,17 +443,16 @@ async function exportToEpub(options) {
     fs.writeFileSync(mainContentPath, mainContent, "utf-8");
     // 8. Prepare all HTML files for EPUB generation
     const allHtmlFiles = [mainContentPath, tocPath, ...htmlFiles];
-    console.log("All HTML files for EPUB:", allHtmlFiles);
     // 9. Generate EPUB using pandoc
-    console.log("Generating EPUB file...");
+    console.log("📖 Generating EPUB file...");
     const epubPath = path.join(epubOutDir, `${courseSlug}.epub`);
-    await generateEpub(allHtmlFiles, epubPath, metadata);
+    await generateEpub(allHtmlFiles, epubPath, metadata, epubMetadata, coverImagePath);
     console.log("EPUB generated successfully:", epubPath);
     // Clean up temporary files
     console.log("Cleaning up temporary files...");
     rimraf.sync(path.join(epubOutDir, "html"));
     rimraf.sync(path.join(epubOutDir, "exercises"));
-    rimraf.sync(path.join(epubOutDir, ".learn"));
+    rimraf.sync(path.join(epubOutDir, "learn"));
     console.log("EPUB export completed successfully");
     return epubPath;
 }

package/lib/utils/export/index.d.ts

@@ -1,3 +1,3 @@
 export { exportToScorm } from "./scorm";
 export { exportToEpub } from "./epub";
-export { ExportFormat, ExportOptions } from "./types";
+export { ExportFormat, ExportOptions, EpubMetadata } from "./types";

package/lib/utils/export/types.d.ts

@@ -6,6 +6,13 @@ export interface ExportOptions {
     outDir: string;
     language?: string;
 }
+export interface EpubMetadata {
+    creator: string;
+    publisher: string;
+    title: string;
+    rights: string;
+    lang: string;
+}
 export interface CourseMetadata {
     title: string;
     description?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@learnpack/learnpack",
   "description": "Seamlessly build, sell and/or take interactive & auto-graded tutorials, start learning now or build a new tutorial to your audience.",
-  "version": "5.0.277",
+  "version": "5.0.279",
   "author": "Alejandro Sanchez @alesanchezr",
   "contributors": [
     {

package/src/commands/serve.ts

@@ -1952,9 +1952,10 @@ export default class ServeCommand extends SessionCommand {
       }
     })
 
-    app.get("/export/:course_slug/:format", async (req, res) => {
+    // Export endpoint (POST) - supports both SCORM and EPUB
+    app.post("/export/:course_slug/:format", async (req, res) => {
       const { course_slug, format } = req.params
-      const { language } = req.query
+      const { language = "en", metadata } = req.body
 
       try {
         let outputPath: string
@@ -1969,18 +1970,38 @@ export default class ServeCommand extends SessionCommand {
           })
           filename = `${course_slug}-scorm.zip`
         } else if (format === "epub") {
-          outputPath = await exportToEpub({
-            courseSlug: course_slug,
-            format: "epub",
-            bucket,
-            outDir: path.join(__dirname, "../output/directory"),
-            language: (language as string) || "en",
-          })
+          console.log("EPUB export", metadata)
+          // Validate required metadata for EPUB
+          if (
+            !metadata ||
+            !metadata.creator ||
+            !metadata.publisher ||
+            !metadata.title ||
+            !metadata.rights ||
+            !metadata.lang
+          ) {
+            console.log("Missing required metadata for EPUB export", metadata)
+            return res.status(400).json({
+              error: "Missing required metadata for EPUB export",
+              required: ["creator", "publisher", "title", "rights", "lang"],
+            })
+          }
+
+          outputPath = await exportToEpub(
+            {
+              courseSlug: course_slug,
+              format: "epub",
+              bucket,
+              outDir: path.join(__dirname, "../output/directory"),
+              language: language,
+            },
+            metadata
+          )
           filename = `${course_slug}.epub`
         } else {
-          return res
-            .status(400)
-            .json({ error: "Invalid format. Supported formats: scorm, epub" })
+          return res.status(400).json({
+            error: "Invalid format. Supported formats: scorm, epub",
+          })
         }
 
         // Send the file and clean up
@@ -1989,6 +2010,12 @@ export default class ServeCommand extends SessionCommand {
           // Clean up the generated file
           if (fs.existsSync(outputPath)) {
             fs.unlinkSync(outputPath)
+            if (format === "epub") {
+              const tempDir = path.dirname(outputPath)
+              if (fs.existsSync(tempDir)) {
+                rimraf.sync(tempDir)
+              }
+            }
           }
         })
       } catch (error: any) {

package/src/output/directory/04bedc40-a091-4bda-96e5-c71677655944/exercises/00.0-welcome-to-avatar-creation-with-heygen/README.es.md

@@ -0,0 +1,23 @@
+---
+tiempoDeLectura:
+  minutos: 1
+  palabras: 225
+fkglResultado: 11.55
+---
+
+# `00.0` - Bienvenido a la Creación de Avatares con HeyGen
+
+¡Hola, futuro creador de avatares! 🎉 ¿Estás listo para adentrarte en el emocionante mundo de la creación de videos impulsados por IA? En solo 30 minutos, te embarcarás en un viaje para crear tu propio avatar digital usando HeyGen, una plataforma de vanguardia que hace que la producción de videos sea divertida y accesible. Ya seas creador de contenido, educador o simplemente tengas curiosidad por las herramientas de IA, este curso es tu puerta de entrada para crear videos atractivos y personalizados con facilidad.
+
+Esto es lo que lograrás: comprender los conceptos básicos de HeyGen, configurar tu cuenta, crear un avatar único y producir tu primer video. Este curso está estructurado en módulos breves para guiarte paso a paso. ¡Vamos a sumergirnos y desatar tu creatividad—haz clic para comenzar!
+
+### Lo que aprenderás en este curso
+- **Conceptos básicos de HeyGen**: Familiarízate con la plataforma y sus potentes funciones.
+- **Creación de avatares**: Construye una versión digital de ti mismo o un personaje personalizado.
+- **Producción de videos**: Usa tu avatar para crear videos de aspecto profesional sin esfuerzo.
+- **Exploración**: Descubre herramientas adicionales para mejorar tu contenido.
+
+### ¿Por qué HeyGen?
+HeyGen simplifica la creación de videos aprovechando la IA, ahorrándote tiempo y recursos mientras ofrece resultados de alta calidad. Perfecto para principiantes, esta herramienta abre un sinfín de posibilidades para contar historias y comunicarte.
+
+No esperemos más—continúa a la siguiente lección para explorar HeyGen y comenzar tu aventura creando avatares.