@learnpack/learnpack 5.0.355 → 5.0.358

package/lib/commands/serve.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processImage = exports.createLearnJson = void 0;
+exports.processImage = void 0;
 const tslib_1 = require("tslib");
 const command_1 = require("@oclif/command");
 const buffer_1 = require("buffer");
@@ -33,7 +33,12 @@ const creatorUtilities_2 = require("../utils/creatorUtilities");
 const sidebarGenerator_1 = require("../utils/sidebarGenerator");
 const publish_1 = require("./publish");
 const export_1 = require("../utils/export");
+const router_1 = require("../services/ingest/http/router");
+const bucketIo_1 = require("../utils/coursePackage/bucketIo");
+const learnJson_1 = require("../utils/coursePackage/learnJson");
+const sidebar_1 = require("../utils/coursePackage/sidebar");
 const packageManifest_1 = require("../utils/packageManifest");
+const branding_1 = require("../utils/branding");
 const gcsBucketName_1 = require("../utils/gcsBucketName");
 const syllabusSync_1 = require("../utils/syllabusSync");
 const publishJournal_1 = require("../utils/publishJournal");
@@ -86,39 +91,6 @@ async function serializeByCourse(courseSlug, fn) {
     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`;
-    const language = courseInfo.language || "en";
-    const learnJson = {
-        slug: courseInfo.slug,
-        title: {
-            [language]: courseInfo.title,
-        },
-        technologies: courseInfo.technologies || [],
-        difficulty: "beginner",
-        description: {
-            [language]: courseInfo.description,
-        },
-        grading: "isolated",
-        telemetry: {
-            batch: api_1.BREATHECODE_TELEMETRY_URL,
-        },
-        preview: expectedPreviewUrl,
-    };
-    return learnJson;
-};
-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(content, "utf8"));
-};
-const uploadBinaryToBucket = async (bucket, buffer, path, contentType) => {
-    const fileRef = bucket.file(path);
-    await fileRef.save(buffer, Object.assign({ resumable: false }, (contentType && { contentType })));
-};
 const getGithubCredentials = () => {
     var _a, _b;
     const token = (_a = process.env.GITHUB_TOKEN) === null || _a === void 0 ? void 0 : _a.trim();
@@ -331,15 +303,6 @@ const processImage = async (url, description, rigoToken, courseSlug) => {
     }
 };
 exports.processImage = processImage;
-const createInitialSidebar = async (slugs, initialLanguage = "en") => {
-    const sidebar = {};
-    for (const slug of slugs) {
-        sidebar[slug] = {
-            [initialLanguage]: slug,
-        };
-    }
-    return sidebar;
-};
 const uploadInitialReadme = async (bucket, exSlug, targetDir, packageContext) => {
     const isGeneratingText = `
   \`\`\`loader slug="${exSlug}"
@@ -347,7 +310,7 @@ const uploadInitialReadme = async (bucket, exSlug, targetDir, packageContext) =>
   \`\`\`
       `;
     const readmeFilename = `README${(0, creatorUtilities_1.getReadmeExtension)(packageContext.language || "en")}`;
-    await uploadFileToBucket(bucket, isGeneratingText, `${targetDir}/${readmeFilename}`);
+    await (0, bucketIo_1.uploadFileToBucket)(bucket, isGeneratingText, `${targetDir}/${readmeFilename}`);
 };
 const cleanFormState = (formState) => {
     const { description, technologies, purpose, hasContentIndex, duration, isCompleted, variables, currentStep, language } = formState, rest = tslib_1.__rest(formState, ["description", "technologies", "purpose", "hasContentIndex", "duration", "isCompleted", "variables", "currentStep", "language"]);
@@ -581,7 +544,7 @@ function sanitizeSyllabusFromUnknown(syllabus) {
 }
 async function saveSyllabus(courseSlug, syllabus, bucket) {
     sanitizeSyllabusFromUnknown(syllabus);
-    await uploadFileToBucket(bucket, JSON.stringify(syllabus), `courses/${courseSlug}/.learn/initialSyllabus.json`);
+    await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(syllabus), `courses/${courseSlug}/.learn/initialSyllabus.json`);
 }
 // Instrumented syllabus operations for race condition observability
 async function getSyllabusWithLog(courseSlug, bucket, context) {
@@ -771,44 +734,150 @@ async function continueWithNextLesson(courseSlug, currentExerciseIndex, rigoToke
         }) });
     await saveSyllabus(courseSlug, newSyllabus, bucket);
 }
