@learnpack/learnpack 5.0.324 → 5.0.327

package/lib/commands/serve.js

@@ -33,6 +33,7 @@ const sidebarGenerator_1 = require("../utils/sidebarGenerator");
 const publish_1 = require("./publish");
 const export_1 = require("../utils/export");
 const errorHandler_1 = require("../utils/errorHandler");
+const jsdom_1 = require("jsdom");
 const frontMatter = require("front-matter");
 if (process.env.NEW_RELIC_ENABLED === "true") {
     require("newrelic");
@@ -358,6 +359,43 @@ async function updateLessonStatusToError(courseSlug, lessonUID, bucket) {
         console.error(`Error updating lesson ${lessonUID} status to ERROR:`, error);
     }
 }
+async function updateLessonStatusToDone(courseSlug, exerciseSlug, bucket) {
+    try {
+        const syllabus = await getSyllabus(courseSlug, bucket);
+        const lessonIndex = syllabus.lessons.findIndex(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === exerciseSlug);
+        if (lessonIndex === -1) {
+            throw new errorHandler_1.NotFoundError(`Lesson with slug "${exerciseSlug}" not found in course "${courseSlug}"`);
+        }
+        const lesson = syllabus.lessons[lessonIndex];
+        // Update lesson status to DONE
+        lesson.status = "DONE";
+        lesson.generated = true;
+        // Update translations to mark as completed
+        const currentTranslations = lesson.translations || {};
+        const language = syllabus.courseInfo.language || "en";
+        if (currentTranslations[language]) {
+            currentTranslations[language].completedAt = Date.now();
+            // Clear error flag if it existed
+            if (currentTranslations[language].error) {
+                delete currentTranslations[language].error;
+            }
+        }
+        else {
+            currentTranslations[language] = {
+                completionId: 0,
+                startedAt: Date.now(),
+                completedAt: Date.now(),
+            };
+        }
+        lesson.translations = currentTranslations;
+        await saveSyllabus(courseSlug, syllabus, bucket);
+        console.log(`Updated lesson ${exerciseSlug} status to DONE in course ${courseSlug}`);
+    }
+    catch (error) {
+        console.error(`Error updating lesson ${exerciseSlug} status to DONE:`, error);
+        throw error;
+    }
+}
 async function continueWithNextLesson(courseSlug, currentExerciseIndex, rigoToken, finalContent, bucket) {
     const syllabus = await getSyllabus(courseSlug, bucket);
     const nextExercise = syllabus.lessons[currentExerciseIndex + 1] || null;
@@ -428,6 +466,125 @@ const getTitleFromHTML = (html) => {
     const titleMatch = html.match(titleRegex);
     return titleMatch ? titleMatch[1] : null;
 };
+async function processSyncTranslationsSequentially(courseSlug, exerciseSlug, notificationId, sourceReadmeContent, targetLanguages, rigoToken, bucket) {
+    var _a, _b, _c, _d, _e, _f;
+    try {
+        // Process translations sequentially (no race conditions)
+        for (const targetLang of targetLanguages) {
+            try {
+                // Call Rigobot directly with synchronous execution (no webhook needed)
+                // eslint-disable-next-line no-await-in-loop
+                const response = await axios_1.default.post(`${api_1.RIGOBOT_HOST}/v1/prompting/completion/translate-asset-markdown/`, {
+                    inputs: {
+                        text_to_translate: sourceReadmeContent,
+                        output_language: targetLang,
+                    },
+                    include_purpose_objective: false,
+                    execute_async: false, // Synchronous execution
+                }, {
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: "Token " + rigoToken,
+                    },
+                });
+                const translationResult = response.data;
+                // Check if translation was successful
+                if (!((_a = translationResult.parsed) === null || _a === void 0 ? void 0 : _a.translation)) {
+                    throw new Error("Translation result is empty");
+                }
+                // Save translated README
+                const readmePath = `courses/${courseSlug}/exercises/${exerciseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(targetLang)}`;
+                // eslint-disable-next-line no-await-in-loop
+                await bucket
+                    .file(readmePath)
+                    .save(translationResult.parsed.translation);
+                // Update progress in syllabus
+                // eslint-disable-next-line no-await-in-loop
+                const syllabus = await getSyllabus(courseSlug, bucket);
+                const lessonIndex = syllabus.lessons.findIndex(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === exerciseSlug);
+                if (lessonIndex !== -1) {
+                    const lesson = syllabus.lessons[lessonIndex];
+                    const notification = (_b = lesson.syncNotifications) === null || _b === void 0 ? void 0 : _b.find(n => n.id === notificationId);
+                    if (notification === null || notification === void 0 ? void 0 : notification.syncProgress) {
+                        notification.syncProgress.completedLanguages.push(targetLang);
+                        notification.processingLastUpdate = Date.now();
+                        const progress = notification.syncProgress.completedLanguages.length;
+                        const total = notification.syncProgress.totalLanguages;
+                        console.log(`🔄 SYNC: Progress ${progress}/${total} - Completed: [${notification.syncProgress.completedLanguages.join(", ")}]`);
+                        // eslint-disable-next-line no-await-in-loop
+                        await saveSyllabus(courseSlug, syllabus, bucket);
+                        // Emit progress event
+                        (0, creatorSocket_1.emitToCourse)(courseSlug, "sync-notification-progress", {
+                            exerciseSlug,
+                            notificationId,
+                            completed: progress,
+                            total,
+                        });
+                    }
+                }
+            }
+            catch (langError) {
+                // Translation failed for this language
+                console.error(`🔄 SYNC ERROR: Translation failed for ${targetLang}:`, langError);
+                // Update syllabus with failed language
+                // eslint-disable-next-line no-await-in-loop
+                const syllabus = await getSyllabus(courseSlug, bucket);
+                const lessonIndex = syllabus.lessons.findIndex(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === exerciseSlug);
+                if (lessonIndex !== -1) {
+                    const lesson = syllabus.lessons[lessonIndex];
+                    const notification = (_c = lesson.syncNotifications) === null || _c === void 0 ? void 0 : _c.find(n => n.id === notificationId);
+                    if (notification === null || notification === void 0 ? void 0 : notification.syncProgress) {
+                        if (!notification.syncProgress.failedLanguages) {
+                            notification.syncProgress.failedLanguages = [];
+                        }
+                        notification.syncProgress.failedLanguages.push({
+                            code: targetLang,
+                            error: langError.message,
+                        });
+                        // eslint-disable-next-line no-await-in-loop
+                        await saveSyllabus(courseSlug, syllabus, bucket);
+                        (0, creatorSocket_1.emitToCourse)(courseSlug, "sync-notification-language-failed", {
+                            exerciseSlug,
+                            notificationId,
+                            language: targetLang,
+                            error: langError.message,
+                        });
+                    }
+                }
+            }
+        }
+        // All translations processed - check final status
+        const syllabus = await getSyllabus(courseSlug, bucket);
+        const lessonIndex = syllabus.lessons.findIndex(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === exerciseSlug);
+        if (lessonIndex !== -1) {
+            const lesson = syllabus.lessons[lessonIndex];
+            const notification = (_d = lesson.syncNotifications) === null || _d === void 0 ? void 0 : _d.find(n => n.id === notificationId);
+            if (notification === null || notification === void 0 ? void 0 : notification.syncProgress) {
+                const totalProcessed = notification.syncProgress.completedLanguages.length +
+                    (((_e = notification.syncProgress.failedLanguages) === null || _e === void 0 ? void 0 : _e.length) || 0);
+                if (totalProcessed === notification.syncProgress.totalLanguages) {
+                    notification.status =
+                        notification.syncProgress.completedLanguages.length === 0 ?
+                            "error" :
+                            "completed";
+                    await saveSyllabus(courseSlug, syllabus, bucket);
+                    console.log(`🔄 SYNC: ✅ All translations completed for ${exerciseSlug} - Status: ${notification.status}`);
+                    (0, creatorSocket_1.emitToCourse)(courseSlug, "sync-notification-completed", {
+                        exerciseSlug,
+                        notificationId,
+                        status: notification.status,
+                        completed: notification.syncProgress.completedLanguages.length,
+                        failed: ((_f = notification.syncProgress.failedLanguages) === null || _f === void 0 ? void 0 : _f.length) || 0,
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error("🔄 SYNC ERROR: Critical error in processSyncTranslationsSequentially:", error);
+        throw error;
+    }
+}
 class ServeCommand extends SessionCommand_1.default {
     async init() {
         const { flags } = this.parse(ServeCommand);
@@ -502,6 +659,43 @@ class ServeCommand extends SessionCommand_1.default {
             stream.end(buffer);
         });
         const upload = (0, misc_1.createUploadMiddleware)();
+        // Initialize DOMPurify for SVG sanitization
+        // eslint-disable-next-line
+        const createDOMPurify = require("isomorphic-dompurify");
+        const window = new jsdom_1.JSDOM("").window;
+        const DOMPurify = createDOMPurify(window);
+        const sanitizeSVGBuffer = (buffer) => {
+            try {
+                const svgContent = buffer.toString("utf-8");
+                const config = {
+                    USE_PROFILES: { svg: true, svgFilters: true },
+                    FORBID_TAGS: ["script", "iframe", "embed", "object", "foreignObject"],
+                    FORBID_ATTR: [
+                        "onerror",
+                        "onload",
+                        "onclick",
+                        "onmouseover",
+                        "onmouseout",
+                        "onanimationend",
+                        "onanimationstart",
+                        "ontransitionend",
+                        "onfocus",
+                        "onblur",
+                    ],
+                    ALLOW_DATA_ATTR: false, // Block data-* attributes that might contain code
+                };
+                const sanitized = DOMPurify.sanitize(svgContent, config);
+                // Validate that sanitization didn't remove all content
+                if (!sanitized || sanitized.trim().length === 0) {
+                    throw new Error("SVG file is invalid or empty after sanitization");
+                }
+                return buffer_1.Buffer.from(sanitized, "utf-8");
+            }
+            catch (error) {
+                console.error("Error sanitizing SVG:", error);
+                throw new Error(`SVG sanitization failed: ${error.message}`);
+            }
+        };
         app.post("/upload-image-file", upload.single("file"), async (req, res) => {
             console.log("INFO: Uploading image file");
             const destination = req.body.destination;
@@ -515,13 +709,36 @@ class ServeCommand extends SessionCommand_1.default {
             try {
                 // eslint-disable-next-line
                 // @ts-ignore
-                const fileData = req.file.buffer;
+                let fileData = req.file.buffer;
+                // Sanitize if it's an SVG file
+                // eslint-disable-next-line
+                // @ts-ignore
+                if (
+                // eslint-disable-next-line
+                // @ts-ignore
+                req.file.mimetype === "image/svg+xml" ||
+                    destination.toLowerCase().endsWith(".svg")) {
+                    try {
+                        fileData = sanitizeSVGBuffer(fileData);
+                        console.log("INFO: SVG file sanitized successfully");
+                    }
+                    catch (sanitizeError) {
+                        console.error("Error sanitizing SVG:", sanitizeError);
+                        return res.status(400).json({
+                            error: "Invalid SVG file or sanitization failed",
+                        });
+                    }
+                }
                 const file = bucket.file(destination);
                 await file.save(fileData, {
                     resumable: false,
                     // eslint-disable-next-line
                     // @ts-ignore
                     contentType: req.file.mimetype,
+                    metadata: {
+                        cacheControl: "public, max-age=31536000",
+                        contentDisposition: "inline",
+                    },
                 });
                 console.log(`INFO: Image uploaded to ${file.name}`);
                 res.json({ message: "Image uploaded successfully", path: file.name });
@@ -1286,18 +1503,129 @@ class ServeCommand extends SessionCommand_1.default {
         });
         // The following endpoint is used to store an incoming translation where it supposed to be
         app.post("/webhooks/:courseSlug/:exSlug/save-translation", async (req, res) => {
+            var _a, _b, _c, _d;
             const { courseSlug, exSlug } = req.params;
             const body = req.body;
             console.log("RECEIVING TRANSLATION WEBHOOK", body);
-            const readmePath = `courses/${courseSlug}/exercises/${exSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(body.parsed.output_language_code)}`;
-            await uploadFileToBucket(bucket, body.parsed.translation, readmePath);
-            (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-completed", {
-                exercise: exSlug,
-                language: body.parsed.output_language_code,
-                status: "completed",
-                message: `Translation completed for ${exSlug} to ${body.parsed.output_language_code}`,
-            });
-            res.json({ status: "SUCCESS" });
+            try {
+                // Check if there's an error from Rigobot
+                if (body.error || body.status === "ERROR") {
+                    console.error("Translation failed for", exSlug, body.error);
+                    const language = ((_a = body.parsed) === null || _a === void 0 ? void 0 : _a.output_language_code) || body.language;
+                    // Update syllabus with error status
+                    if (language) {
+                        try {
+                            const syllabus = await getSyllabus(courseSlug, bucket);
+                            const lessonIndex = syllabus.lessons.findIndex(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === exSlug);
+                            if (lessonIndex !== -1) {
+                                const lesson = syllabus.lessons[lessonIndex];
+                                if (!lesson.translations) {
+                                    lesson.translations = {};
+                                }
+                                if (lesson.translations[language]) {
+                                    lesson.translations[language].completedAt = Date.now();
+                                    lesson.translations[language].error = true;
+                                }
+                                else {
+                                    // Create entry if it doesn't exist
+                                    lesson.translations[language] = {
+                                        completionId: 0,
+                                        startedAt: Date.now(),
+                                        completedAt: Date.now(),
+                                        error: true,
+                                    };
+                                }
+                            }
+                            await saveSyllabus(courseSlug, syllabus, bucket);
+                        }
+                        catch (syllabusError) {
+                            console.error("Error updating syllabus with error status:", syllabusError);
+                        }
+                    }
+                    // Notify frontend via WebSocket
+                    (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-error", {
+                        exercise: exSlug,
+                        language: language,
+                        error: body.error || "Translation failed",
+                    });
+                    return res.status(500).json({ status: "ERROR", error: body.error });
+                }
+                // Validate required data
+                if (!((_b = body.parsed) === null || _b === void 0 ? void 0 : _b.translation) || !((_c = body.parsed) === null || _c === void 0 ? void 0 : _c.output_language_code)) {
+                    console.error("Missing required translation data", body);
+                    return res.status(400).json({
+                        status: "ERROR",
+                        error: "Missing translation or language code",
+                    });
+                }
+                // Translation successful
+                const readmePath = `courses/${courseSlug}/exercises/${exSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(body.parsed.output_language_code)}`;
+                await uploadFileToBucket(bucket, body.parsed.translation, readmePath);
+                // Verify file exists before updating syllabus (resilience: ensure file was actually saved)
+                const [fileExists] = await bucket.file(readmePath).exists();
+                // Update syllabus with completed status only if file was successfully saved
+                if (fileExists) {
+                    try {
+                        const syllabus = await getSyllabus(courseSlug, bucket);
+                        const lessonIndex = syllabus.lessons.findIndex(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === exSlug);
+                        if (lessonIndex !== -1) {
+                            const lesson = syllabus.lessons[lessonIndex];
+                            const language = body.parsed.output_language_code;
+                            if (!lesson.translations) {
+                                lesson.translations = {};
+                            }
+                            if (lesson.translations[language]) {
+                                lesson.translations[language].completedAt = Date.now();
+                                // Clear error flag if it existed
+                                if (lesson.translations[language].error) {
+                                    delete lesson.translations[language].error;
+                                }
+                            }
+                            else {
+                                // Create entry if it doesn't exist
+                                lesson.translations[language] = {
+                                    completionId: 0,
+                                    startedAt: Date.now(),
+                                    completedAt: Date.now(),
+                                };
+                            }
+                        }
+                        await saveSyllabus(courseSlug, syllabus, bucket);
+                    }
+                    catch (syllabusError) {
+                        console.error("Error updating syllabus with completed status:", syllabusError);
+                        // File exists but syllabus update failed - frontend will detect file and mark as complete
+                    }
+                    // Notify frontend via WebSocket ONLY if file exists
+                    (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-completed", {
+                        exercise: exSlug,
+                        language: body.parsed.output_language_code,
+                    });
+                }
+                else {
+                    console.error(`File ${readmePath} was not found after upload, skipping syllabus update`);
+                    // File upload failed - emit error event instead of success
+                    (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-error", {
+                        exercise: exSlug,
+                        language: body.parsed.output_language_code,
+                        error: "File upload verification failed",
+                    });
+                }
+                res.json({ status: "SUCCESS" });
+            }
+            catch (error) {
+                console.error("Error processing translation webhook:", error);
+                // Notify frontend of error
+                const language = ((_d = body.parsed) === null || _d === void 0 ? void 0 : _d.output_language_code) || body.language || "unknown";
+                (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-error", {
+                    exercise: exSlug,
+                    language: language,
+                    error: error.message,
+                });
+                res
+                    .status(500)
+                    .json({ status: "ERROR", error: error.message });
+            }
         });
         app.get("/check-preview-image/:slug", async (req, res) => {
             const { slug } = req.params;
@@ -1340,6 +1668,10 @@ class ServeCommand extends SessionCommand_1.default {
             const file = path.resolve(__dirname, "../ui/_app/index.html");
             res.sendFile(file);
         });
+        app.get("/preview/:slug/webview", async (req, res) => {
+            const file = path.resolve(__dirname, "../ui/_app/index.html");
+            res.sendFile(file);
+        });
         app.get("/config", async (req, res) => {
             const courseSlug = req.query.slug;
             // GEt the x-rigo-token
@@ -1408,6 +1740,7 @@ class ServeCommand extends SessionCommand_1.default {
             }
         });
         app.get("/.learn/assets/:file", async (req, res) => {
+            var _a;
             console.log("GET /.learn/assets/:file", req.params.file);
             const { file } = req.params;
             const courseSlug = req.query.slug;
@@ -1420,9 +1753,34 @@ class ServeCommand extends SessionCommand_1.default {
             if (!exists) {
                 return res.status(404).send("File not found");
             }
+            // Determine Content-Type based on file extension
+            const ext = (_a = file.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            let contentType = "application/octet-stream";
+            let contentDisposition = `inline; filename="${file}"`; // inline for images
+            switch (ext) {
+                case "svg":
+                    contentType = "image/svg+xml";
+                    break;
+                case "jpg":
+                case "jpeg":
+                    contentType = "image/jpeg";
+                    break;
+                case "png":
+                    contentType = "image/png";
+                    break;
+                case "gif":
+                    contentType = "image/gif";
+                    break;
+                case "webp":
+                    contentType = "image/webp";
+                    break;
+                default:
+                    // For non-image files, use attachment to force download
+                    contentDisposition = `attachment; filename="${file}"`;
+            }
             const fileStream = fileRef.createReadStream();
-            res.set("Content-Type", "application/octet-stream");
-            res.set("Content-Disposition", `attachment; filename="${file}"`);
+            res.set("Content-Type", contentType);
+            res.set("Content-Disposition", contentDisposition);
             fileStream.pipe(res);
         });
         app.put("/exercise/:slug/file/:fileName", express.text(), (0, errorHandler_1.asyncHandler)(async (req, res) => {
@@ -1540,6 +1898,17 @@ class ServeCommand extends SessionCommand_1.default {
         });
         async function processTranslationsAsync(courseSlug, exerciseSlugs, languageCodes, rigoToken, currentLanguage, bucket) {
             try {
+                // Track which languages already exist vs which are being translated
+                const existingLanguages = new Set();
+                const translatingLanguages = new Set();
+                // Get syllabus to track translation status
+                let syllabus = null;
+                try {
+                    syllabus = await getSyllabus(courseSlug, bucket);
+                }
+                catch (_a) {
+                    console.log("Syllabus not found, translations will not be tracked in syllabus");
+                }
                 (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-started", {
                     languages: languageCodes,
                     exercises: exerciseSlugs,
@@ -1548,12 +1917,21 @@ class ServeCommand extends SessionCommand_1.default {
                 });
                 await Promise.all(exerciseSlugs.map(async (slug) => {
                     const readmePath = `courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(currentLanguage)}`;
-                    const readme = await bucket.file(readmePath).download();
+                    // Validate that README exists before attempting translation
+                    const readmeFile = bucket.file(readmePath);
+                    const [readmeExists] = await readmeFile.exists();
+                    if (!readmeExists) {
+                        console.error(`README not found for exercise ${slug} in language ${currentLanguage}`);
+                        return; // Skip this exercise
+                    }
+                    const [readmeBuffer] = await readmeFile.download();
+                    const readme = readmeBuffer.toString();
                     await Promise.all(languageCodes.map(async (language) => {
                         const translationPath = `courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(language)}`;
                         const [exists] = await bucket.file(translationPath).exists();
                         if (exists) {
                             console.log(`Translation in ${language} already exists for exercise ${slug}`);
+                            existingLanguages.add(language);
                             (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-progress", {
                                 exercise: slug,
                                 language: language,
@@ -1562,10 +1940,29 @@ class ServeCommand extends SessionCommand_1.default {
                             });
                             return;
                         }
-                        await (0, rigoActions_1.translateExercise)(rigoToken, {
-                            text_to_translate: readme.toString(),
+                        // Call translateExercise first to get the real completion ID
+                        const translateResponse = await (0, rigoActions_1.translateExercise)(rigoToken, {
+                            text_to_translate: readme,
                             output_language: language,
                         }, `${process.env.HOST}/webhooks/${courseSlug}/${slug}/save-translation`);
+                        // Mark this language as being translated
+                        translatingLanguages.add(language);
+                        // Update syllabus with translation status if available
+                        if (syllabus) {
+                            const lessonIndex = syllabus.lessons.findIndex(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === slug);
+                            if (lessonIndex !== -1) {
+                                const lesson = syllabus.lessons[lessonIndex];
+                                if (!lesson.translations) {
+                                    lesson.translations = {};
+                                }
+                                // Use the real completion ID from the response, fallback to Date.now() if not available
+                                lesson.translations[language] = {
+                                    completionId: (translateResponse === null || translateResponse === void 0 ? void 0 : translateResponse.id) || Date.now(),
+                                    startedAt: Date.now(),
+                                    completedAt: undefined,
+                                };
+                            }
+                        }
                         (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-progress", {
                             exercise: slug,
                             language: language,
@@ -1574,6 +1971,10 @@ class ServeCommand extends SessionCommand_1.default {
                         });
                     }));
                 }));
+                // Save syllabus with translation status
+                if (syllabus && courseSlug) {
+                    await saveSyllabus(courseSlug, syllabus, bucket);
+                }
                 const course = await bucket
                     .file(`courses/${courseSlug}/learn.json`)
                     .download();
@@ -1658,21 +2059,379 @@ class ServeCommand extends SessionCommand_1.default {
                     raw_languages: languagesToTranslate.join(","),
                 });
                 const languageCodes = languageCodesRes.parsed.language_codes;
+                // Pre-calculate which languages already exist vs which need translation
+                // This provides immediate, accurate feedback to the frontend
+                const existingLanguages = new Set();
+                const translatingLanguages = new Set();
+                // Quick check: for each language, check if ALL exercises already have that translation
+                await Promise.all(languageCodes.map(async (language) => {
+                    const allExist = await Promise.all(exerciseSlugs.map(async (slug) => {
+                        const translationPath = `courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(language)}`;
+                        const [exists] = await bucket.file(translationPath).exists();
+                        return exists;
+                    }));
+                    // If all exercises have this language, mark as existing
+                    if (allExist.every(exists => exists)) {
+                        existingLanguages.add(language);
+                    }
+                    else {
+                        // Otherwise, it will be translated
+                        translatingLanguages.add(language);
+                    }
+                }));
+                // Convert Sets to Arrays for JSON response
+                const translatingLanguagesList = [...translatingLanguages];
+                const existingLanguagesList = [...existingLanguages];
                 res.status(200).json({
                     message: "Translation started",
                     languages: languageCodes,
                     exercises: exerciseSlugs,
                     status: "processing",
+                    translatingLanguages: translatingLanguagesList,
+                    existingLanguages: existingLanguagesList,
                 });
-                processTranslationsAsync(courseSlug, exerciseSlugs, languageCodes, rigoToken, currentLanguage, bucket).catch(error => {
-                    console.error("Error in background translation processing:", error);
-                });
+                // Only process translations if there are languages to translate
+                if (translatingLanguagesList.length > 0) {
+                    processTranslationsAsync(courseSlug, exerciseSlugs, languageCodes, rigoToken, currentLanguage, bucket).catch(error => {
+                        console.error("Error in background translation processing:", error);
+                    });
+                }
             }
             catch (error) {
                 console.log(error, "ERROR");
                 return res.status(400).json({ error: error.message });
             }
         });
+        // ============================================
+        // SYNC NOTIFICATIONS ENDPOINTS
+        // ============================================
+        // Create or update sync notification
+        app.post("/courses/:courseSlug/lessons/:exerciseSlug/sync-notification", express.json(), async (req, res) => {
+            console.log("POST /courses/:courseSlug/lessons/:exerciseSlug/sync-notification");
+            const { courseSlug, exerciseSlug } = req.params;
+            const { sourceLanguage } = req.body;
+            try {
+                if (!courseSlug || !exerciseSlug || !sourceLanguage) {
+                    return res.status(400).json({
+                        error: "Missing required parameters",
+                        code: "MISSING_PARAMETERS",
+                    });
+                }
+                const syllabus = await getSyllabus(courseSlug, bucket);
+                if (!syllabus) {
+                    return res.status(404).json({
+                        error: "Syllabus not found",
+                        code: "SYLLABUS_NOT_FOUND",
+                    });
+                }
+                // Find lesson
+                const lessonIndex = syllabus.lessons.findIndex(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === exerciseSlug);
+                if (lessonIndex === -1) {
+                    return res.status(404).json({
+                        error: "Lesson not found",
+                        code: "LESSON_NOT_FOUND",
+                    });
+                }
+                const lesson = syllabus.lessons[lessonIndex];
+                // Verify source README exists
+                const readmePath = `courses/${courseSlug}/exercises/${exerciseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(sourceLanguage)}`;
+                const [readmeExists] = await bucket.file(readmePath).exists();
+                if (!readmeExists) {
+                    return res.status(404).json({
+                        error: "Source README not found",
+                        code: "SOURCE_README_NOT_FOUND",
+                        details: { sourceLanguage, path: readmePath },
+                    });
+                }
+                if (!lesson.syncNotifications) {
+                    lesson.syncNotifications = [];
+                }
+                // Find existing notification for this language in pending status
+                const existingNotification = lesson.syncNotifications.find(n => n.sourceLanguage === sourceLanguage && n.status === "pending");
+                let notificationToReturn;
+                if (existingNotification) {
+                    // Update timestamp of existing notification
+                    existingNotification.updatedAt = Date.now();
+                    notificationToReturn = existingNotification;
+                }
+                else {
+                    const newNotification = {
+                        id: String(Date.now()),
+                        sourceLanguage,
+                        createdAt: Date.now(),
+                        updatedAt: Date.now(),
+                        status: "pending",
+                    };
+                    lesson.syncNotifications.push(newNotification);
+                    notificationToReturn = newNotification;
+                }
+                await saveSyllabus(courseSlug, syllabus, bucket);
+                (0, creatorSocket_1.emitToCourse)(courseSlug, "sync-notification-created", {
+                    exerciseSlug,
+                    sourceLanguage,
+                    notificationId: notificationToReturn.id,
+                });
+                res.json({
+                    status: "SUCCESS",
+                    notification: notificationToReturn,
+                });
+            }
+            catch (error) {
+                console.error("Error creating sync notification:", error);
+                res.status(500).json({
+                    error: "Internal server error",
+                    code: "INTERNAL_ERROR",
+                    message: error.message,
+                });
+            }
+        });
+        // Get all sync notifications for a course
+        app.get("/courses/:courseSlug/sync-notifications", async (req, res) => {
+            console.log("GET /courses/:courseSlug/sync-notifications");
+            try {
+                const { courseSlug } = req.params;
+                if (!courseSlug) {
+                    return res.status(400).json({ error: "Course slug is required" });
+                }
+                const syllabus = await getSyllabus(courseSlug, bucket);
+                if (!syllabus) {
+                    return res.status(404).json({ error: "Syllabus not found" });
+                }
+                const PROCESSING_TIMEOUT = 3 * 60 * 1000; // 3 minutes
+                let modified = false;
+                // Collect active notifications (pending, processing, or error)
+                const notifications = [];
+                for (const lesson of syllabus.lessons) {
+                    if (lesson.syncNotifications && lesson.syncNotifications.length > 0) {
+                        for (const notification of lesson.syncNotifications) {
+                            // Check for timeout in processing notifications
+                            if (notification.status === "processing") {
+                                // Use processingLastUpdate if available, otherwise fallback to updatedAt
+                                const processingLastUpdateTime = notification.processingLastUpdate || notification.updatedAt;
+                                const timeSinceProcessingStarted = Date.now() - processingLastUpdateTime;
+                                if (timeSinceProcessingStarted > PROCESSING_TIMEOUT) {
+                                    notification.status = "error";
+                                    notification.error = {
+                                        message: "Synchronization timeout - process took too long",
+                                        code: "PROCESSING_TIMEOUT",
+                                        timestamp: Date.now(),
+                                    };
+                                    modified = true;
+                                    // Emit error event
+                                    (0, creatorSocket_1.emitToCourse)(courseSlug, "sync-notification-error", {
+                                        exerciseSlug: (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title),
+                                        notificationId: notification.id,
+                                        error: "Processing timeout",
+                                    });
+                                }
+                            }
+                            // Include active notifications (pending, processing, or error)
+                            if (notification.status === "pending" ||
+                                notification.status === "processing" ||
+                                notification.status === "error") {
+                                notifications.push(Object.assign(Object.assign({}, notification), { lessonSlug: (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title), lessonTitle: lesson.title }));
+                            }
+                        }
+                    }
+                }
+                // Save syllabus if any notification was modified
+                if (modified) {
+                    await saveSyllabus(courseSlug, syllabus, bucket);
+                }
+                res.json({ notifications });
+            }
+            catch (error) {
+                console.error("Error fetching sync notifications:", error);
+                res.status(500).json({
+                    error: "Error fetching sync notifications",
+                    message: error.message,
+                });
+            }
+        });
+        // Dismiss sync notification
+        app.delete("/courses/:courseSlug/lessons/:lessonSlug/sync-notification/:notificationId", async (req, res) => {
+            console.log("DELETE /courses/:courseSlug/lessons/:lessonSlug/sync-notification/:notificationId");
+            try {
+                const { courseSlug, lessonSlug, notificationId } = req.params;
+                if (!courseSlug || !lessonSlug || !notificationId) {
+                    return res
+                        .status(400)
+                        .json({ error: "Missing required parameters" });
+                }
+                const syllabus = await getSyllabus(courseSlug, bucket);
+                if (!syllabus) {
+                    return res.status(404).json({ error: "Syllabus not found" });
+                }
+                // Find lesson
+                const lessonIndex = syllabus.lessons.findIndex(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === lessonSlug);
+                if (lessonIndex === -1) {
+                    return res.status(404).json({ error: "Lesson not found" });
+                }
+                const lesson = syllabus.lessons[lessonIndex];
+                if (!lesson.syncNotifications ||
+                    lesson.syncNotifications.length === 0) {
+                    return res.status(404).json({ error: "Notification not found" });
+                }
+                const notificationExists = lesson.syncNotifications.some(n => n.id === notificationId);
+                if (!notificationExists) {
+                    return res.status(404).json({ error: "Notification not found" });
+                }
+                // Filter out the notification
+                lesson.syncNotifications = lesson.syncNotifications.filter(n => n.id !== notificationId);
+                await saveSyllabus(courseSlug, syllabus, bucket);
+                res.json({ status: "SUCCESS", message: "Notification dismissed" });
+            }
+            catch (error) {
+                console.error("Error dismissing notification:", error);
+                res.status(500).json({
+                    error: "Error dismissing notification",
+                    message: error.message,
+                });
+            }
+        });
+        // Accept sync notification and start synchronization
+        app.post("/courses/:courseSlug/lessons/:exerciseSlug/sync-notification/:notificationId/accept", express.json(), async (req, res) => {
+            var _a, _b;
+            console.log("POST /courses/:courseSlug/lessons/:exerciseSlug/sync-notification/:notificationId/accept");
+            const { courseSlug, exerciseSlug, notificationId } = req.params;
+            const rigoToken = req.header("x-rigo-token");
+            try {
+                if (!rigoToken) {
+                    return res.status(400).json({ error: "Rigo token not found" });
+                }
+                if (!courseSlug || !exerciseSlug || !notificationId) {
+                    return res
+                        .status(400)
+                        .json({ error: "Missing required parameters" });
+                }
+                const syllabus = await getSyllabus(courseSlug, bucket);
+                if (!syllabus) {
+                    return res.status(404).json({ error: "Syllabus not found" });
+                }
+                // Find lesson
+                const lessonIndex = syllabus.lessons.findIndex(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === exerciseSlug);
+                if (lessonIndex === -1) {
+                    return res.status(404).json({ error: "Lesson not found" });
+                }
+                const lesson = syllabus.lessons[lessonIndex];
+                // Find notification
+                const notification = (_a = lesson.syncNotifications) === null || _a === void 0 ? void 0 : _a.find(n => n.id === notificationId);
+                if (!notification) {
+                    return res.status(404).json({ error: "Notification not found" });
+                }
+                if (notification.status !== "pending") {
+                    return res.status(400).json({
+                        error: "Notification is not pending",
+                        currentStatus: notification.status,
+                    });
+                }
+                // Get source README
+                const sourceReadmePath = `courses/${courseSlug}/exercises/${exerciseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(notification.sourceLanguage)}`;
+                let sourceReadmeContent;
+                try {
+                    const [content] = await bucket.file(sourceReadmePath).download();
+                    sourceReadmeContent = content.toString();
+                }
+                catch (error) {
+                    console.error("Source README not found:", error);
+                    return res.status(404).json({
+                        error: "Source README not found or inaccessible",
+                        code: "SOURCE_README_ERROR",
+                    });
+                }
+                // Determine target languages
+                const availableLanguages = Object.keys(lesson.translations || {});
+                const targetLanguages = availableLanguages.filter(lang => lang !== notification.sourceLanguage);
+                if (targetLanguages.length === 0) {
+                    return res.status(400).json({
+                        error: "No target languages found",
+                        code: "NO_TARGET_LANGUAGES",
+                    });
+                }
+                // Remove all other notifications for this lesson
+                lesson.syncNotifications =
+                    ((_b = lesson.syncNotifications) === null || _b === void 0 ? void 0 : _b.filter(n => n.id === notificationId)) ||
+                        [];
+                notification.status = "processing";
+                notification.processingLastUpdate = Date.now();
+                notification.syncProgress = {
+                    totalLanguages: targetLanguages.length,
+                    completedLanguages: [], // Array of completed language codes
+                    failedLanguages: [],
+                };
+                await saveSyllabus(courseSlug, syllabus, bucket);
+                (0, creatorSocket_1.emitToCourse)(courseSlug, "sync-notification-started", {
+                    exerciseSlug,
+                    notificationId,
+                    totalLanguages: targetLanguages.length,
+                });
+                // Respond immediately
+                res.json({
+                    status: "PROCESSING",
+                    notificationId,
+                    targetLanguages: targetLanguages.length,
+                });
+                // Process translations sequentially (no race conditions)
+                processSyncTranslationsSequentially(courseSlug, exerciseSlug, notificationId, sourceReadmeContent, targetLanguages, rigoToken, bucket).catch(error => {
+                    console.error("Error in sync translation processing:", error);
+                    // Update notification with critical error
+                    getSyllabus(courseSlug, bucket).then(syl => {
+                        var _a;
+                        const les = syl.lessons.find(l => (0, creatorUtilities_2.slugify)(l.id + "-" + l.title) === exerciseSlug);
+                        const notif = (_a = les === null || les === void 0 ? void 0 : les.syncNotifications) === null || _a === void 0 ? void 0 : _a.find(n => n.id === notificationId);
+                        if (notif) {
+                            notif.status = "error";
+                            notif.error = {
+                                message: error.message,
+                                code: "CRITICAL_ERROR",
+                                timestamp: Date.now(),
+                            };
+                            saveSyllabus(courseSlug, syl, bucket);
+                            (0, creatorSocket_1.emitToCourse)(courseSlug, "sync-notification-error", {
+                                exerciseSlug,
+                                notificationId,
+                                error: error.message,
+                            });
+                        }
+                    });
+                });
+            }
+            catch (error) {
+                console.error("Error accepting sync notification:", error);
+                res.status(500).json({
+                    error: "Internal server error",
+                    message: error.message,
+                });
+            }
+        });
+        // Update lesson status to DONE
+        app.put("/courses/:courseSlug/lessons/:exerciseSlug/status", express.json(), (0, errorHandler_1.asyncHandler)(async (req, res) => {
+            console.log("PUT /courses/:courseSlug/lessons/:exerciseSlug/status");
+            const { courseSlug, exerciseSlug } = req.params;
+            const rigoToken = req.header("x-rigo-token");
+            if (!rigoToken) {
+                throw new errorHandler_1.ValidationError("Rigo token is required. x-rigo-token header is missing");
+            }
+            if (!courseSlug || !exerciseSlug) {
+                throw new errorHandler_1.ValidationError("Course slug and exercise slug are required");
+            }
+            // Verify authorization
+            const { isAuthor } = await (0, rigoActions_1.isPackageAuthor)(rigoToken, courseSlug);
+            if (!isAuthor) {
+                throw new errorHandler_1.ValidationError("You are not authorized to update lesson status for this course");
+            }
+            // Update lesson status to DONE
+            await updateLessonStatusToDone(courseSlug, exerciseSlug, bucket);
+            // Emit WebSocket event to notify frontend
+            (0, creatorSocket_1.emitToCourse)(courseSlug, "lesson-status-updated", {
+                exerciseSlug,
+                status: "DONE",
+            });
+            res.json({
+                status: "SUCCESS",
+                message: `Lesson ${exerciseSlug} status updated to DONE`,
+            });
+        }));
         app.delete("/exercise/:slug/delete", async (req, res) => {
             console.log("DELETE /exercise/:slug/delete");
             const { slug } = req.params;