@learnpack/learnpack 5.0.262 → 5.0.266

package/lib/commands/serve.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processImage = exports.createLearnJson = void 0;
 const tslib_1 = require("tslib");
 const command_1 = require("@oclif/command");
+const buffer_1 = require("buffer");
 const youtube_transcript_1 = require("youtube-transcript");
 const express = require("express");
 const cors = require("cors");
@@ -64,7 +65,7 @@ const createLearnJson = (courseInfo) => {
 exports.createLearnJson = createLearnJson;
 const uploadFileToBucket = async (bucket, file, path) => {
     const fileRef = bucket.file(path);
-    await fileRef.save(Buffer.from(file, "utf8"));
+    await fileRef.save(buffer_1.Buffer.from(file, "utf8"));
 };
 const PARAMS = {
     expected_grade_level: "8",
@@ -123,7 +124,7 @@ const createMultiLangAsset = async (bucket, rigoToken, bcToken, courseSlug, cour
         // eslint-disable-next-line no-await-in-loop
         const [indexReadmeContent] = await indexReadme.download();
         const indexReadmeString = indexReadmeContent.toString();
-        const b64IndexReadme = Buffer.from(indexReadmeString).toString("base64");
+        const b64IndexReadme = buffer_1.Buffer.from(indexReadmeString).toString("base64");
         // eslint-disable-next-line no-await-in-loop
         const asset = await (0, publish_1.handleAssetCreation)({ token: bcToken, rigobotToken: rigoToken.trim() }, courseJson, lang, deployUrl, b64IndexReadme, all_translations);
         if (!asset) {
@@ -236,7 +237,7 @@ class ServeCommand extends SessionCommand_1.default {
             if (!bucket) {
                 return res.status(500).send("Upload failed");
             }
-            const buffer = Buffer.from(content, "utf-8");
+            const buffer = buffer_1.Buffer.from(content, "utf-8");
             const file = bucket.file(destination);
             const stream = file.createWriteStream({
                 resumable: false,
@@ -330,39 +331,77 @@ class ServeCommand extends SessionCommand_1.default {
         app.post("/webhooks/:courseSlug/initial-readme-processor", async (req, res) => {
             const { courseSlug } = req.params;
             const body = req.body;
-            // Save the file as courses/courseSlug/README.md
-            const filePath = `courses/${courseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(body.parsed.language_code)}`;
-            await uploadFileToBucket(bucket, body.parsed.content, filePath);
+            console.log("RECEIVING INITIAL README WEBHOOK", body);
+            const langCode = body.parsed.language_code || body.parsed.output_language_code || "";
+            const content = body.parsed.content || body.parsed.translation || "";
+            if (!content || !langCode) {
+                console.log("No content or language code to save", body);
+                return res.status(400).json({
+                    status: "ERROR",
+                    message: "No content to save",
+                });
+            }
+            const filePath = `courses/${courseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(langCode)}`;
+            await uploadFileToBucket(bucket, content, filePath);
             res.json({ status: "SUCCESS" });
         });
         app.post("/webhooks/:courseSlug/images/:imageId", async (req, res) => {
             const { courseSlug, imageId } = req.params;
             const body = req.body;
-            console.log("RECEIVING IMAGE WEBHOOK", body);
-            const imageUrl = body.image_url;
-            const imagePath = `courses/${courseSlug}/.learn/assets/${imageId}`;
-            const imageFile = bucket.file(imagePath);
-            const [exists] = await imageFile.exists();
-            if (!exists) {
-                // Descargar la imagen
-                const response = await fetch(imageUrl);
-                if (!response.ok) {
-                    return res.status(400).json({
+            try {
+                if (body.error) {
+                    (0, creatorSocket_1.emitToNotification)(imageId, {
                         status: "ERROR",
-                        message: "No se pudo descargar la imagen",
+                        message: "Error generating image",
                     });
+                    return res.json({ status: "ERROR" });
+                }
+                fs.writeFileSync(`image-${imageId}.json`, JSON.stringify(body, null, 2));
+                const imageUrl = body.image_url;
+                const format = body.format;
+                const imagePath = `courses/${courseSlug}/.learn/assets/${imageId}`;
+                const imageFile = bucket.file(imagePath);
+                const [exists] = await imageFile.exists();
+                if (!exists) {
+                    let buffer;
+                    if (format === "b64" || imageUrl.startsWith("data:image/")) {
+                        const base64Data = imageUrl.includes(",") ?
+                            imageUrl.split(",")[1] :
+                            imageUrl;
+                        buffer = buffer_1.Buffer.from(base64Data, "base64");
+                    }
+                    else if (imageUrl.startsWith("http")) {
+                        const response = await fetch(imageUrl);
+                        if (!response.ok) {
+                            return res.status(400).json({
+                                status: "ERROR",
+                                message: "Could not download the image",
+                            });
+                        }
+                        buffer = new Uint8Array(await response.arrayBuffer());
+                    }
+                    else {
+                        return res.status(400).json({
+                            status: "ERROR",
+                            message: "Image_url format not supported",
+                        });
+                    }
+                    await imageFile.save(buffer, { contentType: "image/png" });
                 }
-                const buffer = await response.arrayBuffer();
-                // Guardar la imagen en el bucket
-                await imageFile.save(new Uint8Array(buffer), {
-                    contentType: "image/png",
+                (0, creatorSocket_1.emitToNotification)(imageId, {
+                    status: "SUCCESS",
+                    message: "Image generated successfully",
                 });
+                res.json({ status: "SUCCESS" });
+            }
+            catch (error) {
+                (0, creatorSocket_1.emitToNotification)(imageId, {
+                    status: "ERROR",
+                    message: "Error receiving image webhook",
+                });
+                console.error("❌ Error receiving image webhook:", error);
+                res.status(500).json({ error: error.message });
             }
-            (0, creatorSocket_1.emitToNotification)(imageId, {
-                status: "SUCCESS",
-                message: "Image generated successfully",
-            });
-            res.json({ status: "SUCCESS" });
         });
         app.post("/webhooks/:courseSlug/exercise-processor/:lessonID/:rigoToken", async (req, res) => {
             // console.log("Receiving a webhook to exercise processor")
@@ -438,6 +477,15 @@ class ServeCommand extends SessionCommand_1.default {
             await uploadFileToBucket(bucket, JSON.stringify(newSyllabus), `courses/${courseSlug}/.learn/initialSyllabus.json`);
             res.json({ status: "SUCCESS" });
         });
+        // 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) => {
+            const { courseSlug, exSlug } = req.params;
+            const body = req.body;
+            console.log("RECEIVING TRANSLATION WEBHOOK", body);
+            const readmePath = `courses/${courseSlug}/exercises/${exSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(body.parsed.output_language_code)}`;
+            await uploadFileToBucket(bucket, body.parsed.translation, readmePath);
+            res.json({ status: "SUCCESS" });
+        });
         app.get("/check-preview-image/:slug", async (req, res) => {
             const { slug } = req.params;
             const file = bucket.file(`courses/${slug}/preview.png`);
@@ -623,65 +671,79 @@ class ServeCommand extends SessionCommand_1.default {
                 return res.status(400).json({ error: "RigoToken not found" });
             }
             const languagesToTranslate = languages.split(",");
-            const course = await bucket
-                .file(`courses/${courseSlug}/learn.json`)
-                .download();
-            const courseJson = JSON.parse(course.toString());
-            const languageCodes = new Set();
+            const languageCodesRes = await (0, rigoActions_1.getLanguageCodes)(rigoToken, {
+                raw_languages: languagesToTranslate.join(","),
+            });
+            const languageCodes = languageCodesRes.parsed.language_codes;
             try {
                 await Promise.all(exerciseSlugs.map(async (slug) => {
                     const readmePath = `courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(currentLanguage)}`;
                     const readme = await bucket.file(readmePath).download();
-                    await Promise.all(languagesToTranslate.map(async (language) => {
-                        const response = await (0, rigoActions_1.translateExercise)(rigoToken, {
+                    await Promise.all(languageCodes.map(async (language) => {
+                        // verify if the translation already exists
+                        const translationPath = `courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(language)}`;
+                        const [exists] = await bucket.file(translationPath).exists();
+                        if (exists) {
+                            console.log(`Translation in ${language} already exists for exercise ${slug}`);
+                            return;
+                        }
+                        await (0, rigoActions_1.translateExercise)(rigoToken, {
                             text_to_translate: readme.toString(),
                             output_language: language,
-                            exercise_slug: slug,
-                        });
-                        const translatedReadme = await bucket.file(`courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(response.parsed.output_language_code)}`);
-                        await translatedReadme.save(response.parsed.translation);
-                        languageCodes.add(response.parsed.output_language_code);
+                        }, `${process.env.HOST}/webhooks/${courseSlug}/${slug}/save-translation`);
                     }));
                 }));
-                const currentLanguages = Object.keys(courseJson.title);
-                for (const languageCode of currentLanguages) {
-                    if (languageCodes.has(languageCode)) {
-                        languageCodes.delete(languageCode);
+                const course = await bucket
+                    .file(`courses/${courseSlug}/learn.json`)
+                    .download();
+                const courseJson = JSON.parse(course.toString());
+                const neededLanguages = new Set();
+                let currentLanguages = Object.keys(courseJson.title);
+                for (const languageCode of languageCodes) {
+                    if (!currentLanguages.includes(languageCode)) {
+                        neededLanguages.add(languageCode);
                     }
                 }
-                if ([...languageCodes].length > 0) {
-                    const translatedCourseMetadata = await Promise.all([...languageCodes].map(async (languageCode) => {
-                        const result = await (0, rigoActions_1.translateCourseMetadata)(rigoToken, {
-                            title: courseJson.title[currentLanguage],
-                            description: courseJson.description[currentLanguage],
-                            destination_lang_code: languageCode,
-                        });
-                        return {
-                            languageCode,
-                            title: result.parsed.title,
-                            description: result.parsed.description,
-                        };
-                    }));
-                    for (const metadata of translatedCourseMetadata) {
-                        courseJson.title[metadata.languageCode] = metadata.title;
-                        courseJson.description[metadata.languageCode] =
-                            metadata.description;
-                    }
+                const neededLanguagesList = [...neededLanguages]
+                    .map((lang) => lang.toLowerCase())
+                    .sort();
+                if (neededLanguagesList.length > 0) {
+                    const result = await (0, rigoActions_1.translateCourseMetadata)(rigoToken, {
+                        title: JSON.stringify(courseJson.title),
+                        description: JSON.stringify(courseJson.description),
+                        new_languages: neededLanguagesList.join(","),
+                    });
+                    const translateTitle = JSON.parse(result.parsed.title);
+                    const translateDescription = JSON.parse(result.parsed.description);
+                    courseJson.title = translateTitle;
+                    courseJson.description = translateDescription;
                     await uploadFileToBucket(bucket, JSON.stringify(courseJson), `courses/${courseSlug}/learn.json`);
-                    const previewReadme = await bucket.file(`courses/${courseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(currentLanguage)}`);
-                    const [previewReadmeContent] = await previewReadme.download();
-                    const previewReadmeContentString = previewReadmeContent.toString();
-                    await Promise.all([...languageCodes].map(async (languageCode) => {
-                        const translatedPreviewReadme = await (0, rigoActions_1.translateExercise)(rigoToken, {
-                            text_to_translate: previewReadmeContentString,
-                            output_language: languageCode,
-                            exercise_slug: "preview-readme",
-                        });
-                        await bucket
-                            .file(`courses/${courseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(languageCode)}`)
-                            .save(translatedPreviewReadme.parsed.translation);
-                    }));
+                    currentLanguages = Object.keys(courseJson.title);
                 }
+                // Check that all the READMEs exists
+                const missingReadmeTranslations = [];
+                let firstAvailable = "";
+                for (const languageCode of currentLanguages) {
+                    // eslint-disable-next-line no-await-in-loop
+                    const previewReadme = await bucket.file(`courses/${courseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(languageCode)}`);
+                    // eslint-disable-next-line no-await-in-loop
+                    const [exists] = await previewReadme.exists();
+                    if (!exists) {
+                        missingReadmeTranslations.push(languageCode);
+                    }
+                    else {
+                        // eslint-disable-next-line no-await-in-loop
+                        const [previewReadmeContent] = await previewReadme.download();
+                        const previewReadmeContentString = previewReadmeContent.toString();
+                        firstAvailable = previewReadmeContentString;
+                    }
+                }
+                await Promise.all(missingReadmeTranslations.map(async (languageCode) => {
+                    await (0, rigoActions_1.translateExercise)(rigoToken, {
+                        text_to_translate: firstAvailable,
+                        output_language: languageCode,
+                    }, `${process.env.HOST}/webhooks/${courseSlug}/initial-readme-processor`);
+                }));
                 return res.status(200).json({ message: "Translated exercises" });
             }
             catch (error) {
@@ -1019,7 +1081,7 @@ class ServeCommand extends SessionCommand_1.default {
             const { link } = req.params;
             try {
                 // 1) Decode the URL
-                const decoded = Buffer.from(link, "base64url").toString("utf-8");
+                const decoded = buffer_1.Buffer.from(link, "base64url").toString("utf-8");
                 const ytMatch = decoded.match(YT_REGEX);
                 if (ytMatch) {
                     const videoId = ytMatch[1];
@@ -1087,7 +1149,7 @@ class ServeCommand extends SessionCommand_1.default {
                 return res.status(400).json({ error: "URL is required" });
             }
             try {
-                const decodedUrl = Buffer.from(url, "base64url").toString("utf-8");
+                const decodedUrl = buffer_1.Buffer.from(url, "base64url").toString("utf-8");
                 const response = await axios_1.default.get(decodedUrl, {
                     responseType: "arraybuffer",
                 });

package/lib/commands/translate.js

@@ -78,8 +78,7 @@ class BuildCommand extends SessionCommand_1.default {
                 const response = await (0, rigoActions_1.translateExercise)(rigoToken, {
                     text_to_translate: readme,
                     output_language: language,
-                    exercise_slug: exercise,
-                });
+                }, `${process.env.HOST}/webhooks/translate-exercise`);
                 await (0, creatorUtilities_1.saveTranslatedReadme)(exercise, response.parsed.output_language_code, response.parsed.translation);
                 console_1.default.success(`Translated ${exercise} to ${language} successfully`);
             }));