@learnpack/learnpack 5.0.324 → 5.0.327

package/src/commands/serve.ts

@@ -58,7 +58,12 @@ import { buildConfig } from "../utils/configBuilder"
 import { checkReadability, slugify } from "../utils/creatorUtilities"
 import { checkAndFixSidebarPure } from "../utils/sidebarGenerator"
 import { handleAssetCreation } from "./publish"
-import { FormState, Lesson, Syllabus } from "../models/creator"
+import {
+  FormState,
+  Lesson,
+  Syllabus,
+  SyncNotification,
+} from "../models/creator"
 import { exportToScorm, exportToEpub, exportToZip } from "../utils/export"
 import {
   errorHandler,
@@ -69,6 +74,7 @@ import {
   InternalServerError,
   NotFoundError,
 } from "../utils/errorHandler"
+import { JSDOM } from "jsdom"
 
 const frontMatter = require("front-matter")
 
@@ -612,6 +618,62 @@ async function updateLessonStatusToError(
   }
 }
 
+async function updateLessonStatusToDone(
+  courseSlug: string,
+  exerciseSlug: string,
+  bucket: Bucket
+): Promise<void> {
+  try {
+    const syllabus = await getSyllabus(courseSlug, bucket)
+    const lessonIndex = syllabus.lessons.findIndex(
+      lesson => slugify(lesson.id + "-" + lesson.title) === exerciseSlug
+    )
+
+    if (lessonIndex === -1) {
+      throw new 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: string,
   currentExerciseIndex: number,
@@ -727,6 +789,186 @@ const getTitleFromHTML = (html: string) => {
   return titleMatch ? titleMatch[1] : null
 }
 
+async function processSyncTranslationsSequentially(
+  courseSlug: string,
+  exerciseSlug: string,
+  notificationId: string,
+  sourceReadmeContent: string,
+  targetLanguages: string[],
+  rigoToken: string,
+  bucket: Bucket
+) {
+  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.post(
+          `${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 (!translationResult.parsed?.translation) {
+          throw new Error("Translation result is empty")
+        }
+
+        // Save translated README
+        const readmePath = `courses/${courseSlug}/exercises/${exerciseSlug}/README${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 => slugify(lesson.id + "-" + lesson.title) === exerciseSlug
+        )
+
+        if (lessonIndex !== -1) {
+          const lesson = syllabus.lessons[lessonIndex]
+          const notification = lesson.syncNotifications?.find(
+            n => n.id === notificationId
+          )
+
+          if (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
+            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 => slugify(lesson.id + "-" + lesson.title) === exerciseSlug
+        )
+
+        if (lessonIndex !== -1) {
+          const lesson = syllabus.lessons[lessonIndex]
+          const notification = lesson.syncNotifications?.find(
+            n => n.id === notificationId
+          )
+
+          if (notification?.syncProgress) {
+            if (!notification.syncProgress.failedLanguages) {
+              notification.syncProgress.failedLanguages = []
+            }
+
+            notification.syncProgress.failedLanguages.push({
+              code: targetLang,
+              error: (langError as Error).message,
+            })
+
+            // eslint-disable-next-line no-await-in-loop
+            await saveSyllabus(courseSlug, syllabus, bucket)
+
+            emitToCourse(courseSlug, "sync-notification-language-failed", {
+              exerciseSlug,
+              notificationId,
+              language: targetLang,
+              error: (langError as Error).message,
+            })
+          }
+        }
+      }
+    }
+
+    // All translations processed - check final status
+    const syllabus = await getSyllabus(courseSlug, bucket)
+    const lessonIndex = syllabus.lessons.findIndex(
+      lesson => slugify(lesson.id + "-" + lesson.title) === exerciseSlug
+    )
+
+    if (lessonIndex !== -1) {
+      const lesson = syllabus.lessons[lessonIndex]
+      const notification = lesson.syncNotifications?.find(
+        n => n.id === notificationId
+      )
+
+      if (notification?.syncProgress) {
+        const totalProcessed =
+          notification.syncProgress.completedLanguages.length +
+          (notification.syncProgress.failedLanguages?.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}`
+          )
+
+          emitToCourse(courseSlug, "sync-notification-completed", {
+            exerciseSlug,
+            notificationId,
+            status: notification.status,
+            completed: notification.syncProgress.completedLanguages.length,
+            failed: notification.syncProgress.failedLanguages?.length || 0,
+          })
+        }
+      }
+    }
+  } catch (error) {
+    console.error(
+      "🔄 SYNC ERROR: Critical error in processSyncTranslationsSequentially:",
+      error
+    )
+    throw error
+  }
+}
+
 export default class ServeCommand extends SessionCommand {
   static description = "Runs a small server to build tutorials"
 
@@ -846,6 +1088,48 @@ export default class ServeCommand extends SessionCommand {
 
     const upload = createUploadMiddleware()
 
+    // Initialize DOMPurify for SVG sanitization
+    // eslint-disable-next-line
+    const createDOMPurify = require("isomorphic-dompurify");
+    const window = new JSDOM("").window
+    const DOMPurify = createDOMPurify(window)
+
+    const sanitizeSVGBuffer = (buffer: Buffer): 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.from(sanitized, "utf-8")
+      } catch (error) {
+        console.error("Error sanitizing SVG:", error)
+        throw new Error(`SVG sanitization failed: ${(error as Error).message}`)
+      }
+    }
+
     app.post("/upload-image-file", upload.single("file"), async (req, res) => {
       console.log("INFO: Uploading image file")
 
@@ -862,7 +1146,27 @@ export default class ServeCommand extends SessionCommand {
       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, {
@@ -870,6 +1174,10 @@ export default class ServeCommand extends SessionCommand {
           // 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}`)
@@ -1911,20 +2219,155 @@ export default class ServeCommand extends SessionCommand {
 
         console.log("RECEIVING TRANSLATION WEBHOOK", body)
 
-        const readmePath = `courses/${courseSlug}/exercises/${exSlug}/README${getReadmeExtension(
-          body.parsed.output_language_code
-        )}`
+        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 = body.parsed?.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 => slugify(lesson.id + "-" + lesson.title) === exSlug
+                )
 
-        await uploadFileToBucket(bucket, body.parsed.translation, readmePath)
+                if (lessonIndex !== -1) {
+                  const lesson = syllabus.lessons[lessonIndex]
 
-        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}`,
-        })
+                  if (!lesson.translations) {
+                    lesson.translations = {}
+                  }
 
-        res.json({ status: "SUCCESS" })
+                  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
+            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 (!body.parsed?.translation || !body.parsed?.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${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 => 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
+            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
+            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 =
+            body.parsed?.output_language_code || body.language || "unknown"
+          emitToCourse(courseSlug, "translation-error", {
+            exercise: exSlug,
+            language: language,
+            error: (error as Error).message,
+          })
+
+          res
+            .status(500)
+            .json({ status: "ERROR", error: (error as Error).message })
+        }
       }
     )
 
@@ -1986,6 +2429,11 @@ export default class ServeCommand extends SessionCommand {
       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 as string
       // GEt the x-rigo-token
@@ -2090,9 +2538,36 @@ export default class ServeCommand extends SessionCommand {
         return res.status(404).send("File not found")
       }
 
+      // Determine Content-Type based on file extension
+      const ext = file.split(".").pop()?.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)
     })
 
@@ -2281,6 +2756,20 @@ export default class ServeCommand extends SessionCommand {
       bucket: Bucket
     ) {
       try {
+        // Track which languages already exist vs which are being translated
+        const existingLanguages = new Set<string>()
+        const translatingLanguages = new Set<string>()
+
+        // Get syllabus to track translation status
+        let syllabus: Syllabus | null = null
+        try {
+          syllabus = await getSyllabus(courseSlug, bucket)
+        } catch {
+          console.log(
+            "Syllabus not found, translations will not be tracked in syllabus"
+          )
+        }
+
         emitToCourse(courseSlug, "translation-started", {
           languages: languageCodes,
           exercises: exerciseSlugs,
@@ -2293,7 +2782,19 @@ export default class ServeCommand extends SessionCommand {
             const readmePath = `courses/${courseSlug}/exercises/${slug}/README${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: string) => {
@@ -2306,6 +2807,7 @@ export default class ServeCommand extends SessionCommand {
                   console.log(
                     `Translation in ${language} already exists for exercise ${slug}`
                   )
+                  existingLanguages.add(language)
                   emitToCourse(courseSlug, "translation-progress", {
                     exercise: slug,
                     language: language,
@@ -2315,15 +2817,40 @@ export default class ServeCommand extends SessionCommand {
                   return
                 }
 
-                await translateExercise(
+                // Call translateExercise first to get the real completion ID
+                const translateResponse = await translateExercise(
                   rigoToken,
                   {
-                    text_to_translate: readme.toString(),
+                    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 => 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?.id || Date.now(),
+                      startedAt: Date.now(),
+                      completedAt: undefined,
+                    }
+                  }
+                }
+
                 emitToCourse(courseSlug, "translation-progress", {
                   exercise: slug,
                   language: language,
@@ -2335,6 +2862,11 @@ export default class ServeCommand extends SessionCommand {
           })
         )
 
+        // Save syllabus with translation status
+        if (syllabus && courseSlug) {
+          await saveSyllabus(courseSlug, syllabus, bucket)
+        }
+
         const course = await bucket
           .file(`courses/${courseSlug}/learn.json`)
           .download()
@@ -2450,29 +2982,526 @@ export default class ServeCommand extends SessionCommand {
         })
         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<string>()
+        const translatingLanguages = new Set<string>()
+
+        // Quick check: for each language, check if ALL exercises already have that translation
+        await Promise.all(
+          languageCodes.map(async (language: string) => {
+            const allExist = await Promise.all(
+              exerciseSlugs.map(async (slug: string) => {
+                const translationPath = `courses/${courseSlug}/exercises/${slug}/README${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 as 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 => 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${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: SyncNotification = {
+              id: String(Date.now()),
+              sourceLanguage,
+              createdAt: Date.now(),
+              updatedAt: Date.now(),
+              status: "pending",
+            }
+            lesson.syncNotifications.push(newNotification)
+            notificationToReturn = newNotification
+          }
+
+          await saveSyllabus(courseSlug, syllabus, bucket)
+
+          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 as 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: any[] = []
+
+        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
+                  emitToCourse(courseSlug, "sync-notification-error", {
+                    exerciseSlug: 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({
+                  ...notification,
+                  lessonSlug: 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 as 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 => 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 as Error).message,
+          })
+        }
+      }
+    )
+
+    // Accept sync notification and start synchronization
+    app.post(
+      "/courses/:courseSlug/lessons/:exerciseSlug/sync-notification/:notificationId/accept",
+      express.json(),
+      async (req, res) => {
+        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 => 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 = lesson.syncNotifications?.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${getReadmeExtension(
+            notification.sourceLanguage
+          )}`
+          let sourceReadmeContent: string
+
+          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 =
+            lesson.syncNotifications?.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)
+
+          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 => {
+              const les = syl.lessons.find(
+                l => slugify(l.id + "-" + l.title) === exerciseSlug
+              )
+              const notif = les?.syncNotifications?.find(
+                n => n.id === notificationId
+              )
+
+              if (notif) {
+                notif.status = "error"
+                notif.error = {
+                  message: (error as Error).message,
+                  code: "CRITICAL_ERROR",
+                  timestamp: Date.now(),
+                }
+                saveSyllabus(courseSlug, syl, bucket)
+
+                emitToCourse(courseSlug, "sync-notification-error", {
+                  exerciseSlug,
+                  notificationId,
+                  error: (error as Error).message,
+                })
+              }
+            })
+          })
+        } catch (error) {
+          console.error("Error accepting sync notification:", error)
+          res.status(500).json({
+            error: "Internal server error",
+            message: (error as Error).message,
+          })
+        }
+      }
+    )
+
+    // Update lesson status to DONE
+    app.put(
+      "/courses/:courseSlug/lessons/:exerciseSlug/status",
+      express.json(),
+      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 ValidationError(
+            "Rigo token is required. x-rigo-token header is missing"
+          )
+        }
+
+        if (!courseSlug || !exerciseSlug) {
+          throw new ValidationError(
+            "Course slug and exercise slug are required"
+          )
+        }
+
+        // Verify authorization
+        const { isAuthor } = await isPackageAuthor(rigoToken, courseSlug)
+        if (!isAuthor) {
+          throw new 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
+        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")