@learnpack/learnpack 5.0.335 → 5.0.340

package/lib/commands/serve.js

@@ -10,6 +10,7 @@ const path = require("path");
 const http = require("http");
 const creatorSocket_1 = require("../utils/creatorSocket");
 const os = require("os");
+const crypto = require("crypto");
 const archiver = require("archiver");
 const mkdirp = require("mkdirp");
 const html_to_text_1 = require("html-to-text");
@@ -37,11 +38,47 @@ const jsdom_1 = require("jsdom");
 const redis_1 = require("redis");
 const historyManager_1 = require("../managers/historyManager");
 const readmeHistoryService_1 = require("../managers/readmeHistoryService");
+const readmeSanitizer_1 = require("../utils/readmeSanitizer");
 const frontMatter = require("front-matter");
 if (process.env.NEW_RELIC_ENABLED === "true") {
     require("newrelic");
 }
 dotenv.config();
+// Observability utilities for syllabus race condition detection
+function syllabusHash(syllabus) {
+    const content = JSON.stringify(syllabus);
+    return crypto.createHash("md5").update(content).digest("hex").slice(0, 8);
+}
+function translationsSummary(lesson) {
+    if (!(lesson === null || lesson === void 0 ? void 0 : lesson.translations))
+        return "{}";
+    const summary = {};
+    for (const [lang, data] of Object.entries(lesson.translations)) {
+        summary[lang] = data.completedAt ? "done" : "pending";
+    }
+    return JSON.stringify(summary);
+}
+function opId() {
+    return crypto.randomBytes(4).toString("hex");
+}
+// Serialization per course to prevent syllabus race conditions
+const courseQueues = new Map();
+async function serializeByCourse(courseSlug, fn) {
+    var _a;
+    const prev = (_a = courseQueues.get(courseSlug)) !== null && _a !== void 0 ? _a : Promise.resolve();
+    const next = prev
+        .then(() => fn())
+        .catch(error => {
+        throw error;
+    })
+        .finally(() => {
+        if (courseQueues.get(courseSlug) === next) {
+            courseQueues.delete(courseSlug);
+        }
+    });
+    courseQueues.set(courseSlug, next);
+    return next;
+}
 const createLearnJson = (courseInfo) => {
     // console.log("courseInfo to create learn json", courseInfo)
     const expectedPreviewUrl = `https://${courseInfo.slug}.learn-pack.com/preview.png`;
@@ -66,8 +103,10 @@ const createLearnJson = (courseInfo) => {
 };
 exports.createLearnJson = createLearnJson;
 const uploadFileToBucket = async (bucket, file, path) => {
+    const isReadme = /readme(\.\w+)?\.md$/i.test(path);
+    const content = isReadme ? (0, readmeSanitizer_1.sanitizeReadmeNewlines)(file) : file;
     const fileRef = bucket.file(path);
-    await fileRef.save(buffer_1.Buffer.from(file, "utf8"));
+    await fileRef.save(buffer_1.Buffer.from(content, "utf8"));
 };
 const PARAMS = {
     expected_grade_level: "8",
@@ -95,18 +134,18 @@ async function fetchComponentsYml() {
             axios_1.default.get("https://raw.githubusercontent.com/learnpack/ide/refs/heads/master/docs/assessment_components.yml"),
             axios_1.default.get("https://raw.githubusercontent.com/learnpack/ide/refs/heads/master/docs/explanatory_components.yml"),
         ]);
-        const combinedContent = `
-# ASSESSMENT COMPONENTS
-These components are designed for evaluation and knowledge assessment:
-
-${assessmentResponse.data}
-
----
-
-# EXPLANATORY COMPONENTS  
-These components are designed for explanation and learning support:
-
-${explanatoryResponse.data}
+        const combinedContent = `
+# ASSESSMENT COMPONENTS
+These components are designed for evaluation and knowledge assessment:
+
+${assessmentResponse.data}
+
+---
+
+# EXPLANATORY COMPONENTS  
+These components are designed for explanation and learning support:
+
+${explanatoryResponse.data}
 `;
         return combinedContent;
     }
@@ -140,10 +179,10 @@ const createInitialSidebar = async (slugs, initialLanguage = "en") => {
     return sidebar;
 };
 const uploadInitialReadme = async (bucket, exSlug, targetDir, packageContext) => {
-    const isGeneratingText = `
-  \`\`\`loader slug="${exSlug}"
-  :rigo
-  \`\`\`
+    const isGeneratingText = `
+  \`\`\`loader slug="${exSlug}"
+  :rigo
+  \`\`\`
       `;
     const readmeFilename = `README${(0, creatorUtilities_1.getReadmeExtension)(packageContext.language || "en")}`;
     await uploadFileToBucket(bucket, isGeneratingText, `${targetDir}/${readmeFilename}`);
@@ -327,9 +366,51 @@ async function getSyllabus(courseSlug, bucket) {
     const [content] = await syllabus.download();
     return JSON.parse(content.toString());
 }
+function sanitizeSyllabusFromUnknown(syllabus) {
+    var _a;
+    for (const lesson of (_a = syllabus.lessons) !== null && _a !== void 0 ? _a : []) {
+        if (lesson.translations && "unknown" in lesson.translations) {
+            delete lesson.translations.unknown;
+        }
+    }
+}
 async function saveSyllabus(courseSlug, syllabus, bucket) {
+    sanitizeSyllabusFromUnknown(syllabus);
     await uploadFileToBucket(bucket, JSON.stringify(syllabus), `courses/${courseSlug}/.learn/initialSyllabus.json`);
 }
+// Instrumented syllabus operations for race condition observability
+async function getSyllabusWithLog(courseSlug, bucket, context) {
+    const readAt = Date.now();
+    const syllabus = await getSyllabus(courseSlug, bucket);
+    const hash = syllabusHash(syllabus);
+    console.log("[SYLLABUS_READ]", {
+        op: context.op,
+        courseSlug,
+        exSlug: context.exSlug,
+        lang: context.lang,
+        hash,
+        readAt,
+        lessonsCount: syllabus.lessons.length,
+    });
+    return { syllabus, hash, readAt };
+}
+async function saveSyllabusWithLog(courseSlug, syllabus, bucket, context) {
+    const writeAt = Date.now();
+    const newHash = syllabusHash(syllabus);
+    const elapsedMs = writeAt - context.readAt;
+    await saveSyllabus(courseSlug, syllabus, bucket);
+    console.log("[SYLLABUS_WRITE]", {
+        op: context.op,
+        courseSlug,
+        exSlug: context.exSlug,
+        lang: context.lang,
+        readHash: context.readHash,
+        newHash,
+        writeAt,
+        elapsedMs,
+    });
+    return { success: true, newHash, writeAt };
+}
 async function updateUsedComponents(courseSlug, usedComponents, bucket) {
     const syllabus = await getSyllabus(courseSlug, bucket);
     // Initialize used_components if undefined
@@ -503,6 +584,7 @@ const getTitleFromHTML = (html) => {
 async function processSyncTranslationsSequentially(courseSlug, exerciseSlug, notificationId, sourceReadmeContent, targetLanguages, rigoToken, bucket, historyManager) {
     var _a, _b, _c, _d, _e, _f;
     try {
+        const sanitizedSource = (0, readmeSanitizer_1.sanitizeReadmeNewlines)(sourceReadmeContent);
         // Process translations sequentially (no race conditions)
         for (const targetLang of targetLanguages) {
             try {
@@ -510,7 +592,7 @@ async function processSyncTranslationsSequentially(courseSlug, exerciseSlug, not
                 // 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,
+                        text_to_translate: sanitizedSource,
                         output_language: targetLang,
                     },
                     include_purpose_objective: false,
@@ -674,7 +756,7 @@ class ServeCommand extends SessionCommand_1.default {
                     url: redisUrl,
                     socket: {
                         tls: useTLS,
-                        rejectUnauthorized: useTLS,
+                        rejectUnauthorized: false,
                         reconnectStrategy: (retries) => {
                             if (retries > 10) {
                                 console.error("❌ Too many Redis reconnection attempts");
@@ -1603,129 +1685,219 @@ 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;
+            var _a, _b;
             const { courseSlug, exSlug } = req.params;
             const body = req.body;
-            console.log("RECEIVING TRANSLATION WEBHOOK", body);
-            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,
-                                    };
+            const op = opId();
+            const language = ((_a = body.parsed) === null || _a === void 0 ? void 0 : _a.output_language_code) || body.language || "unknown";
+            console.log("[TRANSLATION_WEBHOOK] RECEIVED", {
+                op,
+                courseSlug,
+                exSlug,
+                language,
+                completionId: body.id,
+                hasTranslation: !!((_b = body.parsed) === null || _b === void 0 ? void 0 : _b.translation),
+                status: body.status,
+            });
+            const queuedAt = Date.now();
+            await serializeByCourse(courseSlug, async () => {
+                var _a, _b, _c, _d;
+                const waitedMs = Date.now() - queuedAt;
+                if (waitedMs > 0) {
+                    console.log("[TRANSLATION_WEBHOOK] QUEUE_WAIT", {
+                        op,
+                        courseSlug,
+                        exSlug,
+                        language,
+                        waitedMs,
+                    });
+                }
+                try {
+                    // Check if there's an error from Rigobot
+                    if (body.error || body.status === "ERROR") {
+                        console.error("[TRANSLATION_WEBHOOK] Translation failed", {
+                            op,
+                            exSlug,
+                            error: body.error,
+                        });
+                        // Update syllabus with error status (skip when language is invalid fallback "unknown")
+                        if (language && language !== "unknown") {
+                            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("[TRANSLATION_WEBHOOK] Error updating syllabus with error status", { op, exSlug, language, error: syllabusError });
                             }
-                            await saveSyllabus(courseSlug, syllabus, bucket);
-                        }
-                        catch (syllabusError) {
-                            console.error("Error updating syllabus with error status:", syllabusError);
                         }
+                        (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 });
                     }
-                    // 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);
+                    // Validate required data
+                    if (!((_a = body.parsed) === null || _a === void 0 ? void 0 : _a.translation) ||
+                        !((_b = body.parsed) === null || _b === void 0 ? void 0 : _b.output_language_code)) {
+                        console.error("[TRANSLATION_WEBHOOK] Missing required data", {
+                            op,
+                            courseSlug,
+                            exSlug,
+                        });
+                        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) {
+                        const { syllabus, hash: readHash, readAt, } = await getSyllabusWithLog(courseSlug, bucket, {
+                            op,
+                            exSlug,
+                            lang: body.parsed.output_language_code,
+                        });
                         const lessonIndex = syllabus.lessons.findIndex(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === exSlug);
-                        if (lessonIndex !== -1) {
+                        if (lessonIndex === -1) {
+                            console.warn("[TRANSLATION_WEBHOOK] LESSON_NOT_FOUND", {
+                                op,
+                                courseSlug,
+                                exSlug,
+                                language: body.parsed.output_language_code,
+                                availableSlugs: syllabus.lessons.map(l => (0, creatorUtilities_2.slugify)(l.id + "-" + l.title)),
+                            });
+                        }
+                        else {
                             const lesson = syllabus.lessons[lessonIndex];
-                            const language = body.parsed.output_language_code;
+                            console.log("[TRANSLATION_WEBHOOK] BEFORE_MODIFY", {
+                                op,
+                                exSlug,
+                                language: body.parsed.output_language_code,
+                                translationsBefore: translationsSummary(lesson),
+                            });
                             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;
+                            if (lesson.translations[body.parsed.output_language_code]) {
+                                lesson.translations[body.parsed.output_language_code].completedAt = Date.now();
+                                if (lesson.translations[body.parsed.output_language_code].error) {
+                                    delete lesson.translations[body.parsed.output_language_code]
+                                        .error;
                                 }
                             }
                             else {
-                                // Create entry if it doesn't exist
-                                lesson.translations[language] = {
-                                    completionId: 0,
+                                lesson.translations[body.parsed.output_language_code] = {
+                                    completionId: body.id || 0,
                                     startedAt: Date.now(),
                                     completedAt: Date.now(),
                                 };
                             }
+                            console.log("[TRANSLATION_WEBHOOK] AFTER_MODIFY", {
+                                op,
+                                exSlug,
+                                language: body.parsed.output_language_code,
+                                translationsAfter: translationsSummary(lesson),
+                            });
+                            try {
+                                await saveSyllabusWithLog(courseSlug, syllabus, bucket, {
+                                    op,
+                                    exSlug,
+                                    lang: body.parsed.output_language_code,
+                                    readHash,
+                                    readAt,
+                                });
+                                // Verify: re-read to confirm changes persisted
+                                const verification = await getSyllabus(courseSlug, bucket);
+                                const verifyLesson = verification.lessons[lessonIndex];
+                                const persisted = (_d = (_c = verifyLesson === null || verifyLesson === void 0 ? void 0 : verifyLesson.translations) === null || _c === void 0 ? void 0 : _c[body.parsed.output_language_code]) === null || _d === void 0 ? void 0 : _d.completedAt;
+                                console.log("[TRANSLATION_WEBHOOK] VERIFY", {
+                                    op,
+                                    exSlug,
+                                    language: body.parsed.output_language_code,
+                                    persisted: !!persisted,
+                                    finalHash: syllabusHash(verification),
+                                });
+                                if (!persisted) {
+                                    console.error("[TRANSLATION_WEBHOOK] RACE_CONDITION_DETECTED", {
+                                        op,
+                                        exSlug,
+                                        language: body.parsed.output_language_code,
+                                        message: "Translation was saved but not persisted - likely overwritten by concurrent operation",
+                                    });
+                                }
+                            }
+                            catch (syllabusError) {
+                                console.error("[TRANSLATION_WEBHOOK] Error updating syllabus with completed status", {
+                                    op,
+                                    exSlug,
+                                    language: body.parsed.output_language_code,
+                                    error: syllabusError,
+                                });
+                            }
                         }
-                        await saveSyllabus(courseSlug, syllabus, bucket);
+                        (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-completed", {
+                            exercise: exSlug,
+                            language: body.parsed.output_language_code,
+                        });
                     }
-                    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
+                    else {
+                        console.error("[TRANSLATION_WEBHOOK] File not found after upload", {
+                            op,
+                            readmePath,
+                        });
+                        (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-error", {
+                            exercise: exSlug,
+                            language: body.parsed.output_language_code,
+                            error: "File upload verification failed",
+                        });
                     }
-                    // Notify frontend via WebSocket ONLY if file exists
-                    (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-completed", {
-                        exercise: exSlug,
-                        language: body.parsed.output_language_code,
-                    });
+                    res.json({ status: "SUCCESS" });
                 }
-                else {
-                    console.error(`File ${readmePath} was not found after upload, skipping syllabus update`);
-                    // File upload failed - emit error event instead of success
+                catch (error) {
+                    console.error("[TRANSLATION_WEBHOOK] ERROR", {
+                        op,
+                        courseSlug,
+                        exSlug,
+                        language,
+                        error: error.message,
+                    });
                     (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-error", {
                         exercise: exSlug,
-                        language: body.parsed.output_language_code,
-                        error: "File upload verification failed",
+                        language: language,
+                        error: error.message,
                     });
+                    res
+                        .status(500)
+                        .json({ status: "ERROR", error: error.message });
                 }
-                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;
@@ -1822,14 +1994,16 @@ class ServeCommand extends SessionCommand_1.default {
                     foundLang = match[1].toLowerCase();
                 }
                 const [contentBuffer] = await bucket.file(selectedFile).download();
+                const rawContent = contentBuffer.toString();
+                const content = (0, readmeSanitizer_1.sanitizeReadmeNewlines)(rawContent);
                 try {
-                    const { attributes, body } = frontMatter(contentBuffer.toString());
+                    const { attributes, body } = frontMatter(content);
                     res.send({ attributes, body, lang: foundLang });
                 }
                 catch (_a) {
                     res.status(200).json({
                         attributes: {},
-                        body: contentBuffer.toString(),
+                        body: content,
                         lang: foundLang,
                     });
                 }
@@ -2218,6 +2392,85 @@ class ServeCommand extends SessionCommand_1.default {
             }
             res.send({ message: "Files renamed" });
         });
+        app.post("/actions/update-title", express.json(), async (req, res) => {
+            var _a;
+            console.log("POST /actions/update-title");
+            const { language, title } = req.body;
+            const courseSlug = typeof req.query.slug === "string" ? req.query.slug : undefined;
+            const rigoToken = req.header("x-rigo-token");
+            if (!courseSlug) {
+                return res.status(400).json({ error: "Course slug not found" });
+            }
+            if (!rigoToken) {
+                return res.status(400).json({ error: "Rigo token not found" });
+            }
+            if (!language || !title) {
+                return res
+                    .status(400)
+                    .json({ error: "Language and title are required" });
+            }
+            try {
+                const learnJsonFile = bucket.file(`courses/${courseSlug}/learn.json`);
+                const [learnJsonContent] = await learnJsonFile.download();
+                const learnJson = JSON.parse(learnJsonContent.toString());
+                if (!learnJson.title)
+                    learnJson.title = {};
+                learnJson.title[language] = title;
+                await uploadFileToBucket(bucket, JSON.stringify(learnJson), `courses/${courseSlug}/learn.json`);
+                const configFile = bucket.file(`courses/${courseSlug}/.learn/config.json`);
+                const [configContent] = await configFile.download();
+                const configJson = JSON.parse(configContent.toString());
+                configJson.config = configJson.config || {};
+                configJson.config.title = Object.assign(Object.assign({}, configJson.config.title), learnJson.title);
+                await uploadFileToBucket(bucket, JSON.stringify(configJson), `courses/${courseSlug}/.learn/config.json`);
+                try {
+                    const syllabusFile = bucket.file(`courses/${courseSlug}/.learn/initialSyllabus.json`);
+                    const [syllabusContent] = await syllabusFile.download();
+                    const syllabusJson = JSON.parse(syllabusContent.toString());
+                    if (syllabusJson === null || syllabusJson === void 0 ? void 0 : syllabusJson.courseInfo) {
+                        syllabusJson.courseInfo.title = title;
+                        await uploadFileToBucket(bucket, JSON.stringify(syllabusJson), `courses/${courseSlug}/.learn/initialSyllabus.json`);
+                    }
+                }
+                catch (error) {
+                    console.warn("Skipping syllabus title update:", error);
+                }
+                const existingDescription = learnJson.description || {};
+                const targetLanguages = Object.keys(learnJson.title).filter(lang => lang !== language);
+                if (targetLanguages.length > 0) {
+                    try {
+                        const result = await (0, rigoActions_1.translateCourseMetadata)(rigoToken, {
+                            title: JSON.stringify(learnJson.title),
+                            description: JSON.stringify(existingDescription),
+                            new_languages: targetLanguages.join(","),
+                        });
+                        if ((_a = result === null || result === void 0 ? void 0 : result.parsed) === null || _a === void 0 ? void 0 : _a.title) {
+                            const translatedTitle = JSON.parse(result.parsed.title);
+                            learnJson.title = Object.assign(Object.assign(Object.assign({}, learnJson.title), translatedTitle), { [language]: title });
+                            await uploadFileToBucket(bucket, JSON.stringify(learnJson), `courses/${courseSlug}/learn.json`);
+                            configJson.config.title = Object.assign(Object.assign({}, configJson.config.title), learnJson.title);
+                            await uploadFileToBucket(bucket, JSON.stringify(configJson), `courses/${courseSlug}/.learn/config.json`);
+                        }
+                    }
+                    catch (translationError) {
+                        console.error("Title translation failed:", translationError);
+                        return res.json({
+                            status: "PARTIAL_SUCCESS",
+                            title: learnJson.title,
+                            message: "Title updated for current language, translation failed for others",
+                        });
+                    }
+                }
+                return res.json({
+                    status: "SUCCESS",
+                    title: learnJson.title,
+                });
+            }
+            catch (error) {
+                console.error("Error updating course title:", error);
+                return res.status(500).json({ error: error.message });
+            }
+        });
         async function processTranslationsAsync(courseSlug, exerciseSlugs, languageCodes, rigoToken, currentLanguage, bucket) {
             try {
                 // Track which languages already exist vs which are being translated
@@ -2264,7 +2517,7 @@ class ServeCommand extends SessionCommand_1.default {
                         }
                         // Call translateExercise first to get the real completion ID
                         const translateResponse = await (0, rigoActions_1.translateExercise)(rigoToken, {
-                            text_to_translate: readme,
+                            text_to_translate: (0, readmeSanitizer_1.sanitizeReadmeNewlines)(readme),
                             output_language: language,
                         }, `${process.env.HOST}/webhooks/${courseSlug}/${slug}/save-translation`);
                         // Mark this language as being translated
@@ -2343,7 +2596,7 @@ class ServeCommand extends SessionCommand_1.default {
                 }
                 await Promise.all(missingReadmeTranslations.map(async (languageCode) => {
                     await (0, rigoActions_1.translateExercise)(rigoToken, {
-                        text_to_translate: firstAvailable,
+                        text_to_translate: (0, readmeSanitizer_1.sanitizeReadmeNewlines)(firstAvailable),
                         output_language: languageCode,
                     }, `${process.env.HOST}/webhooks/${courseSlug}/initial-readme-processor`);
                 }));
@@ -2759,13 +3012,222 @@ class ServeCommand extends SessionCommand_1.default {
             const { slug } = req.params;
             const query = req.query;
             const courseSlug = query.slug;
-            const filePrefix = `courses/${courseSlug}/exercises/${slug}/`;
-            const [files] = await bucket.getFiles({ prefix: filePrefix });
-            for (const file of files) {
-                // eslint-disable-next-line no-await-in-loop
-                await file.delete();
+            try {
+                // Delete exercise files from bucket
+                const filePrefix = `courses/${courseSlug}/exercises/${slug}/`;
+                const [files] = await bucket.getFiles({ prefix: filePrefix });
+                for (const file of files) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await file.delete();
+                }
+                // Update syllabus to remove the lesson
+                const syllabus = await getSyllabus(courseSlug, bucket);
+                const lessonIndex = syllabus.lessons.findIndex(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === slug);
+                if (lessonIndex !== -1) {
+                    syllabus.lessons.splice(lessonIndex, 1);
+                    await saveSyllabus(courseSlug, syllabus, bucket);
+                    console.log(`✅ Removed lesson ${slug} from syllabus`);
+                }
+                else {
+                    console.warn(`⚠️ Lesson ${slug} not found in syllabus`);
+                }
+                res.send({
+                    message: "Exercise deleted successfully",
+                    removedFromSyllabus: lessonIndex !== -1,
+                });
+            }
+            catch (error) {
+                console.error("❌ Error deleting exercise:", error);
+                res.status(500).send({
+                    error: "Error deleting exercise",
+                    details: error.message,
+                });
+            }
+        });
+        app.post("/actions/synchronize-syllabus", async (req, res) => {
+            console.log("POST /actions/synchronize-syllabus");
+            const { slug } = req.query;
+            const courseSlug = slug;
+            if (!courseSlug) {
+                return res.status(400).json({ error: "Course slug is required" });
+            }
+            try {
+                // Get the current syllabus
+                const syllabus = await getSyllabus(courseSlug, bucket);
+                const removedLessons = [];
+                const keptLessons = [];
+                const duplicatesRemoved = [];
+                const addedLessons = [];
+                console.log(`📋 Checking ${syllabus.lessons.length} lessons in syllabus...`);
+                // First pass: Check each lesson to see if it exists in the bucket and count files.
+                // We try two possible folder names because they can differ by source:
+                // - Initial upload / most flows: folder = slugify(lesson.id + "-" + lesson.title)
+                // - create-step flow: folder = lesson.uid (Rigo's stepSlug), which may not match slugify()
+                //   (e.g. casing or character handling). GCS prefixes are case-sensitive.
+                const existingLessons = [];
+                for (const lesson of syllabus.lessons) {
+                    const lessonSlug = (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title);
+                    let filePrefix = `courses/${courseSlug}/exercises/${lessonSlug}/`;
+                    // eslint-disable-next-line no-await-in-loop
+                    let [files] = await bucket.getFiles({
+                        prefix: filePrefix,
+                    });
+                    if (files.length === 0 && lesson.uid) {
+                        filePrefix = `courses/${courseSlug}/exercises/${lesson.uid}/`;
+                        // eslint-disable-next-line no-await-in-loop
+                        [files] = await bucket.getFiles({ prefix: filePrefix });
+                    }
+                    const resolvedSlug = files.length > 0 ?
+                        filePrefix
+                            .replace(`courses/${courseSlug}/exercises/`, "")
+                            .replace(/\/$/, "") :
+                        lessonSlug;
+                    if (files.length === 0) {
+                        removedLessons.push({
+                            id: lesson.id,
+                            title: lesson.title,
+                            slug: lessonSlug,
+                        });
+                        console.log(`❌ Lesson not found: ${lessonSlug}${lesson.uid ? ` (also tried uid: ${lesson.uid})` : ""}`);
+                    }
+                    else {
+                        existingLessons.push({
+                            lesson,
+                            slug: resolvedSlug,
+                            fileCount: files.length,
+                        });
+                        console.log(`✅ Lesson exists: ${resolvedSlug} (${files.length} files)`);
+                    }
+                }
+                // Second pass: Detect and resolve duplicates
+                const slugMap = new Map();
+                // Group by slug
+                for (const item of existingLessons) {
+                    if (!slugMap.has(item.slug)) {
+                        slugMap.set(item.slug, []);
+                    }
+                    slugMap.get(item.slug).push(item);
+                }
+                // Process each group
+                for (const [slug, items] of slugMap.entries()) {
+                    if (items.length > 1) {
+                        // Duplicates found! Sort by file count (descending) and keep the most complete
+                        items.sort((a, b) => b.fileCount - a.fileCount);
+                        const winner = items[0];
+                        const losers = items.slice(1);
+                        console.log(`🔍 Duplicate slug detected: ${slug}`);
+                        console.log(`   ✅ Keeping: ${winner.lesson.id} - ${winner.lesson.title} (${winner.fileCount} files)`);
+                        // Keep the winner
+                        keptLessons.push({
+                            id: winner.lesson.id,
+                            title: winner.lesson.title,
+                            slug: winner.slug,
+                            fileCount: winner.fileCount,
+                        });
+                        // Mark losers for removal
+                        for (const loser of losers) {
+                            console.log(`   ❌ Removing duplicate: ${loser.lesson.id} - ${loser.lesson.title} (${loser.fileCount} files)`);
+                            duplicatesRemoved.push({
+                                id: loser.lesson.id,
+                                title: loser.lesson.title,
+                                slug: loser.slug,
+                                fileCount: loser.fileCount,
+                            });
+                        }
+                    }
+                    else {
+                        // No duplicates, keep as is
+                        keptLessons.push({
+                            id: items[0].lesson.id,
+                            title: items[0].lesson.title,
+                            slug: items[0].slug,
+                            fileCount: items[0].fileCount,
+                        });
+                    }
+                }
+                // Update syllabus: keep only the winners and remove non-existent + duplicates
+                const totalRemoved = removedLessons.length + duplicatesRemoved.length;
+                if (totalRemoved > 0) {
+                    syllabus.lessons = syllabus.lessons.filter(lesson => {
+                        const lessonSlug = (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title);
+                        const isRemoved = removedLessons.some(removed => removed.slug === lessonSlug);
+                        const isDuplicate = duplicatesRemoved.some(dup => dup.id === lesson.id && dup.title === lesson.title);
+                        return !isRemoved && !isDuplicate;
+                    });
+                }
+                // Third pass: add lessons that exist in the bucket but are missing from the syllabus
+                const existingSlugs = new Set(existingLessons.map(e => e.slug));
+                const exercisesPrefix = `courses/${courseSlug}/exercises/`;
+                const [allExerciseFiles] = await bucket.getFiles({
+                    prefix: exercisesPrefix,
+                });
+                const bucketFolderSlugs = new Set();
+                for (const file of allExerciseFiles) {
+                    if (!file.name.startsWith(exercisesPrefix))
+                        continue;
+                    const afterPrefix = file.name.slice(exercisesPrefix.length);
+                    const segment = afterPrefix.split("/")[0];
+                    if (segment)
+                        bucketFolderSlugs.add(segment);
+                }
+                for (const folderSlug of bucketFolderSlugs) {
+                    if (existingSlugs.has(folderSlug))
+                        continue;
+                    const idMatch = folderSlug.match(/^(\d+(?:\.\d+)?)(?:-(.*))?$/);
+                    const id = idMatch ? idMatch[1] : folderSlug;
+                    const titlePart = idMatch && idMatch[2] ? idMatch[2] : folderSlug;
+                    const title = titlePart.replace(/-/g, " ").trim() || folderSlug;
+                    const newLesson = {
+                        id,
+                        uid: folderSlug,
+                        title,
+                        type: "READ",
+                        description: title,
+                        duration: 2,
+                        generated: true,
+                        status: "DONE",
+                    };
+                    syllabus.lessons.push(newLesson);
+                    addedLessons.push({ id, title, slug: folderSlug });
+                    console.log(`➕ Added missing lesson from bucket: ${folderSlug}`);
+                }
+                if (addedLessons.length > 0) {
+                    syllabus.lessons.sort((a, b) => {
+                        const na = parseFloat(a.id);
+                        const nb = parseFloat(b.id);
+                        if (!Number.isNaN(na) && !Number.isNaN(nb))
+                            return na - nb;
+                        return String(a.id).localeCompare(String(b.id));
+                    });
+                }
+                if (totalRemoved > 0 || addedLessons.length > 0) {
+                    await saveSyllabus(courseSlug, syllabus, bucket);
+                    console.log(`✅ Syllabus synchronized. Removed ${removedLessons.length} non-existent, ${duplicatesRemoved.length} duplicate(s); added ${addedLessons.length} from bucket.`);
+                }
+                else {
+                    console.log(`✅ Syllabus is already in sync. No changes.`);
+                }
+                res.json({
+                    status: "SUCCESS",
+                    message: `Syllabus synchronized successfully`,
+                    totalLessons: syllabus.lessons.length,
+                    keptLessons: keptLessons.length,
+                    removedLessons: removedLessons.length,
+                    duplicatesResolved: duplicatesRemoved.length,
+                    addedLessons: addedLessons.length,
+                    removed: removedLessons,
+                    duplicates: duplicatesRemoved,
+                    kept: keptLessons,
+                    added: addedLessons,
+                });
+            }
+            catch (error) {
+                console.error("❌ Error synchronizing syllabus:", error);
+                res.status(500).json({
+                    error: "Error synchronizing syllabus",
+                    details: error.message,
+                });
             }
-            res.send({ message: "Files deleted" });
         });
         app.get("/translations/sidebar", async (req, res) => {
             const { slug } = req.query;
@@ -2900,6 +3362,7 @@ class ServeCommand extends SessionCommand_1.default {
                 const syllabus = await bucket.file(`courses/${courseSlug}/.learn/initialSyllabus.json`);
                 const [content] = await syllabus.download();
                 const syllabusJson = JSON.parse(content.toString());
+                sanitizeSyllabusFromUnknown(syllabusJson);
                 res.json(syllabusJson);
             }
             catch (error) {