-const fixPreviewUrl = (slug, previewUrl) => {
-    if (!previewUrl) {
-        return null;
+/**
+ * The `og:image` of a published course.
+ *
+ * A published package is served from `{slug}.learn-pack.com`, so the course's
+ * own `preview.png` is the right card whenever it exists. This used to go
+ * through a helper that returned null for an empty preview, and both call sites
+ * passed an empty string — so every published course, preview or not, fell back
+ * to a shared SVG that no unfurl crawler can render.
+ */
+const resolveCoursePreviewUrl = async (bucket, slug, configuredPreview) => {
+    // `config` is parsed from a config.json in the bucket, so its declared types
+    // are an assertion rather than a guarantee: an old or hand-edited course can
+    // carry anything here, and a throw would fail the whole publication.
+    if (typeof configuredPreview === "string" &&
+        configuredPreview.startsWith("http")) {
+        return configuredPreview;
     }
-    if (previewUrl.startsWith("http")) {
-        return previewUrl;
+    try {
+        const [exists] = await bucket.file(`courses/${slug}/preview.png`).exists();
+        if (exists) {
+            return (0, packageManifest_1.resolvePreviewUrl)(slug);
+        }
     }
-    const expectedUrl = `https://${slug}.learn-pack.com/preview.png`;
-    return expectedUrl;
+    catch (error) {
+        console.error(`WARNING: could not check preview.png for ${slug}, using the brand card`, error);
+    }
+    return (0, branding_1.getFallbackPreviewUrl)();
 };
 const getTitleFromHTML = (html) => {
     const titleRegex = /<title>(.*?)<\/title>/;
     const titleMatch = html.match(titleRegex);
     return titleMatch ? titleMatch[1] : null;
 };
+const escapeHtmlAttribute = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+/**
+ * The IDE shell served to draft courses, with its meta tags filled in.
+ *
+ * The shell ships with `{{title}}`, `{{description}}` and `{{preview}}`
+ * placeholders that only get substituted when a course is published. Drafts were
+ * served the raw template, so a link shared in Slack or WhatsApp unfurled to a
+ * literal `{{title}}` / `{{description}}`.
+ */
+let draftShellTemplate = null;
+const loadDraftShellTemplate = () => {
+    const file = path.resolve(__dirname, "../ui/_app/index.html");
+    draftShellTemplate = fs
+        .readFileSync(file, "utf-8")
+        // A draft is not a real Course, so it must not emit Course structured data.
+        // The match is anchored to the typed opening tag and non-greedy on purpose:
+        // the shell also carries an inline <script> that loads the app bundle from
+        // CloudFront, and a looser pattern would swallow it and blank the page.
+        .replace(/[^\S\n]*<script type="application\/ld\+json">[\S\s]*?<\/script>\n?/, "");
+    return draftShellTemplate;
+};
+const renderDraftShell = (req) => {
+    const template = draftShellTemplate || loadDraftShellTemplate();
+    // Only the path: a preview URL can carry tokens in its query string, and
+    // og:url ends up in whatever crawler cache unfurls the link.
+    const canonicalUrl = escapeHtmlAttribute(`${(0, branding_1.getPublicHost)()}${req.path}`);
+    return (template
+        .replace(/<title>.*<\/title>/, `<title>${branding_1.DRAFT_PREVIEW_TITLE}</title>`)
+        .replace(/{{title}}/g, branding_1.DRAFT_PREVIEW_TITLE)
+        .replace(/{{description}}/g, branding_1.DRAFT_PREVIEW_DESCRIPTION)
+        .replace(/{{preview}}/g, (0, branding_1.getFallbackPreviewUrl)())
+        .replace("</head>", `  <meta property="og:url" content="${canonicalUrl}" />\n` +
+        `    <meta name="robots" content="noindex, nofollow, noarchive" />\n  </head>`)
+        // Safety net for placeholders a future shell may add: shipping an empty
+        // value to a crawler beats shipping "{{whatever}}".
+        .replace(/{{\w+}}/g, ""));
+};
+/**
+ * Drafts are unlisted work in progress. `noindex` goes out as both a meta tag
+ * and a header so it reaches crawlers that skip the markup; a `robots.txt`
+ * `Disallow` would be the wrong tool, since it blocks the fetch itself and
+ * would stop Slack and X from unfurling the link at all.
+ */
+const sendDraftShell = (req, res) => {
+    res
+        .type("html")
+        .set("X-Robots-Tag", "noindex, nofollow")
+        .send(renderDraftShell(req));
+};
+/** How often the notification is touched while a translation is running. */
+const SYNC_HEARTBEAT_INTERVAL_MS = 60 * 1000;
+/**
+ * A synchronization with no news for this long is considered stuck: the GET
+ * endpoint flags it as failed and it can be accepted again.
+ */
+const SYNC_PROCESSING_TIMEOUT_MS = 3 * 60 * 1000;
+// True when a processing notification stopped reporting progress.
+function isSyncProcessingStale(notification) {
+    const lastUpdate = notification.processingLastUpdate || notification.updatedAt;
+    return Date.now() - lastUpdate > SYNC_PROCESSING_TIMEOUT_MS;
+}
+function findSyncNotification(syllabus, exerciseSlug, notificationId) {
+    var _a;
+    const lesson = syllabus.lessons.find(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title) === exerciseSlug);
+    return (_a = lesson === null || lesson === void 0 ? void 0 : lesson.syncNotifications) === null || _a === void 0 ? void 0 : _a.find(n => n.id === notificationId);
+}
 async function processSyncTranslationsSequentially(courseSlug, exerciseSlug, notificationId, sourceReadmeContent, targetLanguages, rigoToken, bucket, historyManager) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     try {
         const sanitizedSource = (0, readmeSanitizer_1.sanitizeReadmeNewlines)(sourceReadmeContent);
+        let lastHeartbeatAt = Date.now();
+        // Keeps `processingLastUpdate` fresh while a language is being translated,
+        // otherwise the PROCESSING_TIMEOUT in GET /sync-notifications can flag a
+        // running synchronization as failed. Throttled, since every beat rewrites
+        // the syllabus in the bucket.
+        const heartbeat = async (targetLang) => {
+            if (Date.now() - lastHeartbeatAt < SYNC_HEARTBEAT_INTERVAL_MS) {
+                return;
+            }
+            lastHeartbeatAt = Date.now();
+            try {
+                await serializeByCourse(courseSlug, async () => {
+                    const syllabus = await getSyllabus(courseSlug, bucket);
+                    const notification = findSyncNotification(syllabus, exerciseSlug, notificationId);
+                    if (!notification) {
+                        return;
+                    }
+                    notification.processingLastUpdate = Date.now();
+                    if (notification.syncProgress) {
+                        notification.syncProgress.currentLanguage = targetLang;
+                    }
+                    await saveSyllabus(courseSlug, syllabus, bucket);
+                });
+            }
+            catch (error) {
+                console.warn(`🔄 SYNC: heartbeat failed for ${exerciseSlug}:`, error.message);
+            }
+        };
         // Process translations sequentially (no race conditions)
         for (const targetLang of targetLanguages) {
             try {
-                // Call Rigobot directly with synchronous execution (no webhook needed)
+                const languageStartedAt = Date.now();
+                // The translation runs as an asynchronous Rigobot job that we poll:
+                // waiting for it inside a single request takes 28-45s for a full
+                // README and Heroku kills anything above 30s.
                 // 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: sanitizedSource,
-                        output_language: targetLang,
-                    },
-                    include_purpose_objective: false,
-                    execute_async: false, // Synchronous execution
-                }, {
-                    headers: {
-                        "Content-Type": "application/json",
-                        Authorization: "Token " + rigoToken,
-                    },
-                });
-                const translationResult = response.data;
+                const translationResult = await (0, rigoActions_1.translateExerciseAndWait)(rigoToken, {
+                    text_to_translate: sanitizedSource,
+                    output_language: targetLang,
+                }, { onPoll: () => heartbeat(targetLang) });
+                console.log(`🔄 SYNC: ${targetLang} translated in ${Math.round((Date.now() - languageStartedAt) / 1000)}s (job ${translationResult.id})`);
                 // Check if translation was successful
                 if (!((_a = translationResult.parsed) === null || _a === void 0 ? void 0 : _a.translation)) {
                     throw new Error("Translation result is empty");
@@ -897,10 +966,20 @@ async function processSyncTranslationsSequentially(courseSlug, exerciseSlug, not
                 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";
+                    const completedCount = notification.syncProgress.completedLanguages.length;
+                    const failedCount = ((_f = notification.syncProgress.failedLanguages) === null || _f === void 0 ? void 0 : _f.length) || 0;
+                    // A partial result stays actionable: the notification remains
+                    // visible so the user can retry just the languages that failed.
+                    if (completedCount === 0) {
+                        notification.status = "error";
+                    }
+                    else if (failedCount > 0) {
+                        notification.status = "partial";
+                    }
+                    else {
+                        notification.status = "completed";
+                    }
+                    notification.updatedAt = Date.now();
                     await saveSyllabus(courseSlug, syllabus, bucket);
                     console.log(`🔄 SYNC: ✅ All translations completed for ${exerciseSlug} - Status: ${notification.status}`);
                     (0, creatorSocket_1.emitToCourse)(courseSlug, "sync-notification-completed", {
@@ -908,7 +987,7 @@ async function processSyncTranslationsSequentially(courseSlug, exerciseSlug, not
                         notificationId,
                         status: notification.status,
                         completed: notification.syncProgress.completedLanguages.length,
-                        failed: ((_f = notification.syncProgress.failedLanguages) === null || _f === void 0 ? void 0 : _f.length) || 0,
+                        failed: ((_g = notification.syncProgress.failedLanguages) === null || _g === void 0 ? void 0 : _g.length) || 0,
                     });
                 }
             }
@@ -1021,6 +1100,7 @@ class ServeCommand extends SessionCommand_1.default {
         // app.use(express.static(distPath))
         app.use(express.json({ limit: "20mb" }));
         app.use(cors());
+        app.use("/generation", (0, router_1.createIngestRouter)());
         const appPath = path.resolve(__dirname, "../ui/_app");
         const tarPath = path.resolve(__dirname, "../ui/app.tar.gz");
         if (fs.existsSync(appPath)) {
@@ -1033,6 +1113,10 @@ class ServeCommand extends SessionCommand_1.default {
         await (0, file_1.decompress)(`${__dirname}/../ui/app.tar.gz`, `${__dirname}/../ui/_app/`);
         const localAppPath = path.resolve(__dirname, "../ui/_app");
         // app.use(express.static(localAppPath))
+        // Warm the draft shell now that _app is on disk. Doing it here rather than
+        // on first request means a corrupt tarball fails at boot, with a stack
+        // trace, instead of on some user's preview link.
+        loadDraftShellTemplate();
         app.post("/upload", async (req, res) => {
             const { content, destination } = req.body;
             //   console.log("UPLOAD", content, destination)
@@ -1207,7 +1291,7 @@ class ServeCommand extends SessionCommand_1.default {
                 });
             }
             const filePath = `courses/${courseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(langCode)}`;
-            await uploadFileToBucket(bucket, content, filePath);
+            await (0, bucketIo_1.uploadFileToBucket)(bucket, content, filePath);
             res.json({ status: "SUCCESS" });
         });
         app.post("/webhooks/:courseSlug/images/:imageId", async (req, res) => {
@@ -1302,7 +1386,7 @@ class ServeCommand extends SessionCommand_1.default {
                                 if (fileObj.name && fileObj.content) {
                                     const filePath = `${exerciseDir}/${flatFileName}`;
                                     // eslint-disable-next-line no-await-in-loop
-                                    await uploadFileToBucket(bucket, fileObj.content, filePath);
+                                    await (0, bucketIo_1.uploadFileToBucket)(bucket, fileObj.content, filePath);
                                     console.log(`✅ Saved file: ${filePath}`);
                                 }
                                 // Save the solution file if it exists
@@ -1314,7 +1398,7 @@ class ServeCommand extends SessionCommand_1.default {
                                         const solutionFileName = `${baseName}.solution.hide.${extension}`;
                                         const solutionFilePath = `${exerciseDir}/${solutionFileName}`;
                                         // eslint-disable-next-line no-await-in-loop
-                                        await uploadFileToBucket(bucket, fileObj.solution, solutionFilePath);
+                                        await (0, bucketIo_1.uploadFileToBucket)(bucket, fileObj.solution, solutionFilePath);
                                         console.log(`✅ Saved solution file: ${solutionFilePath}`);
                                     }
                                     else {
@@ -1322,7 +1406,7 @@ class ServeCommand extends SessionCommand_1.default {
                                         const solutionFileName = `${flatFileName}.solution.hide`;
                                         const solutionFilePath = `${exerciseDir}/${solutionFileName}`;
                                         // eslint-disable-next-line no-await-in-loop
-                                        await uploadFileToBucket(bucket, fileObj.solution, solutionFilePath);
+                                        await (0, bucketIo_1.uploadFileToBucket)(bucket, fileObj.solution, solutionFilePath);
                                         console.log(`✅ Saved solution file: ${solutionFilePath}`);
                                     }
                                 }
@@ -1870,7 +1954,7 @@ class ServeCommand extends SessionCommand_1.default {
                 const readmeFilename = `README${(0, creatorUtilities_1.getReadmeExtension)(response.parsed.output_language ||
                     syllabus.courseInfo.language ||
                     "en")}`;
-                await uploadFileToBucket(bucket, readability.newMarkdown, `${targetDir}/${readmeFilename}`);
+                await (0, bucketIo_1.uploadFileToBucket)(bucket, readability.newMarkdown, `${targetDir}/${readmeFilename}`);
                 // Update used components if provided by the AI
                 if (response.parsed.used_components &&
                     Array.isArray(response.parsed.used_components)) {
@@ -1994,7 +2078,7 @@ class ServeCommand extends SessionCommand_1.default {
                     }
                     // 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);
+                    await (0, bucketIo_1.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
@@ -2132,7 +2216,7 @@ class ServeCommand extends SessionCommand_1.default {
             console.log("BODY", body);
             const readmePath = `courses/${courseSlug}/exercises/${exSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(lang)}`;
             if (body.parsed.content) {
-                await uploadFileToBucket(bucket, body.parsed.content, readmePath);
+                await (0, bucketIo_1.uploadFileToBucket)(bucket, body.parsed.content, readmePath);
             }
             (0, creatorSocket_1.emitToNotification)(notificationId, {
                 status: "SUCCESS",
@@ -2148,8 +2232,7 @@ class ServeCommand extends SessionCommand_1.default {
             console.log("GET /");
             const slug = req.query.slug;
             if (slug) {
-                const file = path.resolve(__dirname, "../ui/_app/index.html");
-                res.sendFile(file);
+                sendDraftShell(req, res);
             }
             else {
                 res.redirect("https://learnpack.co");
@@ -2157,12 +2240,16 @@ class ServeCommand extends SessionCommand_1.default {
         });
         app.get("/preview/:slug", async (req, res) => {
             console.log("GET COURSE PREVIEW /");
-            const file = path.resolve(__dirname, "../ui/_app/index.html");
-            res.sendFile(file);
+            sendDraftShell(req, res);
         });
         app.get("/preview/:slug/webview", async (req, res) => {
-            const file = path.resolve(__dirname, "../ui/_app/index.html");
-            res.sendFile(file);
+            sendDraftShell(req, res);
+        });
+        // The brand card used as og:image by drafts, and as the last-resort
+        // fallback by published courses without a preview of their own.
+        app.get("/og-image.png", (req, res) => {
+            res.set("Cache-Control", "public, max-age=86400");
+            res.sendFile(path.resolve(__dirname, "../ui/static/og-image.png"));
         });
         app.get("/config", async (req, res) => {
             const courseSlug = req.query.slug;
@@ -2178,7 +2265,7 @@ class ServeCommand extends SessionCommand_1.default {
                 const config = await mergeConfigPreservingGithub(bucket, courseSlug, builtConfig);
                 res.set("X-Creator-Web", "true");
                 res.set("Access-Control-Expose-Headers", "X-Creator-Web");
-                await uploadFileToBucket(bucket, JSON.stringify({ config, exercises }), `courses/${courseSlug}/.learn/config.json`);
+                await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify({ config, exercises }), `courses/${courseSlug}/.learn/config.json`);
                 res.json({ config, exercises });
             }
             catch (error) {
@@ -2590,7 +2677,7 @@ class ServeCommand extends SessionCommand_1.default {
                     completedAt: 0,
                 },
             };
-            await uploadFileToBucket(bucket, JSON.stringify(Object.assign(Object.assign({}, initialSyllabus), { lessons: newLessons })), `courses/${courseSlug}/.learn/initialSyllabus.json`);
+            await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(Object.assign(Object.assign({}, initialSyllabus), { lessons: newLessons })), `courses/${courseSlug}/.learn/initialSyllabus.json`);
             const targetDir = `courses/${courseSlug}/exercises/${stepSlug}`;
             await uploadInitialReadme(bucket, stepSlug, targetDir, initialSyllabus.courseInfo);
             res.json({ status: "SUCCESS", message: "Exercise generati on started!" });
@@ -2633,20 +2720,20 @@ class ServeCommand extends SessionCommand_1.default {
                 if (!learnJson.title)
                     learnJson.title = {};
                 learnJson.title[language] = title;
-                await uploadFileToBucket(bucket, JSON.stringify(learnJson), `courses/${courseSlug}/learn.json`);
+                await (0, bucketIo_1.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`);
+                await (0, bucketIo_1.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`);
+                        await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(syllabusJson), `courses/${courseSlug}/.learn/initialSyllabus.json`);
                     }
                 }
                 catch (error) {
@@ -2664,9 +2751,9 @@ class ServeCommand extends SessionCommand_1.default {
                         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`);
+                            await (0, bucketIo_1.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`);
+                            await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(configJson), `courses/${courseSlug}/.learn/config.json`);
                         }
                     }
                     catch (translationError) {
@@ -2791,7 +2878,7 @@ class ServeCommand extends SessionCommand_1.default {
                     const translatedDescription = JSON.parse(result.parsed.description);
                     courseJson.title = translatedTitle;
                     courseJson.description = translatedDescription;
-                    await uploadFileToBucket(bucket, JSON.stringify(courseJson), `courses/${courseSlug}/learn.json`);
+                    await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(courseJson), `courses/${courseSlug}/learn.json`);
                     currentLanguages = Object.keys(courseJson.title);
                 }
                 const missingReadmeTranslations = [];
@@ -2989,37 +3076,35 @@ class ServeCommand extends SessionCommand_1.default {
                 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)
+                // Collect active notifications (pending, processing, partial 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",
-                                    });
-                                }
+                            if (notification.status === "processing" &&
+                                isSyncProcessingStale(notification)) {
+                                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)
+                            // Include active notifications (pending, processing, partial or
+                            // error): a partial sync is still actionable, the user can retry
+                            // the languages that failed.
                             if (notification.status === "pending" ||
                                 notification.status === "processing" ||
+                                notification.status === "partial" ||
                                 notification.status === "error") {
                                 notifications.push(Object.assign(Object.assign({}, notification), { lessonSlug: (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title), lessonTitle: lesson.title }));
                             }
@@ -3083,7 +3168,7 @@ class ServeCommand extends SessionCommand_1.default {
         });
         // Accept sync notification and start synchronization
         app.post("/courses/:courseSlug/lessons/:exerciseSlug/sync-notification/:notificationId/accept", express.json(), async (req, res) => {
-            var _a, _b;
+            var _a, _b, _c;
             console.log("POST /courses/:courseSlug/lessons/:exerciseSlug/sync-notification/:notificationId/accept");
             const { courseSlug, exerciseSlug, notificationId } = req.params;
             const rigoToken = req.header("x-rigo-token");
@@ -3111,9 +3196,21 @@ class ServeCommand extends SessionCommand_1.default {
                 if (!notification) {
                     return res.status(404).json({ error: "Notification not found" });
                 }
-                if (notification.status !== "pending") {
+                // A synchronization can be accepted again unless it is actively
+                // running: after a failure or a partial result this same
+                // notification is what the Retry button acts on.
+                if (notification.status === "processing" &&
+                    !isSyncProcessingStale(notification)) {
+                    return res.status(409).json({
+                        error: "Notification is already being synchronized",
+                        code: "ALREADY_PROCESSING",
+                        currentStatus: notification.status,
+                    });
+                }
+                if (notification.status === "completed") {
                     return res.status(400).json({
-                        error: "Notification is not pending",
+                        error: "Notification is already synchronized",
+                        code: "ALREADY_COMPLETED",
                         currentStatus: notification.status,
                     });
                 }
@@ -3131,9 +3228,13 @@ class ServeCommand extends SessionCommand_1.default {
                         code: "SOURCE_README_ERROR",
                     });
                 }
-                // Determine target languages
+                // Determine target languages. On a retry only what is still missing
+                // is translated again, so the languages that already succeeded are
+                // neither paid for twice nor overwritten.
+                const alreadyCompleted = ((_b = notification.syncProgress) === null || _b === void 0 ? void 0 : _b.completedLanguages) || [];
                 const availableLanguages = Object.keys(lesson.translations || {});
-                const targetLanguages = availableLanguages.filter(lang => lang !== notification.sourceLanguage);
+                const targetLanguages = availableLanguages.filter(lang => lang !== notification.sourceLanguage &&
+                    !alreadyCompleted.includes(lang));
                 if (targetLanguages.length === 0) {
                     return res.status(400).json({
                         error: "No target languages found",
@@ -3142,10 +3243,14 @@ class ServeCommand extends SessionCommand_1.default {
                 }
                 // Remove all other notifications for this lesson
                 lesson.syncNotifications =
-                    ((_b = lesson.syncNotifications) === null || _b === void 0 ? void 0 : _b.filter(n => n.id === notificationId)) ||
+                    ((_c = lesson.syncNotifications) === null || _c === void 0 ? void 0 : _c.filter(n => n.id === notificationId)) ||
                         [];
+                // Start from a clean slate so a previous failure does not leak into
+                // this run.
                 notification.status = "processing";
+                notification.updatedAt = Date.now();
                 notification.processingLastUpdate = Date.now();
+                delete notification.error;
                 notification.syncProgress = {
                     totalLanguages: targetLanguages.length,
                     completedLanguages: [], // Array of completed language codes
@@ -3391,7 +3496,7 @@ class ServeCommand extends SessionCommand_1.default {
                 const removedCount = initialCount - kept.length;
                 exercise.files = kept;
                 if (removedCount > 0) {
-                    await uploadFileToBucket(bucket, JSON.stringify({ config: configJson.config, exercises }), `courses/${courseSlug}/.learn/config.json`);
+                    await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify({ config: configJson.config, exercises }), `courses/${courseSlug}/.learn/config.json`);
                 }
                 if (movedCount > 0 || removedCount > 0) {
                     console.log(`[sync-lesson-files] ${lessonSlug}: ${movedCount} moved from subdir, ${removedCount} removed from config`);
@@ -3427,7 +3532,7 @@ class ServeCommand extends SessionCommand_1.default {
                     const { exercises } = await (0, configBuilder_1.buildConfig)(bucket, courseSlug);
                     const { fixedSidebar, valid } = await (0, sidebarGenerator_1.checkAndFixSidebarPure)(sidebar, exercises, rigoToken);
                     if (fixedSidebar) {
-                        await uploadFileToBucket(bucket, JSON.stringify(fixedSidebar), `courses/${courseSlug}/.learn/sidebar.json`);
+                        await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(fixedSidebar), `courses/${courseSlug}/.learn/sidebar.json`);
                         return res.json(fixedSidebar);
                     }
                 }
@@ -3437,12 +3542,12 @@ class ServeCommand extends SessionCommand_1.default {
                 if (error.code === 404) {
                     const { exercises } = await (0, configBuilder_1.buildConfig)(bucket, courseSlug);
                     const exerciseSlugsArray = exercises.map(exercise => exercise.slug);
-                    const sidebar = await createInitialSidebar(exerciseSlugsArray);
-                    await uploadFileToBucket(bucket, JSON.stringify(sidebar), `courses/${courseSlug}/.learn/sidebar.json`);
+                    const sidebar = await (0, sidebar_1.createInitialSidebar)(exerciseSlugsArray);
+                    await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(sidebar), `courses/${courseSlug}/.learn/sidebar.json`);
                     if (rigoToken) {
                         const { fixedSidebar } = await (0, sidebarGenerator_1.checkAndFixSidebarPure)(sidebar, exercises, rigoToken);
                         if (fixedSidebar) {
-                            await uploadFileToBucket(bucket, JSON.stringify(fixedSidebar), `courses/${courseSlug}/.learn/sidebar.json`);
+                            await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(fixedSidebar), `courses/${courseSlug}/.learn/sidebar.json`);
                         }
                         return res.status(200).json(fixedSidebar);
                     }
@@ -3486,7 +3591,7 @@ class ServeCommand extends SessionCommand_1.default {
             }
             const courseSlug = syllabus.courseInfo.slug;
             const tutorialDir = `courses/${courseSlug}`;
-            const learnJson = (0, exports.createLearnJson)(syllabus.courseInfo);
+            const learnJson = (0, learnJson_1.createLearnJson)(syllabus.courseInfo);
             try {
                 await api_1.default.createRigoPackage(rigoToken, courseSlug, learnJson);
             }
@@ -3495,7 +3600,7 @@ class ServeCommand extends SessionCommand_1.default {
                 return res.status(400).json({ error: "Failed to create Rigo package" });
             }
             try {
-                await uploadFileToBucket(bucket, JSON.stringify(learnJson), `${tutorialDir}/learn.json`);
+                await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(learnJson), `${tutorialDir}/learn.json`);
             }
             catch (error) {
                 console.error("Failed to upload learn.json:", error);
@@ -3509,15 +3614,15 @@ class ServeCommand extends SessionCommand_1.default {
                 // eslint-disable-next-line no-await-in-loop
                 await uploadInitialReadme(bucket, exSlug, targetDir, syllabus.courseInfo);
             }
-            const sidebar = await createInitialSidebar(syllabus.lessons.map(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title)), syllabus.courseInfo.language);
+            const sidebar = await (0, sidebar_1.createInitialSidebar)(syllabus.lessons.map(lesson => (0, creatorUtilities_2.slugify)(lesson.id + "-" + lesson.title)), syllabus.courseInfo.language);
             const initialSyllabus = Object.assign(Object.assign({}, syllabus), { lessons: syllabus.lessons.map((lesson, index) => {
                     if (index < 1) {
                         return Object.assign(Object.assign({}, lesson), { generated: false, status: "GENERATING" });
                     }
                     return Object.assign(Object.assign({}, lesson), { generated: false, status: "PENDING" });
                 }) });
-            await uploadFileToBucket(bucket, JSON.stringify(initialSyllabus), `${tutorialDir}/.learn/initialSyllabus.json`);
-            await uploadFileToBucket(bucket, JSON.stringify(sidebar), `${tutorialDir}/.learn/sidebar.json`);
+            await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(initialSyllabus), `${tutorialDir}/.learn/initialSyllabus.json`);
+            await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(sidebar), `${tutorialDir}/.learn/sidebar.json`);
             const firstLesson = syllabus.lessons[0];
             const lastResult = "---";
             // Use new two-phase generation workflow
@@ -3712,13 +3817,13 @@ class ServeCommand extends SessionCommand_1.default {
                     title = config.title[availableLangs[0]];
                     selectedLang = availableLangs[0];
                 }
+                const previewUrl = await resolveCoursePreviewUrl(bucket, slug, config.preview);
                 const idxTpl = fs.readFileSync(path.join(uiSrc, "index.html"), "utf-8");
                 const idxHtml = idxTpl
                     .replace(/{{title}}/g, title)
                     .replace(/<title>.*<\/title>/, `<title>${title}</title>`)
                     .replace(/{{description}}/g, config.description[selectedLang])
-                    .replace(/{{preview}}/g, fixPreviewUrl(slug, "") ||
-                    "https://raw.githubusercontent.com/learnpack/ide/master/public/learnpack.svg")
+                    .replace(/{{preview}}/g, previewUrl)
                     .replace(/{{slug}}/g, slug)
                     .replace(/{{duration}}/g, (0, misc_1.minutesToISO8601Duration)(config.duration));
                 fs.writeFileSync(path.join(buildRoot, "index.html"), idxHtml);
@@ -3748,9 +3853,9 @@ class ServeCommand extends SessionCommand_1.default {
                 // 8) Crear el config.json en buildRoot con lo que retorna buildConfig
                 const fullConfig = { config, exercises };
                 fullConfig.config.slug = slug;
-                fullConfig.config.preview =
-                    fixPreviewUrl(slug, "") ||
-                        "https://raw.githubusercontent.com/learnpack/ide/master/public/learnpack.svg";
+                // Same URL the meta tags got: this used to overwrite the real preview
+                // of every published package with the unusable SVG fallback.
+                fullConfig.config.preview = previewUrl;
                 fs.writeFileSync(path.join(buildRoot, "config.json"), JSON.stringify(fullConfig, null, 2), "utf-8");
                 // 9) Empaquetar en ZIP (solo contenido de buildRoot)
                 const zipName = `${slug}.zip`;
@@ -4220,19 +4325,19 @@ class ServeCommand extends SessionCommand_1.default {
                 const [learnJsonContent] = await learnJsonFile.download();
                 const learnJson = JSON.parse(learnJsonContent.toString());
                 learnJson.slug = newSlug;
-                await uploadFileToBucket(bucket, JSON.stringify(learnJson), `${newPrefix}learn.json`);
+                await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(learnJson), `${newPrefix}learn.json`);
                 // Update initialSyllabus.json with new slug
                 const syllabusFile = bucket.file(`${newPrefix}.learn/initialSyllabus.json`);
                 const [syllabusContent] = await syllabusFile.download();
                 const syllabus = JSON.parse(syllabusContent.toString());
                 syllabus.courseInfo.slug = newSlug;
-                await uploadFileToBucket(bucket, JSON.stringify(syllabus), `${newPrefix}.learn/initialSyllabus.json`);
+                await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(syllabus), `${newPrefix}.learn/initialSyllabus.json`);
                 // Update config.json with new slug
                 const configFile = bucket.file(`${newPrefix}.learn/config.json`);
                 const [configContent] = await configFile.download();
                 const config = JSON.parse(configContent.toString());
                 config.config.slug = newSlug;
-                await uploadFileToBucket(bucket, JSON.stringify(config), `${newPrefix}.learn/config.json`);
+                await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(config), `${newPrefix}.learn/config.json`);
                 // Update Rigobot package slug
                 const updateUrl = `${api_1.RIGOBOT_HOST}/v1/learnpack/package/${currentSlug}/`;
                 await axios_1.default.put(updateUrl, { new_slug: newSlug }, {
@@ -4394,7 +4499,7 @@ class ServeCommand extends SessionCommand_1.default {
                 defaultBranch,
                 lastSyncSHA: commitRes.sha,
             };
-            await uploadFileToBucket(bucket, JSON.stringify(configJson), `courses/${courseSlug}/.learn/config.json`);
+            await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(configJson), `courses/${courseSlug}/.learn/config.json`);
             return res.json({
                 success: true,
                 repository,
@@ -4568,7 +4673,7 @@ class ServeCommand extends SessionCommand_1.default {
                 compareRes.files.length === 0) {
                 configJson.config = configJson.config || {};
                 configJson.config.github = Object.assign(Object.assign({}, configJson.config.github), { lastSyncSHA: targetSHA });
-                await uploadFileToBucket(bucket, JSON.stringify(configJson), `courses/${courseSlug}/.learn/config.json`);
+                await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(configJson), `courses/${courseSlug}/.learn/config.json`);
                 return res.json({
                     success: true,
                     syncedLessons: [],
@@ -4700,12 +4805,12 @@ class ServeCommand extends SessionCommand_1.default {
                     const buffer = buffer_1.Buffer.from(content, "base64");
                     if (item.isAsset || isImageFile(item.relativePath)) {
                         // eslint-disable-next-line no-await-in-loop -- Sequential processing to avoid rate limits
-                        await uploadBinaryToBucket(bucket, buffer, item.bucketPath, "application/octet-stream");
+                        await (0, bucketIo_1.uploadBinaryToBucket)(bucket, buffer, item.bucketPath, "application/octet-stream");
                     }
                     else {
                         const text = buffer.toString("utf8");
                         // eslint-disable-next-line no-await-in-loop -- Sequential processing to avoid rate limits
-                        await uploadFileToBucket(bucket, text, item.bucketPath);
+                        await (0, bucketIo_1.uploadFileToBucket)(bucket, text, item.bucketPath);
                     }
                     if (item.isAsset) {
                         syncedAssetsUploaded++;
@@ -4718,7 +4823,7 @@ class ServeCommand extends SessionCommand_1.default {
             }
             configJson.config = configJson.config || {};
             configJson.config.github = Object.assign(Object.assign({}, configJson.config.github), { lastSyncSHA: targetSHA });
-            await uploadFileToBucket(bucket, JSON.stringify(configJson), `courses/${courseSlug}/.learn/config.json`);
+            await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(configJson), `courses/${courseSlug}/.learn/config.json`);
             return res.json({
                 success: true,
                 syncedLessons: [...syncedLessonSlugs],
@@ -4787,7 +4892,7 @@ class ServeCommand extends SessionCommand_1.default {
             });
             configJson.config = configJson.config || {};
             configJson.config.github = Object.assign(Object.assign({}, configJson.config.github), { lastSyncSHA: commitRes.sha });
-            await uploadFileToBucket(bucket, JSON.stringify(configJson), `courses/${courseSlug}/.learn/config.json`);
+            await (0, bucketIo_1.uploadFileToBucket)(bucket, JSON.stringify(configJson), `courses/${courseSlug}/.learn/config.json`);
             return res.json({
                 success: true,
                 repository,
@@ -4862,7 +4967,7 @@ class ServeCommand extends SessionCommand_1.default {
             }
             try {
                 const memoryBankPath = `courses/${courseSlug}/.learn/memory_bank.txt`;
-                await uploadFileToBucket(bucket, content, memoryBankPath);
+                await (0, bucketIo_1.uploadFileToBucket)(bucket, content, memoryBankPath);
                 console.log(`✅ Memory bank updated for course: ${courseSlug}`);
                 res.json({ message: "Memory bank updated successfully" });
             }